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