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