Enable event_handler on Frame component
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / bridge / frame / SwingScilabFrame.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007 - INRIA - Vincent Couvert
4  * Copyright (C) 2007 - INRIA - Marouane BEN JELLOUL
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  *
12  */
13
14 package org.scilab.modules.gui.bridge.frame;
15
16
17 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_BORDER_OPT_PADDING__;
18 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_CHILDREN__;
19 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_GRID_OPT_GRID__;
20 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_GRID_OPT_PADDING__;
21 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_LAYOUT__;
22 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_POSITION__;
23 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_TAG__;
24 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_TYPE__;
25 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UICONTROL__;
26 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_ENABLE__;
27 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_FRAME_BORDER__;
28 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_ICON__;
29 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_STRING__;
30 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_VALUE__;
31 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_VISIBLE__;
32 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_EVENTHANDLER_NAME__;
33 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_EVENTHANDLER_ENABLE__;
34
35
36
37
38
39 import java.awt.BorderLayout;
40 import java.awt.Color;
41 import java.awt.Component;
42 import java.awt.Container;
43 import java.awt.Dimension;
44 import java.awt.GridBagConstraints;
45 import java.awt.GridBagLayout;
46 import java.awt.GridLayout;
47 import java.awt.Insets;
48 import java.awt.event.ComponentEvent;
49 import java.awt.event.ComponentListener;
50
51 import javax.swing.JPanel;
52 import javax.swing.SwingUtilities;
53 import javax.swing.UIManager;
54 import javax.swing.border.Border;
55
56 import org.scilab.modules.graphic_objects.axes.AxesContainer;
57 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
58 import org.scilab.modules.graphic_objects.graphicModel.GraphicModel;
59 import org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties;
60 import org.scilab.modules.graphic_objects.uicontrol.Uicontrol;
61 import org.scilab.modules.graphic_objects.utils.LayoutType;
62 import org.scilab.modules.gui.SwingView;
63 import org.scilab.modules.gui.SwingViewObject;
64 import org.scilab.modules.gui.SwingViewWidget;
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.label.SwingScilabLabel;
70 import org.scilab.modules.gui.bridge.listbox.SwingScilabListBox;
71 import org.scilab.modules.gui.bridge.pushbutton.SwingScilabPushButton;
72 import org.scilab.modules.gui.bridge.radiobutton.SwingScilabRadioButton;
73 import org.scilab.modules.gui.bridge.slider.SwingScilabScroll;
74 import org.scilab.modules.gui.bridge.tab.SwingScilabAxes;
75 import org.scilab.modules.gui.bridge.tab.SwingScilabDockablePanel;
76 import org.scilab.modules.gui.bridge.tab.SwingScilabPanel;
77 import org.scilab.modules.gui.bridge.tab.SwingScilabTabGroup;
78 import org.scilab.modules.gui.bridge.textbox.SwingScilabTextBox;
79 import org.scilab.modules.gui.bridge.window.SwingScilabWindow;
80 import org.scilab.modules.gui.canvas.Canvas;
81 import org.scilab.modules.gui.checkbox.CheckBox;
82 import org.scilab.modules.gui.console.Console;
83 import org.scilab.modules.gui.dockable.Dockable;
84 import org.scilab.modules.gui.editbox.EditBox;
85 import org.scilab.modules.gui.editor.EditorEventListener;
86 import org.scilab.modules.gui.events.ScilabEventListener;
87 import org.scilab.modules.gui.events.callback.CommonCallBack;
88 import org.scilab.modules.gui.frame.Frame;
89 import org.scilab.modules.gui.frame.SimpleFrame;
90 import org.scilab.modules.gui.label.Label;
91 import org.scilab.modules.gui.listbox.ListBox;
92 import org.scilab.modules.gui.menubar.MenuBar;
93 import org.scilab.modules.gui.pushbutton.PushButton;
94 import org.scilab.modules.gui.radiobutton.RadioButton;
95 import org.scilab.modules.gui.slider.Slider;
96 import org.scilab.modules.gui.tab.Tab;
97 import org.scilab.modules.gui.textbox.TextBox;
98 import org.scilab.modules.gui.toolbar.ToolBar;
99 import org.scilab.modules.gui.utils.BorderConvertor;
100 import org.scilab.modules.gui.utils.Position;
101 import org.scilab.modules.gui.utils.PositionConverter;
102 import org.scilab.modules.gui.utils.ScilabRelief;
103 import org.scilab.modules.gui.utils.Size;
104 import org.scilab.modules.gui.utils.UnitsConverter;
105 import org.scilab.modules.gui.utils.UnitsConverter.UicontrolUnits;
106 import org.scilab.modules.gui.widget.Widget;
107
108 /**
109  * Swing implementation for Scilab frames in GUI
110  * @author Vincent COUVERT
111  * @author Marouane BEN JELLOUL
112  */
113 public class SwingScilabFrame extends JPanel implements SwingViewObject, SimpleFrame {
114
115     private static final long serialVersionUID = -7401084975837285447L;
116
117     private Integer uid = -1;
118     int redraw = 0;
119     protected boolean hasLayout = false;
120     private Border defaultBorder = null;
121     private SwingScilabCanvas canvas = null;
122     private EditorEventListener editorEventHandler = null;
123     private ScilabEventListener eventHandler;
124     private boolean eventEnabled = false;
125
126     /**
127      * Constructor
128      */
129     public SwingScilabFrame() {
130         super();
131         // the Default layout is null so we have to set a Position and a Size of every Dockable we add to it
132         super.setLayout(null);
133         hasLayout = false;
134         addComponentListener(new ComponentListener() {
135             public void componentShown(ComponentEvent e) { }
136
137             public void componentResized(ComponentEvent e) {
138                 if (getId() != -1 && getParent() != null) {
139
140                     Double[] newPosition = new Double[4];
141                     Double[] positions = (Double[]) GraphicController.getController().getProperty(getId(), GraphicObjectProperties.__GO_POSITION__);
142                     if (positions == null) {
143                         // Position property not yet set
144                         return;
145                     }
146
147                     UicontrolUnits unitsProperty = UnitsConverter.stringToUnitsEnum((String) GraphicController.getController().getProperty(uid, GraphicObjectProperties.__GO_UI_UNITS__));
148
149                     //normalized values are always good
150                     if (unitsProperty != UicontrolUnits.NORMALIZED) {
151                         newPosition[0] = UnitsConverter.convertFromPixel(getPosition().getX(), unitsProperty, (SwingScilabFrame) SwingView.getFromId(uid), true);
152                         newPosition[1] = UnitsConverter.convertFromPixel(getPosition().getY(), unitsProperty, (SwingScilabFrame) SwingView.getFromId(uid), true);
153                         newPosition[2] = UnitsConverter.convertFromPixel(getWidth(), unitsProperty, (SwingScilabFrame) SwingView.getFromId(uid), true);
154                         newPosition[3] = UnitsConverter.convertFromPixel(getHeight(), unitsProperty, (SwingScilabFrame) SwingView.getFromId(uid), true);
155                         positions[2] = newPosition[2];
156                         positions[3] = newPosition[3];
157                         if (getParent() != null && getParent().getLayout() == null) {
158                             GraphicController.getController().setProperty(getId(), GraphicObjectProperties.__GO_POSITION__, newPosition);
159                         } else {
160                             GraphicController.getController().setProperty(getId(), GraphicObjectProperties.__GO_POSITION__, positions);
161                         }
162                     }
163                 }
164
165                 if (hasLayout == false) {
166                     for (Component comp : getComponents()) {
167                         if (comp instanceof Widget) {
168                             SwingViewObject obj = (SwingViewObject) comp;
169                             obj.update(__GO_POSITION__, GraphicController.getController().getProperty(obj.getId(), __GO_POSITION__));
170                         }
171                     }
172                 }
173             }
174
175             public void componentMoved(ComponentEvent e) { }
176
177             public void componentHidden(ComponentEvent e) { }
178         });
179     }
180
181     /**
182      * Draws a Swing Scilab frame
183      * @see org.scilab.modules.gui.UIElement#draw()
184      */
185     public void draw() {
186         this.setVisible(true);
187         this.doLayout();
188     }
189
190     /**
191      * Gets the dimensions (width and height) of a swing Scilab frame
192      * @return the dimension of the frame
193      * @see org.scilab.modules.gui.UIElement#getDims()
194      */
195     public Size getDims() {
196         return new Size(this.getSize().width, this.getSize().height);
197     }
198
199     /**
200      * Gets the position (X-coordinate and Y-coordinate) of a swing Scilab frame
201      * @return the position of the frame
202      * @see org.scilab.modules.gui.UIElement#getPosition()
203      */
204     public Position getPosition() {
205         return PositionConverter.javaToScilab(getLocation(), getSize(), getParent());
206     }
207
208     /**
209      * Sets the dimensions (width and height) of a swing Scilab frame
210      * @param newSize the size we want to set to the frame
211      * @see org.scilab.modules.gui.UIElement#setDims(org.scilab.modules.gui.utils.Size)
212      */
213     public void setDims(Size newSize) {
214         this.setSize(newSize.getWidth(), newSize.getHeight());
215     }
216
217     /**
218      * Sets the position (X-coordinate and Y-coordinate) of a swing Scilab frame
219      * @param newPosition the position we want to set to the frame
220      * @see org.scilab.modules.gui.UIElement#setPosition(org.scilab.modules.gui.utils.Position)
221      */
222     public void setPosition(Position newPosition) {
223         Position javaPosition = PositionConverter.scilabToJava(newPosition, getDims(), getParent());
224         setLocation(javaPosition.getX(), javaPosition.getY());
225     }
226
227     /**
228      * Add a SwingViewObject (from SwingView.java) to container and returns its index
229      * @param member the member to add
230      */
231     public void addMember(SwingViewObject member) {
232         //forward disable status
233         if (isEnabled() == false) {
234             ((Component) member).setEnabled(false);
235         }
236
237         if (member instanceof SwingScilabAxes) {
238             if (canvas == null) {
239                 editorEventHandler = new EditorEventListener(getId());
240                 AxesContainer frame = (AxesContainer) GraphicModel.getModel().getObjectFromId(getId());
241                 canvas = new SwingScilabCanvas(frame);
242                 canvas.addEventHandlerKeyListener(editorEventHandler);
243                 canvas.addEventHandlerMouseListener(editorEventHandler);
244                 canvas.addEventHandlerMouseMotionListener(editorEventHandler);
245                 editorEventHandler.setEnable(true);
246
247                 setLayout(new GridLayout(1, 1));
248                 hasLayout = true;
249                 add(canvas);
250             }
251             return;
252         }
253
254         Uicontrol uicontrol = (Uicontrol) GraphicModel.getModel().getObjectFromId(member.getId());
255         if (getLayout() instanceof BorderLayout) {
256             switch (uicontrol.getBorderPositionAsEnum()) {
257                 case BOTTOM:
258                     add((Component) member, BorderLayout.SOUTH);
259                     break;
260                 case TOP:
261                     add((Component) member, BorderLayout.NORTH);
262                     break;
263                 case LEFT:
264                     add((Component) member, BorderLayout.WEST);
265                     break;
266                 case RIGHT:
267                     add((Component) member, BorderLayout.EAST);
268                     break;
269                 case CENTER:
270                     add((Component) member, BorderLayout.CENTER);
271                     break;
272                 default:
273                     break;
274             }
275
276             Integer[] preferredSize = uicontrol.getBorderPreferredSize();
277             if (preferredSize[0].equals(-1) == false && preferredSize[1].equals(-1) == false) {
278                 ((Component) member).setPreferredSize(new Dimension(preferredSize[0], preferredSize[1]));
279             }
280         } else if (getLayout() instanceof GridBagLayout) {
281             GridBagConstraints constraints = new GridBagConstraints();
282
283             // Grid
284             Integer[] grid = uicontrol.getGridBagGrid();
285             constraints.gridx = grid[0];
286             constraints.gridy = grid[1];
287             constraints.gridwidth = grid[2];
288             constraints.gridheight = grid[3];
289
290             // Weight
291             Double[] weight = uicontrol.getGridBagWeight();
292             constraints.weightx = weight[0];
293             constraints.weighty = weight[1];
294
295             // Anchor
296             switch (uicontrol.getGridBagAnchorAsEnum()) {
297                 case LEFT :
298                     constraints.anchor = GridBagConstraints.WEST;
299                     break;
300                 case UPPER :
301                     constraints.anchor = GridBagConstraints.NORTH;
302                     break;
303                 case LOWER:
304                     constraints.anchor = GridBagConstraints.SOUTH;
305                     break;
306                 case LOWER_LEFT:
307                     constraints.anchor = GridBagConstraints.SOUTHWEST;
308                     break;
309                 case LOWER_RIGHT:
310                     constraints.anchor = GridBagConstraints.SOUTHEAST;
311                     break;
312                 case RIGHT:
313                     constraints.anchor = GridBagConstraints.EAST;
314                     break;
315                 case UPPER_LEFT:
316                     constraints.anchor = GridBagConstraints.NORTHWEST;
317                     break;
318                 case UPPER_RIGHT:
319                     constraints.anchor = GridBagConstraints.NORTHEAST;
320                     break;
321                 case CENTER :
322                 default :
323                     constraints.anchor = GridBagConstraints.CENTER;
324                     break;
325             }
326
327             // Fill
328             switch (uicontrol.getGridBagFillAsEnum()) {
329                 case BOTH :
330                     constraints.fill = GridBagConstraints.BOTH;
331                     break;
332                 case HORIZONTAL:
333                     constraints.fill = GridBagConstraints.HORIZONTAL;
334                     break;
335                 case VERTICAL:
336                     constraints.fill = GridBagConstraints.VERTICAL;
337                     break;
338                 case NONE:
339                 default:
340                     constraints.fill = GridBagConstraints.NONE;
341                     break;
342             }
343
344             // Insets
345             Double[] margins = uicontrol.getMargins();
346             constraints.insets = new Insets(
347                 margins[0].intValue(), margins[1].intValue(),
348                 margins[2].intValue(), margins[3].intValue());
349
350             // Padding
351             Integer[] padding = uicontrol.getGridBagPadding();
352             constraints.ipadx = padding[0];
353             constraints.ipady = padding[1];
354
355             Integer[] preferredSize = uicontrol.getGridBagPreferredSize();
356             if (preferredSize[0].equals(-1) == false && preferredSize[1].equals(-1) == false) {
357                 ((Component) member).setPreferredSize(new Dimension(preferredSize[0], preferredSize[1]));
358             }
359
360             add((Component) member, constraints);
361             revalidate();
362         } else if (getLayout() instanceof GridLayout) {
363             this.add((Component) member, 0);
364         } else {
365             this.add((Component) member);
366         }
367
368         //force update position
369         member.update(__GO_POSITION__, GraphicController.getController().getProperty(member.getId(), __GO_POSITION__));
370     }
371
372     /**
373      * Add a member (dockable element) to container and returns its index
374      * @param member the member to add
375      * @return index of member in ArrayList
376      */
377     public int addMember(Console member) {
378         return this.addMember((SwingScilabConsole) member.getAsSimpleConsole());
379     }
380
381     /**
382      * Add a member (dockable element) to container and returns its index
383      * @param member the member to add
384      * @return index of member in ArrayList
385      */
386     private int addMember(SwingScilabConsole member) {
387         this.add(member);
388         return this.getComponentZOrder(member);
389     }
390
391     /**
392      * Add a member (dockable element) to container and returns its index
393      * @param member the member to add
394      * @return index of member in ArrayList
395      */
396     public int addMember(EditBox member) {
397         return this.addMember((SwingScilabEditBox) member.getAsSimpleEditBox());
398     }
399
400     /**
401      * Add a member (dockable element) to container and returns its index
402      * @param member the member to add
403      * @return index of member in ArrayList
404      */
405     private int addMember(SwingScilabEditBox member) {
406         this.add(member);
407         return this.getComponentZOrder(member);
408     }
409
410     /**
411      * Add a member (dockable element) to container and returns its index
412      * @param member the member to add
413      * @return index of member in ArrayList
414      */
415     public int addMember(Label member) {
416         // FIXME replace member with member.getAsSimpleLabel() when ready
417         return this.addMember((SwingScilabLabel) member);
418     }
419
420     /**
421      * Add a member (dockable element) to container and returns its index
422      * @param member the member to add
423      * @return index of member in ArrayList
424      */
425     private int addMember(SwingScilabLabel member) {
426         this.add(member);
427         return this.getComponentZOrder(member);
428     }
429
430     /**
431      * Add a member (dockable element) to container and returns its index
432      * @param member the member to add
433      * @return index of member in ArrayList
434      */
435     public int addMember(Frame member) {
436         return this.addMember((SwingScilabFrame) member.getAsSimpleFrame());
437     }
438
439     /**
440      * Add a member (dockable element) to container and returns its index
441      * @param member the member to add
442      * @return index of member in ArrayList
443      */
444     private int addMember(SwingScilabFrame member) {
445         this.add(member);
446         return this.getComponentZOrder(member);
447     }
448
449     /**
450      * Add a Frame in a Frame with a BorderLayout.
451      * @param member the member to add
452      * @param borderLayout the BorderLayout to use
453      * @return the position of the Frame in the member list.
454      */
455     public int addMember(Frame member, String borderLayout) {
456         return this.addMember((SwingScilabFrame) member.getAsSimpleFrame(), borderLayout);
457     }
458
459     /**
460      * Add a member (dockable element) to container and returns its index
461      * @param member the member to add
462      * @param borderLayout the BorderLayout to use
463      * @return index of member in ArrayList
464      */
465     private int addMember(SwingScilabFrame member, String borderLayout) {
466         this.add(member, borderLayout);
467         return this.getComponentZOrder(member);
468     }
469
470     /**
471      * Add a Frame in a Frame with a layout.
472      * @param member the member to add
473      * @param layoutPosition the Layout position to use
474      * @return the position of the Frame in the member list.
475      */
476     public int addMember(Frame member, int layoutPosition) {
477         return this.addMember((SwingScilabFrame) member.getAsSimpleFrame(), layoutPosition);
478     }
479
480     /**
481      * Add a member (dockable element) to container and returns its index
482      * @param member the member to add
483      * @param layoutPosition the Layout position to use
484      * @return index of member in ArrayList
485      */
486     private int addMember(SwingScilabFrame member, int layoutPosition) {
487         this.add(member, layoutPosition);
488         return this.getComponentZOrder(member);
489     }
490
491     /**
492      * Add a member (dockable element) to container and returns its index
493      * @param member the member to add
494      * @return index of member in ArrayList
495      */
496     public int addMember(Canvas member) {
497         return this.addMember((SwingScilabCanvas) member.getAsSimpleCanvas());
498     }
499
500     /**
501      * Add a member (dockable element) to container and returns its index
502      * @param member the member to add
503      * @return index of member in ArrayList
504      */
505     private int addMember(SwingScilabCanvas member) {
506         return 0;
507     }
508
509     /**
510      * Add a member (dockable element) to container and returns its index
511      * @param member the member to add
512      * @return index of member in ArrayList
513      */
514     public int addMember(CheckBox member) {
515         // FIXME replace member with member.getAsSimpleCheckBox() when ready
516         return this.addMember((SwingScilabCheckBox) member);
517     }
518
519     /**
520      * Add a member (dockable element) to container and returns its index
521      * @param member the member to add
522      * @return index of member in ArrayList
523      */
524     private int addMember(SwingScilabCheckBox member) {
525         this.add(member);
526         return this.getComponentZOrder(member);
527     }
528
529     /**
530      * Add a member (dockable element) to container and returns its index
531      * @param member the member to add
532      * @return index of member in ArrayList
533      */
534     public int addMember(ListBox member) {
535         return this.addMember((SwingScilabListBox) member.getAsSimpleListBox());
536     }
537
538     /**
539      * Add a member (dockable element) to container and returns its index
540      * @param member the member to add
541      * @return index of member in ArrayList
542      */
543     private int addMember(SwingScilabListBox member) {
544         this.add(member);
545         return this.getComponentZOrder(member);
546     }
547
548     /**
549      * Add a member (dockable element) to container and returns its index
550      * @param member the member to add
551      * @return index of member in ArrayList
552      */
553     public int addMember(PushButton member) {
554         return this.addMember((SwingScilabPushButton) member.getAsSimplePushButton());
555     }
556
557     /**
558      * Add a member (dockable element) to container and returns its index
559      * @param member the member to add
560      * @return index of member in ArrayList
561      */
562     private int addMember(SwingScilabPushButton member) {
563         this.add(member);
564         return this.getComponentZOrder(member);
565     }
566
567     /**
568      * Add a member (dockable element) to container and returns its index
569      * @param member the member to add
570      * @return index of member in ArrayList
571      */
572     public int addMember(RadioButton member) {
573         //               FIXME replace member with member.getAsSimpleRadioButton() when ready
574         return this.addMember((SwingScilabRadioButton) member);
575     }
576
577     /**
578      * Add a member (dockable element) to container and returns its index
579      * @param member the member to add
580      * @return index of member in ArrayList
581      */
582     private int addMember(SwingScilabRadioButton member) {
583         this.add(member);
584         return this.getComponentZOrder(member);
585     }
586
587     /**
588      * Add a member (dockable element) to container and returns its index
589      * @param member the member to add
590      * @return index of member in ArrayList
591      */
592     public int addMember(Slider member) {
593         //               FIXME replace member with member.getAsSimpleSlider() when ready
594         return this.addMember((SwingScilabScroll) member);
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     private int addMember(SwingScilabScroll member) {
603         this.add(member);
604         return this.getComponentZOrder(member);
605     }
606
607     /**
608      * Add a PushButton in a Frame with a BorderLayout.
609      * @param member the PushButton to add
610      * @param borderLayout the BorderLayout to use
611      * @return the position of the PushButton in the member list.
612      */
613     public int addMember(PushButton member, String borderLayout) {
614         return this.addMember((SwingScilabPushButton) member.getAsSimplePushButton(), borderLayout);
615     }
616
617     /**
618      * Add a PushButton (dockable element) to Frame and returns its index
619      * @param member the PushButton to add
620      * @param layoutPosition the layout Position to use
621      * @return index of member in ArrayList
622      */
623     private int addMember(SwingScilabPushButton member, int layoutPosition) {
624         this.add(member, layoutPosition);
625         return this.getComponentZOrder(member);
626     }
627
628     /**
629      * Add a PushButton in a Frame with a layout.
630      * @param member the PushButton to add
631      * @param layoutPosition the layout Position to use
632      * @return the position of the PushButton in the member list.
633      */
634     public int addMember(PushButton member, int layoutPosition) {
635         return this.addMember((SwingScilabPushButton) member.getAsSimplePushButton(), layoutPosition);
636     }
637
638     /**
639      * Add a PushButton (dockable element) to Frame and returns its index
640      * @param member the PushButton to add
641      * @param borderLayout the BorderLayout to use
642      * @return index of member in ArrayList
643      */
644     private int addMember(SwingScilabPushButton member, String borderLayout) {
645         this.add(member, borderLayout);
646         return this.getComponentZOrder(member);
647     }
648
649     //   TODO : Check if it should be possible to add a Tab to a frame and how it should behave
650     /**
651      * Add a member (dockable element) to container and returns its index
652      * @param member the member to add
653      * @return index of member in ArrayList
654      */
655     public int addMember(Tab member) {
656         return this.addMember((SwingScilabDockablePanel) member.getAsSimpleTab());
657     }
658     //   TODO : Check if it should be possible to add a Tab to a frame and how it should behave
659     /**
660      * Add a member (dockable element) to container and returns its index
661      * @param member the member to add
662      * @return index of member in ArrayList
663      */
664     private int addMember(SwingScilabDockablePanel member) {
665         this.add(member);
666         return this.getComponentZOrder(member);
667     }
668
669     /**
670      * Add a member (dockable element) to container and returns its index
671      * @param member the member to add
672      * @return index of member in ArrayList
673      */
674     public int addMember(TextBox member) {
675         return this.addMember((SwingScilabTextBox) member.getAsSimpleTextBox());
676     }
677
678     /**
679      * Add a member (dockable element) to container and returns its index
680      * @param member the member to add
681      * @return index of member in ArrayList
682      */
683     private int addMember(SwingScilabTextBox member) {
684         this.add(member);
685         return this.getComponentZOrder(member);
686     }
687
688     /**
689      * Add a callback to the Frame
690      * @param callback the callback to set.
691      */
692     public void setCallback(CommonCallBack callback) {
693         // Nothing to do...
694     }
695
696     /**
697      * Setter for MenuBar
698      * @param menuBarToAdd the MenuBar associated to the Frame.
699      */
700     public void addMenuBar(MenuBar menuBarToAdd) {
701         /* Unimplemented for Frames */
702         throw new UnsupportedOperationException();
703     }
704
705     /**
706      * Setter for ToolBar
707      * @param toolBarToAdd the ToolBar associated to the Frame.
708      */
709     public void addToolBar(ToolBar toolBarToAdd) {
710         /* Unimplemented for Frames */
711         throw new UnsupportedOperationException();
712     }
713
714     /**
715      * Getter for MenuBar
716      * @return MenuBar: the MenuBar associated to the Frame.
717      */
718     public MenuBar getMenuBar() {
719         /* Unimplemented for Frames */
720         throw new UnsupportedOperationException();
721     }
722
723     /**
724      * Getter for ToolBar
725      * @return ToolBar: the ToolBar associated to the Frame.
726      */
727     public ToolBar getToolBar() {
728         /* Unimplemented for Frames */
729         throw new UnsupportedOperationException();
730     }
731
732     /**
733      * Get the text of the Frame
734      * @return the text of the frame
735      * @see org.scilab.modules.gui.frame.SimpleFrame#getText()
736      */
737     public String getText() {
738         return this.getName();
739     }
740
741     /**
742      * Set the text of the Frame
743      * @param text the text to set to the frame
744      * @see org.scilab.modules.gui.frame.SimpleFrame#setText()
745      */
746     public void setText(String text) {
747         this.setName(text);
748     }
749
750     public void setEmptyText() {
751         setText("");
752     }
753
754     /**
755      * Add a dockable element in the Frame (Not available for the moment)
756      * @param member the object we want to add to the Frame
757      * @return the index of the member in the Frame
758      * @see org.scilab.modules.gui.container.Container#addMember(org.scilab.modules.gui.dockable.Dockable)
759      */
760     public int addMember(Dockable member) {
761         /* Unimplemented for Frames */
762         throw new UnsupportedOperationException();
763     }
764
765     /**
766      * Set the Relief of the Frame
767      * @param reliefType the type of the relief to set (See ScilabRelief.java)
768      */
769     public void setRelief(String reliefType) {
770         if (defaultBorder == null) {
771             defaultBorder = getBorder();
772         }
773         setBorder(ScilabRelief.getBorderFromRelief(reliefType, defaultBorder));
774     }
775
776     /**
777      * Destroy the Frame
778      */
779     public void destroy() {
780         getParent().remove(this);
781         this.setVisible(false);
782     }
783
784     /**
785      * Setter for InfoBar
786      * @param infoBarToAdd the InfoBar associated to the Frame.
787      */
788     public void addInfoBar(TextBox infoBarToAdd) {
789         /* Unimplemented for Frames */
790         throw new UnsupportedOperationException();
791     }
792
793     /**
794      * Getter for InfoBar
795      * @return the InfoBar associated to the Frame.
796      */
797     public TextBox getInfoBar() {
798         /* Unimplemented for Frames */
799         throw new UnsupportedOperationException();
800     }
801
802     /**
803      * Set the horizontal alignment for the Slider text
804      * @param alignment the value for the alignment (See ScilabAlignment.java)
805      */
806     public void setHorizontalAlignment(String alignment) {
807         // Nothing to do here
808     }
809
810     /**
811      * Set the vertical alignment for the Slider text
812      * @param alignment the value for the alignment (See ScilabAlignment.java)
813      */
814     public void setVerticalAlignment(String alignment) {
815         // Nothing to do here
816     }
817
818     /**
819      * Set the UID
820      * @param id the UID
821      */
822     public void setId(Integer id) {
823         uid = id;
824     }
825
826     /**
827      * Get the UID
828      * @return the UID
829      */
830     public Integer getId() {
831         return uid;
832     }
833
834     /**
835      * Generic update method
836      * @param property property name
837      * @param value property value
838      */
839     public void update(int property, Object value) {
840         GraphicController controller = GraphicController.getController();
841
842         switch (property) {
843             case __GO_UI_VALUE__: {
844                 if (this instanceof SwingScilabLayer) {
845                     SwingScilabLayer layer = (SwingScilabLayer) this;
846                     Double[] doubleValue = ((Double[]) value);
847                     if (doubleValue.length == 0) {
848                         return;
849                     }
850
851                     Integer val = doubleValue[0].intValue();
852
853                     //if intValue[0] is out of bounds, do not update view but let "wrong" value in model
854                     layer.setActiveLayer(val);
855                 }
856                 break;
857             }
858             case __GO_UI_STRING__: {
859                 // Update tab title
860                 Container parent = getParent();
861                 if (parent instanceof SwingScilabTabGroup) {
862                     SwingScilabTabGroup tab = (SwingScilabTabGroup) parent;
863                     int index = tab.indexOfComponent(this);
864                     if (index != -1) {
865                         tab.setTitleAt(index, ((String[]) value)[0]);
866                     }
867                 }
868
869                 if (this instanceof SwingScilabLayer) {
870                     SwingScilabLayer layer = (SwingScilabLayer) this;
871                     //if intValue[0] is out of bounds, do not update view but let "wrong" value in model
872                     layer.setActiveLayerFromName(((String[]) value)[0]);
873                 }
874                 break;
875             }
876             case __GO_UI_ICON__: {
877                 // Update tab icon title
878                 Container parent = getParent();
879                 if (parent instanceof SwingScilabTabGroup) {
880                     SwingScilabTabGroup tab = (SwingScilabTabGroup) parent;
881                     int index = tab.indexOfComponent(this);
882                     if (index != -1) {
883                         tab.setIconAt(index, (String) value);
884                     }
885                 }
886
887                 break;
888             }
889             case __GO_POSITION__: {
890                 SwingViewWidget.updatePosition(this, uid, value);
891                 validate();
892                 doLayout();
893                 break;
894             }
895             case __GO_UI_FRAME_BORDER__: {
896                 Integer borderId = (Integer) value;
897                 Border border = BorderConvertor.getBorder(borderId);
898                 setBorder(border);
899                 break;
900             }
901             case __GO_LAYOUT__: {
902                 hasLayout = false;
903
904                 invalidate();
905
906                 LayoutType newLayout = LayoutType.intToEnum((Integer) value);
907                 switch (newLayout) {
908                     case BORDER: {
909                         Integer[] padding = (Integer[]) controller.getProperty(getId(), __GO_BORDER_OPT_PADDING__);
910                         setLayout(new BorderLayout(padding[0], padding[1]));
911                         hasLayout = true;
912                         break;
913                     }
914                     case GRIDBAG:
915                         setLayout(new GridBagLayout());
916                         hasLayout = true;
917                         break;
918                     case GRID: {
919                         Integer[] padding = (Integer[]) controller.getProperty(getId(), __GO_GRID_OPT_PADDING__);
920                         Integer[] grid = (Integer[]) controller.getProperty(getId(), __GO_GRID_OPT_GRID__);
921                         if (grid[0] == 0 && grid[1] == 0) {
922                             grid[0] = 1;
923                         }
924
925                         setLayout(new GridLayout(grid[0], grid[1], padding[0], padding[1]));
926                         hasLayout = true;
927                         break;
928                     }
929                     case NONE:
930                     default: {
931                         setLayout(null);
932                         hasLayout = false;
933                         break;
934                     }
935                 }
936
937                 validate();
938                 break;
939             }
940             case __GO_GRID_OPT_PADDING__:
941             case __GO_GRID_OPT_GRID__: {
942                 Integer layout = (Integer) GraphicController.getController().getProperty(getId(), __GO_LAYOUT__);
943                 LayoutType layoutType = LayoutType.intToEnum(layout);
944
945                 if (layoutType != LayoutType.GRID) {
946                     break;
947                 }
948
949                 Integer[] padding = (Integer[]) GraphicController.getController().getProperty(getId(), __GO_GRID_OPT_PADDING__);
950
951                 Integer[] grid = (Integer[]) GraphicController.getController().getProperty(getId(), __GO_GRID_OPT_GRID__);
952                 Integer[] localGrid = new Integer[] { 0, 0 };
953                 localGrid[0] = grid[0];
954                 localGrid[1] = grid[1];
955
956                 if (localGrid[0] == 0 && localGrid[1] == 0) {
957                     localGrid[0] = 1;
958                 }
959
960                 invalidate();
961
962                 GridLayout gl = (GridLayout)getLayout();
963                 gl.setRows(localGrid[0]);
964                 gl.setColumns(localGrid[1]);
965                 gl.setHgap(padding[0]);
966                 gl.setVgap(padding[1]);
967
968                 validate();
969                 break;
970             }
971             case __GO_BORDER_OPT_PADDING__: {
972                 Integer layout = (Integer) GraphicController.getController().getProperty(getId(), __GO_LAYOUT__);
973                 LayoutType layoutType = LayoutType.intToEnum(layout);
974
975                 if (layoutType != LayoutType.BORDER) {
976                     break;
977                 }
978
979                 invalidate();
980
981                 Integer[] padding = (Integer[])value;
982                 BorderLayout bl = (BorderLayout)getLayout();
983                 bl.setHgap(padding[0]);
984                 bl.setVgap(padding[1]);
985
986                 validate();
987                 break;
988             }
989             case __GO_VISIBLE__: {
990                 boolean needUpdate = true;
991                 Component parent = getParent();
992                 if (parent instanceof SwingScilabLayer) {
993                     //no no no don't touch visible on layer children !
994                     Boolean visible = (Boolean) value;
995                     SwingScilabLayer layer = (SwingScilabLayer) parent;
996                     Boolean isActive = layer.isLayerActive(this);
997                     if (isActive != visible) {
998                         controller.setProperty(uid, __GO_VISIBLE__, isActive);
999                     }
1000
1001                     needUpdate = false;
1002                 } else if (parent instanceof SwingScilabTabGroup) {
1003                     //no no no don't touch visible on layer children !
1004                     Boolean visible = (Boolean) value;
1005                     SwingScilabTabGroup layer = (SwingScilabTabGroup) parent;
1006                     Boolean isActive = layer.isTabActive(this);
1007                     if (isActive != visible) {
1008                         controller.setProperty(uid, __GO_VISIBLE__, isActive);
1009                     }
1010
1011                     needUpdate = false;
1012                 }
1013
1014                 if (needUpdate) {
1015                     setVisible(((Boolean) value).booleanValue());
1016                 }
1017
1018                 break;
1019             }
1020             case __GO_TAG__ : {
1021                 Component parent = getParent();
1022                 if (parent instanceof SwingScilabLayer) {
1023                     SwingScilabLayer layer = (SwingScilabLayer)parent;
1024                     layer.updateModelProperties(null, layer.getActiveLayer());
1025                 } else if (parent instanceof SwingScilabTabGroup) {
1026                     ((SwingScilabTabGroup)parent).updateModelProperties();
1027                 }
1028                 break;
1029             }
1030             case __GO_EVENTHANDLER_ENABLE__ : {
1031                 Boolean enabled = (Boolean) GraphicController.getController().getProperty(getId(), __GO_EVENTHANDLER_ENABLE__);
1032                 setEventHandlerEnabled(enabled);
1033                 break;
1034             }
1035             case __GO_EVENTHANDLER_NAME__: {
1036                 String eventHandlerName = (String) GraphicController.getController().getProperty(getId(), __GO_EVENTHANDLER_NAME__);
1037                 setEventHandler(eventHandlerName);
1038                 break;
1039             }
1040             default:
1041                 SwingViewWidget.update(this, property, value);
1042                 break;
1043         }
1044     }
1045
1046     /**
1047      * Set the enable status of the frame and its children
1048      * @param status the status to set
1049      */
1050     public void setEnabled(boolean status) {
1051         if (status) {
1052             // Enable the frame
1053             super.setEnabled(status);
1054             // Enable its children according to their __GO_UI_ENABLE__ property
1055             Integer[] children = (Integer[]) GraphicController.getController().getProperty(uid, __GO_CHILDREN__);
1056             for (int kChild = 0; kChild < children.length; kChild++) {
1057                 Integer type = (Integer)GraphicController.getController().getProperty(children[kChild], __GO_TYPE__);
1058                 if (type == __GO_UICONTROL__) {
1059                     Boolean childStatus = (Boolean) GraphicController.getController().getProperty(children[kChild], __GO_UI_ENABLE__);
1060                     SwingView.getFromId(children[kChild]).update(__GO_UI_ENABLE__, childStatus);
1061                 }
1062             }
1063         } else {
1064             // Disable the frame
1065             super.setEnabled(status);
1066             // Disable its children
1067             Component[] components = getComponents();
1068             for (int compIndex = 0; compIndex < components.length; compIndex++) {
1069                 components[compIndex].setEnabled(false);
1070             }
1071         }
1072
1073         //if parent is a tab enable/disable children tab
1074         Component parent = getParent();
1075         if (parent instanceof SwingScilabTabGroup) {
1076             SwingScilabTabGroup tab = (SwingScilabTabGroup)parent;
1077             Integer index = tab.getIndex(this);
1078             if (index != -1) {
1079                 tab.setEnabledAt(index, status);
1080             }
1081         }
1082     }
1083
1084     //    public void setForeground(Color color) {
1085     //        System.out.println((Color)UIManager.getLookAndFeelDefaults().get("Panel.foreground"));
1086     //        super.setForeground((Color)UIManager.getLookAndFeelDefaults().get("Panel.foreground"));
1087     //    }
1088
1089     public void resetBackground() {
1090         Color color = (Color)UIManager.getLookAndFeelDefaults().get("Panel.background");
1091         if (color != null) {
1092             setBackground(color);
1093         }
1094     }
1095
1096     public void resetForeground() {
1097         Color color = (Color)UIManager.getLookAndFeelDefaults().get("Panel.foreground");
1098         if (color != null) {
1099             setForeground(color);
1100         }
1101     }
1102
1103     public void removeAxes() {
1104         if (canvas != null) {
1105             canvas.setEnabled(false);
1106             remove(canvas);
1107             canvas.removeNotify();
1108             canvas = null;
1109             repaint();
1110         }
1111     }
1112     
1113     /**
1114      * Set the event handler of the Canvas
1115      * @param funName the name of the Scilab function to call
1116      */
1117     public void setEventHandler(String funName) {
1118         disableEventHandler();
1119         eventHandler = new ScilabEventListener(funName, getId());
1120         if (eventEnabled) {
1121             editorEventHandler.setEnable(false);
1122             enableEventHandler();
1123         }
1124     }
1125
1126     /**
1127      * Set the status of the event handler of the Canvas
1128      * @param status is true to set the event handler active
1129      */
1130     public void setEventHandlerEnabled(boolean status) {
1131         if (status && eventEnabled) {
1132             return;
1133         }
1134
1135         if (status) {
1136             editorEventHandler.setEnable(false);
1137             enableEventHandler();
1138             eventEnabled = true;
1139         } else {
1140             editorEventHandler.setEnable(true);
1141             disableEventHandler();
1142             eventEnabled = false;
1143         }
1144     }
1145     
1146     /**
1147      * Turn on event handling.
1148      */
1149     private void enableEventHandler() {
1150         if (canvas != null) {
1151             canvas.addEventHandlerKeyListener(eventHandler);
1152             canvas.addEventHandlerMouseListener(eventHandler);
1153             canvas.addEventHandlerMouseMotionListener(eventHandler);
1154         }
1155     }
1156
1157     /**
1158      * Turn off event handling.
1159      */
1160     private void disableEventHandler() {
1161         if (eventHandler != null && canvas != null) {
1162             canvas.removeEventHandlerKeyListener(eventHandler);
1163             canvas.removeEventHandlerMouseListener(eventHandler);
1164             canvas.removeEventHandlerMouseMotionListener(eventHandler);
1165         }
1166     }
1167
1168 }