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 }