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