Merge remote-tracking branch 'origin/5.5'
[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.UIManager;
53 import javax.swing.border.Border;
54
55 import org.scilab.modules.graphic_objects.axes.AxesContainer;
56 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
57 import org.scilab.modules.graphic_objects.graphicModel.GraphicModel;
58 import org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties;
59 import org.scilab.modules.graphic_objects.uicontrol.Uicontrol;
60 import org.scilab.modules.graphic_objects.utils.LayoutType;
61 import org.scilab.modules.gui.SwingView;
62 import org.scilab.modules.gui.SwingViewObject;
63 import org.scilab.modules.gui.SwingViewWidget;
64 import org.scilab.modules.gui.bridge.canvas.SwingScilabCanvas;
65 import org.scilab.modules.gui.bridge.console.SwingScilabConsole;
66 import org.scilab.modules.gui.bridge.tab.SwingScilabAxes;
67 import org.scilab.modules.gui.bridge.tab.SwingScilabDockablePanel;
68 import org.scilab.modules.gui.bridge.tab.SwingScilabTabGroup;
69 import org.scilab.modules.gui.bridge.textbox.SwingScilabTextBox;
70 import org.scilab.modules.gui.canvas.Canvas;
71 import org.scilab.modules.gui.console.Console;
72 import org.scilab.modules.gui.dockable.Dockable;
73 import org.scilab.modules.gui.editor.EditorEventListener;
74 import org.scilab.modules.gui.events.ScilabEventListener;
75 import org.scilab.modules.gui.events.callback.CommonCallBack;
76 import org.scilab.modules.gui.menubar.MenuBar;
77 import org.scilab.modules.gui.tab.Tab;
78 import org.scilab.modules.gui.textbox.TextBox;
79 import org.scilab.modules.gui.toolbar.ToolBar;
80 import org.scilab.modules.gui.utils.BorderConvertor;
81 import org.scilab.modules.gui.utils.Position;
82 import org.scilab.modules.gui.utils.PositionConverter;
83 import org.scilab.modules.gui.utils.ScilabRelief;
84 import org.scilab.modules.gui.utils.Size;
85 import org.scilab.modules.gui.utils.UnitsConverter;
86 import org.scilab.modules.gui.utils.UnitsConverter.UicontrolUnits;
87 import org.scilab.modules.gui.widget.Widget;
88
89 /**
90  * Swing implementation for Scilab frames in GUI
91  * @author Vincent COUVERT
92  * @author Marouane BEN JELLOUL
93  */
94 public class SwingScilabFrame extends JPanel implements SwingViewObject, Widget {
95
96     private static final long serialVersionUID = -7401084975837285447L;
97
98     private Integer uid = -1;
99     int redraw = 0;
100     protected boolean hasLayout = false;
101     private Border defaultBorder = null;
102     private SwingScilabCanvas canvas = null;
103     
104     // BJ: This EditorEventListener leads to a huge leak mem openning many Axes withih Frames.
105     // DO NOT ACTIVATE THIS until EditorEventListener can manage Axes within Frames (Only Figure is working now)
106     //private EditorEventListener editorEventHandler = null;
107     
108     private ScilabEventListener eventHandler;
109     private boolean eventEnabled = false;
110
111     /**
112      * Constructor
113      */
114     public SwingScilabFrame() {
115         super();
116         // the Default layout is null so we have to set a Position and a Size of every Dockable we add to it
117         super.setLayout(null);
118         hasLayout = false;
119         addComponentListener(new ComponentListener() {
120             public void componentShown(ComponentEvent e) { }
121
122             public void componentResized(ComponentEvent e) {
123                 if (getId() != -1 && getParent() != null) {
124
125                     Double[] newPosition = new Double[4];
126                     Double[] positions = (Double[]) GraphicController.getController().getProperty(getId(), GraphicObjectProperties.__GO_POSITION__);
127                     if (positions == null) {
128                         // Position property not yet set
129                         return;
130                     }
131
132                     UicontrolUnits unitsProperty = UnitsConverter.stringToUnitsEnum((String) GraphicController.getController().getProperty(uid, GraphicObjectProperties.__GO_UI_UNITS__));
133
134                     //normalized values are always good
135                     if (unitsProperty != UicontrolUnits.NORMALIZED) {
136                         newPosition[0] = UnitsConverter.convertFromPixel(getPosition().getX(), unitsProperty, (SwingScilabFrame) SwingView.getFromId(uid), true);
137                         newPosition[1] = UnitsConverter.convertFromPixel(getPosition().getY(), unitsProperty, (SwingScilabFrame) SwingView.getFromId(uid), true);
138                         newPosition[2] = UnitsConverter.convertFromPixel(getWidth(), unitsProperty, (SwingScilabFrame) SwingView.getFromId(uid), true);
139                         newPosition[3] = UnitsConverter.convertFromPixel(getHeight(), unitsProperty, (SwingScilabFrame) SwingView.getFromId(uid), true);
140                         positions[2] = newPosition[2];
141                         positions[3] = newPosition[3];
142                         if (getParent() != null && getParent().getLayout() == null) {
143                             GraphicController.getController().setProperty(getId(), GraphicObjectProperties.__GO_POSITION__, newPosition);
144                         } else {
145                             GraphicController.getController().setProperty(getId(), GraphicObjectProperties.__GO_POSITION__, positions);
146                         }
147                     }
148                 }
149
150                 if (hasLayout == false) {
151                     for (Component comp : getComponents()) {
152                         if (comp instanceof Widget) {
153                             SwingViewObject obj = (SwingViewObject) comp;
154                             obj.update(__GO_POSITION__, GraphicController.getController().getProperty(obj.getId(), __GO_POSITION__));
155                         }
156                     }
157                 }
158             }
159
160             public void componentMoved(ComponentEvent e) { }
161
162             public void componentHidden(ComponentEvent e) { }
163         });
164     }
165
166     /**
167      * Draws a Swing Scilab frame
168      * @see org.scilab.modules.gui.UIElement#draw()
169      */
170     public void draw() {
171         this.setVisible(true);
172         this.doLayout();
173     }
174
175     /**
176      * Gets the dimensions (width and height) of a swing Scilab frame
177      * @return the dimension of the frame
178      * @see org.scilab.modules.gui.UIElement#getDims()
179      */
180     public Size getDims() {
181         return new Size(this.getSize().width, this.getSize().height);
182     }
183
184     /**
185      * Gets the position (X-coordinate and Y-coordinate) of a swing Scilab frame
186      * @return the position of the frame
187      * @see org.scilab.modules.gui.UIElement#getPosition()
188      */
189     public Position getPosition() {
190         return PositionConverter.javaToScilab(getLocation(), getSize(), getParent());
191     }
192
193     /**
194      * Sets the dimensions (width and height) of a swing Scilab frame
195      * @param newSize the size we want to set to the frame
196      * @see org.scilab.modules.gui.UIElement#setDims(org.scilab.modules.gui.utils.Size)
197      */
198     public void setDims(Size newSize) {
199         this.setSize(newSize.getWidth(), newSize.getHeight());
200     }
201
202     /**
203      * Sets the position (X-coordinate and Y-coordinate) of a swing Scilab frame
204      * @param newPosition the position we want to set to the frame
205      * @see org.scilab.modules.gui.UIElement#setPosition(org.scilab.modules.gui.utils.Position)
206      */
207     public void setPosition(Position newPosition) {
208         Position javaPosition = PositionConverter.scilabToJava(newPosition, getDims(), getParent());
209         setLocation(javaPosition.getX(), javaPosition.getY());
210     }
211
212     /**
213      * Add a SwingViewObject (from SwingView.java) to container and returns its index
214      * @param member the member to add
215      */
216     public void addMember(SwingViewObject member) {
217         //forward disable status
218         if (isEnabled() == false) {
219             ((Component) member).setEnabled(false);
220         }
221
222         if (member instanceof SwingScilabAxes) {
223             if (canvas == null) {
224                 //editorEventHandler = new EditorEventListener(getId());
225                 AxesContainer frame = (AxesContainer) GraphicModel.getModel().getObjectFromId(getId());
226                 canvas = new SwingScilabCanvas(frame);
227                 //canvas.addEventHandlerKeyListener(editorEventHandler);
228                 //canvas.addEventHandlerMouseListener(editorEventHandler);
229                 //canvas.addEventHandlerMouseMotionListener(editorEventHandler);
230                 //editorEventHandler.setEnable(true);
231
232                 setLayout(new GridLayout(1, 1));
233                 hasLayout = true;
234                 add(canvas);
235             }
236             return;
237         }
238
239         Uicontrol uicontrol = (Uicontrol) GraphicModel.getModel().getObjectFromId(member.getId());
240         if (getLayout() instanceof BorderLayout) {
241             switch (uicontrol.getBorderPositionAsEnum()) {
242                 case BOTTOM:
243                     add((Component) member, BorderLayout.SOUTH);
244                     break;
245                 case TOP:
246                     add((Component) member, BorderLayout.NORTH);
247                     break;
248                 case LEFT:
249                     add((Component) member, BorderLayout.WEST);
250                     break;
251                 case RIGHT:
252                     add((Component) member, BorderLayout.EAST);
253                     break;
254                 case CENTER:
255                     add((Component) member, BorderLayout.CENTER);
256                     break;
257                 default:
258                     break;
259             }
260
261             Integer[] preferredSize = uicontrol.getBorderPreferredSize();
262             if (preferredSize[0].equals(-1) == false && preferredSize[1].equals(-1) == false) {
263                 ((Component) member).setPreferredSize(new Dimension(preferredSize[0], preferredSize[1]));
264             }
265         } else if (getLayout() instanceof GridBagLayout) {
266             GridBagConstraints constraints = new GridBagConstraints();
267
268             // Grid
269             Integer[] grid = uicontrol.getGridBagGrid();
270             constraints.gridx = grid[0];
271             constraints.gridy = grid[1];
272             constraints.gridwidth = grid[2];
273             constraints.gridheight = grid[3];
274
275             // Weight
276             Double[] weight = uicontrol.getGridBagWeight();
277             constraints.weightx = weight[0];
278             constraints.weighty = weight[1];
279
280             // Anchor
281             switch (uicontrol.getGridBagAnchorAsEnum()) {
282                 case LEFT :
283                     constraints.anchor = GridBagConstraints.WEST;
284                     break;
285                 case UPPER :
286                     constraints.anchor = GridBagConstraints.NORTH;
287                     break;
288                 case LOWER:
289                     constraints.anchor = GridBagConstraints.SOUTH;
290                     break;
291                 case LOWER_LEFT:
292                     constraints.anchor = GridBagConstraints.SOUTHWEST;
293                     break;
294                 case LOWER_RIGHT:
295                     constraints.anchor = GridBagConstraints.SOUTHEAST;
296                     break;
297                 case RIGHT:
298                     constraints.anchor = GridBagConstraints.EAST;
299                     break;
300                 case UPPER_LEFT:
301                     constraints.anchor = GridBagConstraints.NORTHWEST;
302                     break;
303                 case UPPER_RIGHT:
304                     constraints.anchor = GridBagConstraints.NORTHEAST;
305                     break;
306                 case CENTER :
307                 default :
308                     constraints.anchor = GridBagConstraints.CENTER;
309                     break;
310             }
311
312             // Fill
313             switch (uicontrol.getGridBagFillAsEnum()) {
314                 case BOTH :
315                     constraints.fill = GridBagConstraints.BOTH;
316                     break;
317                 case HORIZONTAL:
318                     constraints.fill = GridBagConstraints.HORIZONTAL;
319                     break;
320                 case VERTICAL:
321                     constraints.fill = GridBagConstraints.VERTICAL;
322                     break;
323                 case NONE:
324                 default:
325                     constraints.fill = GridBagConstraints.NONE;
326                     break;
327             }
328
329             // Insets
330             Double[] margins = uicontrol.getMargins();
331             constraints.insets = new Insets(
332                 margins[0].intValue(), margins[1].intValue(),
333                 margins[2].intValue(), margins[3].intValue());
334
335             // Padding
336             Integer[] padding = uicontrol.getGridBagPadding();
337             constraints.ipadx = padding[0];
338             constraints.ipady = padding[1];
339
340             Integer[] preferredSize = uicontrol.getGridBagPreferredSize();
341             if (preferredSize[0].equals(-1) == false && preferredSize[1].equals(-1) == false) {
342                 ((Component) member).setPreferredSize(new Dimension(preferredSize[0], preferredSize[1]));
343             }
344
345             add((Component) member, constraints);
346             revalidate();
347         } else if (getLayout() instanceof GridLayout) {
348             this.add((Component) member, 0);
349         } else {
350             this.add((Component) member);
351         }
352
353         //force update position
354         member.update(__GO_POSITION__, GraphicController.getController().getProperty(member.getId(), __GO_POSITION__));
355     }
356
357     /**
358      * Add a member (dockable element) to container and returns its index
359      * @param member the member to add
360      * @return index of member in ArrayList
361      */
362     public int addMember(Console member) {
363         return this.addMember((SwingScilabConsole) member.getAsSimpleConsole());
364     }
365
366     /**
367      * Add a member (dockable element) to container and returns its index
368      * @param member the member to add
369      * @return index of member in ArrayList
370      */
371     private int addMember(SwingScilabConsole member) {
372         this.add(member);
373         return this.getComponentZOrder(member);
374     }
375
376     /**
377      * Add a member (dockable element) to container and returns its index
378      * @param member the member to add
379      * @return index of member in ArrayList
380      */
381     public int addMember(Canvas member) {
382         return this.addMember((SwingScilabCanvas) member.getAsSimpleCanvas());
383     }
384
385     /**
386      * Add a member (dockable element) to container and returns its index
387      * @param member the member to add
388      * @return index of member in ArrayList
389      */
390     private int addMember(SwingScilabCanvas member) {
391         return 0;
392     }
393
394     //   TODO : Check if it should be possible to add a Tab to a frame and how it should behave
395     /**
396      * Add a member (dockable element) to container and returns its index
397      * @param member the member to add
398      * @return index of member in ArrayList
399      */
400     public int addMember(Tab member) {
401         return this.addMember((SwingScilabDockablePanel) member.getAsSimpleTab());
402     }
403     //   TODO : Check if it should be possible to add a Tab to a frame and how it should behave
404     /**
405      * Add a member (dockable element) to container and returns its index
406      * @param member the member to add
407      * @return index of member in ArrayList
408      */
409     private int addMember(SwingScilabDockablePanel member) {
410         this.add(member);
411         return this.getComponentZOrder(member);
412     }
413
414     /**
415      * Add a member (dockable element) to container and returns its index
416      * @param member the member to add
417      * @return index of member in ArrayList
418      */
419     public int addMember(TextBox member) {
420         return this.addMember((SwingScilabTextBox) member.getAsSimpleTextBox());
421     }
422
423     /**
424      * Add a member (dockable element) to container and returns its index
425      * @param member the member to add
426      * @return index of member in ArrayList
427      */
428     private int addMember(SwingScilabTextBox member) {
429         this.add(member);
430         return this.getComponentZOrder(member);
431     }
432
433     /**
434      * Add a callback to the Frame
435      * @param callback the callback to set.
436      */
437     public void setCallback(CommonCallBack callback) {
438         // Nothing to do...
439     }
440
441     /**
442      * Setter for MenuBar
443      * @param menuBarToAdd the MenuBar associated to the Frame.
444      */
445     public void addMenuBar(MenuBar menuBarToAdd) {
446         /* Unimplemented for Frames */
447         throw new UnsupportedOperationException();
448     }
449
450     /**
451      * Setter for ToolBar
452      * @param toolBarToAdd the ToolBar associated to the Frame.
453      */
454     public void addToolBar(ToolBar toolBarToAdd) {
455         /* Unimplemented for Frames */
456         throw new UnsupportedOperationException();
457     }
458
459     /**
460      * Getter for MenuBar
461      * @return MenuBar: the MenuBar associated to the Frame.
462      */
463     public MenuBar getMenuBar() {
464         /* Unimplemented for Frames */
465         throw new UnsupportedOperationException();
466     }
467
468     /**
469      * Getter for ToolBar
470      * @return ToolBar: the ToolBar associated to the Frame.
471      */
472     public ToolBar getToolBar() {
473         /* Unimplemented for Frames */
474         throw new UnsupportedOperationException();
475     }
476
477     /**
478      * Get the text of the Frame
479      * @return the text of the frame
480      * @see org.scilab.modules.gui.frame.SimpleFrame#getText()
481      */
482     public String getText() {
483         return this.getName();
484     }
485
486     /**
487      * Set the text of the Frame
488      * @param text the text to set to the frame
489      * @see org.scilab.modules.gui.frame.SimpleFrame#setText()
490      */
491     public void setText(String text) {
492         this.setName(text);
493     }
494
495     public void setEmptyText() {
496         setText("");
497     }
498
499     /**
500      * Add a dockable element in the Frame (Not available for the moment)
501      * @param member the object we want to add to the Frame
502      * @return the index of the member in the Frame
503      * @see org.scilab.modules.gui.container.Container#addMember(org.scilab.modules.gui.dockable.Dockable)
504      */
505     public int addMember(Dockable member) {
506         /* Unimplemented for Frames */
507         throw new UnsupportedOperationException();
508     }
509
510     /**
511      * Set the Relief of the Frame
512      * @param reliefType the type of the relief to set (See ScilabRelief.java)
513      */
514     public void setRelief(String reliefType) {
515         if (defaultBorder == null) {
516             defaultBorder = getBorder();
517         }
518         setBorder(ScilabRelief.getBorderFromRelief(reliefType, defaultBorder));
519     }
520
521     /**
522      * Destroy the Frame
523      */
524     public void destroy() {
525         this.setVisible(false);
526         //if (editorEventHandler != null) {
527         //    editorEventHandler.onExit();
528         //}
529     }
530
531     /**
532      * Setter for InfoBar
533      * @param infoBarToAdd the InfoBar associated to the Frame.
534      */
535     public void addInfoBar(TextBox infoBarToAdd) {
536         /* Unimplemented for Frames */
537         throw new UnsupportedOperationException();
538     }
539
540     /**
541      * Getter for InfoBar
542      * @return the InfoBar associated to the Frame.
543      */
544     public TextBox getInfoBar() {
545         /* Unimplemented for Frames */
546         throw new UnsupportedOperationException();
547     }
548
549     /**
550      * Set the horizontal alignment for the Slider text
551      * @param alignment the value for the alignment (See ScilabAlignment.java)
552      */
553     public void setHorizontalAlignment(String alignment) {
554         // Nothing to do here
555     }
556
557     /**
558      * Set the vertical alignment for the Slider text
559      * @param alignment the value for the alignment (See ScilabAlignment.java)
560      */
561     public void setVerticalAlignment(String alignment) {
562         // Nothing to do here
563     }
564
565     /**
566      * Set the UID
567      * @param id the UID
568      */
569     public void setId(Integer id) {
570         uid = id;
571     }
572
573     /**
574      * Get the UID
575      * @return the UID
576      */
577     public Integer getId() {
578         return uid;
579     }
580
581     /**
582      * Generic update method
583      * @param property property name
584      * @param value property value
585      */
586     public void update(int property, Object value) {
587         GraphicController controller = GraphicController.getController();
588
589         switch (property) {
590             case __GO_UI_VALUE__: {
591                 if (this instanceof SwingScilabLayer) {
592                     SwingScilabLayer layer = (SwingScilabLayer) this;
593                     Double[] doubleValue = ((Double[]) value);
594                     if (doubleValue.length == 0) {
595                         return;
596                     }
597
598                     Integer val = doubleValue[0].intValue();
599
600                     //if intValue[0] is out of bounds, do not update view but let "wrong" value in model
601                     layer.setActiveLayer(val);
602                 }
603                 break;
604             }
605             case __GO_UI_STRING__: {
606                 // Update tab title
607                 Container parent = getParent();
608                 if (parent instanceof SwingScilabTabGroup) {
609                     SwingScilabTabGroup tab = (SwingScilabTabGroup) parent;
610                     int index = tab.indexOfComponent(this);
611                     if (index != -1) {
612                         tab.setTitleAt(index, ((String[]) value)[0]);
613                     }
614                 }
615
616                 if (this instanceof SwingScilabLayer) {
617                     SwingScilabLayer layer = (SwingScilabLayer) this;
618                     //if intValue[0] is out of bounds, do not update view but let "wrong" value in model
619                     layer.setActiveLayerFromName(((String[]) value)[0]);
620                 }
621                 break;
622             }
623             case __GO_UI_ICON__: {
624                 // Update tab icon title
625                 Container parent = getParent();
626                 if (parent instanceof SwingScilabTabGroup) {
627                     SwingScilabTabGroup tab = (SwingScilabTabGroup) parent;
628                     int index = tab.indexOfComponent(this);
629                     if (index != -1) {
630                         tab.setIconAt(index, (String) value);
631                     }
632                 }
633
634                 break;
635             }
636             case __GO_POSITION__: {
637                 SwingViewWidget.updatePosition(this, uid, value);
638                 validate();
639                 doLayout();
640                 break;
641             }
642             case __GO_UI_FRAME_BORDER__: {
643                 Integer borderId = (Integer) value;
644                 Border border = BorderConvertor.getBorder(borderId);
645                 setBorder(border);
646                 break;
647             }
648             case __GO_LAYOUT__: {
649                 hasLayout = false;
650
651                 invalidate();
652
653                 LayoutType newLayout = LayoutType.intToEnum((Integer) value);
654                 switch (newLayout) {
655                     case BORDER: {
656                         Integer[] padding = (Integer[]) controller.getProperty(getId(), __GO_BORDER_OPT_PADDING__);
657                         setLayout(new BorderLayout(padding[0], padding[1]));
658                         hasLayout = true;
659                         break;
660                     }
661                     case GRIDBAG:
662                         setLayout(new GridBagLayout());
663                         hasLayout = true;
664                         break;
665                     case GRID: {
666                         Integer[] padding = (Integer[]) controller.getProperty(getId(), __GO_GRID_OPT_PADDING__);
667                         Integer[] grid = (Integer[]) controller.getProperty(getId(), __GO_GRID_OPT_GRID__);
668                         if (grid[0] == 0 && grid[1] == 0) {
669                             grid[0] = 1;
670                         }
671
672                         setLayout(new GridLayout(grid[0], grid[1], padding[0], padding[1]));
673                         hasLayout = true;
674                         break;
675                     }
676                     case NONE:
677                     default: {
678                         setLayout(null);
679                         hasLayout = false;
680                         break;
681                     }
682                 }
683
684                 validate();
685                 break;
686             }
687             case __GO_GRID_OPT_PADDING__:
688             case __GO_GRID_OPT_GRID__: {
689                 Integer layout = (Integer) GraphicController.getController().getProperty(getId(), __GO_LAYOUT__);
690                 LayoutType layoutType = LayoutType.intToEnum(layout);
691
692                 if (layoutType != LayoutType.GRID) {
693                     break;
694                 }
695
696                 Integer[] padding = (Integer[]) GraphicController.getController().getProperty(getId(), __GO_GRID_OPT_PADDING__);
697
698                 Integer[] grid = (Integer[]) GraphicController.getController().getProperty(getId(), __GO_GRID_OPT_GRID__);
699                 Integer[] localGrid = new Integer[] { 0, 0 };
700                 localGrid[0] = grid[0];
701                 localGrid[1] = grid[1];
702
703                 if (localGrid[0] == 0 && localGrid[1] == 0) {
704                     localGrid[0] = 1;
705                 }
706
707                 invalidate();
708
709                 GridLayout gl = (GridLayout)getLayout();
710                 gl.setRows(localGrid[0]);
711                 gl.setColumns(localGrid[1]);
712                 gl.setHgap(padding[0]);
713                 gl.setVgap(padding[1]);
714
715                 validate();
716                 break;
717             }
718             case __GO_BORDER_OPT_PADDING__: {
719                 Integer layout = (Integer) GraphicController.getController().getProperty(getId(), __GO_LAYOUT__);
720                 LayoutType layoutType = LayoutType.intToEnum(layout);
721
722                 if (layoutType != LayoutType.BORDER) {
723                     break;
724                 }
725
726                 invalidate();
727
728                 Integer[] padding = (Integer[])value;
729                 BorderLayout bl = (BorderLayout)getLayout();
730                 bl.setHgap(padding[0]);
731                 bl.setVgap(padding[1]);
732
733                 validate();
734                 break;
735             }
736             case __GO_VISIBLE__: {
737                 boolean needUpdate = true;
738                 Component parent = getParent();
739                 if (parent instanceof SwingScilabLayer) {
740                     //no no no don't touch visible on layer children !
741                     Boolean visible = (Boolean) value;
742                     SwingScilabLayer layer = (SwingScilabLayer) parent;
743                     Boolean isActive = layer.isLayerActive(this);
744                     if (isActive != visible) {
745                         controller.setProperty(uid, __GO_VISIBLE__, isActive);
746                     }
747
748                     needUpdate = false;
749                 } else if (parent instanceof SwingScilabTabGroup) {
750                     //no no no don't touch visible on layer children !
751                     Boolean visible = (Boolean) value;
752                     SwingScilabTabGroup layer = (SwingScilabTabGroup) parent;
753                     Boolean isActive = layer.isTabActive(this);
754                     if (isActive != visible) {
755                         controller.setProperty(uid, __GO_VISIBLE__, isActive);
756                     }
757
758                     needUpdate = false;
759                 }
760
761                 if (needUpdate) {
762                     setVisible(((Boolean) value).booleanValue());
763                 }
764
765                 break;
766             }
767             case __GO_TAG__ : {
768                 Component parent = getParent();
769                 if (parent instanceof SwingScilabLayer) {
770                     SwingScilabLayer layer = (SwingScilabLayer)parent;
771                     layer.updateModelProperties(null, layer.getActiveLayer());
772                 } else if (parent instanceof SwingScilabTabGroup) {
773                     ((SwingScilabTabGroup)parent).updateModelProperties();
774                 }
775                 break;
776             }
777             case __GO_EVENTHANDLER_ENABLE__ : {
778                 Boolean enabled = (Boolean) GraphicController.getController().getProperty(getId(), __GO_EVENTHANDLER_ENABLE__);
779                 setEventHandlerEnabled(enabled);
780                 break;
781             }
782             case __GO_EVENTHANDLER_NAME__: {
783                 String eventHandlerName = (String) GraphicController.getController().getProperty(getId(), __GO_EVENTHANDLER_NAME__);
784                 setEventHandler(eventHandlerName);
785                 break;
786             }
787             default:
788                 SwingViewWidget.update(this, property, value);
789                 break;
790         }
791     }
792
793     /**
794      * Set the enable status of the frame and its children
795      * @param status the status to set
796      */
797     public void setEnabled(boolean status) {
798         if (status) {
799             // Enable the frame
800             super.setEnabled(status);
801             // Enable its children according to their __GO_UI_ENABLE__ property
802             Integer[] children = (Integer[]) GraphicController.getController().getProperty(uid, __GO_CHILDREN__);
803             for (int kChild = 0; kChild < children.length; kChild++) {
804                 Integer type = (Integer)GraphicController.getController().getProperty(children[kChild], __GO_TYPE__);
805                 if (type == __GO_UICONTROL__) {
806                     Boolean childStatus = (Boolean) GraphicController.getController().getProperty(children[kChild], __GO_UI_ENABLE__);
807                     SwingView.getFromId(children[kChild]).update(__GO_UI_ENABLE__, childStatus);
808                 }
809             }
810         } else {
811             // Disable the frame
812             super.setEnabled(status);
813             // Disable its children
814             Component[] components = getComponents();
815             for (int compIndex = 0; compIndex < components.length; compIndex++) {
816                 components[compIndex].setEnabled(false);
817             }
818         }
819
820         //if parent is a tab enable/disable children tab
821         Component parent = getParent();
822         if (parent instanceof SwingScilabTabGroup) {
823             SwingScilabTabGroup tab = (SwingScilabTabGroup)parent;
824             Integer index = tab.getIndex(this);
825             if (index != -1) {
826                 tab.setEnabledAt(index, status);
827             }
828         }
829     }
830
831     //    public void setForeground(Color color) {
832     //        System.out.println((Color)UIManager.getLookAndFeelDefaults().get("Panel.foreground"));
833     //        super.setForeground((Color)UIManager.getLookAndFeelDefaults().get("Panel.foreground"));
834     //    }
835
836     public void resetBackground() {
837         Color color = (Color)UIManager.getLookAndFeelDefaults().get("Panel.background");
838         if (color != null) {
839             setBackground(color);
840         }
841     }
842
843     public void resetForeground() {
844         Color color = (Color)UIManager.getLookAndFeelDefaults().get("Panel.foreground");
845         if (color != null) {
846             setForeground(color);
847         }
848     }
849
850     public void removeAxes() {
851         if (canvas != null) {
852             canvas.setEnabled(false);
853             remove(canvas);
854             canvas.removeNotify();
855             canvas = null;
856             repaint();
857         }
858     }
859     
860     /**
861      * Set the event handler of the Canvas
862      * @param funName the name of the Scilab function to call
863      */
864     public void setEventHandler(String funName) {
865         disableEventHandler();
866         eventHandler = new ScilabEventListener(funName, getId());
867         if (eventEnabled) {
868             //editorEventHandler.setEnable(false);
869             enableEventHandler();
870         }
871     }
872
873     /**
874      * Set the status of the event handler of the Canvas
875      * @param status is true to set the event handler active
876      */
877     public void setEventHandlerEnabled(boolean status) {
878         if (status && eventEnabled) {
879             return;
880         }
881
882         if (status) {
883             //editorEventHandler.setEnable(false);
884             enableEventHandler();
885             eventEnabled = true;
886         } else {
887             //editorEventHandler.setEnable(true);
888             disableEventHandler();
889             eventEnabled = false;
890         }
891     }
892     
893     /**
894      * Turn on event handling.
895      */
896     private void enableEventHandler() {
897         if (canvas != null) {
898             canvas.addEventHandlerKeyListener(eventHandler);
899             canvas.addEventHandlerMouseListener(eventHandler);
900             canvas.addEventHandlerMouseMotionListener(eventHandler);
901         }
902     }
903
904     /**
905      * Turn off event handling.
906      */
907     private void disableEventHandler() {
908         if (eventHandler != null && canvas != null) {
909             canvas.removeEventHandlerKeyListener(eventHandler);
910             canvas.removeEventHandlerMouseListener(eventHandler);
911             canvas.removeEventHandlerMouseMotionListener(eventHandler);
912         }
913     }
914
915 }