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