scilab/modules/gui/src/java/org/scilab/modules/gui/editor/Editor.java

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