add property layout_options in figure and uicontrol handles
[scilab.git] / scilab / modules / graphic_objects / src / java / org / scilab / modules / graphic_objects / figure / Figure.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Manuel JULIACHS
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.1-en.txt
10  *
11  */
12
13 package org.scilab.modules.graphic_objects.figure;
14
15 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_ANTIALIASING__;
16 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_AUTORESIZE__;
17 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_AXES_SIZE__;
18 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_BACKGROUND__;
19 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_BORDER_OPT_PADDING__;
20 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_CLOSEREQUESTFCN__;
21 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_COLORMAP_SIZE__;
22 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_COLORMAP__;
23 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_DOCKABLE__;
24 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_EVENTHANDLER_ENABLE__;
25 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_EVENTHANDLER_NAME__;
26 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_GRID_OPT_GRID__;
27 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_GRID_OPT_PADDING__;
28 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_ID__;
29 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_IMMEDIATE_DRAWING__;
30 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_INFOBAR_VISIBLE__;
31 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_INFO_MESSAGE__;
32 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_LAYOUT_SET__;
33 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_LAYOUT__;
34 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_MENUBAR_VISIBLE__;
35 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_MENUBAR__;
36 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_NAME__;
37 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_PIXEL_DRAWING_MODE__;
38 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_PIXMAP__;
39 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_POSITION__;
40 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_RESIZEFCN__;
41 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_RESIZE__;
42 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_ROTATION_TYPE__;
43 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_SIZE__;
44 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_TOOLBAR_VISIBLE__;
45 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_TOOLBAR__;
46 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_VIEWPORT__;
47
48 import java.util.Arrays;
49
50 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject;
51 import org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties;
52 import org.scilab.modules.graphic_objects.graphicObject.Visitor;
53 import org.scilab.modules.graphic_objects.utils.LayoutType;
54 /**
55  * Figure class
56  * @author Manuel JULIACHS
57  */
58 public class Figure extends GraphicObject {
59     /** Figure properties names */
60     private enum FigureProperty {
61         INFOMESSAGE, COLORMAP, COLORMAPSIZE, BACKGROUND, ROTATIONTYPE,
62         RESIZEFCN, CLOSEREQUESTFCN, RESIZE, TOOLBAR, TOOLBAR_VISIBLE,
63         MENUBAR, MENUBAR_VISIBLE, INFOBAR_VISIBLE, DOCKABLE, LAYOUT, LAYOUT_SET,
64         GRIDOPT_GRID, GRIDOPT_PADDING, BORDEROPT_PADDING
65     };
66
67     /** Specifies whether rotation applies to a single subwindow or to all the figure's subwindows */
68     public enum RotationType { UNARY, MULTIPLE;
69
70                                /**
71                                 * Converts an integer to the corresponding enum
72                                 * @param intValue the integer value
73                                 * @return the rotation type enum
74                                 */
75     public static RotationType intToEnum(Integer intValue) {
76         switch (intValue) {
77             case 0:
78                 return RotationType.UNARY;
79             case 1:
80                 return RotationType.MULTIPLE;
81             default:
82                 return null;
83         }
84     }
85                              }
86     public enum BarType { NONE, FIGURE;
87     public static BarType intToEnum(Integer intValue) {
88         switch (intValue) {
89             default:
90             case 0:
91                 return BarType.NONE;
92             case 1:
93                 return BarType.FIGURE;
94         }
95     }
96                         }
97     /** Pixel drawing logical operations */
98     private enum PixelDrawingMode { CLEAR, AND, ANDREVERSE, COPY, ANDINVERTED, NOOP, XOR, OR, NOR,
99                                     EQUIV, INVERT, ORREVERSE, COPYINVERTED, ORINVERTED, NAND, SET;
100
101                                     /**
102                                      * Converts an integer to the corresponding enum
103                                      * @param intValue the integer value
104                                      * @return the pixel drawing mode enum
105                                      */
106     public static PixelDrawingMode intToEnum(Integer intValue) {
107         switch (intValue) {
108             case 0:
109                 return PixelDrawingMode.CLEAR;
110             case 1:
111                 return PixelDrawingMode.AND;
112             case 2:
113                 return PixelDrawingMode.ANDREVERSE;
114             case 3:
115                 return PixelDrawingMode.COPY;
116             case 4:
117                 return PixelDrawingMode.ANDINVERTED;
118             case 5:
119                 return PixelDrawingMode.NOOP;
120             case 6:
121                 return PixelDrawingMode.XOR;
122             case 7:
123                 return PixelDrawingMode.OR;
124             case 8:
125                 return PixelDrawingMode.NOR;
126             case 9:
127                 return PixelDrawingMode.EQUIV;
128             case 10:
129                 return PixelDrawingMode.INVERT;
130             case 11:
131                 return PixelDrawingMode.ORREVERSE;
132             case 12:
133                 return PixelDrawingMode.COPYINVERTED;
134             case 13:
135                 return PixelDrawingMode.ORINVERTED;
136             case 14:
137                 return PixelDrawingMode.NAND;
138             case 15:
139                 return PixelDrawingMode.SET;
140             default:
141                 return null;
142         }
143     }
144                                   };
145
146     /** FigureDimensions properties names */
147     public enum FigureDimensionsProperty { POSITION, SIZE };
148
149     /**
150      * FigureDimensions class
151      */
152     private class FigureDimensions {
153         /** Position (x,y) of the upper-left corner in the top-level window */
154         private Integer[] position;
155
156         /** Dimensions (w, h) of the figure window */
157         private Integer[] size;
158
159         /**
160          * Default constructor
161          */
162         public FigureDimensions() {
163             position = new Integer[2];
164             size = new Integer[2];
165         }
166
167         /**
168          * Copy constructor
169          * @param figureDimensions the FigureDimensions to copy
170          */
171         public FigureDimensions(FigureDimensions figureDimensions) {
172             this.position = new Integer[2];
173             this.position[0] = figureDimensions.position[0];
174             this.position[1] = figureDimensions.position[1];
175
176             this.size = new Integer[2];
177             this.size[0] = figureDimensions.size[0];
178             this.size[1] = figureDimensions.size[1];
179         }
180     }
181
182     /** CanvasProperty properties names */
183     public enum CanvasProperty { AUTORESIZE, VIEWPORT, AXESSIZE };
184
185     /**
186      * Canvas class
187      */
188     private class Canvas {
189         /** Specifies whether automatic resizing is used */
190         private boolean autoResize;
191
192         /** Viewport position (x,y) */
193         private Integer[] viewport;
194
195         /** Rendering canvas (w,h) dimensions */
196         private Integer[] axesSize;
197
198         /**
199          * Default constructor
200          */
201         public Canvas() {
202             autoResize = false;
203             viewport = new Integer[2];
204             axesSize = new Integer[2];
205         }
206
207         /**
208          * Copy constructor
209          * @param canvas the Canvas to copy
210          */
211         public Canvas(Canvas canvas) {
212             this.autoResize = canvas.autoResize;
213
214             this.viewport = new Integer[2];
215
216             this.viewport[0] = canvas.viewport[0];
217             this.viewport[1] = canvas.viewport[1];
218
219             this.axesSize = new Integer[2];
220
221             this.axesSize[0] = canvas.axesSize[0];
222             this.axesSize[1] = canvas.axesSize[1];
223         }
224     }
225
226     /** FigureName properties names */
227     public enum FigureNameProperty { NAME, ID };
228
229     /**
230      * FigureName class
231      */
232     public class FigureName implements Cloneable {
233         /** Name */
234         private String name;
235
236         /** Identifier */
237         private int id;
238
239         public FigureName clone() throws CloneNotSupportedException {
240             FigureName copy;
241
242             //    return (FigureName) super.clone();
243
244             copy = (FigureName) super.clone();
245
246             copy.name = new String(this.name);
247             copy.id = this.id;
248
249             return copy;
250         }
251
252         /**
253          * Default constructor
254          */
255         public FigureName() {
256             name = "";
257             id = 0;
258         }
259
260         /**
261          * Copy constructor
262          * @param figureName the FigureName to copy
263          */
264         public FigureName(FigureName figureName) {
265             name = new String(figureName.name);
266             id = figureName.id;
267         }
268
269     }
270
271     /** RenderingMode properties names */
272     public enum RenderingModeProperty { PIXMAP, PIXELDRAWINGMODE, ANTIALIASING, IMMEDIATEDRAWING };
273
274     /**
275      * RenderingMode class
276      */
277     private class RenderingMode {
278         /** Specifies rendering into a pixmap */
279         private boolean pixmap;
280
281         /** Specifies the pixel drawing mode used */
282         private PixelDrawingMode pixelDrawingMode;
283
284         /** Antialising level (0 == off) */
285         private int antialiasing;
286
287         /** Specifies whether immediate drawing is used or not */
288         private boolean immediateDrawing;
289
290         /**
291          * Default constructor
292          */
293         public RenderingMode() {
294             pixmap = false;
295             pixelDrawingMode = PixelDrawingMode.COPY;
296             antialiasing = 0;
297             immediateDrawing = true;
298         }
299
300         /**
301          * Copy constructor
302          * @param renderingMode the RenderingMode to copy
303          */
304         public RenderingMode(RenderingMode renderingMode) {
305             pixmap = renderingMode.pixmap;
306             pixelDrawingMode = renderingMode.pixelDrawingMode;
307             antialiasing = renderingMode.antialiasing;
308             immediateDrawing = renderingMode.immediateDrawing;
309         }
310
311     }
312
313     /** EventHandler properties names */
314     public enum EventHandlerProperty { EVENTHANDLER, EVENTHANDLERENABLE };
315
316     /**
317      * EventHandler class
318      */
319     private class EventHandler {
320         /** Event handler string */
321         private String eventHandler = "";
322
323         /** Specifies whether the event handler is enabled or not */
324         private Boolean eventHandlerEnabled = false;
325
326         /**
327          * Default constructor
328          */
329         public EventHandler() {
330             eventHandler = "";
331             eventHandlerEnabled = false;
332         }
333
334         /**
335          * Copy constructor
336          * @param eventHandler the EventHandler to copy
337          */
338         public EventHandler(EventHandler eventHandler) {
339             this.eventHandler = eventHandler.eventHandler;
340             this.eventHandlerEnabled = eventHandler.eventHandlerEnabled;
341         }
342     }
343
344     /** Figure dimensions */
345     private FigureDimensions dimensions;
346
347     /** Canvas property */
348     private Canvas canvas;
349
350     /** Figure name */
351     private FigureName figureName;
352
353     /** Info message */
354     private String infoMessage;
355
356     /**
357      * Default ColorMap: (3 x N) matrix, where N is the
358      * number of colors and 3 the number of color channels
359      */
360     private ColorMap colorMap;
361
362     /** Rendering mode */
363     private RenderingMode renderingMode;
364
365     /** Background color */
366     private int background;
367
368     /** Event handler */
369     private EventHandler eventHandler;
370
371     /** ResizeFcn */
372     private String resizeFcn;
373
374     /** CloseRequestFcn */
375     private String closeRequestFcn;
376
377     /** Rotation type */
378     private RotationType rotation;
379
380     /** resize */
381     private Boolean resize;
382
383     /** toolbar */
384     private BarType toolbar;
385     private Boolean toolbarVisible;
386
387     /** menubar */
388     private BarType menubar;
389     private Boolean menubarVisible;
390
391     /** infobar */
392     private Boolean infobarVisible;
393
394     /** dockable */
395     private Boolean dockable;
396
397     /** layout */
398     private LayoutType layout;
399
400     /** layout options */
401     private Integer[] gridOptGrid = new Integer[2];
402     private Integer[] gridOptPadding = new Integer[2];
403     private Integer[] borderOptPadding = new Integer[2];
404
405     /** Constructor */
406     public Figure() {
407         super();
408         dimensions = new FigureDimensions();
409         canvas = new Canvas();
410         figureName = new FigureName();
411         infoMessage = null;
412         colorMap = new ColorMap();
413
414         renderingMode = new RenderingMode();
415         background = 0;
416         eventHandler = new EventHandler();
417         resizeFcn = "";
418         closeRequestFcn = "";
419         rotation = RotationType.UNARY;
420         resize = true;
421         toolbarVisible = true;
422         toolbar = BarType.FIGURE;
423         menubarVisible = true;
424         menubar = BarType.FIGURE;
425         infobarVisible = true;
426         dockable = true;
427         layout = LayoutType.NONE;
428     }
429
430     @Override
431     public Figure clone() {
432         Figure copy = null;
433         copy = (Figure) super.clone();
434
435         copy.dimensions = new FigureDimensions(this.dimensions);
436         copy.canvas = new Canvas(this.canvas);
437         copy.figureName = new FigureName(this.figureName);
438         copy.colorMap = new ColorMap(this.colorMap);
439         copy.renderingMode = new RenderingMode(this.renderingMode);
440         copy.eventHandler = new EventHandler(this.eventHandler);
441
442         copy.setValid(true);
443
444         return copy;
445     }
446
447     @Override
448     public void accept(Visitor visitor) {
449         visitor.visit(this);
450     }
451
452     /**
453      * Returns the enum associated to a property name
454      * @param propertyName the property name
455      * @return the property enum
456      */
457     public Object getPropertyFromName(int propertyName) {
458         switch (propertyName) {
459             case __GO_POSITION__ :
460                 return FigureDimensionsProperty.POSITION;
461             case __GO_SIZE__ :
462                 return FigureDimensionsProperty.SIZE;
463             case __GO_AUTORESIZE__ :
464                 return CanvasProperty.AUTORESIZE;
465             case __GO_VIEWPORT__ :
466                 return CanvasProperty.VIEWPORT;
467             case __GO_AXES_SIZE__ :
468                 return CanvasProperty.AXESSIZE;
469             case __GO_NAME__ :
470                 return FigureNameProperty.NAME;
471             case __GO_ID__ :
472                 return FigureNameProperty.ID;
473             case __GO_INFO_MESSAGE__ :
474                 return FigureProperty.INFOMESSAGE;
475             case __GO_COLORMAP__ :
476                 return FigureProperty.COLORMAP;
477             case __GO_COLORMAP_SIZE__ :
478                 return FigureProperty.COLORMAPSIZE;
479             case __GO_PIXMAP__ :
480                 return RenderingModeProperty.PIXMAP;
481             case __GO_PIXEL_DRAWING_MODE__ :
482                 return RenderingModeProperty.PIXELDRAWINGMODE;
483             case __GO_ANTIALIASING__ :
484                 return RenderingModeProperty.ANTIALIASING;
485             case __GO_IMMEDIATE_DRAWING__ :
486                 return RenderingModeProperty.IMMEDIATEDRAWING;
487             case __GO_BACKGROUND__ :
488                 return FigureProperty.BACKGROUND;
489             case __GO_EVENTHANDLER_NAME__ :
490                 return EventHandlerProperty.EVENTHANDLER;
491             case __GO_EVENTHANDLER_ENABLE__ :
492                 return EventHandlerProperty.EVENTHANDLERENABLE;
493             case __GO_ROTATION_TYPE__ :
494                 return FigureProperty.ROTATIONTYPE;
495             case __GO_RESIZEFCN__ :
496                 return FigureProperty.RESIZEFCN;
497             case __GO_CLOSEREQUESTFCN__ :
498                 return FigureProperty.CLOSEREQUESTFCN;
499             case __GO_RESIZE__ :
500                 return FigureProperty.RESIZE;
501             case __GO_TOOLBAR__ :
502                 return FigureProperty.TOOLBAR;
503             case __GO_TOOLBAR_VISIBLE__ :
504                 return FigureProperty.TOOLBAR_VISIBLE;
505             case __GO_MENUBAR__ :
506                 return FigureProperty.MENUBAR;
507             case __GO_MENUBAR_VISIBLE__ :
508                 return FigureProperty.MENUBAR_VISIBLE;
509             case __GO_INFOBAR_VISIBLE__ :
510                 return FigureProperty.INFOBAR_VISIBLE;
511             case __GO_DOCKABLE__ :
512                 return FigureProperty.DOCKABLE;
513             case __GO_LAYOUT__ :
514                 return FigureProperty.LAYOUT;
515             case __GO_LAYOUT_SET__ :
516                 return FigureProperty.LAYOUT_SET;
517             case __GO_GRID_OPT_GRID__ :
518                 return FigureProperty.GRIDOPT_GRID;
519             case __GO_GRID_OPT_PADDING__ :
520                 return FigureProperty.GRIDOPT_PADDING;
521             case __GO_BORDER_OPT_PADDING__ :
522                 return FigureProperty.BORDEROPT_PADDING;
523             default :
524                 return super.getPropertyFromName(propertyName);
525         }
526     }
527
528     /**
529      * Fast property get method
530      * @param property the property to get
531      * @return the property value
532      */
533     public Object getProperty(Object property) {
534         if (property == FigureDimensionsProperty.POSITION) {
535             return getPosition();
536         } else if (property == FigureDimensionsProperty.SIZE) {
537             return getSize();
538         } else if (property == CanvasProperty.AUTORESIZE) {
539             return getAutoResize();
540         } else if (property == CanvasProperty.VIEWPORT) {
541             return getViewport();
542         } else if (property == CanvasProperty.AXESSIZE) {
543             return getAxesSize();
544         } else if (property == FigureNameProperty.NAME) {
545             return getName();
546         } else if (property == FigureNameProperty.ID) {
547             return getId();
548         } else if (property == FigureProperty.INFOMESSAGE) {
549             return getInfoMessage();
550         } else if (property == FigureProperty.COLORMAP) {
551             return getColorMap().getData();
552         } else if (property == FigureProperty.COLORMAPSIZE) {
553             return getColorMap().getSize();
554         } else if (property == RenderingModeProperty.PIXMAP) {
555             return getPixmap();
556         } else if (property == RenderingModeProperty.PIXELDRAWINGMODE) {
557             return getPixelDrawingMode();
558         } else if (property == RenderingModeProperty.ANTIALIASING) {
559             return getAntialiasing();
560         } else if (property == RenderingModeProperty.IMMEDIATEDRAWING) {
561             return getImmediateDrawing();
562         } else if (property == FigureProperty.BACKGROUND) {
563             return getBackground();
564         } else if (property == EventHandlerProperty.EVENTHANDLER) {
565             return getEventHandlerString();
566         } else if (property == EventHandlerProperty.EVENTHANDLERENABLE) {
567             return getEventHandlerEnable();
568         } else if (property == FigureProperty.ROTATIONTYPE) {
569             return getRotation();
570         } else if (property == FigureProperty.RESIZEFCN) {
571             return getResizeFcn();
572         } else if (property == FigureProperty.CLOSEREQUESTFCN) {
573             return getCloseRequestFcn();
574         } else if (property == FigureProperty.RESIZE) {
575             return getResize();
576         } else if (property == FigureProperty.TOOLBAR) {
577             return getToolbar();
578         } else if (property == FigureProperty.TOOLBAR_VISIBLE) {
579             return getToolbarVisible();
580         } else if (property == FigureProperty.MENUBAR) {
581             return getMenubar();
582         } else if (property == FigureProperty.MENUBAR_VISIBLE) {
583             return getMenubarVisible();
584         } else if (property == FigureProperty.INFOBAR_VISIBLE) {
585             return getInfobarVisible();
586         } else if (property == FigureProperty.DOCKABLE) {
587             return getDockable();
588         } else if (property == FigureProperty.LAYOUT) {
589             return getLayout();
590         } else if (property == FigureProperty.LAYOUT_SET) {
591             return isLayoutSettable();
592         } else if (property == FigureProperty.GRIDOPT_GRID) {
593             return getGridOptGrid();
594         } else if (property == FigureProperty.GRIDOPT_PADDING) {
595             return getGridOptPadding();
596         } else if (property == FigureProperty.BORDEROPT_PADDING) {
597             return getBorderOptPadding();
598         } else {
599             return super.getProperty(property);
600         }
601     }
602
603     /**
604      * Fast property set method
605      * @param property the property to set
606      * @param value the property value
607      * @return true if the property has been set, false otherwise
608      */
609     public UpdateStatus setProperty(Object property, Object value) {
610         if (property instanceof FigureProperty) {
611             switch ((FigureProperty)property) {
612                 case BACKGROUND:
613                     return setBackground((Integer) value);
614                 case CLOSEREQUESTFCN:
615                     return setCloseRequestFcn((String) value);
616                 case COLORMAP:
617                     return getColorMap().setData((Double[]) value);
618                 case COLORMAPSIZE:
619                     return UpdateStatus.NoChange;
620                 case INFOMESSAGE:
621                     return setInfoMessage((String) value);
622                 case RESIZEFCN:
623                     return setResizeFcn((String) value);
624                 case ROTATIONTYPE:
625                     return setRotation((Integer) value);
626                 case RESIZE:
627                     return setResize((Boolean) value);
628                 case TOOLBAR:
629                     return setToolbar((Integer) value);
630                 case TOOLBAR_VISIBLE:
631                     return setToolbarVisible((Boolean) value);
632                 case MENUBAR:
633                     return setMenubar((Integer) value);
634                 case MENUBAR_VISIBLE:
635                     return setMenubarVisible((Boolean) value);
636                 case INFOBAR_VISIBLE:
637                     return setInfobarVisible((Boolean) value);
638                 case DOCKABLE:
639                     return setDockable((Boolean) value);
640                 case LAYOUT:
641                     return setLayout((Integer) value);
642                 case GRIDOPT_GRID:
643                     return setGridOptGrid((Integer[]) value);
644                 case GRIDOPT_PADDING:
645                     return setGridOptPadding((Integer[]) value);
646                 case BORDEROPT_PADDING:
647                     return setBorderOptPadding((Integer[]) value);
648                 default:
649                     break;
650             }
651         } else if (property instanceof CanvasProperty) {
652             switch ((CanvasProperty)property) {
653                 case AUTORESIZE:
654                     return setAutoResize((Boolean) value);
655                 case AXESSIZE:
656                     return setAxesSize((Integer[]) value);
657                 case VIEWPORT:
658                     return setViewport((Integer[]) value);
659             }
660         } else if (property instanceof FigureDimensionsProperty) {
661             switch ((FigureDimensionsProperty)property) {
662                 case POSITION:
663                     return setPosition((Integer[]) value);
664                 case SIZE:
665                     return setSize((Integer[]) value);
666             }
667         } else if (property instanceof FigureNameProperty) {
668             switch ((FigureNameProperty)property) {
669                 case ID:
670                     return setId((Integer) value);
671                 case NAME:
672                     return setName((String) value);
673             }
674         } else if (property instanceof RenderingModeProperty) {
675             switch ((RenderingModeProperty)property) {
676                 case ANTIALIASING:
677                     return setAntialiasing((Integer) value);
678                 case IMMEDIATEDRAWING:
679                     return setImmediateDrawing((Boolean) value);
680                 case PIXELDRAWINGMODE:
681                     return setPixelDrawingMode((Integer) value);
682                 case PIXMAP:
683                     return setPixmap((Boolean) value);
684             }
685         } else if (property instanceof EventHandlerProperty) {
686             switch ((EventHandlerProperty)property) {
687                 case EVENTHANDLER:
688                     return setEventHandlerString((String) value);
689                 case EVENTHANDLERENABLE:
690                     return setEventHandlerEnable((Boolean) value);
691             }
692         } else {
693             return super.setProperty(property, value);
694         }
695
696         return UpdateStatus.Success;
697     }
698
699     /**
700      * @return the background
701      */
702     public Integer getBackground() {
703         return background;
704     }
705
706     /**
707      * @param background the background to set
708      */
709     public UpdateStatus setBackground(Integer background) {
710         if (this.background == background) {
711             return UpdateStatus.NoChange;
712         }
713         this.background = background;
714         return UpdateStatus.Success;
715     }
716
717     /**
718      * @return the canvas
719      */
720     public Canvas getCanvas() {
721         return canvas;
722     }
723
724     /**
725      * @param canvas the canvas to set
726      */
727     public UpdateStatus setCanvas(Canvas canvas) {
728         this.canvas = canvas;
729         return UpdateStatus.Success;
730     }
731
732     /**
733      * @return the autoresize
734      */
735     public Boolean getAutoResize() {
736         return canvas.autoResize;
737     }
738
739     /**
740      * @param autoResize the autoresize to set
741      */
742     public UpdateStatus setAutoResize(Boolean autoResize) {
743         if (canvas.autoResize == autoResize) {
744             return UpdateStatus.NoChange;
745         }
746         canvas.autoResize = autoResize;
747         return UpdateStatus.Success;
748     }
749
750     /**
751      * @return the viewport
752      */
753     public Integer[] getViewport() {
754         Integer[] retViewport = new Integer[2];
755
756         retViewport[0] = canvas.viewport[0];
757         retViewport[1] = canvas.viewport[1];
758
759         return retViewport;
760     }
761
762     /**
763      * @param viewport the viewport to set
764      */
765     public UpdateStatus setViewport(Integer[] viewport) {
766         if (Arrays.equals(canvas.viewport, viewport)) {
767             return UpdateStatus.NoChange;
768         }
769         canvas.viewport[0] = viewport[0];
770         canvas.viewport[1] = viewport[1];
771         return UpdateStatus.Success;
772     }
773
774     /**
775      * @return the axes size
776      */
777     public Integer[] getAxesSize() {
778         //System.out.println("getAxesSize : (" + canvas.axesSize[0] + "," + canvas.axesSize[1] + ")");
779         Integer[] retAxesSize = new Integer[2];
780
781         retAxesSize[0] = canvas.axesSize[0];
782         retAxesSize[1] = canvas.axesSize[1];
783
784         return retAxesSize;
785     }
786
787     /**
788      * @param axesSize the axes size to set
789      */
790     public UpdateStatus setAxesSize(Integer[] axesSize) {
791         //System.out.println("setAxesSize : (" + axesSize[0] + "," + axesSize[1] + ")");
792         if (Arrays.equals(canvas.axesSize, axesSize)) {
793             //must return Success to broadcast information
794             return UpdateStatus.Success;
795         }
796         canvas.axesSize[0] = axesSize[0];
797         canvas.axesSize[1] = axesSize[1];
798         return UpdateStatus.Success;
799     }
800
801     /**
802      * @return the colorMap
803      */
804     public ColorMap getColorMap() {
805         return colorMap;
806     }
807
808     /**
809      * @return the dimensions
810      */
811     public FigureDimensions getDimensions() {
812         return dimensions;
813     }
814
815     /**
816      * @param dimensions the dimensions to set
817      */
818     public UpdateStatus setDimensions(FigureDimensions dimensions) {
819         if (this.dimensions == dimensions) {
820             return UpdateStatus.NoChange;
821         }
822         this.dimensions = dimensions;
823         return UpdateStatus.Success;
824     }
825
826     /**
827      * @return the figure position
828      */
829     public Integer[] getPosition() {
830         Integer[] retPosition = new Integer[2];
831
832         retPosition[0] = dimensions.position[0];
833         retPosition[1] = dimensions.position[1];
834
835         return retPosition;
836     }
837
838     /**
839      * @param position the position to set
840      */
841     public UpdateStatus setPosition(Integer[] position) {
842         if (Arrays.equals(dimensions.position, position)) {
843             return UpdateStatus.NoChange;
844         }
845
846         dimensions.position[0] = position[0];
847         dimensions.position[1] = position[1];
848         return UpdateStatus.Success;
849     }
850
851     /**
852      * @return the figure size
853      */
854     public Integer[] getSize() {
855         //System.out.println("getSize : (" + dimensions.size[0] + "," + dimensions.size[1] + ")");
856         Integer[] retSize = new Integer[2];
857
858         retSize[0] = dimensions.size[0];
859         retSize[1] = dimensions.size[1];
860
861         return retSize;
862     }
863
864     /**
865      * @param size the size to set
866      */
867     public UpdateStatus setSize(Integer[] size) {
868         //System.out.println("setSize : (" + size[0] + "," + size[1] + ")");
869         if (Arrays.equals(dimensions.size, size)) {
870             return UpdateStatus.NoChange;
871         }
872
873         dimensions.size[0] = size[0];
874         dimensions.size[1] = size[1];
875         return UpdateStatus.Success;
876     }
877
878     /**
879      * @return the eventHandler
880      */
881     public EventHandler getEventHandler() {
882         return eventHandler;
883     }
884
885     /**
886      * @param eventHandler the eventHandler to set
887      */
888     public UpdateStatus setEventHandler(EventHandler eventHandler) {
889         if (this.eventHandler.equals(eventHandler)) {
890             return UpdateStatus.NoChange;
891         }
892         this.eventHandler = eventHandler;
893         return UpdateStatus.Success;
894     }
895
896     /**
897      * @return the eventHandler string
898      */
899     public String getEventHandlerString() {
900         return eventHandler.eventHandler;
901     }
902
903     /**
904      * @param eventHandlerString the eventHandler string to set
905      */
906     public UpdateStatus setEventHandlerString(String eventHandlerString) {
907         if (eventHandler.eventHandler.equals(eventHandlerString)) {
908             return UpdateStatus.NoChange;
909         }
910         eventHandler.eventHandler = eventHandlerString;
911         return UpdateStatus.Success;
912     }
913
914     /**
915      * @return the eventHandlerEnabled
916      */
917     public Boolean getEventHandlerEnable() {
918         return eventHandler.eventHandlerEnabled;
919     }
920
921     /**
922      * @param eventHandlerEnabled the eventHandlerEnabled to set
923      */
924     public UpdateStatus setEventHandlerEnable(Boolean eventHandlerEnabled) {
925         if (eventHandler.eventHandlerEnabled == eventHandlerEnabled) {
926             return UpdateStatus.NoChange;
927         }
928         eventHandler.eventHandlerEnabled = eventHandlerEnabled;
929         return UpdateStatus.Success;
930     }
931
932     /**
933      * @return the infoMessage
934      */
935     public String getInfoMessage() {
936         return infoMessage;
937     }
938
939     /**
940      * @param infoMessage the infoMessage to set
941      */
942     public UpdateStatus setInfoMessage(String infoMessage) {
943         if (this.infoMessage != null && this.infoMessage.equals(infoMessage)) {
944             return UpdateStatus.NoChange;
945         }
946         this.infoMessage = infoMessage;
947         return UpdateStatus.Success;
948     }
949
950     /**
951      * @return the name
952      */
953     public FigureName getFigureName() {
954         return figureName;
955     }
956
957     /**
958      * @param figureName the figure name to set
959      */
960     public UpdateStatus setFigureName(FigureName figureName) {
961         if (this.figureName.equals(figureName)) {
962             return UpdateStatus.NoChange;
963         }
964         this.figureName = figureName;
965         return UpdateStatus.Success;
966     }
967
968     /**
969      * @return the figure name
970      */
971     public String getName() {
972         return figureName.name;
973     }
974
975     /**
976      * @param name the name to set
977      */
978     public UpdateStatus setName(String name) {
979         if (figureName.name.equals(name)) {
980             return UpdateStatus.NoChange;
981         }
982         figureName.name = name;
983         return UpdateStatus.Success;
984     }
985
986     /**
987      * @return the id
988      */
989     public Integer getId() {
990         return figureName.id;
991     }
992
993     /**
994      * @param id the id to set
995      */
996     public UpdateStatus setId(Integer id) {
997         //must return Success to update Views
998         figureName.id = id;
999         return UpdateStatus.Success;
1000     }
1001
1002     /**
1003      * @return the renderingMode
1004      */
1005     public RenderingMode getRenderingMode() {
1006         return renderingMode;
1007     }
1008
1009     /**
1010      * @param renderingMode the renderingMode to set
1011      */
1012     public UpdateStatus setRenderingMode(RenderingMode renderingMode) {
1013         if (this.renderingMode.equals(renderingMode)) {
1014             return UpdateStatus.NoChange;
1015         }
1016         this.renderingMode = renderingMode;
1017         return UpdateStatus.Success;
1018     }
1019
1020     /**
1021      * @return the pixmap
1022      */
1023     public Boolean getPixmap() {
1024         return renderingMode.pixmap;
1025     }
1026
1027     /**
1028      * @param pixmap the pixmap to set
1029      */
1030     public UpdateStatus setPixmap(Boolean pixmap) {
1031         if (renderingMode.pixmap == pixmap) {
1032             return UpdateStatus.NoChange;
1033         }
1034         renderingMode.pixmap = pixmap;
1035         return UpdateStatus.Success;
1036     }
1037
1038     /**
1039      * @return the pixel drawing mode enum
1040      */
1041     public PixelDrawingMode getPixelDrawingModeAsEnum() {
1042         return renderingMode.pixelDrawingMode;
1043     }
1044
1045     /**
1046      * @return the pixel drawing mode
1047      */
1048     public Integer getPixelDrawingMode() {
1049         return getPixelDrawingModeAsEnum().ordinal();
1050     }
1051
1052     /**
1053      * @param pixelDrawingMode the pixel drawing mode to set
1054      */
1055     public UpdateStatus setPixelDrawingMode(PixelDrawingMode pixelDrawingMode) {
1056         if (renderingMode.pixelDrawingMode.equals(pixelDrawingMode)) {
1057             return UpdateStatus.NoChange;
1058         }
1059         renderingMode.pixelDrawingMode = pixelDrawingMode;
1060         return UpdateStatus.Success;
1061     }
1062
1063     /**
1064      * @param pixelDrawingMode the pixel drawing mode to set
1065      */
1066     public UpdateStatus setPixelDrawingMode(Integer pixelDrawingMode) {
1067         PixelDrawingMode mode = PixelDrawingMode.intToEnum(pixelDrawingMode);
1068         if (renderingMode.pixelDrawingMode == mode) {
1069             return UpdateStatus.NoChange;
1070         }
1071
1072         renderingMode.pixelDrawingMode = mode;
1073         return UpdateStatus.Success;
1074     }
1075
1076     /**
1077      * @return the pixmap
1078      */
1079     public Integer getAntialiasing() {
1080         return renderingMode.antialiasing;
1081     }
1082
1083     /**
1084      * @param antialiasing the antialiasing to set
1085      */
1086     public UpdateStatus setAntialiasing(Integer antialiasing) {
1087         if (renderingMode.antialiasing == antialiasing) {
1088             return UpdateStatus.NoChange;
1089         }
1090         renderingMode.antialiasing = antialiasing;
1091         return UpdateStatus.Success;
1092     }
1093
1094     /**
1095      * @return the immediateDrawing
1096      */
1097     public Boolean getImmediateDrawing() {
1098         return renderingMode.immediateDrawing;
1099     }
1100
1101     /**
1102      * @param immediateDrawing the immediateDrawing to set
1103      */
1104     public UpdateStatus setImmediateDrawing(Boolean immediateDrawing) {
1105         if (renderingMode.immediateDrawing == immediateDrawing) {
1106             return UpdateStatus.NoChange;
1107         }
1108
1109         renderingMode.immediateDrawing = immediateDrawing;
1110         return UpdateStatus.Success;
1111     }
1112
1113     /**
1114      * @return the rotation
1115      */
1116     public RotationType getRotationAsEnum() {
1117         return rotation;
1118     }
1119
1120     /**
1121      * @return the rotation
1122      */
1123     public Integer getRotation() {
1124         return getRotationAsEnum().ordinal();
1125     }
1126
1127     /**
1128      * @param rotation the rotation to set
1129      */
1130     public UpdateStatus setRotation(RotationType rotation) {
1131         if (this.rotation.equals(rotation)) {
1132             return UpdateStatus.NoChange;
1133         }
1134         this.rotation = rotation;
1135         return UpdateStatus.Success;
1136     }
1137
1138     /**
1139      * @param rotation the rotation to set
1140      */
1141     public UpdateStatus setRotation(Integer rotation) {
1142         RotationType rotationType = RotationType.intToEnum(rotation);
1143         if (rotationType == null || this.rotation == rotationType) {
1144             return UpdateStatus.NoChange;
1145         }
1146
1147         this.rotation = rotationType;
1148         return UpdateStatus.Success;
1149     }
1150
1151     /**
1152      * @return the resize function
1153      */
1154     public String getResizeFcn() {
1155         return resizeFcn;
1156     }
1157
1158     /**
1159      * @param resizeFcn the resize function to set
1160      */
1161     public UpdateStatus setResizeFcn(String resizeFcn) {
1162         if (this.resizeFcn.equals(resizeFcn)) {
1163             return UpdateStatus.NoChange;
1164         }
1165         this.resizeFcn = resizeFcn;
1166         return UpdateStatus.Success;
1167     }
1168
1169     /**
1170      * @return the close request function
1171      */
1172     public String getCloseRequestFcn() {
1173         return closeRequestFcn;
1174     }
1175
1176     /**
1177      * @param closeRequestFcn the close request function to set
1178      */
1179     public UpdateStatus setCloseRequestFcn(String closeRequestFcn) {
1180         if (this.closeRequestFcn.equals(closeRequestFcn)) {
1181             return UpdateStatus.NoChange;
1182         }
1183         this.closeRequestFcn = closeRequestFcn;
1184         return UpdateStatus.Success;
1185     }
1186
1187
1188     public Boolean getResize() {
1189         return resize;
1190     }
1191
1192     public UpdateStatus setResize(Boolean status) {
1193         if (status.equals(resize)) {
1194             return UpdateStatus.NoChange;
1195         }
1196
1197         resize = status;
1198         return UpdateStatus.Success;
1199     }
1200
1201     public Boolean getToolbarVisible() {
1202         return toolbarVisible;
1203     }
1204
1205     public UpdateStatus setToolbarVisible(Boolean status) {
1206         if (status.equals(toolbarVisible)) {
1207             return UpdateStatus.NoChange;
1208         }
1209
1210         toolbarVisible = status;
1211         return UpdateStatus.Success;
1212     }
1213
1214     public Integer getToolbar() {
1215         return toolbar.ordinal();
1216     }
1217
1218     public BarType getToolbarAsEnum() {
1219         return toolbar;
1220     }
1221
1222     public UpdateStatus setToolbar(Integer toolbar) {
1223         return setToolbar(BarType.intToEnum(toolbar));
1224     }
1225
1226     public UpdateStatus setToolbar(BarType toolbar) {
1227         if (toolbar == this.toolbar) {
1228             return UpdateStatus.NoChange;
1229         }
1230
1231         this.toolbar = toolbar;
1232         return UpdateStatus.Success;
1233     }
1234
1235     public Boolean getMenubarVisible() {
1236         return menubarVisible;
1237     }
1238
1239     public UpdateStatus setMenubarVisible(Boolean status) {
1240         if (status.equals(menubarVisible)) {
1241             return UpdateStatus.NoChange;
1242         }
1243
1244         menubarVisible = status;
1245         return UpdateStatus.Success;
1246     }
1247
1248     public Integer getMenubar() {
1249         return menubar.ordinal();
1250     }
1251
1252     public BarType getMenubarAsEnum() {
1253         return menubar;
1254     }
1255
1256     public UpdateStatus setMenubar(Integer menubar) {
1257         return setMenubar(BarType.intToEnum(menubar));
1258     }
1259
1260     public UpdateStatus setMenubar(BarType menubar) {
1261         if (menubar == this.menubar) {
1262             return UpdateStatus.NoChange;
1263         }
1264
1265         this.menubar = menubar;
1266         return UpdateStatus.Success;
1267     }
1268
1269     public Boolean getInfobarVisible() {
1270         return infobarVisible;
1271     }
1272
1273     public UpdateStatus setInfobarVisible(Boolean status) {
1274         if (status.equals(infobarVisible)) {
1275             return UpdateStatus.NoChange;
1276         }
1277
1278         infobarVisible = status;
1279         return UpdateStatus.Success;
1280     }
1281
1282     public Boolean getDockable() {
1283         return dockable;
1284     }
1285
1286     public UpdateStatus setDockable(Boolean status) {
1287         if (status.equals(dockable)) {
1288             return UpdateStatus.NoChange;
1289         }
1290
1291         dockable = status;
1292         return UpdateStatus.Success;
1293     }
1294
1295     public Integer getLayout() {
1296         return layout.ordinal();
1297     }
1298
1299     public LayoutType getLayoutAsEnum() {
1300         return layout;
1301     }
1302
1303     public boolean isLayoutSettable() {
1304         return (this.layout == LayoutType.NONE);
1305     }
1306
1307     public UpdateStatus setLayout(Integer value) {
1308         return setLayout(LayoutType.intToEnum(value));
1309     }
1310
1311     public UpdateStatus setLayout(LayoutType layout) {
1312         //avoid to set layout twice
1313         if (this.layout == LayoutType.NONE) {
1314             if (layout == LayoutType.NONE) {
1315                 return UpdateStatus.NoChange;
1316             }
1317
1318             this.layout = layout;
1319             return UpdateStatus.Success;
1320         }
1321
1322         return UpdateStatus.Fail;
1323     }
1324
1325     public Integer[] getBorderOptPadding() {
1326         return borderOptPadding;
1327     }
1328
1329     public UpdateStatus setBorderOptPadding(Integer[] value) {
1330         UpdateStatus status = UpdateStatus.NoChange;
1331         if (borderOptPadding.length != value.length) {
1332             return UpdateStatus.Fail;
1333         }
1334
1335         for (int i = 0 ; i < value.length ; i++) {
1336             if (borderOptPadding[i] != value[i]) {
1337                 borderOptPadding[i] = value[i];
1338                 status = UpdateStatus.Success;
1339             }
1340         }
1341
1342         return status;
1343     }
1344
1345     public Integer[] getGridOptPadding() {
1346         return gridOptPadding;
1347     }
1348
1349     public UpdateStatus setGridOptPadding(Integer[] value) {
1350         UpdateStatus status = UpdateStatus.NoChange;
1351         if (gridOptPadding.length != value.length) {
1352             return UpdateStatus.Fail;
1353         }
1354
1355         for (int i = 0 ; i < value.length ; i++) {
1356             if (gridOptPadding[i] != value[i]) {
1357                 gridOptPadding[i] = value[i];
1358                 status = UpdateStatus.Success;
1359             }
1360         }
1361
1362         return status;
1363     }
1364
1365     public Integer[] getGridOptGrid() {
1366         return gridOptGrid;
1367     }
1368
1369     public UpdateStatus setGridOptGrid(Integer[] value) {
1370         UpdateStatus status = UpdateStatus.NoChange;
1371         if (gridOptGrid.length != value.length) {
1372             return UpdateStatus.Fail;
1373         }
1374
1375         for (int i = 0 ; i < value.length ; i++) {
1376             if (gridOptGrid[i] != value[i]) {
1377                 gridOptGrid[i] = value[i];
1378                 status = UpdateStatus.Success;
1379             }
1380         }
1381
1382         return status;
1383     }
1384
1385
1386     /**
1387      * @return Type as String
1388      */
1389     public Integer getType() {
1390         return GraphicObjectProperties.__GO_FIGURE__;
1391     }
1392
1393 }