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