scilab/modules/gui/src/java/org/scilab/modules/gui/bridge/tab/SwingScilabDockablePanel.java

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2007-2008 - INRIA - Vincent Couvert
   4  * Copyright (C) 2007 - INRIA - Bruno JOFRET
   5  * Copyright (C) 2007 - INRIA - Marouane BEN JELLOUL
   6  * Copyright (C) 2011 - DIGITEO - Vincent Couvert
   7  * Copyright (C) 2014 - Scilab Enterprises - Bruno JOFRET
   8  *
   9  * This file must be used under the terms of the CeCILL.
  10  * This source file is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution.  The terms
  12  * are also available at
  13  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  14  *
  15  */
  16
  17 package org.scilab.modules.gui.bridge.tab;
  18
  19 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_AUTORESIZE__;
  20 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_AXES_SIZE__;
  21 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_CLOSEREQUESTFCN__;
  22 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_POSITION__;
  23 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_SIZE__;
  24
  25 import java.awt.Color;
  26 import java.awt.Component;
  27 import java.awt.Container;
  28 import java.awt.Dimension;
  29 import java.awt.Graphics;
  30 import java.awt.Image;
  31 import java.awt.event.ComponentEvent;
  32 import java.awt.event.ComponentListener;
  33 import java.awt.event.FocusEvent;
  34 import java.awt.event.FocusListener;
  35 import java.awt.event.HierarchyBoundsListener;
  36 import java.awt.event.HierarchyEvent;
  37 import java.awt.event.KeyEvent;
  38 import java.awt.event.KeyListener;
  39 import java.lang.reflect.InvocationTargetException;
  40 import java.util.Iterator;
  41 import java.util.List;
  42 import java.util.ListIterator;
  43
  44 import javax.swing.Action;
  45 import javax.swing.ImageIcon;
  46 import javax.swing.JLayeredPane;
  47 import javax.swing.JTextPane;
  48 import javax.swing.KeyStroke;
  49 import javax.swing.SwingUtilities;
  50
  51 import org.flexdock.docking.DockingConstants;
  52 import org.flexdock.docking.DockingManager;
  53 import org.flexdock.docking.DockingPort;
  54 import org.flexdock.docking.activation.ActiveDockableTracker;
  55 import org.flexdock.docking.event.DockingEvent;
  56 import org.flexdock.docking.props.PropertyChangeListenerFactory;
  57 import org.flexdock.view.Titlebar;
  58 import org.flexdock.view.View;
  59 import org.scilab.modules.action_binding.InterpreterManagement;
  60 import org.scilab.modules.commons.ScilabConstants;
  61 import org.scilab.modules.commons.gui.FindIconHelper;
  62 import org.scilab.modules.graphic_objects.figure.Figure;
  63 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
  64 import org.scilab.modules.gui.SwingViewObject;
  65 import org.scilab.modules.gui.bridge.canvas.SwingScilabCanvas;
  66 import org.scilab.modules.gui.bridge.checkbox.SwingScilabCheckBox;
  67 import org.scilab.modules.gui.bridge.console.SwingScilabConsole;
  68 import org.scilab.modules.gui.bridge.editbox.SwingScilabEditBox;
  69 import org.scilab.modules.gui.bridge.frame.SwingScilabFrame;
  70 import org.scilab.modules.gui.bridge.frame.SwingScilabScrollableFrame;
  71 import org.scilab.modules.gui.bridge.helpbrowser.SwingScilabHelpBrowser;
  72 import org.scilab.modules.gui.bridge.label.SwingScilabLabel;
  73 import org.scilab.modules.gui.bridge.listbox.SwingScilabListBox;
  74 import org.scilab.modules.gui.bridge.menubar.SwingScilabMenuBar;
  75 import org.scilab.modules.gui.bridge.popupmenu.SwingScilabPopupMenu;
  76 import org.scilab.modules.gui.bridge.pushbutton.SwingScilabPushButton;
  77 import org.scilab.modules.gui.bridge.radiobutton.SwingScilabRadioButton;
  78 import org.scilab.modules.gui.bridge.slider.SwingScilabScroll;
  79 import org.scilab.modules.gui.bridge.tree.SwingScilabTree;
  80 import org.scilab.modules.gui.bridge.uidisplaytree.SwingScilabUiDisplayTree;
  81 import org.scilab.modules.gui.bridge.uiimage.SwingScilabUiImage;
  82 import org.scilab.modules.gui.bridge.uitable.SwingScilabUiTable;
  83 import org.scilab.modules.gui.bridge.window.SwingScilabWindow;
  84 import org.scilab.modules.gui.canvas.Canvas;
  85 import org.scilab.modules.gui.checkbox.CheckBox;
  86 import org.scilab.modules.gui.console.Console;
  87 import org.scilab.modules.gui.console.ScilabConsole;
  88 import org.scilab.modules.gui.dockable.Dockable;
  89 import org.scilab.modules.gui.editbox.EditBox;
  90 import org.scilab.modules.gui.editor.EditorEventListener;
  91 import org.scilab.modules.gui.events.GlobalEventWatcher;
  92 import org.scilab.modules.gui.events.ScilabEventListener;
  93 import org.scilab.modules.gui.events.callback.CommonCallBack;
  94 import org.scilab.modules.gui.frame.Frame;
  95 import org.scilab.modules.gui.frame.SimpleFrame;
  96 import org.scilab.modules.gui.helpbrowser.HelpBrowser;
  97 import org.scilab.modules.gui.label.Label;
  98 import org.scilab.modules.gui.listbox.ListBox;
  99 import org.scilab.modules.gui.menubar.MenuBar;
 100 import org.scilab.modules.gui.popupmenu.PopupMenu;
 101 import org.scilab.modules.gui.pushbutton.PushButton;
 102 import org.scilab.modules.gui.radiobutton.RadioButton;
 103 import org.scilab.modules.gui.slider.Slider;
 104 import org.scilab.modules.gui.tab.SimpleTab;
 105 import org.scilab.modules.gui.textbox.TextBox;
 106 import org.scilab.modules.gui.toolbar.ToolBar;
 107 import org.scilab.modules.gui.tree.Tree;
 108 import org.scilab.modules.gui.uidisplaytree.UiDisplayTree;
 109 import org.scilab.modules.gui.uitable.UiTable;
 110 import org.scilab.modules.gui.utils.BarUpdater;
 111 import org.scilab.modules.gui.utils.ClosingOperationsManager;
 112 import org.scilab.modules.gui.utils.Position;
 113 import org.scilab.modules.gui.utils.SciClosingAction;
 114 import org.scilab.modules.gui.utils.SciHelpOnComponentAction;
 115 import org.scilab.modules.gui.utils.SciUndockingAction;
 116 import org.scilab.modules.gui.utils.Size;
 117
 118 /**
 119  * Swing implementation for Scilab tabs in GUIs
 120  * This implementation uses FlexDock package
 121  * @author Bruno JOFRET
 122  * @author Vincent COUVERT
 123  * @author Marouane BEN JELLOUL
 124  * @author Jean-Baptiste SILVY
 125  */
 126
 127 public class SwingScilabDockablePanel extends View implements SimpleTab, FocusListener, KeyListener, SwingScilabPanel {
 128
 129
 130
 131     private static final Image SCILAB_ICON = new ImageIcon(FindIconHelper.findIcon("scilab", "256x256")).getImage();
 132
 133     private static final long serialVersionUID = 1L;
 134
 135     private static final String UNDOCK = "undock";
 136     private static final String HELP = "help";
 137
 138     private Integer id;
 139
 140     private boolean eventEnabled = false;
 141
 142     static {
 143         PropertyChangeListenerFactory.addFactory(new BarUpdater.UpdateBarFactory());
 144     }
 145
 146     private String parentWindowId;
 147     private MenuBar menuBar;
 148     private ToolBar toolBar;
 149     private TextBox infoBar;
 150     private String helpID;
 151     private boolean paintEnable = true;
 152
 153     /** Contains the canvas and widgets */
 154     private JLayeredPane uiContentPane;
 155     private JLayeredPane layerdPane;
 156
 157     /** Scroll the axes */
 158     private SwingScilabScrollPane scrolling;
 159
 160     private Image icon;
 161
 162     private Action closeAction;
 163
 164     /** The listener for event handling */
 165     private ScilabEventListener eventHandler;
 166     private EditorEventListener editorEventHandler = null;
 167
 168     /** A reference to the canvas used for event handling management */
 169     private SwingScilabCanvas contentCanvas = null;
 170
 171     /**
 172      * Constructor
 173      * @param name the name of the tab
 174      * @param uuid an uuid to identify the tab
 175      */
 176     public SwingScilabDockablePanel(String name, String uuid) {
 177         super(uuid, name, name);
 178         //This button is "overloaded" when we add a callback
 179         //this.addAction(DockingConstants.CLOSE_ACTION);
 180         // Removed because make JOGL crash when "Unpin"
 181         //this.addAction(DockingConstants.PIN_ACTION);
 182         this.addAction(DockingConstants.ACTIVE_WINDOW);
 183
 184         // no need for an axes
 185         contentPane = null;
 186         uiContentPane = null;
 187         scrolling = null;
 188
 189         this.setVisible(true);
 190         setOpaque(true);
 191
 192         getTitlebar().addFocusListener(this);
 193         addFocusListener(this);
 194         setCallback(null);
 195
 196         getInputMap(WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("shift F6"), ACTION_TOGGLE_PREVIOUS);
 197     }
 198
 199     /**
 200      * Create a graphic tab used to display a figure with 3D graphics and/or UIcontrols
 201      * @param name name of the tab
 202      * @param figureId id of the displayed figure
 203      */
 204     public SwingScilabDockablePanel(String name, int figureId) {
 205         super(name, name, name);
 206
 207         // This button is "overloaded" when we add a callback
 208         //this.addAction(DockingConstants.CLOSE_ACTION);
 209         // Removed because make JOGL crash when "Unpin"
 210         //this.addAction(DockingConstants.PIN_ACTION);
 211         this.addAction(DockingConstants.ACTIVE_WINDOW);
 212
 213         // create the panel in which all the uiobjects will lie.
 214         //contentPane = new SwingScilabAxes(figureId);
 215
 216         // add it inside a JSCrollPane
 217         //scrolling = new SwingScilabScrollPane(contentPane);
 218         //scrolling.setBackground(1, 0, 0);
 219         // put in in the back of the tab
 220         //setContentPane(scrolling.getAsContainer());
 221
 222         this.setVisible(true);
 223         setOpaque(true);
 224
 225         getTitlebar().addFocusListener(this);
 226         addFocusListener(this);
 227         setCallback(null);
 228
 229         getInputMap(WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("shift F6"), ACTION_TOGGLE_PREVIOUS);
 230     }
 231
 232     /**
 233      * Constructor
 234      * @param name the name of the tab (used to identify it)
 235      */
 236     public SwingScilabDockablePanel(String name) {
 237         this(name, name);
 238     }
 239
 240     /**
 241      * Set the associated help page
 242      * @param helpID the xml id of the associated help page
 243      */
 244     public void setAssociatedXMLIDForHelp(String helpID) {
 245         this.helpID = helpID;
 246     }
 247
 248     /**
 249      * Get the associated help page
 250      * @return the xml id of the associated help page
 251      */
 252     public String getAssociatedXMLIDForHelp() {
 253         return helpID;
 254     }
 255
 256     public static void removeActions(SwingScilabDockablePanel tab) {
 257         tab.setActionBlocked(DockingConstants.CLOSE_ACTION, true);
 258         tab.setActionBlocked(UNDOCK, true);
 259         if (tab.getTitlebar() != null) {
 260             tab.getTitlebar().revalidate();
 261         }
 262     }
 263
 264     public static void addActions(SwingScilabDockablePanel tab) {
 265         tab.setActionBlocked(DockingConstants.CLOSE_ACTION, false);
 266         tab.setActionBlocked(UNDOCK, false);
 267         tab.getTitlebar().revalidate();
 268     }
 269
 270     public SwingScilabDockablePanel(String figureTitle, int figureId, final Figure figure) {
 271         this(figureTitle, figureId);
 272         /* OpenGL context */
 273         //SwingScilabCanvas canvas = new SwingScilabCanvas(figureId, figure);
 274         //contentCanvas = canvas;
 275
 276         editorEventHandler = new EditorEventListener(figure.getIdentifier());
 277         //contentCanvas.addEventHandlerKeyListener(editorEventHandler);
 278         //contentCanvas.addEventHandlerMouseListener(editorEventHandler);
 279         //contentCanvas.addEventHandlerMouseMotionListener(editorEventHandler);
 280
 281         layerdPane = new JLayeredPane();
 282         layerdPane.setLayout(null);
 283         layerdPane.setBorder(null);
 284         //layerdPane.add(canvas, JLayeredPane.FRAME_CONTENT_LAYER);
 285         uiContentPane = new JLayeredPane();
 286         uiContentPane.setOpaque(true);
 287         uiContentPane.setLayout(null);
 288         uiContentPane.setBorder(null);
 289         layerdPane.add(uiContentPane, JLayeredPane.DEFAULT_LAYER + 1, 0);
 290
 291         scrolling = new SwingScilabScrollPane(layerdPane, uiContentPane, figure);
 292         //scrolling.setCanvas(canvas);
 293
 294         //contentCanvas.addKeyListener(this);
 295
 296         setContentPane(scrolling.getAsContainer());
 297         //setContentPane(uiContentPane);
 298         //canvas.setVisible(true);
 299         uiContentPane.setVisible(true);
 300
 301         /* Manage figure_position property */
 302         addHierarchyBoundsListener(new HierarchyBoundsListener() {
 303             public void ancestorResized(HierarchyEvent arg0) {
 304             }
 305
 306             public void ancestorMoved(HierarchyEvent e) {
 307                 if (e.getChanged() instanceof SwingScilabWindow) {
 308                     Position parentPosition = SwingScilabWindow.allScilabWindows.get(parentWindowId).getPosition();
 309                     Integer[] newPosition = new Integer[] {parentPosition.getX(), parentPosition.getY()};
 310                     GraphicController.getController().setProperty(id, __GO_POSITION__, newPosition);
 311                 }
 312             }
 313         });
 314
 315         /* Manage figure_size property */
 316         addComponentListener(new ComponentListener() {
 317
 318             public void componentShown(ComponentEvent arg0) {
 319             }
 320
 321             public void componentResized(ComponentEvent arg0) {
 322
 323                 /* Update the figure_size property */
 324                 Size parentSize =  SwingScilabWindow.allScilabWindows.get(parentWindowId).getDims();
 325                 Integer[] newSize = new Integer[] {parentSize.getWidth(), parentSize.getHeight()};
 326
 327                 GraphicController.getController().setProperty(id, __GO_SIZE__, newSize);
 328
 329                 Boolean autoreSize = (Boolean) GraphicController.getController().getProperty(id, __GO_AUTORESIZE__);
 330
 331                 if (autoreSize != null && autoreSize) {
 332                     /* Update the axes_size property */
 333                     Integer[] newAxesSize = new Integer[] {getContentPane().getWidth(), getContentPane().getHeight()};
 334                     GraphicController.getController().setProperty(id, __GO_AXES_SIZE__, newAxesSize);
 335                 }
 336             }
 337
 338             public void componentMoved(ComponentEvent arg0) {
 339             }
 340
 341             public void componentHidden(ComponentEvent arg0) {
 342             }
 343         });
 344
 345         /* Manage closerequestfcn */
 346         ClosingOperationsManager.registerClosingOperation(SwingScilabDockablePanel.this, new ClosingOperationsManager.ClosingOperation() {
 347
 348             public int canClose() {
 349                 String closeRequestFcn = (String) GraphicController.getController().getProperty(getId(), __GO_CLOSEREQUESTFCN__);
 350                 if (!closeRequestFcn.equals("")) {
 351                     String closeCommand = "if exists(\"gcbo\") then %oldgcbo = gcbo; end;"
 352                                           + "gcbo = getcallbackobject(" + getId() + ");"
 353                                           + closeRequestFcn + ";fire_closing_finished();"
 354                                           + ";if exists(\"%oldgcbo\") then gcbo = %oldgcbo; else clear gcbo; end;";
 355                     InterpreterManagement.putCommandInScilabQueue(closeCommand);
 356                     return -1;
 357                 } else {
 358                     closeAction.actionPerformed(null);
 359                     return 1;
 360                 }
 361             }
 362
 363             public void destroy() {
 364             }
 365
 366             public String askForClosing(final List<SwingScilabDockablePanel> list) {
 367                 return null;
 368             }
 369
 370             @Override
 371             public void updateDependencies(List<SwingScilabDockablePanel> list, ListIterator<SwingScilabDockablePanel> it) {
 372
 373             }
 374         });
 375         ClosingOperationsManager.addDependencyWithRoot(this);
 376     }
 377
 378     /**
 379      * @param e the FocusEvent
 380      */
 381     @Override
 382     public void focusGained(FocusEvent e) {
 383         //ActiveDockableTracker.requestDockableActivation(this);
 384         if (contentPane != null) {
 385             contentPane.requestFocus();
 386         } else if (getContentPane() != null) {
 387             getContentPane().requestFocus();
 388         } else {
 389             SwingScilabDockablePanel.this.requestFocusInWindow();
 390         }
 391     }
 392
 393     /**
 394      * Call when the tab restoration is ended.
 395      */
 396     public void endedRestoration() { }
 397
 398     /**
 399      * @return the window icon associated with this tab
 400      */
 401     public Image getWindowIcon() {
 402         if (icon == null) {
 403             return SCILAB_ICON;
 404         } else {
 405             return icon;
 406         }
 407     }
 408
 409     /**
 410      * @param icon the window icon associated with this tab
 411      */
 412     public void setWindowIcon(Image icon) {
 413         this.icon = icon;
 414     }
 415
 416     /**
 417      * @param iconName window icon associated with this tab
 418      */
 419     public void setWindowIcon(String iconName) {
 420         setWindowIcon(new ImageIcon(FindIconHelper.findIcon(iconName, "256x256")).getImage());
 421     }
 422
 423     /**
 424      * @param e the FocusEvent
 425      */
 426     @Override
 427     public void focusLost(FocusEvent e) { }
 428
 429     /**
 430      * {@inheritDoc}
 431      */
 432     @Override
 433     public void dockingComplete(DockingEvent evt) {
 434         super.dockingComplete(evt);
 435
 436         DockingPort port = evt.getNewDockingPort();
 437         SwingScilabWindow win = (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, (Component) port);
 438         Iterator iter = port.getDockables().iterator();
 439
 440         if (port.getDockables().size() > 1) {
 441             while (iter.hasNext()) {
 442                 Object d = iter.next();
 443                 if (d instanceof SwingScilabDockablePanel) {
 444                     SwingScilabDockablePanel view = (SwingScilabDockablePanel) d;
 445                     addActions(view);
 446                 }
 447             }
 448         } else {
 449             removeActions(this);
 450         }
 451
 452         if (win != null) {
 453             setParentWindowId(win.getId());
 454         } else {
 455             // Should not occur
 456             SwingUtilities.invokeLater(new Runnable() {
 457                 public void run() {
 458                     if (getParentWindow() != null) {
 459                         setParentWindowId(getParentWindow().getId());
 460                     } else {
 461                         System.err.println("No window for tab:" + SwingScilabDockablePanel.this.getClass().getName() + " after docking complete");
 462                     }
 463                 }
 464             });
 465         }
 466     }
 467
 468     /**
 469      * Sets the Name of a swing Scilab tab
 470      * @param newTabName the Name of the tab
 471      * @see org.scilab.modules.gui.tab.ScilabTab#setName(String)
 472      */
 473     @Override
 474     public void setName(String newTabName) {
 475         setTitle(newTabName, true);
 476         getTitlePane().repaint();
 477         SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, this).setName(newTabName);
 478     }
 479
 480     /**
 481      * @return the UUID of the parent window
 482      */
 483     public String getParentWindowUUID() {
 484         return ((SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, this)).getUUID();
 485     }
 486
 487     /**
 488      * @return the UUID of the parent window
 489      */
 490     public SwingScilabWindow getParentWindow() {
 491         return (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, this);
 492     }
 493
 494     /**
 495      * Gets the title of a swing Scilab tab
 496      * @return the title of the tab
 497      * @see org.scilab.modules.gui.tab.ScilabTab#getName()
 498      */
 499     @Override
 500     public String getName() {
 501         return this.getTitle();
 502     }
 503
 504     /**
 505      * Paint immediately this component
 506      */
 507     public void paintImmediately() {
 508         // paint all
 509         paintImmediately(0, 0, getWidth(), getHeight());
 510     }
 511
 512     /**
 513      * Draws a swing Scilab tab
 514      * @see org.scilab.modules.gui.uielement.UIElement#draw()
 515      */
 516     @Override
 517     public void draw() {
 518         if (SwingUtilities.isEventDispatchThread()) {
 519             setVisible(true);
 520             paintImmediately();
 521         } else {
 522             try {
 523                 SwingUtilities.invokeAndWait(new Runnable() {
 524                     @Override
 525                     public void run() {
 526                         setVisible(true);
 527                         paintImmediately();
 528                     }
 529                 });
 530             } catch (InterruptedException e) {
 531                 e.printStackTrace();
 532             } catch (InvocationTargetException e) {
 533                 e.printStackTrace();
 534             }
 535         }
 536
 537     }
 538
 539     /**
 540      * Gets the dimensions (width and height) of a swing Scilab tab
 541      * @return the dimensions of the tab
 542      * @see org.scilab.modules.gui.uielement.UIElement#getDims()
 543      */
 544     @Override
 545     public Size getDims() {
 546         return new Size(this.getSize().width, this.getSize().height);
 547     }
 548
 549     /**
 550      * Get the size for the axes
 551      * @return size of the axes in pixels
 552      */
 553     @Override
 554     public Size getAxesSize() {
 555         return new Size(contentPane.getWidth(), contentPane.getHeight());
 556     }
 557
 558     /**
 559      * @param newSize new size to set for the axes
 560      */
 561     @Override
 562     public void setAxesSize(Size newSize) {
 563         contentPane.setSize(new Dimension(newSize.getWidth(), newSize.getHeight()));
 564         uiContentPane.setSize(new Dimension(newSize.getWidth(), newSize.getHeight()));
 565     }
 566
 567     /**
 568      * Gets the position (X-coordinate and Y-coordinate) of a swing Scilab tab
 569      * @return the position of the tab
 570      * @see org.scilab.modules.gui.uielement.UIElement#getPosition()
 571      */
 572     @Override
 573     public Position getPosition() {
 574         return new Position(this.getX(), this.getY());
 575     }
 576
 577     /**
 578      * Sets the dimensions (width and height) of a swing Scilab tab
 579      * @param newSize the dimensions we want to set to the tab
 580      * @see org.scilab.modules.gui.uielement.UIElement#setDims(org.scilab.modules.gui.utils.Size)
 581      */
 582     @Override
 583     public void setDims(Size newSize) {
 584         this.setSize(newSize.getWidth(), newSize.getHeight());
 585     }
 586
 587     /**
 588      * Sets the position (X-coordinate and Y-coordinate) of a swing Scilab tab
 589      * @param newPosition the position we want to set to the tab
 590      * @see org.scilab.modules.gui.uielement.UIElement#setPosition(org.scilab.modules.gui.utils.Position)
 591      */
 592     @Override
 593     public void setPosition(Position newPosition) {
 594         this.setLocation(newPosition.getX(), newPosition.getY());
 595     }
 596
 597     /**
 598      * Add a member (dockable element) to container and returns its index
 599      * @param member the member to add
 600      * @return index of member in ArrayList
 601      */
 602     @Override
 603     public int addMember(Canvas member) {
 604         return 0;
 605     }
 606
 607     /**
 608      * We want to be able to remove directly a Canvas from a Tab.
 609      * @param member canvas to remove
 610      */
 611     @Override
 612     public void removeMember(Canvas member) {
 613     }
 614
 615     /**
 616      * Add a SwingViewObject (from SwingView.java) to container and returns its index
 617      * @param member the member to add
 618      */
 619     public void addMember(SwingViewObject member) {
 620         if (member instanceof SwingScilabAxes) {
 621             if (contentCanvas == null) {
 622                 contentCanvas = new SwingScilabCanvas((Figure) GraphicController.getController().getObjectFromId(((SwingScilabAxes) member).getFigureId()));
 623                 contentCanvas.addEventHandlerKeyListener(editorEventHandler);
 624                 contentCanvas.addEventHandlerMouseListener(editorEventHandler);
 625                 contentCanvas.addEventHandlerMouseMotionListener(editorEventHandler);
 626
 627                 layerdPane.add(contentCanvas, JLayeredPane.FRAME_CONTENT_LAYER);
 628
 629                 scrolling.setCanvas(contentCanvas);
 630                 contentCanvas.addKeyListener(this);
 631             }
 632             return;
 633         }
 634
 635         SwingScilabCommonPanel.addMember(this, member);
 636     }
 637
 638     /**
 639      * Remove a SwingViewObject (from SwingView.java)
 640      * @param member the member to remove
 641      */
 642     public void removeMember(SwingViewObject member) {
 643         SwingScilabCommonPanel.removeMember(this, member);
 644     }
 645
 646     /**
 647      * Add a member (dockable element) to container and returns its index
 648      * @param member the member to add
 649      * @return index of member in ArrayList
 650      */
 651     @Override
 652     public int addMember(Console member) {
 653         return this.addMember((SwingScilabConsole) member.getAsSimpleConsole());
 654     }
 655
 656     /**
 657      * Add a member (dockable element) to container and returns its index
 658      * @param member the member to add
 659      * @return index of member in ArrayList
 660      */
 661     private int addMember(SwingScilabConsole member) {
 662         // replace the current content pane
 663         this.setContentPane(member);
 664         return this.getComponentZOrder(member);
 665     }
 666
 667     /**
 668      * Add a member (dockable element) to container and returns its index
 669      * @param member the member to add
 670      * @return index of member in ArrayList
 671      */
 672     @Override
 673     public int addMember(HelpBrowser member) {
 674         return this.addMember((SwingScilabHelpBrowser) member.getAsSimpleHelpBrowser());
 675     }
 676
 677     /**
 678      * Add a member (dockable element) to container and returns its index
 679      * @param member the member to add
 680      * @return index of member in ArrayList
 681      */
 682     private int addMember(SwingScilabHelpBrowser member) {
 683         // replace the current content pane
 684         this.setContentPane(member);
 685         return this.getComponentZOrder(member);
 686     }
 687
 688     /**
 689      * Add a member (dockable element) to container and returns its index
 690      * @param member the member to add
 691      * @return index of member in ArrayList
 692      */
 693     @Override
 694     public int addMember(Frame member) {
 695         SimpleFrame frame = member.getAsSimpleFrame();
 696         if (frame instanceof SwingScilabFrame) {
 697             return this.addMember((SwingScilabFrame) member.getAsSimpleFrame());
 698         } else {
 699             return this.addMember((SwingScilabScrollableFrame) member.getAsSimpleFrame());
 700         }
 701     }
 702
 703     /**
 704      * Add a member (dockable element) to container and returns its index
 705      * @param member the member to add
 706      * @return index of member in ArrayList
 707      */
 708     private int addMember(SwingScilabScrollableFrame member) {
 709         return 0;
 710     }
 711
 712     private int addMember(SwingScilabFrame member) {
 713         return 0;
 714     }
 715
 716     /**
 717      * Remove a Frame from its container
 718      * @param member the Frame to remove
 719      */
 720     @Override
 721     public void removeMember(Frame member) {
 722         SimpleFrame frame = member.getAsSimpleFrame();
 723         if (frame instanceof SwingScilabFrame) {
 724             this.removeMember((SwingScilabFrame) member.getAsSimpleFrame());
 725         } else {
 726             this.removeMember((SwingScilabScrollableFrame) member.getAsSimpleFrame());
 727         }
 728     }
 729
 730     /**
 731      * Remove a Frame from its container
 732      * @param member the Frame to remove
 733      */
 734     private void removeMember(SwingScilabScrollableFrame member) {
 735     }
 736
 737     private void removeMember(SwingScilabFrame member) {
 738     }
 739
 740     /**
 741      * Add a member (dockable element) to container and returns its index
 742      * @param member the member to add
 743      * @return index of member in ArrayList
 744      */
 745     @Override
 746     public int addMember(PushButton member) {
 747         return this.addMember((SwingScilabPushButton) member.getAsSimplePushButton());
 748     }
 749
 750     /**
 751      * Add a member (dockable element) to container and returns its index
 752      * @param member the member to add
 753      * @return index of member in ArrayList
 754      */
 755     private int addMember(SwingScilabPushButton member) {
 756         repaint();
 757         return 0;
 758     }
 759
 760     /**
 761      * Remove a PushButton from its container
 762      * @param member the PushButton to remove
 763      */
 764     @Override
 765     public void removeMember(PushButton member) {
 766         this.removeMember((SwingScilabPushButton) member.getAsSimplePushButton());
 767     }
 768
 769     /**
 770      * Remove a PushButton from its container
 771      * @param member the PushButton to remove
 772      */
 773     private void removeMember(SwingScilabPushButton member) {
 774         contentPane.remove(member);
 775     }
 776
 777     /**
 778      * Add a member (dockable element) to container and returns its index
 779      * @param member the member to add
 780      * @return index of member in ArrayList
 781      */
 782     @Override
 783     public int addMember(EditBox member) {
 784         return this.addMember((SwingScilabEditBox) member.getAsSimpleEditBox());
 785     }
 786
 787     /**
 788      * Add a member (dockable element) to container and returns its index
 789      * @param member the member to add
 790      * @return index of member in ArrayList
 791      */
 792     private int addMember(SwingScilabEditBox member) {
 793         return 0;
 794     }
 795
 796     /**
 797      * Remove an EditBox from its container
 798      * @param member the EditBox to remove
 799      */
 800     @Override
 801     public void removeMember(EditBox member) {
 802         this.removeMember((SwingScilabEditBox) member.getAsSimpleEditBox());
 803     }
 804
 805     /**
 806      * Remove an EditBox from its container
 807      * @param member the EditBox to remove
 808      */
 809     private void removeMember(SwingScilabEditBox member) {
 810     }
 811
 812     /**
 813      * Add a member (dockable element) to container and returns its index
 814      * @param member the member to add
 815      * @return index of member in ArrayList
 816      */
 817     @Override
 818     public int addMember(Label member) {
 819         return this.addMember((SwingScilabLabel) member.getAsSimpleLabel());
 820     }
 821
 822     /**
 823      * Add a member (dockable element) to container and returns its index
 824      * @param member the member to add
 825      * @return index of member in ArrayList
 826      */
 827     private int addMember(SwingScilabLabel member) {
 828         return 0;
 829     }
 830
 831     /**
 832      * Remove a Label from its container
 833      * @param member the Label to remove
 834      */
 835     @Override
 836     public void removeMember(Label member) {
 837         this.removeMember((SwingScilabLabel) member.getAsSimpleLabel());
 838     }
 839
 840     /**
 841      * Remove a Label from its container
 842      * @param member the Label to remove
 843      */
 844     private void removeMember(SwingScilabLabel member) {
 845     }
 846
 847     /**
 848      * Add a member (dockable element) to container and returns its index
 849      * @param member the member to add
 850      * @return index of member in ArrayList
 851      */
 852     @Override
 853     public int addMember(CheckBox member) {
 854         return this.addMember((SwingScilabCheckBox) member.getAsSimpleCheckBox());
 855     }
 856
 857     /**
 858      * Add a member (dockable element) to container and returns its index
 859      * @param member the member to add
 860      * @return index of member in ArrayList
 861      */
 862     private int addMember(SwingScilabCheckBox member) {
 863         return 0;
 864     }
 865
 866     /**
 867      * Remove a CheckBox from its container
 868      * @param member the CheckBox to remove
 869      */
 870     @Override
 871     public void removeMember(CheckBox member) {
 872         this.removeMember((SwingScilabCheckBox) member.getAsSimpleCheckBox());
 873     }
 874
 875     /**
 876      * Remove a CheckBox from its container
 877      * @param member the CheckBox to remove
 878      */
 879     private void removeMember(SwingScilabCheckBox member) {
 880     }
 881
 882     /**
 883      * Add a member (dockable element) to container and returns its index
 884      * @param member the member to add
 885      * @return index of member in ArrayList
 886      */
 887     @Override
 888     public int addMember(RadioButton member) {
 889         return this.addMember((SwingScilabRadioButton) member.getAsSimpleRadioButton());
 890     }
 891
 892     /**
 893      * Add a member (dockable element) to container and returns its index
 894      * @param member the member to add
 895      * @return index of member in ArrayList
 896      */
 897     private int addMember(SwingScilabRadioButton member) {
 898         return 0;
 899     }
 900
 901     /**
 902      * Remove a RadioButton from its container
 903      * @param member the RadioButton to remove
 904      */
 905     @Override
 906     public void removeMember(RadioButton member) {
 907         this.removeMember((SwingScilabRadioButton) member.getAsSimpleRadioButton());
 908     }
 909
 910     /**
 911      * Remove a RadioButton from its container
 912      * @param member the RadioButton to remove
 913      */
 914     private void removeMember(SwingScilabRadioButton member) {
 915     }
 916
 917     /**
 918      * Add a member (dockable element) to container and returns its index
 919      * @param member the member to add
 920      * @return index of member in ArrayList
 921      */
 922     private int addMember(SwingScilabUiImage member) {
 923         return 0;
 924     }
 925
 926     /**
 927      * Remove a Image from its container
 928      * @param member the Image to remove
 929      */
 930     private void removeMember(SwingScilabUiImage member) {
 931     }
 932
 933     /**
 934      * Add a member (dockable element) to container and returns its index
 935      * @param member the member to add
 936      * @return index of member in ArrayList
 937      */
 938     public int addMember(UiDisplayTree member) {
 939         return this.addMember((SwingScilabUiDisplayTree) member.getAsSimpleUiDisplayTree());
 940     }
 941
 942     /**
 943      * Add a member (dockable element) to container and returns its index
 944      * @param member the member to add
 945      * @return index of member in ArrayList
 946      */
 947     private int addMember(SwingScilabUiDisplayTree member) {
 948         return 0;
 949     }
 950
 951     /**
 952      * Remove a Tree from its container
 953      * @param member the Tree to remove
 954      */
 955     public void removeMember(UiDisplayTree member) {
 956         this.removeMember((SwingScilabUiDisplayTree) member.getAsSimpleUiDisplayTree());
 957     }
 958
 959     /**
 960      * Remove a Tree from its container
 961      * @param member the Tree to remove
 962      */
 963     private void removeMember(SwingScilabUiDisplayTree member) {
 964     }
 965
 966     /**
 967      * Add a member (dockable element) to container and returns its index
 968      * @param member the member to add
 969      * @return index of member in ArrayList
 970      */
 971     public int addMember(UiTable member) {
 972         return this.addMember((SwingScilabUiTable) member.getAsSimpleUiTable());
 973     }
 974
 975     /**
 976      * Add a member (dockable element) to container and returns its index
 977      * @param member the member to add
 978      * @return index of member in ArrayList
 979      */
 980     private int addMember(SwingScilabUiTable member) {
 981         return 0;
 982     }
 983
 984     /**
 985      * Remove a UiTable from its container
 986      * @param member the UiTable to remove
 987      */
 988     public void removeMember(UiTable member) {
 989         this.removeMember((SwingScilabUiTable) member.getAsSimpleUiTable());
 990     }
 991
 992     /**
 993      * Remove a UiTable from its container
 994      * @param member the UiTable to remove
 995      */
 996     private void removeMember(SwingScilabUiTable member) {
 997     }
 998
 999     /**
1000      * Add a member (dockable element) to container and returns its index
1001      * @param member the member to add
1002      * @return index of member in ArrayList
1003      */
1004     public int addMember(Slider member) {
1005         return this.addMember((SwingScilabScroll) member.getAsSimpleSlider());
1006     }
1007
1008     /**
1009      * Add a member (dockable element) to container and returns its index
1010      * @param member the member to add
1011      * @return index of member in ArrayList
1012      */
1013     private int addMember(SwingScilabScroll member) {
1014         return 0;
1015     }
1016
1017     /**
1018      * Remove a Slider from its container
1019      * @param member the Slider to remove
1020      */
1021     @Override
1022     public void removeMember(Slider member) {
1023         this.removeMember((SwingScilabScroll) member.getAsSimpleSlider());
1024     }
1025
1026     /**
1027      * Remove a Slider from its container
1028      * @param member the Slider to remove
1029      */
1030     private void removeMember(SwingScilabScroll member) {
1031     }
1032
1033     /**
1034      * Add a member (dockable element) to container and returns its index
1035      * @param member the member to add
1036      * @return index of member in ArrayList
1037      */
1038     @Override
1039     public int addMember(ListBox member) {
1040         return this.addMember((SwingScilabListBox) member.getAsSimpleListBox());
1041     }
1042
1043     /**
1044      * Add a member (dockable element) to container and returns its index
1045      * @param member the member to add
1046      * @return index of member in ArrayList
1047      */
1048     private int addMember(SwingScilabListBox member) {
1049         return 0;
1050     }
1051
1052     /**
1053      * Remove a ListBox from its container
1054      * @param member the ListBox to remove
1055      */
1056     @Override
1057     public void removeMember(ListBox member) {
1058         this.removeMember((SwingScilabListBox) member.getAsSimpleListBox());
1059     }
1060
1061     /**
1062      * Remove a ListBox from its container
1063      * @param member the ListBox to remove
1064      */
1065     private void removeMember(SwingScilabListBox member) {
1066     }
1067
1068     /**
1069      * Add a member (dockable element) to container and returns its index
1070      * @param member the member to add
1071      * @return index of member in ArrayList
1072      */
1073     @Override
1074     public int addMember(PopupMenu member) {
1075         return this.addMember((SwingScilabPopupMenu) member.getAsSimplePopupMenu());
1076     }
1077
1078     /**
1079      * Add a member (dockable element) to container and returns its index
1080      * @param member the member to add
1081      * @return index of member in ArrayList
1082      */
1083     private int addMember(SwingScilabPopupMenu member) {
1084         return 0;
1085     }
1086
1087     /**
1088      * Remove a PopupMenu from its container
1089      * @param member the PopupMenu to remove
1090      */
1091     @Override
1092     public void removeMember(PopupMenu member) {
1093         this.removeMember((SwingScilabPopupMenu) member.getAsSimplePopupMenu());
1094     }
1095
1096     /**
1097      * Remove a PopupMenu from its container
1098      * @param member the PopupMenu to remove
1099      */
1100     private void removeMember(SwingScilabPopupMenu member) {
1101     }
1102
1103     /**
1104      * Add a Tree member (dockable element) to container and returns its index
1105      * @param member the member to add
1106      * @return index of member in ArrayList
1107      */
1108     @Override
1109     public int addMember(Tree member) {
1110         return this.addMember((SwingScilabTree) member.getAsSimpleTree());
1111     }
1112
1113     /**
1114      * Add a Tree member (dockable element) to container and returns its index
1115      * @param member the member to add
1116      * @return index of member in ArrayList
1117      */
1118     public int addMember(SwingScilabTree member) {
1119         return 0;
1120     }
1121
1122     /**
1123      * Add a Tree member (dockable element) to container and returns its index
1124      * @param member the member to add
1125      * @return index of member in ArrayList
1126      */
1127     public int addTree(SwingScilabTree member) {
1128         this.setContentPane(member.getAsComponent());
1129         return this.getComponentZOrder(member.getAsComponent());
1130     }
1131
1132     /**
1133      * Remove a PopupMenu from its container
1134      * @param member the PopupMenu to remove
1135      */
1136     @Override
1137     public void removeMember(Tree member) {
1138         this.removeMember((SwingScilabTree) member.getAsSimpleTree());
1139     }
1140
1141     /**
1142      * Remove a PopupMenu from its container
1143      * @param member the PopupMenu to remove
1144      */
1145     private void removeMember(SwingScilabTree member) {
1146     }
1147
1148     /**
1149      * Add a member (dockable element) to container and returns its index
1150      * @param member the member to add
1151      * @return index of member in ArrayList
1152      */
1153     public int addMember(Dockable member) {
1154         // TODO Auto-generated method stub
1155         return 0;
1156     }
1157
1158     /**
1159      * Get the current status of the Tab in its parent
1160      * @return true is the tab is the tab currently "on top" in its parent
1161      */
1162     @Override
1163     public boolean isCurrentTab() {
1164         // TODO should not always return TRUE
1165         return true;
1166     }
1167
1168     /**
1169      * Get the parent window id for this tab
1170      * @return the id of the parent window
1171      */
1172     @Override
1173     public String getParentWindowId() {
1174         return this.parentWindowId;
1175     }
1176
1177     /**
1178      * Get the canvas
1179      * @return the canvas
1180      */
1181     public SwingScilabCanvas getContentCanvas() {
1182         return contentCanvas;
1183     }
1184
1185     /**
1186      * Set the parent window id for this tab
1187      * @param id the id of the parent window
1188      */
1189     @Override
1190     public void setParentWindowId(String id) {
1191         this.parentWindowId = id;
1192     }
1193
1194     /**
1195      * Setter for MenuBar
1196      * @param newMenuBar : the MenuBar to set.
1197      * @see org.scilab.modules.gui.tab.SimpleTab#setMenuBar(org.scilab.modules.gui.menubar.MenuBar)
1198      */
1199     @Override
1200     public void setMenuBar(MenuBar newMenuBar) {
1201         if (this.menuBar != newMenuBar) {
1202             if (this.menuBar != null) {
1203                 ((SwingScilabMenuBar) this.menuBar.getAsSimpleMenuBar()).close();
1204             }
1205             this.menuBar = newMenuBar;
1206         }
1207     }
1208
1209     /**
1210      * Getter for MenuBar
1211      * @return MenuBar : the MenuBar associated to the Tab.
1212      * @see org.scilab.modules.gui.tab.SimpleTab#getMenuBar()
1213      */
1214     @Override
1215     public MenuBar getMenuBar() {
1216         return this.menuBar;
1217     }
1218
1219     /**
1220      * Setter for ToolBar
1221      * @param newToolBar : the ToolBar to set.
1222      * @see org.scilab.modules.gui.tab.SimpleTab#setToolBar(org.scilab.modules.gui.toolbar.ToolBar)
1223      */
1224     @Override
1225     public void setToolBar(ToolBar newToolBar) {
1226         this.toolBar = newToolBar;
1227     }
1228
1229     /**
1230      * Getter for ToolBar
1231      * @return ToolBar : the ToolBar associated to the Tab.
1232      * @see org.scilab.modules.gui.tab.SimpleTab#getToolBar()
1233      */
1234     @Override
1235     public ToolBar getToolBar() {
1236         return this.toolBar;
1237     }
1238
1239     /**
1240      * Setter for InfoBar
1241      * @param newInfoBar the InfoBar to set.
1242      */
1243     @Override
1244     public void setInfoBar(TextBox newInfoBar) {
1245         this.infoBar = newInfoBar;
1246     }
1247
1248     /**
1249      * Getter for InfoBar
1250      * @return the InfoBar associated to the Tab.
1251      */
1252     @Override
1253     public TextBox getInfoBar() {
1254         return this.infoBar;
1255     }
1256
1257     /**
1258      * Set the callback of the tab
1259      * @param callback the callback to set.
1260      */
1261     @Override
1262     public void setCallback(CommonCallBack callback) {
1263
1264         if (closeAction != null) {
1265             this.getTitlebar().removeAction(closeAction);
1266         }
1267
1268         if (callback != null) {
1269             closeAction = new SciClosingAction(this, callback);
1270         } else {
1271             closeAction = new SciClosingAction(this);
1272         }
1273
1274         closeAction.putValue(Action.NAME, DockingConstants.CLOSE_ACTION);
1275         ((Titlebar) getTitlePane()).removeAction(DockingConstants.CLOSE_ACTION);
1276         addAction(closeAction);
1277
1278         /* Undock button */
1279         SciUndockingAction undockAction = new SciUndockingAction(this);
1280         undockAction.putValue(Action.NAME, UNDOCK);
1281         ((Titlebar) getTitlePane()).removeAction(UNDOCK);
1282         addAction(undockAction);
1283
1284         /* Help button */
1285         SciHelpOnComponentAction helpAction = new SciHelpOnComponentAction(this);
1286         helpAction.putValue(Action.NAME, HELP);
1287         ((Titlebar) getTitlePane()).removeAction(HELP);
1288         addAction(helpAction);
1289     }
1290
1291     /**
1292      * Set this tab as the current tab of its parent Window
1293      */
1294     @Override
1295     public void setCurrent() {
1296         ActiveDockableTracker.requestDockableActivation(this);
1297     }
1298
1299     /**
1300      * Set the background color of the tab.
1301      * @param red red channel of the color
1302      * @param green green channel
1303      * @param blue blue channel
1304      */
1305     @Override
1306     public void setBackground(double red, double green, double blue) {
1307         Color newColor = new Color((float) red, (float) green, (float) blue);
1308         uiContentPane.setBackground(newColor);
1309         scrolling.setBackground(red, green, blue);
1310         setBackground(newColor);
1311     }
1312
1313     /**
1314      * Get the part of the axes which is currently viewed
1315      * @return [x,y,w,h] array
1316      */
1317     @Override
1318     public int[] getViewingRegion() {
1319         return scrolling.getViewingRegion();
1320     }
1321
1322     /**
1323      * Specify a new viewport for the axes
1324      * For SwingScilabCanvas viewport can not be modified
1325      * since it match the parent tab size
1326      * @param posX X coordinate of upper left point of the viewport within the axes
1327      * @param posY Y coordinate of upper left point of the viewport within the axes
1328      * @param width width of the viewport
1329      * @param height height of the viewport
1330      */
1331     @Override
1332     public void setViewingRegion(int posX, int posY, int width, int height) {
1333     }
1334
1335     /**
1336      * Set the event handler of the Canvas
1337      * @param funName the name of the Scilab function to call
1338      */
1339     public void setEventHandler(String funName) {
1340         disableEventHandler();
1341         eventHandler = new ScilabEventListener(funName, getId());
1342         if (eventEnabled) {
1343             editorEventHandler.setEnable(false);
1344             enableEventHandler();
1345         }
1346     }
1347
1348     /**
1349      * Set the status of the event handler of the Canvas
1350      * @param status is true to set the event handler active
1351      */
1352     public void setEventHandlerEnabled(boolean status) {
1353         if (status && eventEnabled) {
1354             return;
1355         }
1356
1357         if (status) {
1358             editorEventHandler.setEnable(false);
1359             enableEventHandler();
1360             eventEnabled = true;
1361         } else {
1362             editorEventHandler.setEnable(true);
1363             disableEventHandler();
1364             eventEnabled = false;
1365         }
1366     }
1367
1368     /**
1369      * Specify whether the canvas should fit the parent tab size
1370      * (and consequently the scrollpane size) or not
1371      * @param onOrOff true to enable autoresize mode
1372      */
1373     @Override
1374     public void setAutoResizeMode(boolean onOrOff) {
1375     }
1376
1377     /**
1378      * @return whether the resize mode is on or off
1379      */
1380     @Override
1381     public boolean getAutoResizeMode() {
1382         return true;
1383     }
1384
1385     /**
1386      * Close the tab and disable it.
1387      */
1388     public void close() {
1389         if (getTitlePane() != null) {
1390             ((Titlebar) getTitlePane()).removeAction(DockingConstants.CLOSE_ACTION);
1391             ((Titlebar) getTitlePane()).removeAction(UNDOCK);
1392             ((Titlebar) getTitlePane()).removeAction(HELP);
1393         }
1394
1395         if (closeAction != null) {
1396             getTitlebar().removeAction(closeAction);
1397             if (closeAction instanceof SciClosingAction) {
1398                 ((SciClosingAction) closeAction).clean();
1399             }
1400             closeAction = null;
1401         }
1402
1403         setMenuBar(null);
1404         setToolBar(null);
1405         setInfoBar(null);
1406         setTitlebar(null);
1407         removeAll();
1408         //setActive(false);
1409
1410         scrolling = null;
1411         contentPane = null;
1412         DockingManager.unregisterDockable((Component) this);
1413
1414         // without this children canvas are not released.
1415         Container dummyContainer = new Container();
1416         this.setContentPane(dummyContainer);
1417         if (editorEventHandler != null) {
1418             editorEventHandler.onExit();
1419         }
1420     }
1421
1422     public void disablePaint() {
1423         paintEnable = false;
1424     }
1425
1426     /**
1427      * Redefine paint children to be sure that AWT components are well painted.
1428      *  @param g a Graphics
1429      */
1430     @Override
1431     public void paintChildren(Graphics g) {
1432         if (paintEnable) {
1433             Component[] children = getComponents();
1434             for (int i = 0; i < children.length; i++) {
1435                 // AWT children don't draw themselves automatically
1436                 // so force their draw
1437                 if (!children[i].isLightweight()) {
1438                     children[i].paint(g);
1439                 }
1440             }
1441             super.paintChildren(g);
1442         }
1443     }
1444
1445     /**
1446      * Update the tab after a modification of its properties
1447      * @param property the property name
1448      * @param value the property value
1449      * @see org.scilab.modules.gui.SwingViewObject#update(java.lang.String, java.lang.Object)
1450      */
1451     public void update(int property, Object value) {
1452         SwingScilabCommonPanel.update(this, property, value);
1453     }
1454
1455     /**
1456      * Get the tab UID
1457      * @return the UID
1458      * @see org.scilab.modules.gui.SwingViewObject#getId()
1459      */
1460     public Integer getId() {
1461         return id;
1462     }
1463
1464     /**
1465      * Set the tab UID
1466      * @param id the UID
1467      * @see org.scilab.modules.gui.SwingViewObject#setId(java.lang.String)
1468      */
1469     public void setId(Integer id) {
1470         this.id = id;
1471     }
1472
1473     /**
1474      * Turn on event handling.
1475      */
1476     private void enableEventHandler() {
1477         if (contentCanvas != null) {
1478             contentCanvas.addEventHandlerKeyListener(eventHandler);
1479             contentCanvas.addEventHandlerMouseListener(eventHandler);
1480             contentCanvas.addEventHandlerMouseMotionListener(eventHandler);
1481         }
1482     }
1483
1484     /**
1485      * Turn off event handling.
1486      */
1487     private void disableEventHandler() {
1488         if (eventHandler != null && contentCanvas != null) {
1489             contentCanvas.removeEventHandlerKeyListener(eventHandler);
1490             contentCanvas.removeEventHandlerMouseListener(eventHandler);
1491             contentCanvas.removeEventHandlerMouseMotionListener(eventHandler);
1492         }
1493     }
1494
1495     public void keyPressed(KeyEvent e) {
1496
1497     }
1498
1499     public void keyReleased(KeyEvent e) {
1500     }
1501
1502     public void keyTyped(KeyEvent e) {
1503         if (ScilabConstants.isGUI() && (eventHandler == null || !eventEnabled) && !GlobalEventWatcher.isActivated() && !editorEventHandler.isDatatipEnable() && Character.isLetterOrDigit(e.getKeyChar())) {
1504             SwingScilabConsole console = (SwingScilabConsole) ScilabConsole.getConsole().getAsSimpleConsole();
1505             JTextPane input = (JTextPane) console.getConfiguration().getInputCommandView();
1506             input.requestFocus();
1507             SwingScilabWindow win = (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, console);
1508             win.toFront();
1509             input.dispatchEvent(new KeyEvent(input, KeyEvent.KEY_TYPED, System.currentTimeMillis(), e.getModifiers(), e.getKeyCode(), e.getKeyChar(), e.getKeyLocation()));
1510         }
1511     }
1512
1513     public JLayeredPane getWidgetPane() {
1514         return uiContentPane;
1515     }
1516 }