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