UIW: delete module and move the code in gui
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / uiwidget / UIComponent.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - Scilab Enterprises - Calixte DENIZET
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 package org.scilab.modules.gui.uiwidget;
14
15 import java.awt.BorderLayout;
16 import java.awt.Color;
17 import java.awt.Component;
18 import java.awt.Container;
19 import java.awt.Cursor;
20 import java.awt.Dimension;
21 import java.awt.Font;
22 import java.awt.GridBagLayout;
23 import java.awt.KeyEventDispatcher;
24 import java.awt.KeyboardFocusManager;
25 import java.awt.LayoutManager;
26 import java.awt.Point;
27 import java.awt.event.KeyEvent;
28 import java.awt.event.MouseAdapter;
29 import java.awt.font.TextAttribute;
30 import java.awt.geom.Rectangle2D;
31 import java.awt.image.BufferedImage;
32 import java.io.File;
33 import java.lang.reflect.Constructor;
34 import java.lang.reflect.InvocationTargetException;
35 import java.lang.reflect.Method;
36 import java.util.ArrayList;
37 import java.util.HashMap;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.Set;
41 import java.util.TreeMap;
42
43 import javax.imageio.ImageIO;
44 import javax.swing.AbstractButton;
45 import javax.swing.ButtonGroup;
46 import javax.swing.JComponent;
47 import javax.swing.JFrame;
48 import javax.swing.JPopupMenu;
49 import javax.swing.JScrollBar;
50 import javax.swing.JScrollPane;
51 import javax.swing.JTabbedPane;
52 import javax.swing.RootPaneContainer;
53 import javax.swing.ScrollPaneConstants;
54 import javax.swing.SwingUtilities;
55
56 import org.flexdock.view.View;
57 import org.scilab.modules.commons.ScilabCommonsUtils;
58 import org.scilab.modules.gui.bridge.tab.SwingScilabTab;
59 import org.scilab.modules.gui.utils.ScilabRelief;
60 import org.scilab.modules.types.ScilabType;
61 import org.scilab.modules.gui.uiwidget.callback.UICallback;
62 import org.scilab.modules.gui.uiwidget.components.NoLayout;
63 import org.scilab.modules.gui.uiwidget.components.UIFocusListener;
64 import org.scilab.modules.gui.uiwidget.components.UIMouseListener;
65 import org.scilab.modules.gui.uiwidget.components.UITab;
66 import org.scilab.modules.gui.uiwidget.components.UITools;
67 import org.xml.sax.Attributes;
68
69 /**
70  * Main class to handle Java components.
71  */
72 public abstract class UIComponent {
73
74     static {
75         ScilabCommonsUtils.loadOnUse("graphics");
76     }
77
78     private static final MouseAdapter NOMOUSE = new MouseAdapter() { };
79     private static final KeyEventDispatcher NOKEY = new KeyEventDispatcher() {
80         public boolean dispatchKeyEvent(KeyEvent e) {
81             return true;
82         }
83     };
84
85     private static int UID = 0;
86
87     protected Object component;
88     protected Object modifiableComponent;
89     private boolean thisOrComponent = true;
90     private String id;
91     private int uid;
92     protected UIComponent root;
93     protected UIComponent parent;
94     protected Map<String, ButtonGroup> buttonGroups;
95     protected Map<String, UIComponent> children;
96     protected List<UIComponent> childrenList;
97     protected Map<String, Map<String, String>> style;
98     protected UIMouseListener mouseListener;
99     protected UIFocusListener focusListener;
100     protected String path;
101     protected Map<String, String> constraint;
102     protected Map<String, String> uistyle;
103     protected String tabTitle;
104     protected boolean enableEvents = true;
105     protected String relief;
106     protected UITools.FontUnit fontUnit = UITools.FontUnit.POINTS;
107
108     protected NoLayout.NoLayoutConstraint nolayoutconstraint;
109
110     /**
111      * Default empty constructor
112      */
113     protected UIComponent() { }
114
115     /**
116      * Constructor
117      * @param parent the parent UIComponent
118      */
119     public UIComponent(UIComponent parent) throws UIWidgetException {
120         this.parent = parent;
121         this.uid = UID++;
122
123         if (this.parent != null) {
124             this.root = this.parent.root;
125         } else {
126             this.root = this;
127         }
128         UILocator.add(this);
129         registerToParent();
130     }
131
132     /**
133      * Register this component to its parent
134      */
135     private final void registerToParent() {
136         if (!isRoot()) {
137             if (parent.childrenList == null) {
138                 parent.childrenList = new ArrayList<UIComponent>();
139             }
140             parent.childrenList.add(this);
141         }
142     }
143
144     /**
145      * Register id to parent
146      */
147     private final void registerIdToParent() {
148         if (parent != null && parent.path != null && id != null) {
149             if (parent.children == null) {
150                 parent.children = new HashMap<String, UIComponent>();
151             }
152
153             parent.children.put(id, this);
154         }
155     }
156
157     /**
158      * Get a Map from Attributes object
159      * @param attributes the attributes
160      * @return a Map containing the pairs attribute-name -- attribute-value
161      */
162     public static final StringMap getMapFromAttributes(Attributes attributes) {
163         final int len = attributes != null ? attributes.getLength() : 0;
164         StringMap map = new StringMap(len);
165         for (int i = 0; i < len; i++) {
166             map.put(attributes.getLocalName(i), attributes.getValue(i));
167         }
168
169         return map;
170     }
171
172     /**
173      * Construct an UIComponent
174      * @param pack the Java package name containing the component to instantiate
175      * @param name the UIComponent name
176      * @param attributes an array of length 2xN containing attributes name and value
177      * @param parent the parent UIComponent
178      * @return the newly constructed UIComponent
179      */
180     public static final UIComponent getUIComponent(String pack, String name, String[] attributes, UIComponent parent) throws UIWidgetException {
181         final int len = attributes != null ? (attributes.length % 2 == 0 ? attributes.length : attributes.length - 1) : 0;
182         StringMap map = new StringMap(len);
183         for (int i = 0; i < len; i += 2) {
184             map.put(attributes[i], attributes[i + 1]);
185         }
186
187         return getUIComponent(pack, name, map, parent, parent == null ? null : parent.style);
188     }
189
190     /**
191      * Construct an UIComponent
192      * @param pack the Java package name containing the component to instantiate
193      * @param name the UIComponent name
194      * @param attributes the attributes
195      * @param parent the parent UIComponent
196      * @return the newly constructed UIComponent
197      */
198     public static final UIComponent getUIComponent(String pack, String name, Attributes attributes, UIComponent parent, Map<String, Map<String, String>> style) throws UIWidgetException {
199         return getUIComponent(pack, name, getMapFromAttributes(attributes), parent, style);
200     }
201
202     /**
203      * Construct an UIComponent
204      * @param pack the Java package name containing the component to instantiate
205      * @param name the UIComponent name
206      * @param attributes the attributes
207      * @param parent the parent UIComponent
208      * @return the newly constructed UIComponent
209      */
210     public static final UIComponent getUIComponent(String pack, String name, ConvertableMap attributes, final UIComponent parent, Map<String, Map<String, String>> style) throws UIWidgetException {
211         try {
212             Class clazz = UIClassFinder.findClass(pack, name);
213             final Constructor constructor = clazz.getConstructor(UIComponent.class);
214             final UIComponent[] arr = new UIComponent[1];
215
216             if (SwingUtilities.isEventDispatchThread()) {
217                 arr[0] = (UIComponent) constructor.newInstance(parent);
218             } else {
219                 try {
220                     SwingUtilities.invokeAndWait(new Runnable() {
221                         public void run() {
222                             try {
223                                 arr[0] = (UIComponent) constructor.newInstance(parent);
224                             } catch (InvocationTargetException e) {
225                                 System.err.println(e.getCause());
226                                 e.getCause().printStackTrace();
227                             } catch (Exception e) {
228                                 System.err.println(e);
229                                 e.printStackTrace();
230                             }
231                         }
232                     });
233                 } catch (InvocationTargetException e) {
234                     System.err.println(e.getCause());
235                     e.getCause().printStackTrace();
236                     return null;
237                 } catch (Exception e) {
238                     System.err.println(e);
239                     e.printStackTrace();
240                     return null;
241                 }
242             }
243             UIComponent ui = arr[0];
244             String id = null;
245             if (attributes.containsKey("id")) {
246                 id = (String) attributes.get(String.class, "id", null);
247                 attributes.remove("id");
248             } else if (attributes.containsKey("tag")) {
249                 id = (String) attributes.get(String.class, "tag", null);
250                 attributes.remove("tag");
251             }
252             ui.setId(id);
253             ui.setMapStyle(style);
254             String tabTitle = (String) attributes.get(String.class, "tab-title", null);
255             if (tabTitle != null) {
256                 ui.setTabTitle(tabTitle);
257                 attributes.remove("tab-title");
258             }
259             ui.createNewInstance(attributes);
260             try {
261                 //ui.getPropertiesPairs();
262             } catch (Exception e) {
263                 e.printStackTrace();
264             }
265
266             return ui;
267         } catch (ClassNotFoundException e) {
268             throw new UIWidgetException("Cannot find the class " + pack + "." + name);
269         } catch (NoSuchMethodException e) {
270             throw new UIWidgetException("Cannot find a valid constructor in class " + pack + "." + name + ":\n" + e.getMessage());
271         } catch (SecurityException e) {
272             throw new UIWidgetException("Cannot find a valid constructor in class " + pack + "." + name + ":\n" + e.getMessage());
273         } catch (InstantiationException e) {
274             throw new UIWidgetException("Cannot instantiate the class " + pack + "." + name + ":\n" + e.getMessage());
275         } catch (IllegalAccessException e) {
276             throw new UIWidgetException("Cannot instantiate the class " + pack + "." + name + ":\n" + e.getMessage());
277         } catch (IllegalArgumentException e) {
278             throw new UIWidgetException("Cannot instantiate the class " + pack + "." + name + ":\n" + e.getMessage());
279         } catch (InvocationTargetException e) {
280             System.err.println(e);
281             e.getTargetException().printStackTrace();
282             throw new UIWidgetException("Cannot instantiate the class " + pack + "." + name + ":\n" + e.getCause());
283         }
284     }
285
286     public void setNoLayoutConstraint(double x, double y, double width, double height) {
287         if (nolayoutconstraint == null) {
288             nolayoutconstraint = new NoLayout.NoLayoutConstraint();
289         }
290         nolayoutconstraint.setPoint(x, y);
291         nolayoutconstraint.setDims(width, height);
292     }
293
294     public void setNoLayoutConstraint(double width, double height) {
295         if (nolayoutconstraint == null) {
296             nolayoutconstraint = new NoLayout.NoLayoutConstraint();
297             nolayoutconstraint.setPoint(0, 0);
298         }
299         nolayoutconstraint.setDims(width, height);
300     }
301
302     /**
303      * Create a new instance of this UIComponent
304      * @return the created instance
305      */
306     public abstract Object newInstance();
307
308     /**
309      * Get the backed component
310      * @return the component
311      */
312     public Object getComponent() {
313         return component;
314     }
315
316     /**
317      * Set the component
318      * @param o the component
319      */
320     public void setComponent(Object o) {
321         if (this.component != o) {
322             if (this.component != null) {
323                 this.modifiableComponent = null;
324             }
325             this.component = o;
326
327             initialize();
328         }
329     }
330
331     /**
332      * Initialize the component if mandatory
333      */
334     protected void initialize() {
335
336     }
337
338     /**
339      * Get the Scilab representation as used in %h_p.sci
340      * @return an array of string to be evstr
341      */
342     public String[] getScilabRepresentation() {
343         return null;
344     }
345
346     /**
347      * Enable events
348      * @param b if true events are enabled
349      */
350     public void setEnableEvents(boolean b) {
351         if (b != this.enableEvents) {
352             RootPaneContainer root = null;
353             if (component instanceof JComponent) {
354                 root = (RootPaneContainer) ((JComponent) component).getTopLevelAncestor();
355             } else if (component instanceof RootPaneContainer) {
356                 root = (RootPaneContainer) component;
357             }
358             if (root != null) {
359                 root.getGlassPane().setVisible(!b);
360                 if (b) {
361                     KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventDispatcher(NOKEY);
362                     root.getGlassPane().removeMouseListener(NOMOUSE);
363                 } else {
364                     KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(NOKEY);
365                     root.getGlassPane().addMouseListener(NOMOUSE);
366                 }
367             }
368             this.enableEvents = b;
369         }
370     }
371
372     /**
373      * Check if events are enabled
374      * @return true if the events are enabled
375      */
376     public boolean getEnableEvents() {
377         return this.enableEvents;
378     }
379
380     public void setScreenShot(String file) {
381         Component c = null;
382         if (component instanceof JFrame) {
383             c = ((JFrame) component).getRootPane();
384         } else if (component instanceof Component) {
385             c = (Component) component;
386         }
387
388         if (c != null) {
389             BufferedImage image = new BufferedImage(c.getWidth(), c.getHeight(), BufferedImage.TYPE_INT_RGB);
390             c.paint(image.getGraphics());
391
392             try {
393                 ImageIO.write(image, "png", new File(file));
394             } catch (Exception e) {
395                 e.printStackTrace();
396             }
397         }
398     }
399
400     /**
401      * Set the cursor
402      * @param cursor the cursor
403      */
404     public void setCursor(Cursor cursor) {
405         if (component instanceof Component) {
406             ((Component) component).setCursor(cursor);
407         }
408     }
409
410     /**
411      * Get the cursor
412      * @return the cursor
413      */
414     public Cursor getCursor() {
415         if (component instanceof Component) {
416             return ((Component) component).getCursor();
417         }
418
419         return null;
420     }
421
422     /**
423      * Get the modifiable component (can be different of component, e.g. with a JScrollPane containing the component)xs
424      * @return the modfifiable component
425      */
426     public Object getModifiableComponent() {
427         return modifiableComponent == null ? component : modifiableComponent;
428     }
429
430     /**
431      * Get the modifiable component as a JComponent
432      * @return modifiable JComponent
433      */
434     public JComponent getModifiableJComponent() throws UIWidgetException {
435         Object c = getModifiableComponent();
436         if (c instanceof JComponent) {
437             return (JComponent) c;
438         }
439
440         throw new UIWidgetException("Not a JComponent");
441     }
442
443     /**
444      * Get the component as a JComponent
445      * @return the JComponent
446      */
447     public JComponent getJComponent() throws UIWidgetException {
448         Object c = getComponent();
449         if (c instanceof JComponent) {
450             return (JComponent) c;
451         }
452
453         throw new UIWidgetException("Not a JComponent");
454     }
455
456     /**
457      * Get the modifiable component as a Container
458      * @return the Container
459      */
460     public Container getModifiableContainer() throws UIWidgetException {
461         Object c = getModifiableComponent();
462         if (c instanceof Container) {
463             return (Container) c;
464         }
465
466         throw new UIWidgetException("Not a Container");
467     }
468
469     /**
470      * Get the component as a Container
471      * @return the Container
472      */
473     public Container getContainer() throws UIWidgetException {
474         Object c = getComponent();
475         if (c instanceof Container) {
476             return (Container) c;
477         }
478
479         throw new UIWidgetException("Not a Container");
480     }
481
482     /**
483      * Get the layout constraint
484      * @return the constraint
485      */
486     public Map<String, String> getLayoutConstraint() {
487         return this.constraint;
488     }
489
490     /**
491      * @return the UIComponent name
492      */
493     public String getType() {
494         return "UIWidget";
495     }
496
497     /**
498      * @return the UIComponent name
499      */
500     public String getStyle() {
501         return this.getClass().getSimpleName();
502     }
503
504     /**
505      * @return the component visibility
506      */
507     public boolean getHandleVisible() {
508         if (component instanceof Component) {
509             return ((Component) component).isVisible();
510         }
511
512         return false;
513     }
514
515     /**
516      * Set component visibility
517      * @param b true to make it visible
518      */
519     public void setHandleVisible(boolean b) {
520         if (component instanceof Component) {
521             ((Component) component).setVisible(b);
522         }
523     }
524
525     /**
526      * @return the uid
527      */
528     public int getUid() {
529         return uid;
530     }
531
532     /**
533      * Check the component validity
534      * @return true if the component is valid
535      */
536     public boolean isValid() {
537         return component != null;
538     }
539
540     /**
541      * Set the preferred size
542      * @param dim the preferred dimension
543      */
544     public void setPreferredSize(Dimension dim) throws UIWidgetException {
545         getContainer().setPreferredSize(dim);
546     }
547
548     /**
549      * Get the preferred size
550      * @return the preferred dimension
551      */
552     public Dimension getPreferredSize() throws UIWidgetException {
553         return getContainer().getPreferredSize();
554     }
555
556     /**
557      * Set the size
558      * @param d the size
559      */
560     public void setSize(Dimension d) throws UIWidgetException {
561         if (getComponent() instanceof Component) {
562             Component c = (Component) getComponent();
563             Container p = c.getParent();
564             if (p != null && p.getLayout() instanceof NoLayout) {
565                 setNoLayoutConstraint((double) d.width, (double) d.height);
566                 if (p != null && p.isVisible()) {
567                     p.invalidate();
568                     p.validate();
569                     p.repaint();
570                 }
571             } else {
572                 if (!c.getSize().equals(d)) {
573                     JFrame win = (JFrame) SwingUtilities.getAncestorOfClass(JFrame.class, c);
574                     if (win != null) {
575                         win.setPreferredSize(null);
576                         if (c instanceof SwingScilabTab) {
577                             c.setPreferredSize(d);
578                         } else {
579                             c.setSize(d);
580                         }
581                         if (win.isVisible()) {
582                             win.invalidate();
583                             win.pack();
584                         }
585                     }
586                 }
587             }
588         }
589
590     }
591
592     /**
593      * Get the size
594      * @return the dimension
595      */
596     public Dimension getSize() throws UIWidgetException {
597         return getContainer().getSize();
598     }
599
600     /**
601      * Set the minimum size
602      * @param dim the minimum dimension
603      */
604     public void setMinimumSize(Dimension dim) throws UIWidgetException {
605         getContainer().setMinimumSize(dim);
606     }
607
608     /**
609      * Get the minimum size
610      * @return the minimum dimension
611      */
612     public Dimension getMinimumSize() throws UIWidgetException {
613         return getContainer().getMinimumSize();
614     }
615
616     /**
617      * Set the maximum size
618      * @param dim the maximum dimension
619      */
620     public void setMaximumSize(Dimension dim) throws UIWidgetException {
621         getContainer().setMaximumSize(dim);
622     }
623
624     /**
625      * Get the maximum size
626      * @return the maximum dimension
627      */
628     public Dimension getMaximumSize() throws UIWidgetException {
629         return getContainer().getMaximumSize();
630     }
631
632     /**
633      * Set the parent
634      * @param parent the parent
635      */
636     public void setParent(UIComponent parent) throws UIWidgetException {
637         if (parent != this.parent) {
638             if (this.parent != null && this.parent.children != null && id != null) {
639                 this.parent.children.remove(id);
640             }
641             if (this.parent != null && this.parent.childrenList != null) {
642                 this.parent.childrenList.remove(this);
643             }
644             if (isRoot() && buttonGroups != null) {
645                 if (parent.root.buttonGroups == null) {
646                     parent.root.buttonGroups = buttonGroups;
647                 } else {
648                     parent.root.buttonGroups.putAll(buttonGroups);
649                 }
650                 buttonGroups = null;
651             }
652
653             UILocator.removeFromCachedPaths(this);
654             this.parent = parent;
655             setRoot(parent == null ? this : parent.root);
656             invalidateUIPath();
657             registerToParent();
658             registerIdToParent();
659             if (isRoot()) {
660                 UILocator.addRoot(this);
661             } else {
662                 parent.add(this);
663             }
664         }
665     }
666
667     /**
668      * Set the root element
669      * @param root the root element
670      */
671     private void setRoot(final UIComponent root) {
672         this.root = root;
673         if (childrenList != null) {
674             for (UIComponent c : childrenList) {
675                 if (root == null) {
676                     c.setRoot(this);
677                 } else {
678                     c.setRoot(root);
679                 }
680             }
681         }
682     }
683
684     /**
685      * Set the parent with the given id
686      * @param parentId the id of the parent
687      */
688     public void setParent(String parentId) throws UIWidgetException {
689         UIComponent parent = UILocator.get(parentId);
690         if (parent != null) {
691             setParent(parent);
692         }
693     }
694
695     /**
696      * Set the id
697      * @param id the id to set
698      */
699     public void setId(String id) {
700         if ((id != null && !id.equals(this.id)) || (id == null && this.id != null)) {
701             if (!isRoot() && this.id != null && parent.children != null) {
702                 parent.children.remove(this.id);
703             }
704             UILocator.removeFromCachedPaths(this);
705             this.id = id;
706             invalidateUIPath();
707             if (isRoot()) {
708                 UILocator.addRoot(this);
709             } else {
710                 registerIdToParent();
711             }
712         }
713     }
714
715     /**
716      * Get the id of this UIComponent
717      *@return the id
718      */
719     public String getId() {
720         return this.id;
721     }
722
723     /**
724      * Set the tag (Scilab's UIControl compatibility)
725      * @param tag the tag
726      */
727     public void setTag(String tag) {
728         setId(tag);
729     }
730
731     /**
732      * Get the tag (id) of this UIComponent
733      *@return the tag
734      */
735     public String getTag() {
736         return getId();
737     }
738
739     /**
740      * Invalidate the path to this UIComponent
741      */
742     private void invalidateUIPath() {
743         UILocator.removeFromCachedPaths(this);
744         if (id != null) {
745             if (isRoot()) {
746                 path = "/" + id;
747             } else if (parent.path != null) {
748                 path = parent.path + "/" + id;
749             }
750
751             if (path != null) {
752                 if (children != null) {
753                     for (UIComponent ui : children.values()) {
754                         ui.invalidateUIPath();
755                     }
756                 } else {
757                     if (childrenList != null) {
758                         for (UIComponent child : childrenList) {
759                             child.registerIdToParent();
760                         }
761                         if (children != null) {
762                             for (UIComponent ui : children.values()) {
763                                 ui.invalidateUIPath();
764                             }
765                         }
766                     }
767                 }
768             }
769         }
770     }
771
772     /**
773      * Get the path to this UIComponent
774      * @return the path
775      */
776     public String getUIPath() {
777         return this.path;
778     }
779
780     /**
781      * Get the path to this UIComponent
782      * @return the path
783      */
784     public String getPath() {
785         return getUIPath();
786     }
787
788     /**
789      * Get the root id of this UIComponent
790      * @return the root id
791      */
792     public String getRootId() {
793         return getRoot().id;
794     }
795
796     /**
797      * Get the root element
798      * @return the root
799      */
800     public UIComponent getRoot() {
801         return root;
802     }
803
804     /**
805      * Add a button to a button-group
806      * @param name the name of the button-group
807      * @param button the button to add
808      */
809     public void addToButtonGroup(String name, AbstractButton button) {
810         if (isRoot()) {
811             if (buttonGroups == null) {
812                 buttonGroups = new HashMap<String, ButtonGroup>();
813             }
814             ButtonGroup bg = buttonGroups.get(name);
815             if (bg == null) {
816                 bg = new ButtonGroup();
817                 buttonGroups.put(name, bg);
818             }
819             bg.add(button);
820         }
821     }
822
823     /**
824      * Remove a button from a button-group
825      * @param name the name of the button-group
826      * @param button the button to remove
827      */
828     public void removeFromButtonGroup(String name, AbstractButton button) {
829         if (isRoot() && buttonGroups != null) {
830             ButtonGroup bg = buttonGroups.get(name);
831             if (bg != null) {
832                 bg.remove(button);
833             }
834         }
835     }
836
837     /**
838      * Check if this UIComponent is a root element (no parent)
839      * @return true if it is a root element
840      */
841     public boolean isRoot() {
842         return parent == null;
843     }
844
845     /**
846      * Get the child with the given id
847      * @param if the child id
848      * @return the corresponding UIComponent
849      */
850     public UIComponent getUIComponent(final String id) {
851         if (children != null) {
852             return children.get(id);
853         }
854
855         return null;
856     }
857
858     /**
859      * Close this UIComponent
860      */
861     public void closeUIComponent() { }
862
863     /**
864      * Remove the UIComponent from differents cache and delete its children
865      */
866     public void remove() {
867         UIComponent oldParent = parent;
868         remove(true);
869
870         if (oldParent != null) {
871             if (oldParent.component instanceof JComponent) {
872                 JComponent jc = (JComponent) oldParent.component;
873                 jc.revalidate();
874                 jc.repaint();
875             }  else if (oldParent.component instanceof Container) {
876                 Container container = (Container) oldParent.component;
877                 container.invalidate();
878                 container.validate();
879                 container.repaint();
880             }
881         }
882     }
883
884     /**
885      * Remove the UIComponent from differents cache and delete its children
886      * @param removeFromParent if true remove this from its parent
887      */
888     private void remove(boolean removeFromParent) {
889         UserData.removeUIWidgetUserData(uid);
890         UILocator.remove(this);
891         UIComponent oldParent = parent;
892         if (childrenList != null) {
893             for (UIComponent ui : childrenList) {
894                 ui.remove(false);
895             }
896             childrenList = null;
897             children = null;
898         }
899         closeUIComponent();
900         if (removeFromParent && parent != null) {
901             if (parent.childrenList != null) {
902                 parent.childrenList.remove(this);
903             }
904             if (parent.children != null && id != null) {
905                 parent.children.remove(id);
906             }
907         }
908         parent = null;
909         if (mouseListener != null) {
910             mouseListener.addListenerToComponent(null);
911             mouseListener = null;
912         }
913         if (focusListener != null) {
914             focusListener.addListenerToComponent(null);
915             focusListener = null;
916         }
917         if (component instanceof JComponent) {
918             JComponent jc = (JComponent) component;
919             if (jc.getParent() != null) {
920                 jc.getParent().remove(jc);
921             }
922             jc.removeAll();
923         }
924         if (getModifiableComponent() != component && getModifiableComponent() instanceof JComponent) {
925             JComponent jc = (JComponent) getModifiableComponent();
926             if (jc.getParent() != null) {
927                 jc.getParent().remove(jc);
928             }
929             jc.removeAll();
930         }
931         component = null;
932         modifiableComponent = null;
933         root = null;
934     }
935
936     /**
937      * Set the map containing style element
938      */
939     private void setMapStyle(Map<String, Map<String, String>> style) {
940         this.style = style;
941     }
942
943     /**
944      * Finish the UIComponent creation
945      */
946     public void finish() {
947     }
948
949     /**
950      * Replace the component by another one
951      * @param c the new component
952      */
953     public void replaceBy(Component c) {
954         if (component instanceof Component) {
955             Component comp = (Component) component;
956             Container parent = comp.getParent();
957             if (parent != null) {
958                 boolean hasChanged = false;
959                 if ((parent instanceof View) && (c instanceof Container)) {
960                     // Flexdock needs a special treatment...
961                     View v = (View) parent;
962                     if (v.getContentPane() == comp) {
963                         v.setContentPane((Container) c);
964                         hasChanged = true;
965                     }
966                 }
967
968                 if (!hasChanged) {
969                     LayoutManager layout = parent.getLayout();
970                     Object constraint = null;
971                     if (layout instanceof GridBagLayout) {
972                         constraint = ((GridBagLayout) layout).getConstraints(comp);
973                     } else if (layout instanceof BorderLayout) {
974                         constraint = ((BorderLayout) layout).getConstraints(comp);
975                     } else if (layout instanceof NoLayout) {
976                         constraint = ((NoLayout) layout).getConstraints(comp);
977                     }
978
979                     if (constraint != null) {
980                         parent.remove(comp);
981                         parent.add(c, constraint);
982                     } else {
983                         int pos = parent.getComponentZOrder(comp);
984                         parent.remove(comp);
985                         if (pos > parent.getComponentCount()) {
986                             parent.add(c, -1);
987                         } else {
988                             parent.add(c, pos);
989                         }
990                     }
991                 }
992
993                 parent.doLayout();
994                 parent.repaint();
995             }
996             component = c;
997         }
998     }
999
1000     /**
1001      * Get the parent UIComponent
1002      * @return the parent
1003      */
1004     public UIComponent getParent() {
1005         return parent;
1006     }
1007
1008     /**
1009      * Get the id of this UIComponent
1010      * @return the id
1011      */
1012     public String getID() {
1013         return id;
1014     }
1015
1016     /**
1017      * Check if the root element is visible
1018      * @return true if the root element is visible
1019      */
1020     public boolean isRootVisible() {
1021         if (isRoot()) {
1022             if (component instanceof Component) {
1023                 return ((Component) component).isVisible();
1024             }
1025             return false;
1026         } else {
1027             return root.isRootVisible();
1028         }
1029     }
1030
1031     /**
1032      * Get the children
1033      * @return the children as an array
1034      */
1035     public UIComponent[] getChildren() {
1036         if (childrenList != null && !childrenList.isEmpty()) {
1037             return childrenList.toArray(new UIComponent[childrenList.size()]);
1038         }
1039
1040         return null;
1041     }
1042
1043     /**
1044      * Get the uistyle
1045      * @return uistyle as String
1046      */
1047     public String getUIStyle() {
1048         if (uistyle != null) {
1049             String str = "";
1050             for (Map.Entry<String, String> entry : uistyle.entrySet()) {
1051                 str += entry.getKey() + ":" + entry.getValue();
1052             }
1053
1054             return str;
1055         }
1056
1057         return null;
1058     }
1059
1060     /**
1061      * Set the uistyle
1062      * @param style a String containing style definition as a CSS string
1063      */
1064     public void setUiStyle(String style) throws UIWidgetException {
1065         setUiStyle(StyleParser.parseLine(style));
1066     }
1067
1068     /**
1069      * Set the uistyle
1070      * @param style a map
1071      */
1072     public void setUiStyle(Map<String, String> style) throws UIWidgetException {
1073         this.uistyle = style;
1074         Object c = getModifiableComponent();
1075         if (c instanceof JComponent) {
1076             ((JComponent) c).setFont(UITools.getFont(((JComponent) c).getFont(), style));
1077         }
1078         for (String key : style.keySet()) {
1079             try {
1080                 setProperty(key, style.get(key));
1081             } catch (UIWidgetException e) { }
1082         }
1083     }
1084
1085     /**
1086      * Set the tab title if the component is in a JTabbedPane
1087      * @param title the tab title
1088      */
1089     public void setTabTitle(String title) throws UIWidgetException {
1090         if (parent instanceof UITab && title != null && component != null) {
1091             JComponent c = getJComponent();
1092             JTabbedPane tab = (JTabbedPane) ((UITab) parent).getJComponent();
1093             int index = tab.indexOfTabComponent(c);
1094             if (index != -1) {
1095                 tab.setTitleAt(index, title);
1096             }
1097         }
1098         this.tabTitle = title;
1099     }
1100
1101     /**
1102      * Get the tab title if the component is in a JTabbedPane
1103      * @return the tab title
1104      */
1105     public String getTabTitle() throws UIWidgetException {
1106         return tabTitle;
1107     }
1108
1109     /**
1110      * Set the tooltip text
1111      * @param text the tooltip text
1112      */
1113     public void setTooltip(String text) throws UIWidgetException {
1114         getModifiableJComponent().setToolTipText(text);
1115     }
1116
1117     /**
1118      * Get the tooltip text
1119      * @return the tooltip text
1120      */
1121     public String getTooltip() throws UIWidgetException {
1122         return getModifiableJComponent().getToolTipText();
1123     }
1124
1125     /**
1126      * Set the tooltip text
1127      * @param text the tooltip text
1128      */
1129     public void setTooltipString(String text) throws UIWidgetException {
1130         setTooltip(text);
1131     }
1132
1133     /**
1134      * Get the tooltip text
1135      * @return the tooltip text
1136      */
1137     public String getTooltipString() throws UIWidgetException {
1138         return getTooltip();
1139     }
1140
1141     /**
1142      * Set the foreground color
1143      * @param c the color
1144      */
1145     public void setColor(Color c) throws UIWidgetException {
1146         getModifiableJComponent().setForeground(c);
1147     }
1148
1149     /**
1150      * Get the foreground color
1151      * @return the foreground color
1152      */
1153     public Color getColor() throws UIWidgetException {
1154         return getModifiableJComponent().getForeground();
1155     }
1156
1157     /**
1158      * Set the font unit
1159      * @param name the font name
1160      */
1161     public void setFontUnits(UITools.FontUnit unit) throws UIWidgetException {
1162         // TODO: actuellement ds uic, fontunit est ignore et est dc egale a PIXELS
1163         double ratio = UITools.FontUnit.getRatio(fontUnit, UITools.FontUnit.PIXELS);//unit);
1164         if (ratio != 1) {
1165             this.fontUnit = unit;
1166             Font f = getFont();
1167             if (f != null) {
1168                 Map<TextAttribute, Object> map = (Map<TextAttribute, Object>) f.getAttributes();
1169                 map.put(TextAttribute.SIZE, new Double(f.getSize2D() * ratio));
1170                 setFont(new Font(map));
1171             }
1172         }
1173     }
1174
1175     public String getFontUnits() {
1176         return UITools.FontUnit.getAsString(this.fontUnit);
1177     }
1178
1179     /**
1180      * Set the font name
1181      * @param name the font name
1182      */
1183     public void setFontName(String name) throws UIWidgetException {
1184         Font f = getFont();
1185         if (f != null) {
1186             Map<TextAttribute, Object> map = (Map<TextAttribute, Object>) f.getAttributes();
1187             map.put(TextAttribute.FAMILY, name);
1188             setFont(new Font(map));
1189         }
1190     }
1191
1192     /**
1193      * Get the font name
1194      * @return name the font name
1195      */
1196     public String getFontName() throws UIWidgetException {
1197         Font f = getFont();
1198         if (f != null) {
1199             Map<TextAttribute, Object> map = (Map<TextAttribute, Object>) f.getAttributes();
1200             return (String) map.get(TextAttribute.FAMILY);
1201         }
1202
1203         return null;
1204     }
1205
1206     /**
1207      * Set the font size
1208      * @param size the font size
1209      */
1210     public void setFontSize(double size) throws UIWidgetException {
1211         double ratio = UITools.FontUnit.getRatio(fontUnit);
1212         Font f = getFont();
1213         if (f != null) {
1214             Map<TextAttribute, Object> map = (Map<TextAttribute, Object>) f.getAttributes();
1215             map.put(TextAttribute.SIZE, (Double.isNaN(size) || size < 0 || Double.isInfinite(size)) ? new Double(12.0 * ratio) : new Double(size * ratio));
1216             setFont(new Font(map));
1217         }
1218     }
1219
1220     /**
1221      * Get the font size
1222      * @return the font size
1223      */
1224     public double getFontSize() throws UIWidgetException {
1225         Font f = getFont();
1226         if (f != null) {
1227             double ratio = UITools.FontUnit.getRatio(fontUnit);
1228             return Math.round(f.getSize2D() / ratio);
1229         }
1230
1231         return -1;
1232     }
1233
1234     /**
1235      * Set the font weight
1236      * @param weight the font weight
1237      */
1238     public void setFontWeight(UITools.FontWeight weight) throws UIWidgetException {
1239         if (weight != null) {
1240             Font f = getFont();
1241             if (f != null) {
1242                 Map<TextAttribute, Object> map = (Map<TextAttribute, Object>) f.getAttributes();
1243                 map.put(TextAttribute.WEIGHT, weight.value());
1244                 setFont(new Font(map));
1245             }
1246         }
1247     }
1248
1249     /**
1250      * Get the font weight
1251      * @return the font weight
1252      */
1253     public String getFontWeight() throws UIWidgetException {
1254         Font f = getFont();
1255         if (f != null) {
1256             Map<TextAttribute, Object> map = (Map<TextAttribute, Object>) f.getAttributes();
1257             Float fl = (Float) map.get(TextAttribute.WEIGHT);
1258             return UITools.mapTextAttribute.get(fl);
1259         }
1260
1261         return null;
1262     }
1263
1264     /**
1265      * Set the font angle
1266      * @param angle the font angle
1267      */
1268     public void setFontAngle(String angle) throws UIWidgetException {
1269         if (angle != null && !angle.isEmpty()) {
1270             angle = angle.toLowerCase();
1271             boolean italic = angle.equals("italic") || angle.equals("oblique") || angle.equals("it");
1272             Font f = getFont();
1273             if (f != null) {
1274                 Map<TextAttribute, Object> map = (Map<TextAttribute, Object>) f.getAttributes();
1275                 map.put(TextAttribute.POSTURE, italic ? TextAttribute.POSTURE_OBLIQUE : TextAttribute.POSTURE_REGULAR);
1276                 setFont(new Font(map));
1277             }
1278         }
1279     }
1280
1281     /**
1282      * Get the font angle
1283      * @return the font angle
1284      */
1285     public String getFontAngle() throws UIWidgetException {
1286         Font f = getFont();
1287         if (f != null) {
1288             Map<TextAttribute, Object> map = (Map<TextAttribute, Object>) f.getAttributes();
1289             Float fl = (Float) map.get(TextAttribute.POSTURE);
1290             if (fl == null || fl == TextAttribute.POSTURE_REGULAR) {
1291                 return "normal";
1292             } else {
1293                 return "italic";
1294             }
1295         }
1296
1297         return null;
1298     }
1299
1300     /**
1301      * Set the component relief
1302      * @param relief a string which represents the relief
1303      */
1304     public void setRelief(String relief) throws UIWidgetException {
1305         if (relief != null) {
1306             getJComponent().setBorder(ScilabRelief.getBorderFromRelief(relief));
1307             this.relief = relief;
1308         }
1309     }
1310
1311     /**
1312      * Get the relief
1313      * @return the relief
1314      */
1315     public String getRelief() {
1316         return this.relief;
1317     }
1318
1319     /**
1320      * Set the font
1321      * @param f the font
1322      */
1323     public void setFont(Font f) throws UIWidgetException {
1324         getModifiableJComponent().setFont(f);
1325         getJComponent().revalidate();
1326     }
1327
1328     /**
1329      * Get the font
1330      * @return the font
1331      */
1332     public Font getFont() throws UIWidgetException {
1333         return getModifiableJComponent().getFont();
1334     }
1335
1336     public void setUnits(String[] unit) throws UIWidgetException {
1337         if (unit != null) {
1338             boolean mustLayout = false;
1339             if (unit.length >= 4) {
1340                 final int[] units = new int[4];
1341                 for (int i = 0; i < 4; i++) {
1342                     if (unit[i].equals("%") || unit[i].equalsIgnoreCase("n") || unit[i].equalsIgnoreCase("normalized")) {
1343                         units[i] = 1;
1344                     } else if (unit[i].equals("pt") || unit[i].equalsIgnoreCase("points")) {
1345                         units[i] = 2;
1346                     } else {
1347                         units[i] = 0;
1348                     }
1349                 }
1350
1351                 if (this.nolayoutconstraint == null) {
1352                     this.nolayoutconstraint = new NoLayout.NoLayoutConstraint();
1353                 }
1354
1355                 this.nolayoutconstraint.setUnit(units[0], units[1], units[2], units[3]);
1356                 mustLayout = true;
1357             } else if (unit.length == 1) {
1358                 int u = 0;
1359                 if (!unit[0].isEmpty()) {
1360                     if (unit[0].equalsIgnoreCase("points")) {
1361                         u = 2;
1362                     } else if (unit[0].equalsIgnoreCase("normalized")) {
1363                         u = 1;
1364                     }
1365                 }
1366
1367                 if (this.nolayoutconstraint == null) {
1368                     this.nolayoutconstraint = new NoLayout.NoLayoutConstraint();
1369                 }
1370
1371                 this.nolayoutconstraint.setUnit(u, u, u, u);
1372                 mustLayout = true;
1373             }
1374
1375             if (mustLayout) {
1376                 Container p = getJComponent().getParent();
1377                 if (p != null && p.getLayout() instanceof NoLayout) {
1378                     p.invalidate();
1379                     p.doLayout();
1380                     p.repaint();
1381                 }
1382             }
1383         }
1384     }
1385
1386     /**
1387      * Get the position unit (when NoLayout has been set)
1388      * @return the units
1389      */
1390     public String[] getUnits() throws UIWidgetException {
1391         String[] ret;
1392         boolean allTheSame = true;
1393         for (int i = 1; i < 4; i++) {
1394             if (nolayoutconstraint.unit[i] != nolayoutconstraint.unit[0]) {
1395                 allTheSame = false;
1396                 break;
1397             }
1398         }
1399
1400         if (allTheSame) {
1401             ret = new String[1];
1402             switch (nolayoutconstraint.unit[0]) {
1403                 case 1:
1404                     ret[0] = "normalized";
1405                     break;
1406                 case 2:
1407                     ret[0] = "points";
1408                     break;
1409                 default:
1410                     ret[0] = "pixels";
1411                     break;
1412             }
1413         } else {
1414             ret = new String[4];
1415             for (int i = 0; i < 4; i++) {
1416                 switch (nolayoutconstraint.unit[i]) {
1417                     case 1:
1418                         ret[i] = "%";
1419                         break;
1420                     case 2:
1421                         ret[i] = "pt";
1422                         break;
1423                     default:
1424                         ret[i] = "px";
1425                         break;
1426                 }
1427             }
1428         }
1429
1430         return ret;
1431     }
1432
1433     /**
1434      * Get the constraint when no layout
1435      * @return the constraint
1436      */
1437     public NoLayout.NoLayoutConstraint getNoLayoutConstraint() {
1438         return nolayoutconstraint;
1439     }
1440
1441     private void setNoLayoutConstraint(Rectangle2D.Double r) {
1442         if (this.nolayoutconstraint == null) {
1443             this.nolayoutconstraint = new NoLayout.NoLayoutConstraint();
1444         }
1445
1446         this.nolayoutconstraint.setPoint(r.x, r.y);
1447         this.nolayoutconstraint.setDims(r.width, r.height);
1448         this.nolayoutconstraint.setUnit(0, 0, 0, 0);
1449     }
1450
1451     /**
1452      * Set the location
1453      * @param p the location
1454      */
1455     public void setLocation(Point p) throws UIWidgetException {
1456         if (p != null) {
1457             Rectangle2D.Double pos = getPosition();
1458             if (pos != null) {
1459                 setPosition(new Rectangle2D.Double(p.x, p.y, pos.width, pos.height));
1460             }
1461         }
1462     }
1463
1464     /**
1465      * Set the position (when NoLayout has been set)
1466      * @param r the position
1467      */
1468     public void setPosition(Rectangle2D.Double r) throws UIWidgetException {
1469         if (r != null) {
1470             if (getComponent() == null) {
1471                 setNoLayoutConstraint(r);
1472                 return;
1473             }
1474
1475             if (getComponent() instanceof Component) {
1476                 Component c = (Component) getComponent();
1477                 Container p = c.getParent();
1478                 if (c instanceof JFrame) {
1479                     JFrame win = (JFrame) c;
1480                     win.setLocation((int) r.x, (int) r.y);
1481                     Dimension dim = win.getSize();
1482                     if (dim.width != (int) r.width || dim.height != (int) r.height) {
1483                         win.setPreferredSize(new Dimension((int) r.width, (int) r.height));
1484                         if (win.isVisible()) {
1485                             win.invalidate();
1486                             win.pack();
1487                             win.repaint();
1488                         }
1489                     }
1490                 } else if (p == null || p.getLayout() instanceof NoLayout) {
1491                     if (this.nolayoutconstraint == null) {
1492                         this.nolayoutconstraint = new NoLayout.NoLayoutConstraint();
1493                     }
1494
1495                     this.nolayoutconstraint.setPoint(r.x, r.y);
1496                     if (this.nolayoutconstraint.bounds.width != r.width || this.nolayoutconstraint.bounds.height != r.height) {
1497                         this.nolayoutconstraint.setDims(r.width, r.height);
1498                         if (p == null) {
1499                             c.setSize((int) r.width, (int) r.height);
1500                             c.invalidate();
1501                             c.validate();
1502                         }
1503                     }
1504                     if (p != null && p.isVisible()) {
1505                         p.invalidate();
1506                         p.validate();
1507                         p.repaint();
1508                     }
1509                 } else if (p.getLayout() == null) {
1510                     c.setSize((int) r.width, (int) r.height);
1511                     c.invalidate();
1512                     c.validate();
1513                 }
1514             }
1515         }
1516     }
1517
1518     /**
1519      * Get the position
1520      * @return the position
1521      */
1522     public Rectangle2D.Double getPosition() throws UIWidgetException {
1523         if (getComponent() instanceof Component) {
1524             Component c = (Component) getComponent();
1525             Container p = c.getParent();
1526             if (p != null && p.getLayout() instanceof NoLayout) {
1527                 return this.nolayoutconstraint.bounds;
1528             }
1529
1530             Dimension d = c.getSize();
1531             Point pt = c.getLocation();
1532
1533             return new Rectangle2D.Double(pt.x, pt.y, d.width, d.height);
1534         }
1535
1536         return null;
1537     }
1538
1539     /**
1540      * Set the foreground color
1541      * @param c the color
1542      */
1543     public void setForegroundColor(Color c) throws UIWidgetException {
1544         if (c != null) {
1545             getModifiableJComponent().setForeground(c);
1546         }
1547     }
1548
1549     /**
1550      * Get the foreground color
1551      * @return the foreground color
1552      */
1553     public Color getForegroundColor() throws UIWidgetException {
1554         return getModifiableJComponent().getForeground();
1555     }
1556
1557     /**
1558      * Set the background color
1559      * @param c the color
1560      */
1561     public void setBackgroundColor(Color c) throws UIWidgetException {
1562         if (c != null) {
1563             getModifiableJComponent().setBackground(c);
1564         }
1565     }
1566
1567     /**
1568      * Get the background color
1569      * @return the background color
1570      */
1571     public Color getBackgroundColor() throws UIWidgetException {
1572         return getModifiableJComponent().getBackground();
1573     }
1574
1575     /**
1576      * Set the component scrollable or not
1577      * @param b if true the component will be scrollable
1578      */
1579     public void setScrollable(boolean b) {
1580         if (component instanceof JScrollPane) {
1581             JScrollPane scroll = (JScrollPane) component;
1582             if (b) {
1583                 scroll.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
1584                 scroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
1585             } else {
1586                 scroll.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
1587                 scroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER);
1588             }
1589         } else if (component instanceof JComponent && b) {
1590             JComponent c = (JComponent) component;
1591             JScrollPane scroll = new JScrollPane();
1592             replaceBy(scroll);
1593             scroll.getViewport().setView(c);
1594             modifiableComponent = c;
1595         }
1596     }
1597
1598     /**
1599      * Check if the component is scrollable
1600      * @return true if the component is scrollable
1601      */
1602     public boolean getScrollable() {
1603         return component instanceof JScrollPane && ((JScrollPane) component).getHorizontalScrollBarPolicy() == ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED;
1604     }
1605
1606     /**
1607      * Set the horizontal block increment (pgup, pgdown in scroll)
1608      * @param blockIncrement the block increment
1609      */
1610     public void setHorizontalBlockIncrement(int blockIncrement) {
1611         if (component instanceof JScrollPane) {
1612             JScrollPane scroll = (JScrollPane) component;
1613             JScrollBar bar = scroll.getHorizontalScrollBar();
1614             if (bar != null) {
1615                 bar.setBlockIncrement(blockIncrement);
1616             }
1617         }
1618     }
1619
1620     /**
1621      * Get the horizontal block increment
1622      * @return block increment
1623      */
1624     public int getHorizontalBlockIncrement() {
1625         if (component instanceof JScrollPane) {
1626             JScrollPane scroll = (JScrollPane) component;
1627             JScrollBar bar = scroll.getHorizontalScrollBar();
1628             if (bar != null) {
1629                 return bar.getBlockIncrement();
1630             }
1631         }
1632
1633         return -1;
1634     }
1635
1636     /**
1637      * Set the vertical block increment (pgup, pgdown in scroll)
1638      * @param blockIncrement the block increment
1639      */
1640     public void setVerticalBlockIncrement(int blockIncrement) {
1641         if (component instanceof JScrollPane) {
1642             JScrollPane scroll = (JScrollPane) component;
1643             JScrollBar bar = scroll.getVerticalScrollBar();
1644             if (bar != null) {
1645                 bar.setBlockIncrement(blockIncrement);
1646             }
1647         }
1648     }
1649
1650     /**
1651      * Get the vertical block increment
1652      * @return block increment
1653      */
1654     public int getVerticalBlockIncrement() {
1655         if (component instanceof JScrollPane) {
1656             JScrollPane scroll = (JScrollPane) component;
1657             JScrollBar bar = scroll.getVerticalScrollBar();
1658             if (bar != null) {
1659                 return bar.getBlockIncrement();
1660             }
1661         }
1662
1663         return -1;
1664     }
1665
1666     /**
1667      * Set the horizontal unit increment (wheel in scroll)
1668      * @param unitIncrement the unit increment
1669      */
1670     public void setHorizontalUnitIncrement(int unitIncrement) {
1671         if (component instanceof JScrollPane) {
1672             JScrollPane scroll = (JScrollPane) component;
1673             JScrollBar bar = scroll.getHorizontalScrollBar();
1674             if (bar != null) {
1675                 bar.setUnitIncrement(unitIncrement);
1676             }
1677         }
1678     }
1679
1680     /**
1681      * Get the horizontal unit increment
1682      * @return unit increment
1683      */
1684     public int getHorizontalUnitIncrement() {
1685         if (component instanceof JScrollPane) {
1686             JScrollPane scroll = (JScrollPane) component;
1687             JScrollBar bar = scroll.getHorizontalScrollBar();
1688             if (bar != null) {
1689                 return bar.getUnitIncrement();
1690             }
1691         }
1692
1693         return -1;
1694     }
1695
1696     /**
1697      * Set the vertical unit increment (wheel in scroll)
1698      * @param unitIncrement the unit increment
1699      */
1700     public void setVerticalUnitIncrement(int unitIncrement) {
1701         if (component instanceof JScrollPane) {
1702             JScrollPane scroll = (JScrollPane) component;
1703             JScrollBar bar = scroll.getVerticalScrollBar();
1704             if (bar != null) {
1705                 bar.setUnitIncrement(unitIncrement);
1706             }
1707         }
1708     }
1709
1710     /**
1711      * Get the vertical unit increment
1712      * @return unit increment
1713      */
1714     public int getVerticalUnitIncrement() {
1715         if (component instanceof JScrollPane) {
1716             JScrollPane scroll = (JScrollPane) component;
1717             JScrollBar bar = scroll.getVerticalScrollBar();
1718             if (bar != null) {
1719                 return bar.getUnitIncrement();
1720             }
1721         }
1722
1723         return -1;
1724     }
1725
1726     /**
1727      * Set the horizontal scroll value
1728      * @param value the value
1729      */
1730     public void setHorizontalScrollValue(int value) {
1731         if (component instanceof JScrollPane) {
1732             JScrollPane scroll = (JScrollPane) component;
1733             JScrollBar bar = scroll.getHorizontalScrollBar();
1734             if (bar != null) {
1735                 bar.setValue(value);
1736             }
1737         }
1738     }
1739
1740     /**
1741      * Get the horizontal scroll value
1742      * @return the scroll value
1743      */
1744     public int getHorizontalScrollValue() {
1745         if (component instanceof JScrollPane) {
1746             JScrollPane scroll = (JScrollPane) component;
1747             JScrollBar bar = scroll.getHorizontalScrollBar();
1748             if (bar != null) {
1749                 return bar.getValue();
1750             }
1751         }
1752
1753         return -1;
1754     }
1755
1756     /**
1757      * Set the vertical scroll value
1758      * @param value the value
1759      */
1760     public void setVerticalScrollValue(int value) {
1761         if (component instanceof JScrollPane) {
1762             JScrollPane scroll = (JScrollPane) component;
1763             JScrollBar bar = scroll.getVerticalScrollBar();
1764             if (bar != null) {
1765                 bar.setValue(value);
1766             }
1767         }
1768     }
1769
1770     /**
1771      * Get the vertical scroll value
1772      * @return the scroll value
1773      */
1774     public int getVerticalScrollValue() {
1775         if (component instanceof JScrollPane) {
1776             JScrollPane scroll = (JScrollPane) component;
1777             JScrollBar bar = scroll.getVerticalScrollBar();
1778             if (bar != null) {
1779                 return bar.getValue();
1780             }
1781         }
1782
1783         return -1;
1784     }
1785
1786     /**
1787      * Set the component constraints
1788      * @param constraint a string containing layout constraints (CSS style)
1789      */
1790     public void setConstraint(String constraint) throws UIWidgetException {
1791         setConstraint(StyleParser.parseLine(constraint));
1792     }
1793
1794     /**
1795      * Set the component constraints
1796      * @param constraint a map containing layout constraints
1797      */
1798     public void setConstraint(Map<String, String> constraint) throws UIWidgetException {
1799         this.constraint = constraint;
1800         Container p = getJComponent().getParent();
1801         if (p != null && !(p.getLayout() instanceof NoLayout) && getParent() != null) {
1802             getParent().add(this);
1803             p.invalidate();
1804             p.validate();
1805         }
1806     }
1807
1808     /**
1809      * Get the constraint
1810      * @return constraint as String
1811      */
1812     public String getConstraint() {
1813         if (constraint != null) {
1814             String str = "";
1815             for (Map.Entry<String, String> entry : constraint.entrySet()) {
1816                 str += entry.getKey() + ":" + entry.getValue();
1817             }
1818
1819             return str;
1820         }
1821
1822         return null;
1823     }
1824
1825     /**
1826      * Set the layout
1827      * @param layout the layout informations (CSS style)
1828      */
1829     public void setLayout(String layout) throws UIWidgetException {
1830         getModifiableContainer().setLayout(UILayoutFactory.getLayout(getModifiableJComponent(), layout));
1831     }
1832
1833     /**
1834      * Enable or not the component
1835      * @param enable if true, the component is enabled
1836      */
1837     public void setEnable(boolean enable) throws UIWidgetException {
1838         getJComponent().setEnabled(enable);
1839     }
1840
1841     /**
1842      * Check if the component is enabled
1843      * @return true if the component is enabled
1844      */
1845     public boolean getEnable() throws UIWidgetException {
1846         return getJComponent().isEnabled();
1847     }
1848
1849     /**
1850      * Create a MouseListener on this component
1851      */
1852     private final void createMouseListener() throws UIWidgetException {
1853         if (mouseListener == null) {
1854             mouseListener = new UIMouseListener(this);
1855             mouseListener.newInstance();
1856             mouseListener.addListenerToComponent(getModifiableJComponent());
1857         }
1858     }
1859
1860     /**
1861      * Set onmouseclick action
1862      * @param command the command to execute
1863      */
1864     public void setOnmouseclick(String command) throws UIWidgetException {
1865         if (command != null && !command.isEmpty()) {
1866             createMouseListener();
1867             mouseListener.setOnmouseclick(command);
1868         }
1869     }
1870
1871     /**
1872      * Set onmouseover action
1873      * @param command the command to execute
1874      */
1875     public void setOnmouseover(String command) throws UIWidgetException {
1876         if (command != null && !command.isEmpty()) {
1877             createMouseListener();
1878             mouseListener.setOnmouseover(command);
1879         }
1880     }
1881
1882     /**
1883      * Set onmouseenter action
1884      * @param command the command to execute
1885      */
1886     public void setOnmouseenter(String command) throws UIWidgetException {
1887         if (command != null && !command.isEmpty()) {
1888             createMouseListener();
1889             mouseListener.setOnmouseenter(command);
1890         }
1891     }
1892
1893     /**
1894      * Set onmouseexit action
1895      * @param command the command to execute
1896      */
1897     public void setOnmouseexit(String command) throws UIWidgetException {
1898         if (command != null && !command.isEmpty()) {
1899             createMouseListener();
1900             mouseListener.setOnmouseexit(command);
1901         }
1902     }
1903
1904     /**
1905      * Set onmousepress action
1906      * @param command the command to execute
1907      */
1908     public void setOnmousepress(String command) throws UIWidgetException {
1909         if (command != null && !command.isEmpty()) {
1910             createMouseListener();
1911             mouseListener.setOnmousepress(command);
1912         }
1913     }
1914
1915     /**
1916      * Set onmouserelease action
1917      * @param command the command to execute
1918      */
1919     public void setOnmouserelease(String command) throws UIWidgetException {
1920         if (command != null && !command.isEmpty()) {
1921             createMouseListener();
1922             mouseListener.setOnmouserelease(command);
1923         }
1924     }
1925
1926     /**
1927      * Set onmousewheel action
1928      * @param command the command to execute
1929      */
1930     public void setOnmousewheel(String command) throws UIWidgetException {
1931         if (command != null && !command.isEmpty()) {
1932             createMouseListener();
1933             mouseListener.setOnmousewheel(command);
1934         }
1935     }
1936
1937     /**
1938      * Set onmousedrag action
1939      * @param command the command to execute
1940      */
1941     public void setOnmousedrag(String command) throws UIWidgetException {
1942         if (command != null && !command.isEmpty()) {
1943             createMouseListener();
1944             mouseListener.setOnmousedrag(command);
1945         }
1946     }
1947
1948     /**
1949      * Get onmouseclick action
1950      * @return the command to execute
1951      */
1952     public UICallback getOnmouseclick() {
1953         if (mouseListener != null) {
1954             return mouseListener.getOnmouseclick();
1955         }
1956
1957         return null;
1958     }
1959
1960     /**
1961      * Get onmouseover action
1962      * @return the command to execute
1963      */
1964     public UICallback getOnmouseover() {
1965         if (mouseListener != null) {
1966             return mouseListener.getOnmouseover();
1967         }
1968
1969         return null;
1970     }
1971
1972     /**
1973      * Get onmouseenter action
1974      * @return the command to execute
1975      */
1976     public UICallback getOnmouseenter() {
1977         if (mouseListener != null) {
1978             return mouseListener.getOnmouseenter();
1979         }
1980
1981         return null;
1982     }
1983
1984     /**
1985      * Get onmouseexit action
1986      * @return the command to execute
1987      */
1988     public UICallback getOnmouseexit() {
1989         if (mouseListener != null) {
1990             return mouseListener.getOnmouseexit();
1991         }
1992
1993         return null;
1994     }
1995
1996     /**
1997      * Get onmousepress action
1998      * @return the command to execute
1999      */
2000     public UICallback getOnmousepress() {
2001         if (mouseListener != null) {
2002             return mouseListener.getOnmousepress();
2003         }
2004
2005         return null;
2006     }
2007
2008     /**
2009      * Get onmouserelease action
2010      * @return the command to execute
2011      */
2012     public UICallback getOnmouserelease() {
2013         if (mouseListener != null) {
2014             return mouseListener.getOnmouserelease();
2015         }
2016
2017         return null;
2018     }
2019
2020     /**
2021      * Get onmousedrag action
2022      * @return the command to execute
2023      */
2024     public UICallback getOnmousedrag() {
2025         if (mouseListener != null) {
2026             return mouseListener.getOnmousedrag();
2027         }
2028
2029         return null;
2030     }
2031
2032     /**
2033      * Get onmousewheel action
2034      * @return the command to execute
2035      */
2036     public UICallback getOnmousewheel() {
2037         if (mouseListener != null) {
2038             return mouseListener.getOnmousewheel();
2039         }
2040
2041         return null;
2042     }
2043
2044     /**
2045      * Enable onmouseclick
2046      * @param b, if true the action is enabled
2047      */
2048     public void setOnmouseclickEnable(boolean b) {
2049         if (mouseListener != null) {
2050             mouseListener.setOnmouseclickEnable(b);
2051         }
2052     }
2053
2054     /**
2055      * Check if onmouseclick is enabled
2056      * @return true the action is enabled
2057      */
2058     public boolean getOnmouseclickEnable() {
2059         if (mouseListener != null) {
2060             return mouseListener.getOnmouseclickEnable();
2061         }
2062
2063         return false;
2064     }
2065
2066     /**
2067      * Enable onmouseover
2068      * @param b, if true the action is enabled
2069      */
2070     public void setOnmouseoverEnable(boolean b) {
2071         if (mouseListener != null) {
2072             mouseListener.setOnmouseoverEnable(b);
2073         }
2074     }
2075
2076     /**
2077      * Check if onmouseover is enabled
2078      * @return true the action is enabled
2079      */
2080     public boolean getOnmouseoverEnable() {
2081         if (mouseListener != null) {
2082             return mouseListener.getOnmouseoverEnable();
2083         }
2084
2085         return false;
2086     }
2087
2088     /**
2089      * Enable onmouseenter
2090      * @param b, if true the action is enabled
2091      */
2092     public void setOnmouseenterEnable(boolean b) {
2093         if (mouseListener != null) {
2094             mouseListener.setOnmouseenterEnable(b);
2095         }
2096     }
2097
2098     /**
2099      * Check if onmouseenter is enabled
2100      * @return true the action is enabled
2101      */
2102     public boolean getOnmouseenterEnable() {
2103         if (mouseListener != null) {
2104             return mouseListener.getOnmouseenterEnable();
2105         }
2106
2107         return false;
2108     }
2109
2110     /**
2111      * Enable onmouseexit
2112      * @param b, if true the action is enabled
2113      */
2114     public void setOnmouseexitEnable(boolean b) {
2115         if (mouseListener != null) {
2116             mouseListener.setOnmouseexitEnable(b);
2117         }
2118     }
2119
2120     /**
2121      * Check if onmouseexit is enabled
2122      * @return true the action is enabled
2123      */
2124     public boolean getOnmouseexitEnable() {
2125         if (mouseListener != null) {
2126             return mouseListener.getOnmouseexitEnable();
2127         }
2128
2129         return false;
2130     }
2131
2132     /**
2133      * Enable onmousepress
2134      * @param b, if true the action is enabled
2135      */
2136     public void setOnmousepressEnable(boolean b) {
2137         if (mouseListener != null) {
2138             mouseListener.setOnmousepressEnable(b);
2139         }
2140     }
2141
2142     /**
2143      * Check if onmousepress is enabled
2144      * @return true the action is enabled
2145      */
2146     public boolean getOnmousepressEnable() {
2147         if (mouseListener != null) {
2148             return mouseListener.getOnmousepressEnable();
2149         }
2150
2151         return false;
2152     }
2153
2154     /**
2155      * Enable onmouserelease
2156      * @param b, if true the action is enabled
2157      */
2158     public void setOnmousereleaseEnable(boolean b) {
2159         if (mouseListener != null) {
2160             mouseListener.setOnmousereleaseEnable(b);
2161         }
2162     }
2163
2164     /**
2165      * Check if onmouserelease is enabled
2166      * @return true the action is enabled
2167      */
2168     public boolean getOnmousereleaseEnable() {
2169         if (mouseListener != null) {
2170             return mouseListener.getOnmousereleaseEnable();
2171         }
2172
2173         return false;
2174     }
2175
2176     /**
2177      * Enable onmousewheel
2178      * @param b, if true the action is enabled
2179      */
2180     public void setOnmousewheelEnable(boolean b) {
2181         if (mouseListener != null) {
2182             mouseListener.setOnmousewheelEnable(b);
2183         }
2184     }
2185
2186     /**
2187      * Check if onmousewheel is enabled
2188      * @return true the action is enabled
2189      */
2190     public boolean getOnmousewheelEnable() {
2191         if (mouseListener != null) {
2192             return mouseListener.getOnmousewheelEnable();
2193         }
2194
2195         return false;
2196     }
2197
2198     /**
2199      * Enable onmousedrag
2200      * @param b, if true the action is enabled
2201      */
2202     public void setOnmousedragEnable(boolean b) {
2203         if (mouseListener != null) {
2204             mouseListener.setOnmousedragEnable(b);
2205         }
2206     }
2207
2208     /**
2209      * Check if onmousedrag is enabled
2210      * @return true the action is enabled
2211      */
2212     public boolean getOnmousedragEnable() {
2213         if (mouseListener != null) {
2214             return mouseListener.getOnmousedragEnable();
2215         }
2216
2217         return false;
2218     }
2219
2220     /**
2221      * Create a FocusListener on this component
2222      */
2223     private final void createFocusListener() throws UIWidgetException {
2224         if (focusListener == null) {
2225             focusListener = new UIFocusListener(this);
2226             focusListener.newInstance();
2227             focusListener.addListenerToComponent(getModifiableJComponent());
2228         }
2229     }
2230
2231     /**
2232      * Set onfocusgain action
2233      * @param command the command to execute
2234      */
2235     public void setOnfocusgain(String command) throws UIWidgetException {
2236         if (command != null && !command.isEmpty()) {
2237             createFocusListener();
2238             focusListener.setOnfocusgain(command);
2239         }
2240     }
2241
2242     /**
2243      * Set onfocusloss action
2244      * @param command the command to execute
2245      */
2246     public void setOnfocusloss(String command) throws UIWidgetException {
2247         if (command != null && !command.isEmpty()) {
2248             createFocusListener();
2249             focusListener.setOnfocusloss(command);
2250         }
2251     }
2252
2253     /**
2254      * Get onfocusgain action
2255      * @return the command to execute
2256      */
2257     public UICallback getOnfocusgain() {
2258         if (focusListener != null) {
2259             return focusListener.getOnfocusgain();
2260         }
2261
2262         return null;
2263     }
2264
2265     /**
2266      * Get onfocusloss action
2267      * @return the command to execute
2268      */
2269     public UICallback getOnfocusloss() {
2270         if (focusListener != null) {
2271             return focusListener.getOnfocusloss();
2272         }
2273
2274         return null;
2275     }
2276
2277     /**
2278      * Enable onfocusgain
2279      * @param b, if true the action is enabled
2280      */
2281     public void setOnfocusgainEnable(boolean b) {
2282         if (focusListener != null) {
2283             focusListener.setOnfocusgainEnable(b);
2284         }
2285     }
2286
2287     /**
2288      * Check if onfocusgain is enabled
2289      * @return true the action is enabled
2290      */
2291     public boolean getOnfocusgainEnable() {
2292         if (focusListener != null) {
2293             return focusListener.getOnfocusgainEnable();
2294         }
2295
2296         return false;
2297     }
2298
2299     /**
2300      * Enable onfocusloss
2301      * @param b, if true the action is enabled
2302      */
2303     public void setOnfocuslossEnable(boolean b) {
2304         if (focusListener != null) {
2305             focusListener.setOnfocuslossEnable(b);
2306         }
2307     }
2308
2309     /**
2310      * Check if onfocusloss is enabled
2311      * @return true the action is enabled
2312      */
2313     public boolean getOnfocuslossEnable() {
2314         if (focusListener != null) {
2315             return focusListener.getOnfocuslossEnable();
2316         }
2317
2318         return false;
2319     }
2320
2321     /**
2322      * Change the parent and update the dependencies
2323      * @param parent the parent
2324      */
2325     public void updateDependencies(UIComponent parent) throws UIWidgetException {
2326         setParent(parent);
2327     }
2328
2329     /**
2330      * Add a list of children
2331      * @param list the children
2332      */
2333     public void add(List<UIComponent> list) throws UIWidgetException {
2334         for (UIComponent uicomp : list) {
2335             add(uicomp);
2336         }
2337     }
2338
2339     /**
2340      * Add an UIComponent to the children list
2341      * @parent uicomp the child to add
2342      */
2343     public void add(final UIComponent uicomp) throws UIWidgetException {
2344         UIAccessTools.add(this, uicomp);
2345     }
2346
2347     /**
2348      * Add an UIListener
2349      * @parent uicomp the listener to add
2350      */
2351     public void addListener(final UIListener uicomp) throws UIWidgetException {
2352         uicomp.addListenerToComponent(getModifiableJComponent());
2353     }
2354
2355     /**
2356      * Add a popup menu
2357      * @param popup the popup menu
2358      */
2359     public void addPopupMenu(final JPopupMenu popup) {
2360         UIAccessTools.execOnEDT(new Runnable() {
2361             public void run() {
2362                 try {
2363                     getModifiableJComponent().setComponentPopupMenu(popup);
2364                 } catch (Exception e) {
2365
2366                 }
2367             }
2368         });
2369     }
2370
2371     /**
2372      * Set a property of this component
2373      * @param name the property name
2374      * @param value the property value
2375      */
2376     public void setProperty(final String name, final String value) throws UIWidgetException {
2377         try {
2378             if (thisOrComponent) {
2379                 setPropertyViaReflectionInThis(name, value);
2380             } else {
2381                 setPropertyViaReflectionInComponent(name, value);
2382             }
2383         } catch (Exception e) {
2384             if (thisOrComponent) {
2385                 setPropertyViaReflectionInComponent(name, value);
2386             } else {
2387                 setPropertyViaReflectionInThis(name, value);
2388             }
2389         }
2390     }
2391
2392     /**
2393      * Set a property (via relection) of this component
2394      * @param name the property name
2395      * @param value the property value
2396      */
2397     protected final void setPropertyViaReflectionInThis(final String name, final String value) throws UIWidgetException {
2398         UIAccessTools.setPropertyViaReflection(this, name, value);
2399     }
2400
2401     /**
2402      * Set a property (via relection) of the modifiable component
2403      * @param name the property name
2404      * @param value the property value
2405      */
2406     protected final void setPropertyViaReflectionInComponent(final String name, final String value) throws UIWidgetException {
2407         UIAccessTools.setPropertyViaReflection(getModifiableComponent(), name, value);
2408     }
2409
2410     /**
2411      * Set a property of this component
2412      * @param name the property name
2413      * @param value the property value
2414      */
2415     public void setProperty(final String name, final ScilabType value) throws UIWidgetException {
2416         try {
2417             if (thisOrComponent) {
2418                 setPropertyViaReflectionInThis(name, value);
2419             } else {
2420                 setPropertyViaReflectionInComponent(name, value);
2421             }
2422         } catch (Exception e) {
2423             if (thisOrComponent) {
2424                 setPropertyViaReflectionInComponent(name, value);
2425             } else {
2426                 setPropertyViaReflectionInThis(name, value);
2427             }
2428         }
2429     }
2430
2431     /**
2432      * Set a property of this component
2433      * @param name the property name
2434      * @param value the property value
2435      */
2436     public void setProperty(final List<String> names, final List<ScilabType> values) throws UIWidgetException {
2437         if (names != null && values != null) {
2438             final Object modifiableComponent = getModifiableComponent();
2439             final Class clazzThis = this.getClass();
2440             final Class clazzComp = modifiableComponent.getClass();
2441             final List<Object> objs = new ArrayList<Object>(names.size());
2442             final List<Method> methods = new ArrayList<Method>(names.size());
2443
2444             for (String name : names) {
2445                 String methodName = UIAccessTools.getSetterName(name);
2446                 Method method;
2447                 if (thisOrComponent) {
2448                     method = UIMethodFinder.findSetter(methodName, clazzThis);
2449                     if (method == null) {
2450                         method = UIMethodFinder.findSetter(methodName, clazzComp);
2451                         if (method == null) {
2452                             throw new UIWidgetException("No attribute " + name + " in " + clazzThis.getSimpleName());
2453                         }
2454                         objs.add(modifiableComponent);
2455                     } else {
2456                         objs.add(this);
2457                     }
2458                 } else {
2459                     method = UIMethodFinder.findSetter(methodName, clazzComp);
2460                     if (method == null) {
2461                         method = UIMethodFinder.findSetter(methodName, clazzThis);
2462                         if (method == null) {
2463                             throw new UIWidgetException("No attribute " + name + " in " + clazzThis.getSimpleName());
2464                         }
2465                         objs.add(this);
2466                     } else {
2467                         objs.add(modifiableComponent);
2468                     }
2469                 }
2470                 methods.add(method);
2471             }
2472
2473             UIAccessTools.execOnEDT(new Runnable() {
2474                 public void run() {
2475                     try {
2476                         for (int i = 0; i < objs.size(); i++) {
2477                             UIAccessTools.invokeSetter(methods.get(i), objs.get(i), values.get(i));
2478                         }
2479                     } catch (Exception e) {
2480                         System.err.println(e);
2481                     }
2482                 }
2483             });
2484         }
2485     }
2486
2487     /**
2488      * Set a property (via relection) of this component
2489      * @param name the property name
2490      * @param value the property value
2491      */
2492     protected final void setPropertyViaReflectionInThis(final String name, final ScilabType value) throws UIWidgetException {
2493         UIAccessTools.setPropertyViaReflection(this, name, value);
2494     }
2495
2496     /**
2497      * Set a property (via relection) of the modifiable component
2498      * @param name the property name
2499      * @param value the property value
2500      */
2501     protected final void setPropertyViaReflectionInComponent(final String name, final ScilabType value) throws UIWidgetException {
2502         UIAccessTools.setPropertyViaReflection(getModifiableComponent(), name, value);
2503     }
2504
2505     /**
2506      * Get the pairs property name -- method name
2507      * @return the pairs
2508      */
2509     public String[][] getPropertiesPairs() {
2510         Map<String, Method> map = new TreeMap<String, Method>();
2511         if (thisOrComponent) {
2512             UIMethodFinder.getSetter(getModifiableComponent().getClass(), map);
2513             UIMethodFinder.getSetter(this.getClass(), map);
2514         } else {
2515             UIMethodFinder.getSetter(this.getClass(), map);
2516             UIMethodFinder.getSetter(getModifiableComponent().getClass(), map);
2517         }
2518
2519         System.out.println(this.getClass() + ": (" + map.size() + " entries)");
2520         for (Map.Entry<String, Method> entry : map.entrySet()) {
2521             System.out.println(entry.getKey() + " --> " + entry.getValue());
2522         }
2523
2524         return null;
2525     }
2526
2527     /**
2528      * Get a property value
2529      * @param name the property name
2530      */
2531     public Object getProperty(final String name) throws UIWidgetException {
2532         try {
2533             if (thisOrComponent) {
2534                 return getPropertyViaReflectionInThis(name);
2535             } else {
2536                 return getPropertyViaReflectionInComponent(name);
2537             }
2538         } catch (Exception e) {
2539             if (thisOrComponent) {
2540                 return getPropertyViaReflectionInComponent(name);
2541             } else {
2542                 return getPropertyViaReflectionInThis(name);
2543             }
2544         }
2545     }
2546
2547     /**
2548      * Get a property value (via reflection)
2549      * @param name the property name
2550      */
2551     protected Object getPropertyViaReflectionInThis(final String name) throws UIWidgetException {
2552         return UIAccessTools.getPropertyViaReflection(this, name);
2553     }
2554
2555     /**
2556      * Get a property value (via reflection) in the modifiable component
2557      * @param name the property name
2558      */
2559     protected Object getPropertyViaReflectionInComponent(final String name) throws UIWidgetException {
2560         return UIAccessTools.getPropertyViaReflection(getModifiableComponent(), name);
2561     }
2562
2563     /**
2564      * Create a new instance
2565      * @param attributes the attributes
2566      */
2567     private void createNewInstance(final ConvertableMap attributes) throws UIWidgetException {
2568         Set<String> uselessAttrs = UIAccessTools.createNewInstance(this, attributes);
2569         if (uselessAttrs.contains("scrollable")) {
2570             boolean scrollable = (Boolean) attributes.get(boolean.class, "scrollable", false);
2571             if (scrollable && component instanceof JComponent) {
2572                 modifiableComponent = component;
2573                 if (SwingUtilities.isEventDispatchThread()) {
2574                     component = new JScrollPane((JComponent) modifiableComponent);
2575                 } else {
2576                     try {
2577                         SwingUtilities.invokeAndWait(new Runnable() {
2578                             public void run() {
2579                                 try {
2580                                     component = new JScrollPane((JComponent) modifiableComponent);
2581                                 } catch (Exception e) {
2582                                     System.err.println(e);
2583                                     e.printStackTrace();
2584                                 }
2585                             }
2586                         });
2587                     } catch (Exception e) {
2588                         System.err.println(e);
2589                         e.printStackTrace();
2590                     }
2591                 }
2592                 uselessAttrs.remove("scrollable");
2593             }
2594         }
2595
2596         if (uselessAttrs.contains("position")) {
2597             if (attributes instanceof StringMap) {
2598                 setNoLayoutConstraint(StringConverters.getObjectFromValue(Rectangle2D.Double.class, (String) attributes.get("position")));
2599             } else {
2600                 setNoLayoutConstraint(ScilabTypeConverters.getObjectFromValue(Rectangle2D.Double.class, (ScilabType) attributes.get("position")));
2601             }
2602             uselessAttrs.remove("position");
2603         }
2604
2605         setAttributesAndStyle(attributes, uselessAttrs);
2606     }
2607
2608     /**
2609      * Set the attributes and style
2610      * @param attributes the attributes
2611      * @param uselessAttrs the useless attributes
2612      */
2613     private void setAttributesAndStyle(final ConvertableMap attributes, final Set<String> uselessAttrs) {
2614         if (!uselessAttrs.isEmpty()) {
2615             UIAccessTools.execOnEDT(new Runnable() {
2616                 public void run() {
2617                     if (attributes instanceof StringMap) {
2618                         for (String attr : uselessAttrs) {
2619                             try {
2620                                 setProperty(attr, (String) attributes.get(attr));
2621                             } catch (UIWidgetException e) { }
2622                         }
2623                     } else {
2624                         for (String attr : uselessAttrs) {
2625                             try {
2626                                 setProperty(attr, (ScilabType) attributes.get(attr));
2627                             } catch (UIWidgetException e) { }
2628                         }
2629                     }
2630
2631                     if (component instanceof JComponent && nolayoutconstraint == null) {
2632                         JComponent jc = (JComponent) component;
2633                         Dimension d = jc.getPreferredSize();
2634                         setNoLayoutConstraint(0, 0, (double) d.width, (double) d.height);
2635                         nolayoutconstraint.setUnit(0, 0, 0, 0);
2636                     }
2637                 }
2638             });
2639         } else {
2640             if (component instanceof JComponent && nolayoutconstraint == null) {
2641                 UIAccessTools.execOnEDT(new Runnable() {
2642                     public void run() {
2643                         JComponent jc = (JComponent) component;
2644                         Dimension d = jc.getPreferredSize();
2645                         setNoLayoutConstraint(0, 0, (double) d.width, (double) d.height);
2646                         nolayoutconstraint.setUnit(0, 0, 0, 0);
2647                     }
2648                 });
2649             }
2650         }
2651
2652         if (style != null) {
2653             Map<String, String> elementStyle = null;
2654             if (id != null) {
2655                 elementStyle = style.get("#" + id);
2656             }
2657
2658             if (elementStyle == null) {
2659                 String styleClass = (String) attributes.get(String.class, "class", null);
2660                 if (styleClass != null) {
2661                     elementStyle = style.get(styleClass);
2662                 }
2663             }
2664             if (elementStyle == null) {
2665                 elementStyle = style.get("." + this.getClass().getSimpleName());
2666             }
2667
2668             final Map<String, String> es = elementStyle;
2669             if (elementStyle != null) {
2670                 UIAccessTools.execOnEDT(new Runnable() {
2671                     public void run() {
2672                         try {
2673                             setUiStyle(new HashMap<String, String>(es));
2674                         } catch (UIWidgetException e) {
2675                             System.err.println(e);
2676                             e.printStackTrace();
2677                         }
2678                     }
2679                 });
2680             }
2681         }
2682
2683     }
2684
2685     /**
2686      * {@inheritdoc}
2687      */
2688     protected void finalize() throws Throwable {
2689         UserData.removeUIWidgetUserData(uid);
2690         super.finalize();
2691     }
2692 }