Fix some Coverity issues after 33b80b 50fe1d 5f73e9 and c473f9
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / editor / Editor.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - Pedro Arthur dos S. Souza
4  * Copyright (C) 2012 - Caio Lucas dos S. Souza
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16
17 package org.scilab.modules.gui.editor;
18
19
20 import org.scilab.modules.renderer.utils.CommonHandler;
21 import org.scilab.modules.renderer.utils.EntityPicker;
22 import org.scilab.modules.renderer.utils.AxesHandler;
23 import java.awt.event.ActionListener;
24 import java.awt.event.ActionEvent;
25 import java.awt.event.MouseEvent;
26 import java.awt.event.KeyEvent;
27 import java.awt.Component;
28 import javax.swing.JOptionPane;
29 import javax.swing.JMenu;
30 import javax.swing.JMenuItem;
31 import javax.swing.JPopupMenu;
32
33 import org.scilab.modules.gui.datatip.DatatipManager;
34 import org.scilab.modules.gui.editor.ScilabClipboard;
35 import org.scilab.modules.gui.editor.SystemClipboard;
36 import org.scilab.modules.renderer.utils.PolylineHandler;
37 import org.scilab.modules.gui.editor.GEDPicker;
38 import org.scilab.modules.gui.editor.LabelHandler;
39 import org.scilab.modules.renderer.utils.LegendHandler;
40 import org.scilab.modules.gui.editor.action.EditorHistory;
41 import org.scilab.modules.gui.editor.action.ActionDelete;
42 import org.scilab.modules.gui.editor.action.ActionLegend;
43 import org.scilab.modules.gui.editor.action.ActionMove;
44 import org.scilab.modules.gui.editor.action.ActionPaste;
45 import org.scilab.modules.gui.editor.action.ActionTextEdit;
46 import org.scilab.modules.gui.editor.action.ActionPasteStyle;
47 import org.scilab.modules.gui.editor.action.ActionHide;
48 import org.scilab.modules.gui.ged.Inspector;
49 import org.scilab.modules.gui.ged.StartGED;
50 import org.scilab.modules.gui.ged.SwapObject;
51 import org.scilab.modules.localization.Messages;
52 import org.scilab.modules.action_binding.highlevel.ScilabInterpreterManagement;
53
54
55 /**
56  * Point and click figure editor.
57  *
58  * Provides polyline selection by mouse click,
59  * copy, cut, paste, delete, hide, unhide polylines
60  * by popup menus and keyboard shortcuts.
61  *
62  * @author Caio Souza <caioc2bolado@gmail.com>
63  * @author Pedro Souza <bygrandao@gmail.com>
64  *
65  * @since 2012-06-01
66  */
67
68 public class Editor {
69
70     JPopupMenu menu;
71     JMenuItem copy, copyStyle, cut, paste, pasteStyle, delete, clear, hide, unhide, clipboardCopy, labelX, labelY, labelZ, title, insert, remove, ged, editdata, undo, redo;
72     JMenu labels, legends;
73
74     EntityPicker.LegendInfo selectedLegend = null;
75     EntityPicker.SurfaceInfo selectedSurface = null;
76     Integer selected = null;
77     Integer figureUid = null;
78     Integer[] lastClick = { 0, 0 };
79     Integer[] dragClick = { 0, 0 };
80     EntityPicker entityPicker;
81     DataEditor dataEditor;
82     boolean dataModifyEnabled = false;
83     boolean dataEditEnabled = false;
84     boolean updateDrag = true;
85     EditorHistory editorHistory;
86
87     Component dialogComponent;
88
89     enum SelectionType {POLYLINE, LEGEND, SURFACE};
90     SelectionType selectedType;
91
92     public Editor() {
93         init();
94         setSelected(null);
95         setFigure(null);
96         editorHistory = new EditorHistory();
97         entityPicker = new EntityPicker();
98         dataEditor = new DataEditor();
99         dataEditor.setLeaveAction(new ActionListener() {
100             public void actionPerformed(ActionEvent actionEvent) {
101                 leaveDataEditor();
102             }
103         });
104     }
105
106     /**
107      * Enable / disable data modify.
108      * @param b true to enable, false to disable.
109      */
110     public void setDataModifyEnabled(boolean b) {
111         dataModifyEnabled = b;
112         if (!dataModifyEnabled) {
113             leaveDataEditor();
114         } else if (getSelected() != null) {
115             enterDataEditor();
116         }
117     }
118
119     /**
120      * Returns if the data modify is enabled or not.
121      * @return True if enabled, false otherwise.
122      */
123     public boolean isDataModifyEnabled() {
124         return dataModifyEnabled;
125     }
126
127     public void setUpdateDrag(boolean state) {
128         updateDrag = state;
129     }
130
131     /**
132      * On right mouse click, set popup menu visible.
133      * @param event MouseEvent to retrieve click positon in figure.
134      */
135     public void onRightMouseClick(MouseEvent event) {
136         if (!dataEditEnabled) {
137             lastClick[0] = event.getX();
138             lastClick[1] = event.getY();
139             boolean b = ScilabClipboard.getInstance().canPaste();
140             paste.setEnabled(b);
141
142             boolean notBlank = AxesHandler.isAxesNotBlank(figureUid);
143             clipboardCopy.setEnabled(notBlank);
144
145             pasteStyle.setEnabled(ScilabClipboard.getInstance().canPasteStyle());
146             undo.setEnabled(editorHistory.isUndoEnabled());
147             redo.setEnabled(editorHistory.isRedoEnabled());
148
149             menu.show(event.getComponent(), event.getX(), event.getY());
150             dialogComponent = event.getComponent();
151         } else {
152             dataEditor.onRightClick(event);
153         }
154     }
155
156     /**
157      * Handles left mouse clicks.
158      *
159      * @param event the mouse event.
160      */
161     public void onLeftMouseDown(MouseEvent event) {
162
163         lastClick[0] = event.getX();
164         lastClick[1] = event.getY();
165
166         if (!dataEditEnabled) {
167             switch (event.getClickCount()) {
168                 case 1:
169                     setSelected(tryPickAnyObject(lastClick));
170                     break;
171                 case 2:
172                     /*there is a polyline selected? if yes start dataEditor*/
173                     if (selected != null && selectedType == SelectionType.POLYLINE && dataModifyEnabled) {
174                         enterDataEditor();
175                     }
176                     /*on double click over a legend or label open dialog*/
177                     else if (selectedLegend != null) {
178                         onClickInsert(selectedLegend.polyline);
179                     } else {
180                         /*try pick a label and open the dialog*/
181                         onClickLabel(EntityPicker.pickLabel(figureUid, lastClick));
182                     }
183                     break;
184                 default:
185                     break;
186             }
187         } else { /*data editor is enabled, pass event to it*/
188             switch (event.getClickCount()) {
189                 case 1:
190                     dataEditor.onLeftMouseDown(event);
191                     break;
192                 case 2:
193                     dataEditor.onLeftDoubleClick(event);
194                     break;
195                 default:
196                     break;
197             }
198         }
199         dragClick[0] = lastClick[0];
200         dragClick[1] = lastClick[1];
201     }
202
203     public void onLeftMouseRelease(MouseEvent event) {
204
205         Integer object = getSelected();
206         if (dataModifyEnabled && !dataEditEnabled && object != null) {
207             editorHistory.addAction(new ActionMove(object, lastClick, dragClick, (selectedType == SelectionType.LEGEND)));
208         } else {
209             dataEditor.onLeftMouseRelease(event);
210         }
211     }
212
213     /**
214      * On drag move the selected object, if dataEditor
215      * is enabled pass event to it.
216      * @param event The mouse event.
217      */
218     public void onMouseDragged(MouseEvent event) {
219         Integer[] newClick = { event.getX(), event.getY() };
220         if (dataModifyEnabled) {
221             if (!dataEditEnabled) {
222                 Integer objUID = getSelected();
223                 if (objUID != null) {
224                     if (selectedType == SelectionType.LEGEND) {
225                         LegendHandler.dragLegend(objUID, dragClick, newClick);
226                     } else if (selectedType == SelectionType.POLYLINE) {
227                         PolylineHandler.getInstance().dragPolyline(objUID, dragClick, newClick);
228                     }
229                 } else {
230                     LabelHandler.dragLabel(figureUid, dragClick, newClick, updateDrag);
231                 }
232             } else {
233                 dataEditor.onDrag(dragClick, newClick);
234             }
235         }
236         dragClick[0] = newClick[0];
237         dragClick[1] = newClick[1];
238     }
239
240     /**
241      * Handles keyboard input
242      * @param event The Key event.
243      */
244     void onKeyPressed(KeyEvent event) {
245
246         if (event.isControlDown()) {
247             switch (event.getKeyCode()) {
248                 case KeyEvent.VK_C:
249                     if (getSelected() != null) {
250                         onClickCopy();
251                     }
252                     break;
253                 case KeyEvent.VK_V:
254                     if (ScilabClipboard.getInstance().canPaste()) {
255                         onClickPaste();
256                     }
257                     break;
258                 case KeyEvent.VK_X:
259                     onClickCut();
260                     break;
261                 case KeyEvent.VK_Z:
262                     if (editorHistory.isUndoEnabled()) {
263                         onClickUndo();
264                     }
265                     break;
266                 case KeyEvent.VK_N:
267                     try {
268                         ScilabInterpreterManagement.asynchronousScilabExec(null, "scf();");
269                     } catch (Exception e) {
270                         System.err.println(e);
271                     }
272                     break;
273                 default:
274                     break;
275             }
276         } else {
277             switch (event.getKeyCode()) {
278                 case KeyEvent.VK_DELETE:
279                     if (!dataEditEnabled) {
280                         onClickDelete();
281                     }
282                     break;
283                 case KeyEvent.VK_ESCAPE:
284                     leaveDataEditor();
285                     break;
286                 default:
287                     break;
288             }
289         }
290     }
291
292     /**
293      * Initializes the popup menu.
294      *
295      * Create the popup menu and all popup menu items
296      * and set the properly action for each menu item.
297      */
298     public void init() {
299         menu = new JPopupMenu();
300         labels = new JMenu(Messages.gettext("Label"));
301         legends = new JMenu(Messages.gettext("Legend"));
302
303         copy = new JMenuItem(Messages.gettext("Copy"));
304         copy.setToolTipText(Messages.gettext("Copy selected object"));
305         cut = new JMenuItem(Messages.gettext("Cut"));
306         cut.setToolTipText(Messages.gettext("Cut selected object"));
307         paste = new JMenuItem(Messages.gettext("Paste"));
308         paste.setToolTipText(Messages.gettext("Paste copied object on this figure"));
309         delete = new JMenuItem(Messages.gettext("Delete"));
310         delete.setToolTipText(Messages.gettext("Delete selected object"));
311         clear = new JMenuItem(Messages.gettext("Clear axes"));
312         clear.setToolTipText(Messages.gettext("Delete axes contents and labels"));
313         hide = new JMenuItem(Messages.gettext("Hide"));
314         hide.setToolTipText(Messages.gettext("Hide selected object"));
315         unhide = new JMenuItem(Messages.gettext("Unhide all"));
316         unhide.setToolTipText(Messages.gettext("Unhide all objects"));
317         clipboardCopy = new JMenuItem(Messages.gettext("Copy to Clipboard"));
318         clipboardCopy.setToolTipText(Messages.gettext("Copy figure to system clipboard"));
319         title = new JMenuItem(Messages.gettext("Title"));
320         title.setToolTipText(Messages.gettext("Set the axes main title"));
321         labelX = new JMenuItem(Messages.gettext("Label X"));
322         labelX.setToolTipText(Messages.gettext("Set the X axis label"));
323         labelY = new JMenuItem(Messages.gettext("Label Y"));
324         labelY.setToolTipText(Messages.gettext("Set the Y axis label"));
325         labelZ = new JMenuItem(Messages.gettext("Label Z"));
326         labelZ.setToolTipText(Messages.gettext("Set the Z axis label"));
327         insert = new JMenuItem(Messages.gettext("Insert"));
328         insert.setToolTipText(Messages.gettext("Insert a legend into the selected curve"));
329         remove = new JMenuItem(Messages.gettext("Remove"));
330         remove.setToolTipText(Messages.gettext("Remove the legend from the selected curve"));
331         ged = new JMenuItem(Messages.gettext("Open Quick Editor"));
332         ged.setToolTipText(Messages.gettext("Initialize the graphics editor"));
333         editdata = new JMenuItem(Messages.gettext("Edit curve data"));
334         editdata.setToolTipText(Messages.gettext("Enables curve data modification"));
335         undo = new JMenuItem(Messages.gettext("Undo"));
336         undo.setToolTipText(Messages.gettext("Undo last action"));
337         redo = new JMenuItem(Messages.gettext("Redo"));
338         redo.setToolTipText(Messages.gettext("Redo last undo action"));
339         copyStyle = new JMenuItem(Messages.gettext("Copy style"));
340         copyStyle.setToolTipText(Messages.gettext("Copy the style of the axes"));
341         pasteStyle = new JMenuItem(Messages.gettext("Paste style"));
342         pasteStyle.setToolTipText(Messages.gettext("Paste the copied style on these axes"));
343
344         copy.addActionListener(new ActionListener() {
345             public void actionPerformed(ActionEvent actionEvent) {
346                 onClickCopy();
347             }
348         });
349
350         cut.addActionListener(new ActionListener() {
351             public void actionPerformed(ActionEvent actionEvent) {
352                 onClickCut();
353             }
354         });
355
356         paste.addActionListener(new ActionListener() {
357             public void actionPerformed(ActionEvent actionEvent) {
358                 onClickPaste();
359             }
360         });
361
362         delete.addActionListener(new ActionListener() {
363             public void actionPerformed(ActionEvent actionEvent) {
364                 onClickDelete();
365             }
366         });
367
368         clear.addActionListener(new ActionListener() {
369             public void actionPerformed(ActionEvent actionEvent) {
370                 onClickClear();
371             }
372         });
373
374         hide.addActionListener(new ActionListener() {
375             public void actionPerformed(ActionEvent actionEvent) {
376                 onClickHide();
377             }
378         });
379
380         unhide.addActionListener(new ActionListener() {
381             public void actionPerformed(ActionEvent actionEvent) {
382                 onClickUnhide();
383             }
384         });
385
386         clipboardCopy.addActionListener(new ActionListener() {
387             public void actionPerformed(ActionEvent actionEvent) {
388                 onClickCCopy();
389             }
390         });
391
392         labelX.addActionListener(new ActionListener() {
393             public void actionPerformed(ActionEvent actionEvent) {
394                 onClickLabel(AxesHandler.axisTo.__X__);
395             }
396         });
397
398         labelY.addActionListener(new ActionListener() {
399             public void actionPerformed(ActionEvent actionEvent) {
400                 onClickLabel(AxesHandler.axisTo.__Y__);
401             }
402         });
403
404         labelZ.addActionListener(new ActionListener() {
405             public void actionPerformed(ActionEvent actionEvent) {
406                 onClickLabel(AxesHandler.axisTo.__Z__);
407             }
408         });
409         title.addActionListener(new ActionListener() {
410             public void actionPerformed(ActionEvent actionEvent) {
411                 onClickLabel(AxesHandler.axisTo.__TITLE__);
412             }
413         });
414
415         insert.addActionListener(new ActionListener() {
416             public void actionPerformed(ActionEvent actionEvent) {
417                 onClickInsert(getSelected());
418             }
419         });
420
421         remove.addActionListener(new ActionListener() {
422             public void actionPerformed(ActionEvent actionEvent) {
423                 onClickRemove();
424             }
425         });
426
427         ged.addActionListener(new ActionListener() {
428             public void actionPerformed(ActionEvent actionEvent) {
429                 onClickGED();
430             }
431         });
432
433         editdata.addActionListener(new ActionListener() {
434             public void actionPerformed(ActionEvent actionEvent) {
435                 setDataModifyEnabled(true);
436             }
437         });
438
439         undo.addActionListener(new ActionListener() {
440             public void actionPerformed(ActionEvent actionEvent) {
441                 onClickUndo();
442             }
443         });
444
445         redo.addActionListener(new ActionListener() {
446             public void actionPerformed(ActionEvent actionEvent) {
447                 onClickRedo();
448             }
449         });
450
451         copyStyle.addActionListener(new ActionListener() {
452             public void actionPerformed(ActionEvent actionEvent) {
453                 onClickCopyStyle();
454             }
455         });
456
457         pasteStyle.addActionListener(new ActionListener() {
458             public void actionPerformed(ActionEvent actionEvent) {
459                 onClickPasteStyle();
460             }
461         });
462
463
464         labels.add(labelX);
465         labels.add(labelY);
466         labels.add(labelZ);
467         labels.add(title);
468         legends.add(insert);
469         legends.add(remove);
470         menu.add(copy);
471         menu.add(cut);
472         menu.add(paste);
473         menu.add(copyStyle);
474         menu.add(pasteStyle);
475         menu.addSeparator();
476         menu.add(delete);
477         menu.add(clear);
478         menu.add(undo);
479         menu.add(redo);
480         menu.addSeparator();
481         menu.add(hide);
482         menu.add(unhide);
483         menu.addSeparator();
484         menu.add(clipboardCopy);
485         menu.addSeparator();
486         menu.add(labels);
487         menu.add(legends);
488         menu.add(editdata);
489         if (StartGED.enableNewGed) {
490             menu.addSeparator();
491             menu.add(ged);
492         }
493     }
494
495
496     /**
497      * Set the current selected object, change its color,
498      * if there is a previous selected object restores its color,
499      * enable/disable popup menu items if there is/isn't
500      * a object selected.
501      *
502      * @param uid object unique identifier. Null uid unselect previous selection.
503      */
504     public void setSelected(Integer uid) {
505         if (CommonHandler.objectExists(selected)) {
506             CommonHandler.setSelected(selected, false);
507         }
508
509         selected = uid;
510
511         if (selected != null) {
512             CommonHandler.setSelected(selected, true);
513
514             boolean spl = (selectedType == SelectionType.SURFACE || selectedType == SelectionType.POLYLINE || selectedType == SelectionType.LEGEND);
515
516             boolean sp = (selectedType == SelectionType.SURFACE || selectedType == SelectionType.POLYLINE);
517
518             boolean p = selectedType == SelectionType.POLYLINE;
519             /* Enable delete if object is surface or polyline or legend*/
520             delete.setEnabled(true && spl);
521             /* Enable copy, cut, hide if object is surface or polyline*/
522             copy.setEnabled(true && sp);
523             cut.setEnabled(true && sp);
524             hide.setEnabled(true && sp);
525             /* Enable editdata, add legend if object is  polyline*/
526             legends.setEnabled(true && p);
527             editdata.setEnabled(true && p);
528         } else {
529             copy.setEnabled(false);
530             cut.setEnabled(false);
531             delete.setEnabled(false);
532             hide.setEnabled(false);
533             legends.setEnabled(false);
534             editdata.setEnabled(false);
535         }
536     }
537
538     /**
539      * Returns selected object unique identifier.
540      * @return selected object uid or null if there isn't any selected.
541      */
542     public Integer getSelected() {
543         if (CommonHandler.objectExists(selected)) {
544             return selected;
545         } else {
546             setSelected(null);
547             return null;
548         }
549     }
550
551     /**
552      * Set the figure uid wich the editor belongs.
553      * @param uid Figure unique identifier.
554      */
555     public void setFigure(Integer uid) {
556         figureUid = uid;
557     }
558
559     /**
560      * Get the figure uid wich the editor belongs.
561      * @return figure uid.
562      */
563     public Integer getFigureUid() {
564         return figureUid;
565     }
566
567     /**
568      * Implements copy menu item action(Callback).
569      */
570     public void onClickCopy() {
571         if (selectedType != SelectionType.LEGEND) {
572             ScilabClipboard.getInstance().copy(getSelected());
573         }
574     }
575
576     /**
577      * Implements paste menu item action(Callback).
578      */
579     public void onClickPaste() {
580         Integer currentObject, newObject, currentParent, newParent;
581         boolean isDuplicated = false;
582
583         currentObject = ScilabClipboard.getInstance().getCurrentObject();
584         currentParent = CommonHandler.getParent(currentObject);
585         Integer oldFigure = CommonHandler.getParentFigure(currentObject);
586         if (!CommonHandler.cmpColorMap(figureUid, oldFigure)) {
587             String msg =  "The colormap from source figure seems to be different from the destination figure." +
588                           "\nThis may influence the final appearance from the object." +
589                           "\nDo you want copy the color map too?";
590             int i = JOptionPane.showConfirmDialog(dialogComponent, Messages.gettext(msg), Messages.gettext("Warning"), JOptionPane.YES_NO_OPTION);
591
592             if (i == JOptionPane.YES_OPTION) {
593                 CommonHandler.cloneColorMap(oldFigure, figureUid);
594             }
595         }
596
597         AxesHandler.pasteRotationAngles(currentObject, figureUid, lastClick);
598
599         newObject = ScilabClipboard.getInstance().paste(figureUid, lastClick);
600         newParent = CommonHandler.getParent(newObject);
601         if (newObject == currentObject) {
602             isDuplicated = false;
603         }
604         editorHistory.addAction(new ActionPaste(newObject, currentParent, newParent, isDuplicated));
605     }
606
607     /**
608      * Implements cut menu item action
609      */
610     public void onClickCut() {
611         Integer s = getSelected();
612         if (s != null && selectedType != SelectionType.LEGEND) {
613             setSelected(null);
614             ScilabClipboard.getInstance().cut(s);
615         }
616     }
617
618     /**
619      * Implements delete menu item action(Callback).
620      */
621     public void onClickDelete() {
622         Integer toDelete = getSelected();
623         if (toDelete != null) {
624             setSelected(null);
625             editorHistory.addAction(new ActionDelete(toDelete, CommonHandler.getParent(toDelete)));
626             CommonHandler.cut(toDelete);
627         }
628     }
629
630     /**
631      * Implements clear menu item action(Callback).
632      */
633     public void onClickClear() {
634         setSelected(null);
635         Integer axesTo = AxesHandler.clickedAxes(figureUid, lastClick);
636         if (axesTo != null) {
637             PolylineHandler.getInstance().deleteAll(axesTo);
638         }
639     }
640
641     /**
642      * Implements hide menu item action(Callback).
643      */
644     public void onClickHide() {
645         if (getSelected() != null) {
646             CommonHandler.setVisible(selected, false);
647             editorHistory.addAction(new ActionHide(selected));
648             setSelected(null);
649         }
650     }
651
652     /**
653      * Implements unhide menu item action(Callback).
654      */
655     public void onClickUnhide() {
656         CommonHandler.unhideAll(figureUid);
657     }
658
659     /**
660      * Implements clipboard copy menu item action(Callback).
661      */
662     public void onClickCCopy() {
663         SystemClipboard.copyToSysClipboard(figureUid);
664     }
665
666     /**
667      * Implements label insert action(Callback).
668      * @param axis axis number.
669      */
670     public void onClickLabel(AxesHandler.axisTo axis) {
671         Integer axes = AxesHandler.clickedAxes(figureUid, lastClick);
672         if (axes != null && axis != null) {
673             String text = LabelHandler.getLabelText(axes, axis);
674             String s = (String)JOptionPane.showInputDialog(
675                            dialogComponent,
676                            Messages.gettext("Enter the text"),
677                            Messages.gettext("Set label text"),
678                            JOptionPane.PLAIN_MESSAGE,
679                            null,
680                            null,
681                            text);
682             if (s != null) {
683                 String tmp[] = {s};
684                 String[] oldText = {text};
685                 Integer label = LabelHandler.setLabel(axes, tmp, axis);
686                 editorHistory.addAction(new ActionTextEdit(label, oldText, tmp));
687             }
688         }
689     }
690
691     /**
692      * Implements legend insert action(Callback).
693      * @param polyline Polyline to be inserted in the legend.
694      */
695     public void onClickInsert(Integer polyline) {
696         Integer axes = AxesHandler.clickedAxes(figureUid, lastClick);
697         if (axes != null) {
698             String text = LegendHandler.getLegendText(axes, polyline);
699             String s = (String)JOptionPane.showInputDialog(
700                            dialogComponent,
701                            Messages.gettext("Enter the text"),
702                            Messages.gettext("Set legend text"),
703                            JOptionPane.PLAIN_MESSAGE,
704                            null,
705                            null,
706                            text);
707             if (s != null && !s.equals(text)) {
708                 Integer legend = LegendHandler.searchLegend(axes);
709                 Integer[] links = LegendHandler.getLinks(legend);
710                 String[] texts = LegendHandler.getText(legend);
711                 Double[] position = LegendHandler.getPosition(legend);
712                 LegendHandler.setLegend(legend, axes, polyline, s);
713                 editorHistory.addAction(new ActionLegend(axes, links, texts, position));
714             }
715         }
716     }
717
718     /**
719      * Implements legend remove action(Callback).
720      */
721     public void onClickRemove() {
722         Integer axesTo = AxesHandler.clickedAxes(figureUid, lastClick);
723         Integer legend = LegendHandler.searchLegend(axesTo);
724         Integer[] links = LegendHandler.getLinks(legend);
725         String[] text = LegendHandler.getText(legend);
726         Double[] position = LegendHandler.getPosition(legend);
727         LegendHandler.removeLegend(axesTo, selected);
728         editorHistory.addAction(new ActionLegend(axesTo, links, text, position));
729     }
730
731     /**
732      * Enter data editor mode.
733      */
734     public void enterDataEditor() {
735         if (!dataEditEnabled && selectedType == SelectionType.POLYLINE) {
736             dataEditor.beginEdit(selected);
737             dataEditEnabled = true;
738         }
739     }
740
741     /**
742      * Leave data editor mode.
743      */
744     public void leaveDataEditor() {
745         if (dataEditEnabled) {
746             dataEditor.endEdit();
747             dataEditEnabled = false;
748         }
749     }
750
751     /**
752      * Starts the GED with the property selected by user.
753      */
754     public void onClickGED() {
755         if (DatatipManager.getFromUid(figureUid).pickAndHighlight(lastClick[0], lastClick[1])) {
756             Inspector.getInspector(DatatipManager.getFromUid(figureUid).getSelectedTip());
757         } else {
758             Integer[] objects = (new GEDPicker()).pick(figureUid, lastClick);
759             Inspector.getInspector(objects[objects.length - 1]);
760         }
761     }
762
763     /**
764      * Implements Undo action(callBAck)
765      */
766     public void onClickUndo() {
767         editorHistory.undo();
768     }
769
770     /**
771      * Implements Redo action(callBack)
772      */
773     public void onClickRedo() {
774         editorHistory.redo();
775     }
776
777     /**
778      * Implementes copyStyle action(callback)
779      */
780     public void onClickCopyStyle() {
781
782         Integer axes = AxesHandler.clickedAxes(figureUid, lastClick);
783         ScilabClipboard.getInstance().copyStyle(axes);
784     }
785
786     /**
787      * Implementes pasteStyle action(callback)
788      */
789     public void onClickPasteStyle() {
790         boolean flag = true;
791         Integer axes = AxesHandler.clickedAxes(figureUid, lastClick);
792         if (!AxesHandler.isAxesEmpty(axes)) {
793             String msg =  "The axes which the style was copied is not in CubeView" +
794                           "\nIf you don't copy the data bounds the view angles can appear different" +
795                           "\nDo you want copy the data bounds too?(it can shrink/stretch the current view)";
796             int i = JOptionPane.showConfirmDialog(dialogComponent, Messages.gettext(msg), Messages.gettext("Warning"), JOptionPane.YES_NO_OPTION);
797
798             if (i == JOptionPane.NO_OPTION) {
799                 flag = false;
800             }
801         }
802
803         Double[] oldColorMap = CommonHandler.getColorMap(figureUid);
804         Integer backgroundColor = CommonHandler.getBackground(figureUid);
805         Integer oldAxes = AxesHandler.clickedAxes(figureUid, lastClick);
806         Integer newAxes = ScilabClipboard.getInstance().pasteStyle(oldAxes, flag);
807         editorHistory.addAction(new ActionPasteStyle(newAxes, oldAxes, oldColorMap, backgroundColor));
808     }
809
810     /**
811      * Test if the mouse position (pos)
812      * is over a polyline, legend or plot3d
813      * and return the selected object uid or null.
814      * @param pos Vector with position (x, y).
815      * @return The picked object uid or null otherwise.
816      */
817     private Integer tryPickAnyObject(Integer[] pos) {
818         /*try pick a legend*/
819         selectedLegend = entityPicker.pickLegend(figureUid, pos);
820         if (selectedLegend != null) {
821             selectedType = SelectionType.LEGEND;
822             return selectedLegend.legend;
823         }
824         /*try pick a polyline*/
825         Integer picked = entityPicker.pick(figureUid, pos[0], pos[1]);
826         if (picked != null) {
827             selectedType = SelectionType.POLYLINE;
828             return picked;
829         }
830         /* try pick a surface */
831         selectedSurface = entityPicker.pickSurface(figureUid, pos);
832         if (selectedSurface != null && selectedSurface.surface != null) {
833             selectedType = SelectionType.SURFACE;
834             return selectedSurface.surface;
835         }
836         return null;
837     }
838 }