scilab/modules/gui/src/java/org/scilab/modules/gui/bridge/CallScilabBridge.java

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2007-2008 - INRIA - Vincent COUVERT
   4  * Copyright (C) 2008 - DIGITEO - Sylvestre KOUMAR
   5  * Copyright (C) 2010 - DIGITEO - Manuel JULIACHS
   6  * Copyright (C) 2010-2011 - DIGITEO - Vincent COUVERT
   7  *
   8  * This file must be used under the terms of the CeCILL.
   9  * This source file is licensed as described in the file COPYING, which
  10  * you should have received as part of this distribution.  The terms
  11  * are also available at
  12  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  13  *
  14  */
  15
  16
  17 package org.scilab.modules.gui.bridge;
  18
  19 import java.awt.Color;
  20 import java.awt.Font;
  21 import java.awt.Image;
  22 import java.awt.Toolkit;
  23 import java.awt.datatransfer.Clipboard;
  24 import java.awt.datatransfer.DataFlavor;
  25 import java.awt.datatransfer.StringSelection;
  26 import java.awt.datatransfer.Transferable;
  27 import java.awt.datatransfer.UnsupportedFlavorException;
  28 import java.awt.print.PrinterJob;
  29 import java.io.File;
  30 import java.io.FileInputStream;
  31 import java.io.FileNotFoundException;
  32 import java.io.IOException;
  33
  34 import javax.print.Doc;
  35 import javax.print.DocFlavor;
  36 import javax.print.DocPrintJob;
  37 import javax.print.PrintException;
  38 import javax.print.PrintService;
  39 import javax.print.SimpleDoc;
  40 import javax.print.attribute.HashPrintRequestAttributeSet;
  41 import javax.print.attribute.PrintRequestAttribute;
  42 import javax.print.attribute.PrintRequestAttributeSet;
  43 import javax.print.attribute.standard.OrientationRequested;
  44 import javax.swing.JEditorPane;
  45 import javax.swing.JTextPane;
  46 import javax.swing.text.BadLocationException;
  47 import javax.swing.text.Document;
  48
  49 import org.scilab.modules.commons.ScilabCommons;
  50 import org.scilab.modules.console.SciConsole;
  51 import org.scilab.modules.graphic_export.FileExporter;
  52 import org.scilab.modules.graphic_objects.figure.Figure;
  53 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
  54 import org.scilab.modules.gui.SwingView;
  55 import org.scilab.modules.gui.SwingViewObject;
  56 import org.scilab.modules.gui.bridge.canvas.SwingScilabCanvas;
  57 import org.scilab.modules.gui.bridge.canvas.SwingScilabCanvasImpl;
  58 import org.scilab.modules.gui.bridge.console.SwingScilabConsole;
  59 import org.scilab.modules.gui.bridge.contextmenu.SwingScilabContextMenu;
  60 import org.scilab.modules.gui.bridge.frame.SwingScilabFrame;
  61 import org.scilab.modules.gui.bridge.tab.SwingScilabTab;
  62 import org.scilab.modules.gui.checkbox.CheckBox;
  63 import org.scilab.modules.gui.checkbox.ScilabCheckBox;
  64 import org.scilab.modules.gui.checkboxmenuitem.CheckBoxMenuItem;
  65 import org.scilab.modules.gui.colorchooser.ColorChooser;
  66 import org.scilab.modules.gui.colorchooser.ScilabColorChooser;
  67 import org.scilab.modules.gui.console.ScilabConsole;
  68 import org.scilab.modules.gui.contextmenu.ContextMenu;
  69 import org.scilab.modules.gui.contextmenu.ScilabContextMenu;
  70 import org.scilab.modules.gui.editbox.EditBox;
  71 import org.scilab.modules.gui.editbox.ScilabEditBox;
  72 import org.scilab.modules.gui.filechooser.FileChooser;
  73 import org.scilab.modules.gui.filechooser.ScilabFileChooser;
  74 import org.scilab.modules.gui.fontchooser.FontChooser;
  75 import org.scilab.modules.gui.fontchooser.ScilabFontChooser;
  76 import org.scilab.modules.gui.frame.Frame;
  77 import org.scilab.modules.gui.frame.ScilabFrame;
  78 import org.scilab.modules.gui.helpbrowser.HelpBrowser;
  79 import org.scilab.modules.gui.helpbrowser.ScilabHelpBrowser;
  80 import org.scilab.modules.gui.label.Label;
  81 import org.scilab.modules.gui.label.ScilabLabel;
  82 import org.scilab.modules.gui.listbox.ListBox;
  83 import org.scilab.modules.gui.listbox.ScilabListBox;
  84 import org.scilab.modules.gui.menu.Menu;
  85 import org.scilab.modules.gui.menu.ScilabMenu;
  86 import org.scilab.modules.gui.menubar.MenuBar;
  87 import org.scilab.modules.gui.menubar.ScilabMenuBar;
  88 import org.scilab.modules.gui.menuitem.MenuItem;
  89 import org.scilab.modules.gui.menuitem.ScilabMenuItem;
  90 import org.scilab.modules.gui.messagebox.MessageBox;
  91 import org.scilab.modules.gui.messagebox.ScilabMessageBox;
  92 import org.scilab.modules.gui.popupmenu.PopupMenu;
  93 import org.scilab.modules.gui.popupmenu.ScilabPopupMenu;
  94 import org.scilab.modules.gui.pushbutton.PushButton;
  95 import org.scilab.modules.gui.pushbutton.ScilabPushButton;
  96 import org.scilab.modules.gui.radiobutton.RadioButton;
  97 import org.scilab.modules.gui.radiobutton.ScilabRadioButton;
  98 import org.scilab.modules.gui.slider.ScilabSlider;
  99 import org.scilab.modules.gui.slider.Slider;
 100 import org.scilab.modules.gui.tab.ScilabTab;
 101 import org.scilab.modules.gui.tab.Tab;
 102 import org.scilab.modules.gui.textbox.ScilabTextBox;
 103 import org.scilab.modules.gui.textbox.TextBox;
 104 import org.scilab.modules.gui.toolbar.ToolBar;
 105 import org.scilab.modules.gui.uidisplaytree.ScilabUiDisplayTree;
 106 import org.scilab.modules.gui.uidisplaytree.UiDisplayTree;
 107 import org.scilab.modules.gui.uitable.ScilabUiTable;
 108 import org.scilab.modules.gui.uitable.UiTable;
 109 import org.scilab.modules.gui.utils.BarUpdater;
 110 import org.scilab.modules.gui.utils.ClosingOperationsManager;
 111 import org.scilab.modules.gui.utils.ConfigManager;
 112 import org.scilab.modules.gui.utils.ImageExporter;
 113 import org.scilab.modules.gui.utils.Position;
 114 import org.scilab.modules.gui.utils.PrinterHelper;
 115 import org.scilab.modules.gui.utils.ScilabAboutBox;
 116 import org.scilab.modules.gui.utils.ScilabPrint;
 117 import org.scilab.modules.gui.utils.ScilabRelief;
 118 import org.scilab.modules.gui.utils.Size;
 119 import org.scilab.modules.gui.utils.UIElementMapper;
 120 import org.scilab.modules.gui.utils.WebBrowser;
 121 import org.scilab.modules.gui.waitbar.WaitBar;
 122 import org.scilab.modules.gui.widget.Widget;
 123 import org.scilab.modules.gui.window.ScilabWindow;
 124 import org.scilab.modules.gui.window.Window;
 125 import org.scilab.modules.localization.Messages;
 126
 127 /**
 128  * This class is used to call Scilab GUIs objects from Scilab
 129  * @author Vincent COUVERT
 130  */
 131 public class CallScilabBridge {
 132
 133     private static final int NB_COLORS = 3;
 134
 135     private static final int POSITION_SIZE = 4;
 136
 137     private static final int X_INDEX = 0;
 138     private static final int Y_INDEX = 1;
 139     private static final int WIDTH_INDEX = 2;
 140     private static final int HEIGHT_INDEX = 3;
 141
 142     private static final String NORMALFONT = "normal";
 143     private static final String OBLIQUEFONT = "oblique";
 144     private static final String ITALICFONT = "italic";
 145     private static final String BOLDFONT = "bold";
 146     private static final int DEFAULTFONTSIZE = 10;
 147     private static final String DEFAULTFONTNAME = "helvetica";
 148
 149     private static final double DEFAULT_RED_BACKGROUND = 0.8 * 255;
 150     private static final double DEFAULT_GREEN_BACKGROUND = 0.8 * 255;
 151     private static final double DEFAULT_BLUE_BACKGROUND = 0.8 * 255;
 152
 153     private static final double BUTTON_RED_BACKGROUND = 0.6 * 255;
 154     private static final double BUTTON_GREEN_BACKGROUND = 0.6 * 255;
 155     private static final double BUTTON_BLUE_BACKGROUND = 0.6 * 255;
 156
 157     private static final double DEFAULT_RED_FOREGROUND = 0;
 158     private static final double DEFAULT_GREEN_FOREGROUND = 0;
 159     private static final double DEFAULT_BLUE_FOREGROUND = 0;
 160
 161
 162     private static PrintRequestAttributeSet scilabPageFormat = new HashPrintRequestAttributeSet();
 163
 164     private static final String FIGURE_TITLE = "Graphic window number ";
 165
 166     private static final String CONSOLE = "Console";
 167
 168     /**
 169      * Constructor
 170      */
 171     protected CallScilabBridge() {
 172         throw new UnsupportedOperationException(); /* Prevents calls from subclass */
 173     }
 174
 175     /******************/
 176     /*                */
 177     /* CONSOLE BRIDGE */
 178     /*                */
 179     /******************/
 180
 181     /**
 182      * Read a line from the Console
 183      * @return the line read
 184      */
 185     public static String readLine() {
 186         return ScilabConsole.getConsole().readLine();
 187     }
 188
 189     /**
 190      * Display a line in the Console
 191      * @param dataToDisplay the line to display
 192      */
 193     public static void display(String dataToDisplay) {
 194         ScilabConsole.getConsole().display(dataToDisplay);
 195     }
 196
 197     /**
 198      * Get the status of the Console
 199      * @return true if the console is at the prompt
 200      */
 201     public static boolean isWaitingForInput() {
 202         return ScilabConsole.getConsole().isWaitingForInput();
 203     }
 204
 205     /**
 206      * Update the number of lines and columns that Scilab use to format data to display
 207      */
 208     public static void scilabLinesUpdate() {
 209         ScilabConsole.getConsole().scilabLinesUpdate();
 210     }
 211
 212     /**
 213      * Clear the Console
 214      */
 215     public static void clear() {
 216         ScilabConsole.getConsole().clear();
 217     }
 218
 219     /**
 220      * Clear some lines in the Console
 221      * @param nbLines the number of lines to clear
 222      */
 223     public static void clear(int nbLines) {
 224         ScilabConsole.getConsole().clear(nbLines);
 225     }
 226
 227     /**
 228      * Get a char to know if the user wants more data to be displayed
 229      * @return the user answer
 230      */
 231     public static int getCharWithoutOutput() {
 232         return ScilabConsole.getConsole().getAsSimpleConsole().getCharWithoutOutput();
 233     }
 234
 235     /**
 236      * Put the prompt on the top left corner
 237      */
 238     public static void toHome() {
 239         ScilabConsole.getConsole().toHome();
 240     }
 241
 242     /**
 243      * Set the contents of the prompt
 244      * @param prompt the content to set (default is -->)
 245      */
 246     public static void setPrompt(String prompt) {
 247         ScilabConsole.getConsole().setPrompt(prompt);
 248     }
 249
 250     /**
 251      * Clear the commands history
 252      */
 253     public static void clearHistory() {
 254         ScilabConsole.getConsole().clearHistory();
 255     }
 256
 257     /**************************/
 258     /*                        */
 259     /* OBJECT CREATION BRIDGE */
 260     /*                        */
 261     /**************************/
 262
 263     /**
 264      * Create a new Window in Scilab GUIs
 265      * @return the ID of the window in the UIElementMapper
 266      */
 267     // TODO REMOVE ME (NO MORE USED IN JNI)
 268     public static int newWindow() {
 269         Window window = ScilabWindow.createWindow();
 270         return UIElementMapper.add(window);
 271     }
 272
 273     /**
 274      * Create a new Menubar in Scilab GUIs
 275      * @return the ID of the Menubar in the UIElementMapper
 276      */
 277     // TODO REMOVE ME (NO MORE USED IN JNI)
 278     public static int newMenuBar() {
 279         MenuBar menuBar = ScilabMenuBar.createMenuBar();
 280         return UIElementMapper.add(menuBar);
 281     }
 282
 283     /**
 284      * Create a new Menu in Scilab GUIs
 285      * @return the ID of the menu in the UIElementMapper
 286      */
 287     // TODO REMOVE ME (NO MORE USED IN JNI)
 288     public static int newMenu() {
 289         MenuItem menuItem = ScilabMenuItem.createMenuItem(false);
 290         return UIElementMapper.add(menuItem);
 291     }
 292
 293     /**
 294      * Create a new ContextMenu in Scilab GUIs
 295      * @return the ID of the ContextMenu in the UIElementMapper
 296      */
 297     // TODO REMOVE ME (NO MORE USED IN JNI)
 298     public static int newContextMenu() {
 299         ContextMenu contextMenu = ScilabContextMenu.createContextMenu();
 300         return UIElementMapper.add(contextMenu);
 301     }
 302
 303     /**
 304      * Create a new Color Chooser in Scilab GUIs
 305      * @return the ID of the Color Chooser in the UIElementMapper
 306      */
 307     public static int newColorChooser() {
 308         ColorChooser colorChooser = ScilabColorChooser.createColorChooser();
 309         return UIElementMapper.add(colorChooser);
 310     }
 311
 312     /**
 313      * Create a new Font Chooser in Scilab GUIs
 314      * @return the ID of the Font Chooser in the UIElementMapper
 315      */
 316     public static int newFontChooser() {
 317         FontChooser fontChooser = ScilabFontChooser.createFontChooser();
 318         return UIElementMapper.add(fontChooser);
 319     }
 320
 321     /**
 322      * Create a new MessageBox in Scilab GUIs
 323      * @return the ID of the MessageBox in the UIElementMapper
 324      */
 325     // TODO REMOVE ME (NO MORE USED IN JNI)
 326     public static int newMessageBox() {
 327         MessageBox messageBox = ScilabMessageBox.createMessageBox();
 328         return UIElementMapper.add(messageBox);
 329     }
 330
 331     /**
 332      * Create a new PushButton in Scilab GUIs
 333      * @return the ID of the PushButton in the UIElementMapper
 334      */
 335     // TODO REMOVE ME (NO MORE USED IN JNI)
 336     public static int newPushButton() {
 337         PushButton pushButton = ScilabPushButton.createPushButton();
 338         int id = UIElementMapper.add(pushButton);
 339
 340         /* Default font */
 341         setWidgetFontName(id, DEFAULTFONTNAME);
 342         setWidgetFontWeight(id, NORMALFONT);
 343         setWidgetFontSize(id, DEFAULTFONTSIZE);
 344
 345         setWidgetRelief(id, ScilabRelief.RAISED);
 346
 347         /* Default colors */
 348         setWidgetBackgroundColor(id, (int) BUTTON_RED_BACKGROUND, (int) BUTTON_GREEN_BACKGROUND, (int) BUTTON_BLUE_BACKGROUND);
 349         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 350         return id;
 351     }
 352
 353     // TODO REMOVE ME (NO MORE USED IN JNI)
 354     public static void newPushButton(String UID) {
 355         PushButton pushButton = ScilabPushButton.createPushButton();
 356         ((ScilabPushButton) pushButton).setIdentifier(UID);
 357         int id = UIElementMapper.add(pushButton);
 358
 359         /* Default font */
 360         setWidgetFontName(id, DEFAULTFONTNAME);
 361         setWidgetFontWeight(id, NORMALFONT);
 362         setWidgetFontSize(id, DEFAULTFONTSIZE);
 363
 364         setWidgetRelief(id, ScilabRelief.RAISED);
 365
 366         /* Default colors */
 367         setWidgetBackgroundColor(id, (int) BUTTON_RED_BACKGROUND, (int) BUTTON_GREEN_BACKGROUND, (int) BUTTON_BLUE_BACKGROUND);
 368         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 369     }
 370     /**
 371      * Create a new EditBox in Scilab GUIs
 372      * @return the ID of the Edit in the UIElementMapper
 373      */
 374     // TODO REMOVE ME (NO MORE USED IN JNI)
 375     public static int newEditBox() {
 376         EditBox editBox = ScilabEditBox.createEditBox();
 377         int id = UIElementMapper.add(editBox);
 378
 379         /* Default font */
 380         setWidgetFontName(id, DEFAULTFONTNAME);
 381         setWidgetFontWeight(id, NORMALFONT);
 382         setWidgetFontSize(id, DEFAULTFONTSIZE);
 383
 384         setWidgetRelief(id, ScilabRelief.SUNKEN);
 385
 386         /* Default colors */
 387         setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 388         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 389         return id;
 390     }
 391
 392     /**
 393      * Create a new Label in Scilab GUIs
 394      * @return the ID of the Label in the UIElementMapper
 395      */
 396     // TODO REMOVE ME (NO MORE USED IN JNI)
 397     public static int newLabel() {
 398         Label label = ScilabLabel.createLabel();
 399         int id = UIElementMapper.add(label);
 400
 401         /* Default font */
 402         setWidgetFontName(id, DEFAULTFONTNAME);
 403         setWidgetFontWeight(id, NORMALFONT);
 404         setWidgetFontSize(id, DEFAULTFONTSIZE);
 405
 406         setWidgetRelief(id, ScilabRelief.FLAT);
 407
 408         /* Default colors */
 409         setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 410         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 411         return id;
 412     }
 413
 414     /**
 415      * Create a new CheckBox in Scilab GUIs
 416      * @return the ID of the CheckBox in the UIElementMapper
 417      */
 418     // TODO REMOVE ME (NO MORE USED IN JNI)
 419     public static int newCheckBox() {
 420         CheckBox checkBox = ScilabCheckBox.createCheckBox();
 421         int id = UIElementMapper.add(checkBox);
 422
 423         /* Default font */
 424         setWidgetFontName(id, DEFAULTFONTNAME);
 425         setWidgetFontWeight(id, NORMALFONT);
 426         setWidgetFontSize(id, DEFAULTFONTSIZE);
 427
 428         setWidgetRelief(id, ScilabRelief.FLAT);
 429
 430         /* Default colors */
 431         setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 432         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 433         return id;
 434     }
 435
 436     /**
 437      * Create a new RadioButton in Scilab GUIs
 438      * @return the ID of the RadioButton in the UIElementMapper
 439      */
 440     // TODO REMOVE ME (NO MORE USED IN JNI)
 441     public static int newRadioButton() {
 442         RadioButton radioButton = ScilabRadioButton.createRadioButton();
 443         int id = UIElementMapper.add(radioButton);
 444
 445         /* Default font */
 446         setWidgetFontName(id, DEFAULTFONTNAME);
 447         setWidgetFontWeight(id, NORMALFONT);
 448         setWidgetFontSize(id, DEFAULTFONTSIZE);
 449
 450         setWidgetRelief(id, ScilabRelief.FLAT);
 451
 452         /* Default colors */
 453         setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 454         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 455         return id;
 456     }
 457
 458     /**
 459      * Create a new UiTable in Scilab GUIs
 460      * @return the ID of the UiTable in the UIElementMapper
 461      */
 462     // TODO REMOVE ME (NO MORE USED IN JNI)
 463     public static int newUiTable() {
 464         UiTable uiTable = ScilabUiTable.createUiTable();
 465         int id = UIElementMapper.add(uiTable);
 466
 467         /* Default font */
 468         setWidgetFontName(id, DEFAULTFONTNAME);
 469         setWidgetFontWeight(id, NORMALFONT);
 470         setWidgetFontSize(id, DEFAULTFONTSIZE);
 471
 472         setWidgetRelief(id, ScilabRelief.FLAT);
 473
 474         /* Default colors */
 475         setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 476         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 477         return id;
 478     }
 479
 480     /**
 481      * Create a new UiDisplayTree in Scilab GUIs
 482      * @return the ID of the UiDisplayTree in the UIElementMapper
 483      */
 484     // TODO REMOVE ME (NO MORE USED IN JNI)
 485     public static int newUiDisplayTree() {
 486         UiDisplayTree uiTree = ScilabUiDisplayTree.createUiDisplayTree();
 487         int id = UIElementMapper.add(uiTree);
 488
 489         /* Default font */
 490         setWidgetFontName(id, DEFAULTFONTNAME);
 491         setWidgetFontWeight(id, NORMALFONT);
 492         setWidgetFontSize(id, DEFAULTFONTSIZE);
 493
 494         setWidgetRelief(id, ScilabRelief.FLAT);
 495
 496         /* Default colors */
 497         setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 498         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 499         return id;
 500     }
 501
 502     /**
 503      * Create a new Slider in Scilab GUIs
 504      * @return the ID of the Slider in the UIElementMapper
 505      */
 506     // TODO REMOVE ME (NO MORE USED IN JNI)
 507     public static int newSlider() {
 508         Slider slider = ScilabSlider.createSlider();
 509         int id = UIElementMapper.add(slider);
 510
 511         /* Default font */
 512         /* Set a default font because is null when JScrollBar is created */
 513         slider.setFont(new Font(DEFAULTFONTNAME, Font.PLAIN, DEFAULTFONTSIZE));
 514         setWidgetFontName(id, DEFAULTFONTNAME);
 515         setWidgetFontWeight(id, NORMALFONT);
 516         setWidgetFontSize(id, DEFAULTFONTSIZE);
 517
 518         setWidgetRelief(id, ScilabRelief.FLAT);
 519
 520         /* Default colors */
 521         setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 522         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 523
 524         slider.setText(""); /* Because Name property is null at creation */
 525         slider.setMinimumValue(0);
 526         slider.setMaximumValue(1);
 527         slider.setUserValue(0);
 528
 529         return id;
 530     }
 531
 532     /**
 533      * Create a new ListBox in Scilab GUIs
 534      * @return the ID of the ListBox in the UIElementMapper
 535      */
 536     // TODO REMOVE ME (NO MORE USED IN JNI)
 537     public static int newListBox() {
 538         ListBox listBox = ScilabListBox.createListBox();
 539         int id = UIElementMapper.add(listBox);
 540
 541         /* Default font */
 542         setWidgetFontName(id, DEFAULTFONTNAME);
 543         setWidgetFontWeight(id, NORMALFONT);
 544         setWidgetFontSize(id, DEFAULTFONTSIZE);
 545
 546         setWidgetRelief(id, ScilabRelief.FLAT);
 547
 548         /* Default colors */
 549         setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 550         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 551         return id;
 552     }
 553
 554     /**
 555      * Create a new PopupMenu in Scilab GUIs
 556      * @return the ID of the PopupMenu in the UIElementMapper
 557      */
 558     // TODO REMOVE ME (NO MORE USED IN JNI)
 559     public static int newPopupMenu() {
 560         PopupMenu popupMenu = ScilabPopupMenu.createPopupMenu();
 561         int id = UIElementMapper.add(popupMenu);
 562
 563         /* Default font */
 564         setWidgetFontName(id, DEFAULTFONTNAME);
 565         setWidgetFontWeight(id, NORMALFONT);
 566         setWidgetFontSize(id, DEFAULTFONTSIZE);
 567
 568         setWidgetRelief(id, ScilabRelief.FLAT);
 569
 570         /* Default colors */
 571         setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 572         setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 573         return id;
 574     }
 575
 576     /**
 577      * Create a new Frame in Scilab GUIs
 578      * @return the ID of the Frame in the UIElementMapper
 579      */
 580     public static int newFrame() {
 581         Frame frame = ScilabFrame.createFrame();
 582         int id = UIElementMapper.add(frame);
 583
 584         /* Default font */
 585         setFrameFontName(id, DEFAULTFONTNAME);
 586         setFrameFontWeight(id, NORMALFONT);
 587         setFrameFontSize(id, DEFAULTFONTSIZE);
 588
 589         setFrameRelief(id, ScilabRelief.RIDGE);
 590
 591         /* Default colors */
 592         setFrameBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
 593         setFrameForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
 594
 595         frame.setText(""); /* Because Name property is null at creation */
 596         return id;
 597     }
 598
 599     /**
 600      * Create a new ContextMenu in Scilab GUIs
 601      * and wait for a user answer
 602      * @param uicontextmenuUID the id of the Context Menu
 603      * @return the item of the menu selected
 604      */
 605     public static String displayAndWaitContextMenu(String uicontextmenuUID) {
 606         SwingViewObject uicontextmenu = SwingView.getFromId(uicontextmenuUID);
 607         return ((SwingScilabContextMenu) uicontextmenu).displayAndWait();
 608     }
 609
 610     /**
 611      * Destroy a Widget
 612      * @param id the id of the Widget to destroy
 613      */
 614     // TODO REMOVE ME (NO MORE USED IN JNI)
 615     public static void destroyWidget(int id) {
 616         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).destroy();
 617         UIElementMapper.removeMapping(id);
 618     }
 619
 620     /**
 621      * Destroy a Frame
 622      * @param id the id of the Frame to destroy
 623      */
 624     // TODO REMOVE ME (NO MORE USED IN JNI)
 625     public static void destroyFrame(int id) {
 626         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).destroy();
 627         UIElementMapper.removeMapping(id);
 628     }
 629
 630     /**
 631      * Create a new window with id figureIndex.
 632      * The created window contains an empty tab.
 633      * @param figureIndex index of the figure to create
 634      * @return id of the window
 635      */
 636     // TODO REMOVE ME (NO MORE USED IN JNI)
 637     public static int newWindow(int figureIndex) {
 638         Window newWindow = ScilabWindow.createWindow();
 639
 640         newWindow.setTitle(FIGURE_TITLE + figureIndex);
 641         /* MENUBAR */
 642         MenuBar menuBar = null; //MenuBarBuilder.buildMenuBar(MENUBARXMLFILE, figureIndex);
 643         /* TOOLBAR */
 644         ToolBar toolBar = null; //ToolBarBuilder.buildToolBar(TOOLBARXMLFILE, figureIndex);
 645
 646         TextBox infoBar = ScilabTextBox.createTextBox();
 647
 648         // create a tab able to display a figure handle
 649         Tab graphicTab = ScilabTab.createTab(FIGURE_TITLE + figureIndex, figureIndex);
 650         /* Destroy the graphic figure when the tab is closed */
 651         // // check if figure is already closed
 652         // if (get_figure_handle(fid) <> []) then
 653         //   if (get(get_figure_handle(fid), 'event_handler_enable') == 'on') then
 654         //     // execute closing call back
 655         //     execstr(get(get_figure_handle(fid), 'event_handler') + '(fid, -1, -1, -1000)', 'errcatch', 'm');
 656         //   end
 657         //   // destroy the figure
 658         //   delete(get_figure_handle(fid));
 659         // end
 660         String closingCommand =
 661             "if (get_figure_handle(" + figureIndex + ") <> []) then"
 662             +      "  if (get(get_figure_handle(" + figureIndex + "), 'event_handler_enable') == 'on') then"
 663             +      "    execstr(get(get_figure_handle(" + figureIndex + "), 'event_handler')+'(" + figureIndex + ", -1, -1, -1000)', 'errcatch', 'm');"
 664             +      "  end;"
 665             +      "  delete(get_figure_handle(" + figureIndex + "));"
 666             +      "end;";
 667         //graphicTab.setCallback(ScilabCloseCallBack.create(figureIndex, closingCommand));
 668         graphicTab.addMenuBar(menuBar);
 669         graphicTab.addToolBar(toolBar);
 670         graphicTab.addInfoBar(infoBar);
 671         ((SwingScilabTab) graphicTab.getAsSimpleTab()).setWindowIcon("graphic-window");
 672         newWindow.addTab(graphicTab);
 673
 674         // link the tab and canvas with their figure
 675         //        DrawableFigureGL associatedFigure = FigureMapper.getCorrespondingFigure(figureIndex);
 676         //associatedFigure.setRendererProperties(new ScilabRendererProperties(graphicTab, graphicCanvas));
 677         //        associatedFigure.setRendererProperties(new ScilabRendererProperties(graphicTab, null, figureIndex));
 678         // don't draw now, figure will show itself when all its parameters will be set
 679
 680         return 0;
 681     }
 682
 683     /****************************/
 684     /*                          */
 685     /* OBJECT DIMENSIONS BRIDGE */
 686     /*                          */
 687     /****************************/
 688
 689     /**
 690      * Set the dimensions of an object in Scilab GUIs
 691      * @param objID the ID of the object in the UIElementMapper
 692      * @param width the width of the object
 693      * @param height the height of the object
 694      */
 695     public static void setDims(int objID, int width, int height) {
 696         UIElementMapper.getCorrespondingUIElement(objID).setDims(new Size(width, height));
 697     }
 698
 699     /**********************/
 700     /*                    */
 701     /* OBJECT TEXT BRIDGE */
 702     /*                    */
 703     /**********************/
 704
 705     /**
 706      * Set the text of a widget in Scilab GUIs
 707      * @param objID the ID of the Widget in the UIElementMapper
 708      * @param text the text to set to the widget
 709      */
 710     // TODO REMOVE ME (NO MORE USED IN JNI)
 711     public static void setWidgetText(int objID, String text) {
 712         ((Widget) UIElementMapper.getCorrespondingUIElement(objID)).setText(text);
 713     }
 714
 715     /**
 716      * Get the text of a widget in Scilab GUIs
 717      * @param objID the ID of the Widget in the UIElementMapper
 718      * @return the text of the widget
 719      */
 720     // TODO REMOVE ME (NO MORE USED IN JNI)
 721     public static String getWidgetText(int objID) {
 722         return ((Widget) UIElementMapper.getCorrespondingUIElement(objID)).getText();
 723     }
 724
 725     /**
 726      * Set the text of a Frame in Scilab GUIs
 727      * @param objID the ID of the Widget in the UIElementMapper
 728      * @param text the text to set to the Frame
 729      */
 730     // TODO REMOVE ME (NO MORE USED IN JNI)
 731     public static void setFrameText(int objID, String text) {
 732         ((Frame) UIElementMapper.getCorrespondingUIElement(objID)).setText(text);
 733     }
 734
 735     /**
 736      * Get the text of a Frame in Scilab GUIs
 737      * @param objID the ID of the Frame in the UIElementMapper
 738      * @return the text of the Frame
 739      */
 740     // TODO REMOVE ME (NO MORE USED IN JNI)
 741     public static String getFrameText(int objID) {
 742         return ((Frame) UIElementMapper.getCorrespondingUIElement(objID)).getText();
 743     }
 744
 745     /******************/
 746     /*                */
 747     /* PARENT SETTING */
 748     /*                */
 749     /******************/
 750
 751     /**
 752      * Set a figure as parent for an UIElement
 753      * @param figureID the ID of the figure in the FigureMapper
 754      * @param objID the ID of the object in the UIElementMapper
 755      */
 756     // TODO REMOVE ME (NO MORE USED IN JNI)
 757     public static void setFigureAsParent(int figureID, int objID) {
 758         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 759
 760         if (!(UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem)) {
 761             // Add the menu to the tab
 762             parentTab.getMenuBar().add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
 763         } else {
 764             // obj is a MenuItem that has to be converted to a Menu
 765             MenuItem menuItem = (MenuItem) UIElementMapper.getCorrespondingUIElement(objID);
 766
 767             Menu menuToAdd = ScilabMenu.createMenu();
 768             UIElementMapper.removeMapping(objID);
 769             UIElementMapper.addMapping(objID, menuToAdd);
 770
 771             // Copy all properties from MenuItem to Menu
 772             menuToAdd.setText(menuItem.getText());
 773             menuToAdd.setCallback(menuItem.getCallback());
 774             menuToAdd.setForeground(menuItem.getForeground());
 775             menuToAdd.setVisible(menuItem.isVisible());
 776             menuToAdd.setEnabled(menuItem.isEnabled());
 777             menuToAdd.setChecked(menuItem.isChecked());
 778             // End of properties copy
 779
 780             // Add the menu to the tab
 781             parentTab.getMenuBar().add(menuToAdd);
 782         }*/
 783     }
 784
 785     /**
 786      * Set a figure as parent for a PushButton
 787      * @param figureID the ID of the figure in the FigureMapper
 788      * @param objID the ID of the PushButton in the UIElementMapper
 789      */
 790     // TODO REMOVE ME (NO MORE USED IN JNI)
 791     public static void setPushButtonParent(int figureID, int objID) {
 792         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 793         PushButton pushButton = (PushButton) UIElementMapper.getCorrespondingUIElement(objID);
 794         ScilabBridge.addMember(parentTab, pushButton);*/
 795     }
 796
 797     /**
 798      * Remove a PushButton from its parent figure
 799      * @param figureID the ID of the figure in the FigureMapper
 800      * @param objID the ID of the PushButton in the UIElementMapper
 801      */
 802     // TODO REMOVE ME (NO MORE USED IN JNI)
 803     public static void removePushButtonFromParent(int figureID, int objID) {
 804         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 805         PushButton pushButton = (PushButton) UIElementMapper.getCorrespondingUIElement(objID);
 806         ScilabBridge.removeMember(parentTab, pushButton);*/
 807     }
 808
 809     /**
 810      * Set a figure as parent for a EditBox
 811      * @param figureID the ID of the figure in the FigureMapper
 812      * @param objID the ID of the PushButton in the UIElementMapper
 813      */
 814     // TODO REMOVE ME (NO MORE USED IN JNI)
 815     public static void setEditBoxParent(int figureID, int objID) {
 816         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 817         EditBox editBox = (EditBox) UIElementMapper.getCorrespondingUIElement(objID);
 818         ScilabBridge.addMember(parentTab, editBox);*/
 819     }
 820
 821     /**
 822      * Remove an EditBox from its parent figure
 823      * @param figureID the ID of the figure in the FigureMapper
 824      * @param objID the ID of the PushButton in the UIElementMapper
 825      */
 826     // TODO REMOVE ME (NO MORE USED IN JNI)
 827     public static void removeEditBoxFromParent(int figureID, int objID) {
 828         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 829         EditBox editBox = (EditBox) UIElementMapper.getCorrespondingUIElement(objID);
 830         ScilabBridge.removeMember(parentTab, editBox);*/
 831     }
 832
 833     /**
 834      * Set a figure as parent for a Label
 835      * @param figureID the ID of the figure in the FigureMapper
 836      * @param objID the ID of the PushButton in the UIElementMapper
 837      */
 838     // TODO REMOVE ME (NO MORE USED IN JNI)
 839     public static void setLabelParent(int figureID, int objID) {
 840         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 841         Label label = (Label) UIElementMapper.getCorrespondingUIElement(objID);
 842         ScilabBridge.addMember(parentTab, label);*/
 843     }
 844
 845     /**
 846      * Remove a Label from its parent figure
 847      * @param figureID the ID of the figure in the FigureMapper
 848      * @param objID the ID of the PushButton in the UIElementMapper
 849      */
 850     // TODO REMOVE ME (NO MORE USED IN JNI)
 851     public static void removeLabelFromParent(int figureID, int objID) {
 852         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 853         Label label = (Label) UIElementMapper.getCorrespondingUIElement(objID);
 854         ScilabBridge.removeMember(parentTab, label);*/
 855     }
 856
 857     /**
 858      * Set a figure as parent for a CheckBox
 859      * @param figureID the ID of the figure in the FigureMapper
 860      * @param objID the ID of the PushButton in the UIElementMapper
 861      */
 862     // TODO REMOVE ME (NO MORE USED IN JNI)
 863     public static void setCheckBoxParent(int figureID, int objID) {
 864         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 865         CheckBox checkBox = (CheckBox) UIElementMapper.getCorrespondingUIElement(objID);
 866         ScilabBridge.addMember(parentTab, checkBox);*/
 867     }
 868
 869     /**
 870      * Remove a CheckBox from its parent figure
 871      * @param figureID the ID of the figure in the FigureMapper
 872      * @param objID the ID of the PushButton in the UIElementMapper
 873      */
 874     // TODO REMOVE ME (NO MORE USED IN JNI)
 875     public static void removeCheckBoxFromParent(int figureID, int objID) {
 876         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 877         CheckBox checkBox = (CheckBox) UIElementMapper.getCorrespondingUIElement(objID);
 878         ScilabBridge.removeMember(parentTab, checkBox);*/
 879     }
 880
 881     /**
 882      * Set a figure as parent for a RadioButton
 883      * @param figureID the ID of the figure in the FigureMapper
 884      * @param objID the ID of the PushButton in the UIElementMapper
 885      */
 886     // TODO REMOVE ME (NO MORE USED IN JNI)
 887     public static void setRadioButtonParent(int figureID, int objID) {
 888         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 889         RadioButton radioButton = (RadioButton) UIElementMapper.getCorrespondingUIElement(objID);
 890         ScilabBridge.addMember(parentTab, radioButton);*/
 891     }
 892
 893     /**
 894      * Remove a RadioButton from its parent figure
 895      * @param figureID the ID of the figure in the FigureMapper
 896      * @param objID the ID of the PushButton in the UIElementMapper
 897      */
 898     // TODO REMOVE ME (NO MORE USED IN JNI)
 899     public static void removeRadioButtonFromParent(int figureID, int objID) {
 900         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 901         RadioButton radioButton = (RadioButton) UIElementMapper.getCorrespondingUIElement(objID);
 902         ScilabBridge.removeMember(parentTab, radioButton);*/
 903     }
 904
 905     /**
 906      * Set a figure as parent for a UiTable
 907      * @param figureID the ID of the figure in the FigureMapper
 908      * @param objID the ID of the PushButton in the UIElementMapper
 909      */
 910     // TODO REMOVE ME (NO MORE USED IN JNI)
 911     public static void setUiTableParent(int figureID, int objID) {
 912         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 913         UiTable uiTable = (UiTable) UIElementMapper.getCorrespondingUIElement(objID);
 914         ScilabBridge.addMember(parentTab, uiTable);*/
 915     }
 916
 917     /**
 918      * Remove a UiTable from its parent figure
 919      * @param figureID the ID of the figure in the FigureMapper
 920      * @param objID the ID of the PushButton in the UIElementMapper
 921      */
 922     // TODO REMOVE ME (NO MORE USED IN JNI)
 923     public static void removeUiTableFromParent(int figureID, int objID) {
 924         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 925         UiTable uiTable = (UiTable) UIElementMapper.getCorrespondingUIElement(objID);
 926         ScilabBridge.removeMember(parentTab, uiTable);*/
 927     }
 928
 929     // TODO REMOVE ME (NO MORE USED IN JNI)
 930     public static void setUiDisplayTreeParent(int figureID, int objID) {
 931         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 932         UiDisplayTree uiTree = (UiDisplayTree) UIElementMapper.getCorrespondingUIElement(objID);
 933         ScilabBridge.addMember(parentTab, uiTree);*/
 934     }
 935     // TODO REMOVE ME (NO MORE USED IN JNI)
 936     public static void removeUiDisplayTreeFromParent(int figureID, int objID) {
 937         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 938         UiDisplayTree uiTree = (UiDisplayTree) UIElementMapper.getCorrespondingUIElement(objID);
 939         ScilabBridge.removeMember(parentTab, uiTree);*/
 940     }
 941
 942     /**
 943      * Set a figure as parent for a Slider
 944      * @param figureID the ID of the figure in the FigureMapper
 945      * @param objID the ID of the PushButton in the UIElementMapper
 946      */
 947     // TODO REMOVE ME (NO MORE USED IN JNI)
 948     public static void setSliderParent(int figureID, int objID) {
 949         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 950         Slider slider = (Slider) UIElementMapper.getCorrespondingUIElement(objID);
 951         ScilabBridge.addMember(parentTab, slider);*/
 952     }
 953
 954     /**
 955      * Remove a Slider from its parent figure
 956      * @param figureID the ID of the figure in the FigureMapper
 957      * @param objID the ID of the Slider in the UIElementMapper
 958      */
 959     // TODO REMOVE ME (NO MORE USED IN JNI)
 960     public static void removeSliderFromParent(int figureID, int objID) {
 961         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 962         Slider slider = (Slider) UIElementMapper.getCorrespondingUIElement(objID);
 963         ScilabBridge.removeMember(parentTab, slider);*/
 964     }
 965
 966     /**
 967      * Set a figure as parent for a ListBox
 968      * @param figureID the ID of the figure in the FigureMapper
 969      * @param objID the ID of the ListBox in the UIElementMapper
 970      */
 971     // TODO REMOVE ME (NO MORE USED IN JNI)
 972     public static void setListBoxParent(int figureID, int objID) {
 973         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 974         ListBox listBox = (ListBox) UIElementMapper.getCorrespondingUIElement(objID);
 975         ScilabBridge.addMember(parentTab, listBox);*/
 976     }
 977
 978     /**
 979      * Remove a ListBox from its parent figure
 980      * @param figureID the ID of the figure in the FigureMapper
 981      * @param objID the ID of the ListBox in the UIElementMapper
 982      */
 983     // TODO REMOVE ME (NO MORE USED IN JNI)
 984     public static void removeListBoxFromParent(int figureID, int objID) {
 985         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 986         ListBox listBox = (ListBox) UIElementMapper.getCorrespondingUIElement(objID);
 987         ScilabBridge.removeMember(parentTab, listBox);*/
 988     }
 989
 990     /**
 991      * Set a figure as parent for a PopupMenu
 992      * @param figureID the ID of the figure in the FigureMapper
 993      * @param objID the ID of the PopupMenu in the UIElementMapper
 994      */
 995     // TODO REMOVE ME (NO MORE USED IN JNI)
 996     public static void setPopupMenuParent(int figureID, int objID) {
 997         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
 998         PopupMenu popupMenu = (PopupMenu) UIElementMapper.getCorrespondingUIElement(objID);
 999         ScilabBridge.addMember(parentTab, popupMenu);*/
1000     }
1001
1002     /**
1003      * Remove a PopupMenu from its parent figure
1004      * @param figureID the ID of the figure in the FigureMapper
1005      * @param objID the ID of the PopupMenu in the UIElementMapper
1006      */
1007     // TODO REMOVE ME (NO MORE USED IN JNI)
1008     public static void removePopupMenuFromParent(int figureID, int objID) {
1009         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
1010         PopupMenu popupMenu = (PopupMenu) UIElementMapper.getCorrespondingUIElement(objID);
1011         ScilabBridge.removeMember(parentTab, popupMenu);*/
1012     }
1013
1014     /**
1015      * Set a figure as parent for a Frame
1016      * @param figureID the ID of the figure in the FigureMapper
1017      * @param objID the ID of the PopupMenu in the UIElementMapper
1018      */
1019     // TODO REMOVE ME (NO MORE USED IN JNI)
1020     public static void setFrameParent(int figureID, int objID) {
1021         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
1022         Frame frame = (Frame) UIElementMapper.getCorrespondingUIElement(objID);
1023         ScilabBridge.addMember(parentTab, frame);*/
1024     }
1025
1026     /**
1027      * Remove a Frame from its parent figure
1028      * @param figureID the ID of the figure in the FigureMapper
1029      * @param objID the ID of the PopupMenu in the UIElementMapper
1030      */
1031     // TODO REMOVE ME (NO MORE USED IN JNI)
1032     public static void removeFrameFromParent(int figureID, int objID) {
1033         /*Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
1034         Frame frame = (Frame) UIElementMapper.getCorrespondingUIElement(objID);
1035         ScilabBridge.removeMember(parentTab, frame);*/
1036     }
1037
1038     /**
1039      * Set root Scilab object (the console tab) as the parent of the menu
1040      * @param objID the id of the menu
1041      */
1042     // TODO REMOVE ME (NO MORE USED IN JNI)
1043     public static void setRootAsParent(int objID) {
1044         if (!(UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem)) {
1045             // Add the menu to the tab
1046             ScilabConsole.getConsole().getMenuBar().add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
1047         } else {
1048             // obj is a MenuItem that has top be converted to a Menu
1049             MenuItem menuItem = (MenuItem) UIElementMapper.getCorrespondingUIElement(objID);
1050
1051             Menu menuToAdd = ScilabMenu.createMenu();
1052             UIElementMapper.removeMapping(objID);
1053             UIElementMapper.addMapping(objID, menuToAdd);
1054             // Copy all properties from MenuItem to Menu
1055             menuToAdd.setText(menuItem.getText());
1056             menuToAdd.setCallback(menuItem.getCallback());
1057             menuToAdd.setForeground(menuItem.getForeground());
1058             menuToAdd.setVisible(menuItem.isVisible());
1059             // End of properties copy
1060
1061             ScilabConsole.getConsole().getMenuBar().add(menuToAdd);
1062         }
1063     }
1064
1065     /**
1066      * Set an other menu as the parent of the menu
1067      * @param menuID the id of the parent menu
1068      * @param objID the id of the menu
1069      */
1070     // TODO REMOVE ME (NO MORE USED IN JNI)
1071     public static void setMenuAsParent(int menuID, int objID) {
1072
1073         if (UIElementMapper.getCorrespondingUIElement(menuID) instanceof CheckBoxMenuItem) {
1074             CheckBoxMenuItem parentMenu = (CheckBoxMenuItem) UIElementMapper.getCorrespondingUIElement(menuID);
1075
1076             if (!(UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem)) {
1077                 parentMenu.add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
1078             } else if (UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem) {
1079                 parentMenu.add((MenuItem) UIElementMapper.getCorrespondingUIElement(objID));
1080             }
1081         } else if (UIElementMapper.getCorrespondingUIElement(menuID) instanceof MenuItem) {
1082             MenuItem parentMenu = (MenuItem) UIElementMapper.getCorrespondingUIElement(menuID);
1083
1084             if (!(UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem)) {
1085                 parentMenu.add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
1086             } else if (UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem) {
1087                 parentMenu.add((MenuItem) UIElementMapper.getCorrespondingUIElement(objID));
1088             }
1089         } else if (UIElementMapper.getCorrespondingUIElement(menuID) instanceof ContextMenu) {
1090             ContextMenu parentMenu = (ContextMenu) UIElementMapper.getCorrespondingUIElement(menuID);
1091
1092             if (!(UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem)) {
1093                 parentMenu.add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
1094             } else if (UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem) {
1095                 parentMenu.add((MenuItem) UIElementMapper.getCorrespondingUIElement(objID));
1096             }
1097         } else if (UIElementMapper.getCorrespondingUIElement(menuID) instanceof Menu) {
1098             Menu parentMenu = (Menu) UIElementMapper.getCorrespondingUIElement(menuID);
1099
1100             if (!(UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem)) {
1101                 parentMenu.add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
1102             } else if (UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem) {
1103                 parentMenu.add((MenuItem) UIElementMapper.getCorrespondingUIElement(objID));
1104             }
1105         }
1106     }
1107
1108     /*******************/
1109     /*                 */
1110     /* OBJECT CALLBACK */
1111     /*                 */
1112     /*******************/
1113
1114     /**
1115      * Set a callback for a Widget
1116      * @param objID the ID of the object in the UIElementMapper
1117      * @param callbackString the text of the callback
1118      * @param callbackType the type of the callback
1119      */
1120     // TODO REMOVE ME (NO MORE USED IN JNI)
1121     public static void setWidgetCallback(int objID, String callbackString, int callbackType) {
1122         //((Widget) UIElementMapper.getCorrespondingUIElement(objID))
1123         //.setCallback(CommonCallBack.createCallback(callbackString, callbackType, objID));
1124     }
1125
1126     /**
1127      * Set a callback for a Frame
1128      * @param objID the ID of the object in the UIElementMapper
1129      * @param callbackString the text of the callback
1130      * @param callbackType the type of the callback
1131      */
1132     // TODO REMOVE ME (NO MORE USED IN JNI)
1133     public static void setFrameCallback(int objID, String callbackString, int callbackType) {
1134         //((Frame) UIElementMapper.getCorrespondingUIElement(objID)).setCallback(CommonCallBack.createCallback(callbackString, callbackType, objID));
1135     }
1136
1137     /************************/
1138     /*                      */
1139     /* ENABLE/DISABLE MENUS */
1140     /*                      */
1141     /************************/
1142
1143     /**
1144      * Enable/Disable a menu of a Scilab figure or console giving its name
1145      * @param parentUID the UID of the figure or console
1146      * @param menuName the name of the menu
1147      * @param status true to set the menu enabled
1148      */
1149     public static void setMenuEnabled(String parentUID, String menuName, boolean status) {
1150         SwingScilabTab parentTab = (SwingScilabTab) SwingView.getFromId(parentUID);
1151         if (parentTab != null) { /** Parent must exist */
1152             parentTab.getMenuBar().getAsSimpleMenuBar().setMenuEnabled(menuName, status);
1153         }
1154     }
1155
1156     /**
1157      * Disable a MenuItem of a Scilab figure or console giving its parent name and position
1158      * @param parentUID the UID of the figure or console
1159      * @param parentMenuName the name of the parent menu
1160      * @param menuItemPosition the name of the parent menu
1161      * @param status true to set the menu enabled
1162      */
1163     public static void setSubMenuEnabled(String parentUID, String parentMenuName, int menuItemPosition, boolean status) {
1164         SwingScilabTab parentTab = (SwingScilabTab) SwingView.getFromId(parentUID);
1165         if (parentTab != null) { /** Parent must exist */
1166             parentTab.getMenuBar().getAsSimpleMenuBar().setSubMenuEnabled(parentMenuName, menuItemPosition, status);
1167         }
1168     }
1169
1170     /****************/
1171     /*              */
1172     /* REMOVE MENUS */
1173     /*              */
1174     /****************/
1175
1176     /**
1177      * Delete a menu of a Scilab figure or console giving its name
1178      * @param parentUID the UID of the figure or console
1179      * @param menuName the name of the menu
1180      */
1181     public static void removeMenu(String parentUID, String menuName) {
1182         SwingScilabTab parentTab = (SwingScilabTab) SwingView.getFromId(parentUID);
1183         if (parentTab != null) { /** Parent must exist */
1184             parentTab.getMenuBar().getAsSimpleMenuBar().removeMenu(menuName);
1185         }
1186     }
1187
1188     /***********************/
1189     /*                     */
1190     /* FILE CHOOSER BRIDGE */
1191     /*                     */
1192     /***********************/
1193
1194
1195
1196     /**
1197      * Create a new Graphic Export File Chooser in Scilab GUIs
1198      * @param figureId id of the figure to export
1199      * @return the ID of the File Chooser in the UIElementMapper
1200      */
1201
1202     public static int newExportFileChooser(String figureId) {
1203         FileChooser fileChooser = ScilabFileChooser.createExportFileChooser(figureId);
1204         return 0;
1205     }
1206
1207
1208
1209     /**********************/
1210     /*                    */
1211     /* MESSAGE BOX BRIDGE */
1212     /*                    */
1213     /**********************/
1214
1215     /**
1216      * Set the MessageBox title
1217      * @param id the id of the messageBox
1218      * @param title the title of the messageBox
1219      */
1220     public static void setMessageBoxTitle(int id, String title) {
1221         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setTitle(title);
1222     }
1223
1224     /**
1225      * Set the MessageBox message
1226      * @param id the id of the messageBox
1227      * @param message the message of the messageBox
1228      */
1229     public static void setMessageBoxMessage(int id, String message) {
1230         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setMessage(message);
1231     }
1232
1233     /**
1234      * Set the MessageBox message (multi-line)
1235      * @param id the id of the messageBox
1236      * @param message the message of the messageBox
1237      */
1238     public static void setMessageBoxMessage(int id, String[] message) {
1239         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setMessage(message);
1240     }
1241
1242     /**
1243      * Display this chooser and wait for user selection
1244      * @param id the id of the messageBox
1245      */
1246     public static void messageBoxDisplayAndWait(int id) {
1247         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).displayAndWait();
1248     }
1249
1250     /**
1251      * Get the index of the selected button
1252      * @param id the id of the messageBox
1253      * @return the index of the selected button
1254      */
1255     public static int getMessageBoxSelectedButton(int id) {
1256         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectedButton();
1257     }
1258
1259     /**
1260      * Set the indices of the default selected buttons (x_choices)
1261      * @param id the id of the MessageBox
1262      * @param indices the indices of the default selected buttons
1263      */
1264     public static void setMessageBoxDefaultSelectedButtons(int id, int[] indices) {
1265         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setDefaultSelectedButtons(indices);
1266     }
1267
1268     /**
1269      * Get the indices of the user selected buttons (x_choices)
1270      * @param id the id of the MessageBox
1271      * @return the indices of the user selected buttons
1272      */
1273     public static int[] getMessageBoxUserSelectedButtons(int id) {
1274         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getUserSelectedButtons();
1275     }
1276
1277     /**
1278      * Set the labels of the buttons in the MessageBox
1279      * @param id the id of the MessageBox
1280      * @param labels the labels of the buttons
1281      */
1282     public static void setMessageBoxButtonsLabels(int id, String[] labels) {
1283         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setButtonsLabels(labels);
1284     }
1285
1286     /**
1287      * Set the initial value for the editable part of the MessageBox
1288      * @param id the id of the MessageBox
1289      * @param value the initial value
1290      */
1291     public static void setMessageBoxInitialValue(int id, String[] value) {
1292         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setInitialValue(value);
1293     }
1294
1295     /**
1296      * Get the value of the editable zone in the MessageBox
1297      * @param id the id of the MessageBox
1298      * @return the value
1299      */
1300     public static String[] getMessageBoxValue(int id) {
1301         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getValue();
1302     }
1303
1304     /**
1305      * Get the size of the value of the editable zone in the MessageBox
1306      * @param id the id of the MessageBox
1307      * @return the value size
1308      */
1309     public static int getMessageBoxValueSize(int id) {
1310         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getValueSize();
1311     }
1312
1313     /**
1314      * Set the items of the listbox in the MessageBox
1315      * @param id the id of the MessageBox
1316      * @param items the items to set
1317      */
1318     public static void setMessageBoxListBoxItems(int id, String[] items) {
1319         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setListBoxItems(items);
1320     }
1321
1322     /**
1323      * Get the index of the selected item in the listbox in the MessageBox
1324      * @param id the id of the MessageBox
1325      * @return the index
1326      */
1327     public static int getMessageBoxSelectedItem(int id) {
1328         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectedItem();
1329     }
1330
1331     /**
1332      * Set the name of the lines labels in the editable zone in the MessageBox
1333      * @param id the id of the MessageBox
1334      * @param labels the labels
1335      */
1336     public static void setMessageBoxLineLabels(int id, String[] labels) {
1337         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setLineLabels(labels);
1338     }
1339
1340     /**
1341      * Set the name of the columns labels in the editable zone in the MessageBox
1342      * @param id the id of the MessageBox
1343      * @param labels the labels
1344      */
1345     public static void setMessageBoxColumnLabels(int id, String[] labels) {
1346         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setColumnLabels(labels);
1347     }
1348
1349     /**
1350      * Set the default values of a multi-value editable zone in the MessageBox
1351      * @param id the id of the MessageBox
1352      * @param values the values
1353      */
1354     public static void setMessageBoxDefaultInput(int id, String[] values) {
1355         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setDefaultInput(values);
1356     }
1357
1358     /**
1359      * Set a MessageBox modal or not
1360      * @param id the id of the MessageBox
1361      * @param status true to set the MessageBox modal and false else
1362      */
1363     public static void setMessageBoxModal(int id, boolean status) {
1364         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setModal(status);
1365     }
1366
1367     /**
1368      * Set the MessageBox icon
1369      * @param id the id of the MessageBox
1370      * @param name the name of the icon
1371      */
1372     public static void setMessageBoxIcon(int id, String name) {
1373         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setIcon(name);
1374     }
1375
1376     /************************/
1377     /*                      */
1378     /* OBJECT COLORS BRIDGE */
1379     /*                      */
1380     /************************/
1381
1382     /**
1383      * Builds a color with composants between 0 and 255
1384      * @param red the red value for the color
1385      * @param green the green value for the color
1386      * @param blue the blue value for the color
1387      */
1388     public static Color getGoodColor(int red, int green, int blue) {
1389         int r = Math.max(0, Math.min(red, 255));
1390         int g = Math.max(0, Math.min(green, 255));
1391         int b = Math.max(0, Math.min(blue, 255));
1392
1393         return new Color(r, g, b);
1394     }
1395
1396     /**
1397      * Set the background color of a Widget
1398      * @param id the id of the Widget
1399      * @param red the red value for the color
1400      * @param green the green value for the color
1401      * @param blue the blue value for the color
1402      */
1403     // TODO REMOVE ME (NO MORE USED IN JNI)
1404     public static void setWidgetBackgroundColor(int id, int red, int green, int blue) {
1405         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setBackground(getGoodColor(red, green, blue));
1406     }
1407
1408     /**
1409      * Get the background color of a widget
1410      * @param id the id of the widget
1411      * @return the color [R, G, B]
1412      */
1413     // TODO REMOVE ME (NO MORE USED IN JNI)
1414     public static int[] getWidgetBackgroundColor(int id) {
1415         Color tmpColor = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getBackground();
1416         int[] color = new int[NB_COLORS];
1417         color[0] = tmpColor.getRed();
1418         color[1] = tmpColor.getGreen();
1419         color[2] = tmpColor.getBlue();
1420         return color;
1421     }
1422
1423     /**
1424      * Set the foreground color of a Widget
1425      * @param id the id of the Widget
1426      * @param red the red value for the color
1427      * @param green the green value for the color
1428      * @param blue the blue value for the color
1429      */
1430     // TODO REMOVE ME (NO MORE USED IN JNI)
1431     public static void setWidgetForegroundColor(int id, int red, int green, int blue) {
1432         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setForeground(getGoodColor(red, green, blue));
1433     }
1434
1435     /**
1436      * Get the foreground color of a Widget
1437      * @param id the id of the Widget
1438      * @return the color [R, G, B]
1439      */
1440     // TODO REMOVE ME (NO MORE USED IN JNI)
1441     public static int[] getWidgetForegroundColor(int id) {
1442         Color tmpColor = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getForeground();
1443         int[] color = new int[NB_COLORS];
1444         color[0] = tmpColor.getRed();
1445         color[1] = tmpColor.getGreen();
1446         color[2] = tmpColor.getBlue();
1447         return color;
1448     }
1449
1450     /**
1451      * Set the background color of a Frame
1452      * @param id the id of the Frame
1453      * @param red the red value for the color
1454      * @param green the green value for the color
1455      * @param blue the blue value for the color
1456      */
1457     // TODO REMOVE ME (NO MORE USED IN JNI)
1458     public static void setFrameBackgroundColor(int id, int red, int green, int blue) {
1459         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setBackground(getGoodColor(red, green, blue));
1460     }
1461
1462     /**
1463      * Get the background color of a Frame
1464      * @param id the id of the Frame
1465      * @return the color [R, G, B]
1466      */
1467     // TODO REMOVE ME (NO MORE USED IN JNI)
1468     public static int[] getFrameBackgroundColor(int id) {
1469         Color tmpColor = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getBackground();
1470         int[] color = new int[NB_COLORS];
1471         color[0] = tmpColor.getRed();
1472         color[1] = tmpColor.getGreen();
1473         color[2] = tmpColor.getBlue();
1474         return color;
1475     }
1476
1477     /**
1478      * Set the foreground color of a Frame
1479      * @param id the id of the Frame
1480      * @param red the red value for the color
1481      * @param green the green value for the color
1482      * @param blue the blue value for the color
1483      */
1484     // TODO REMOVE ME (NO MORE USED IN JNI)
1485     public static void setFrameForegroundColor(int id, int red, int green, int blue) {
1486         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setForeground(getGoodColor(red, green, blue));
1487     }
1488
1489     /**
1490      * Get the foreground color of a Frame
1491      * @param id the id of the Frame
1492      * @return the color [R, G, B]
1493      */
1494     // TODO REMOVE ME (NO MORE USED IN JNI)
1495     public static int[] getFrameForegroundColor(int id) {
1496         Color tmpColor = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getForeground();
1497         int[] color = new int[NB_COLORS];
1498         color[0] = tmpColor.getRed();
1499         color[1] = tmpColor.getGreen();
1500         color[2] = tmpColor.getBlue();
1501         return color;
1502     }
1503
1504     /**********************/
1505     /*                    */
1506     /* OBJECT FONT BRIDGE */
1507     /*                    */
1508     /**********************/
1509
1510     /**
1511      * Set the name of a Widget font
1512      * @param id the id of the Widget
1513      * @param name the name of the Widget font
1514      */
1515     // TODO REMOVE ME (NO MORE USED IN JNI)
1516     public static void setWidgetFontName(int id, String name) {
1517         Font font = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1518         font = new Font(name, font.getStyle(), font.getSize());
1519         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1520     }
1521
1522     /**
1523      * Get the name of a Widget font
1524      * @param id the id of the Widget
1525      * @return the name of the Widget font
1526      */
1527     // TODO REMOVE ME (NO MORE USED IN JNI)
1528     public static String getWidgetFontName(int id) {
1529         return ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont().getName();
1530     }
1531
1532     /**
1533      * Set the weight of a Widget font
1534      * @param id the id of the Widget
1535      * @param weight the weight of the Widget font
1536      */
1537     // TODO REMOVE ME (NO MORE USED IN JNI)
1538     public static void setWidgetFontWeight(int id, String weight) {
1539         Font font = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1540
1541         if (weight.equals(BOLDFONT)) {
1542             if (font.isItalic()) {
1543                 font = new Font(font.getName(), Font.ITALIC + Font.BOLD, font.getSize());
1544             } else {
1545                 font = new Font(font.getName(), Font.BOLD, font.getSize());
1546             }
1547         } else {
1548             if (font.isItalic()) {
1549                 font = new Font(font.getName(), Font.ITALIC, font.getSize());
1550             } else {
1551                 font = new Font(font.getName(), Font.PLAIN, font.getSize());
1552             }
1553         }
1554
1555         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1556     }
1557
1558     /**
1559      * Set the angle of a Widget font
1560      * @param id the id of the Widget
1561      * @param angle the angle of the Widget font
1562      */
1563     // TODO REMOVE ME (NO MORE USED IN JNI)
1564     public static void setWidgetFontAngle(int id, String angle) {
1565         Font font = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1566
1567         if (angle.equals(ITALICFONT) || angle.equals(OBLIQUEFONT)) {
1568             if (font.isBold()) {
1569                 font = new Font(font.getName(), Font.ITALIC + Font.BOLD, font.getSize());
1570             } else {
1571                 font = new Font(font.getName(), Font.ITALIC, font.getSize());
1572             }
1573         } else {
1574             if (font.isBold()) {
1575                 font = new Font(font.getName(), Font.BOLD, font.getSize());
1576             } else {
1577                 font = new Font(font.getName(), Font.PLAIN, font.getSize());
1578             }
1579         }
1580
1581         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1582     }
1583
1584     /**
1585      * Set the size of a Widget font
1586      * @param id the id of the Widget
1587      * @param size the size of the Widget font
1588      */
1589     // TODO REMOVE ME (NO MORE USED IN JNI)
1590     public static void setWidgetFontSize(int id, int size) {
1591         Font font = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1592         font = new Font(font.getName(), font.getStyle(), size);
1593         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1594     }
1595
1596     /**
1597      * Get the size of a Widget font
1598      * @param id the id of the Widget
1599      * @return the size of the Widget font
1600      */
1601     // TODO REMOVE ME (NO MORE USED IN JNI)
1602     public static int getWidgetFontSize(int id) {
1603         return ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont().getSize();
1604     }
1605
1606     /**
1607      * Set the weight of a Frame font
1608      * @param id the id of the Frame
1609      * @param weight the weight of the Frame font
1610      */
1611     // TODO REMOVE ME (NO MORE USED IN JNI)
1612     public static void setFrameFontWeight(int id, String weight) {
1613         Font font = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1614
1615         if (weight.equals(BOLDFONT)) {
1616             if (font.isItalic()) {
1617                 font = new Font(font.getName(), Font.ITALIC + Font.BOLD, font.getSize());
1618             } else {
1619                 font = new Font(font.getName(), Font.BOLD, font.getSize());
1620             }
1621         } else {
1622             if (font.isItalic()) {
1623                 font = new Font(font.getName(), Font.ITALIC, font.getSize());
1624             } else {
1625                 font = new Font(font.getName(), Font.PLAIN, font.getSize());
1626             }
1627         }
1628
1629         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1630     }
1631
1632     /**
1633      * Set the angle of a Frame font
1634      * @param id the id of the Frame
1635      * @param angle the angle of the Frame font
1636      */
1637     // TODO REMOVE ME (NO MORE USED IN JNI)
1638     public static void setFrameFontAngle(int id, String angle) {
1639         Font font = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1640
1641         if (angle.equals(ITALICFONT) || angle.equals(OBLIQUEFONT)) {
1642             if (font.isBold()) {
1643                 font = new Font(font.getName(), Font.ITALIC + Font.BOLD, font.getSize());
1644             } else {
1645                 font = new Font(font.getName(), Font.ITALIC, font.getSize());
1646             }
1647         } else {
1648             if (font.isBold()) {
1649                 font = new Font(font.getName(), Font.BOLD, font.getSize());
1650             } else {
1651                 font = new Font(font.getName(), Font.PLAIN, font.getSize());
1652             }
1653         }
1654
1655         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1656     }
1657
1658     /**
1659      * Set the size of a Frame font
1660      * @param id the id of the Frame
1661      * @param size the size of the Frame font
1662      */
1663     // TODO REMOVE ME (NO MORE USED IN JNI)
1664     public static void setFrameFontSize(int id, int size) {
1665         Font font = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1666         font = new Font(font.getName(), font.getStyle(), size);
1667         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1668     }
1669
1670     /**
1671      * Get the size of a Frame font
1672      * @param id the id of the Frame
1673      * @return the size of the Frame font
1674      */
1675     // TODO REMOVE ME (NO MORE USED IN JNI)
1676     public static int getFrameFontSize(int id) {
1677         return ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont().getSize();
1678     }
1679
1680     /**
1681      * Set the name of a Frame font
1682      * @param id the id of the Frame
1683      * @param name the name of the Frame font
1684      */
1685     // TODO REMOVE ME (NO MORE USED IN JNI)
1686     public static void setFrameFontName(int id, String name) {
1687         Font font = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1688         font = new Font(name, font.getStyle(), font.getSize());
1689         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1690     }
1691
1692     /**
1693      * Get the name of a Frame font
1694      * @param id the id of the Frame
1695      * @return the name of the Frame font
1696      */
1697     // TODO REMOVE ME (NO MORE USED IN JNI)
1698     public static String getFrameFontName(int id) {
1699         return ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont().getName();
1700     }
1701
1702     /**************************/
1703     /*                        */
1704     /* OBJECT POSITION BRIDGE */
1705     /*                        */
1706     /**************************/
1707
1708     /**
1709      * Set the position (in Scilab terms) of a Widget
1710      * @param id the id of the Widget
1711      * @param x the X-coordinate for the Widget
1712      * @param y the Y-coordinate for the Widget
1713      * @param width the width of the Widget
1714      * @param height the height of the Widget
1715      */
1716     // TODO REMOVE ME (NO MORE USED IN JNI)
1717     public static void setWidgetPosition(int id, int x, int y, int width, int height) {
1718         /* Dimensions must be set before position beacause of PositionConverter */
1719         UIElementMapper.getCorrespondingUIElement(id).setDims(new Size(width, height));
1720         UIElementMapper.getCorrespondingUIElement(id).setPosition(new Position(x, y));
1721     }
1722
1723     /**
1724      * Get the position (in Scilab terms) of a widget
1725      * @param id the id of the widget
1726      * @return the position (X-coordinate, Y-coordinate, width, height) of the button
1727      */
1728     // TODO REMOVE ME (NO MORE USED IN JNI)
1729     public static int[] getWidgetPosition(int id) {
1730         int[] position = new int[POSITION_SIZE];
1731
1732         position[X_INDEX] = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getPosition().getX();
1733         position[Y_INDEX] = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getPosition().getY();
1734         position[WIDTH_INDEX] = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getDims().getWidth();
1735         position[HEIGHT_INDEX] = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getDims().getHeight();
1736
1737         return position;
1738     }
1739
1740     /**
1741      * Set the position (in Scilab terms) of a Frame
1742      * @param id the id of the Frame
1743      * @param x the X-coordinate for the Frame
1744      * @param y the Y-coordinate for the Frame
1745      * @param width the width of the Frame
1746      * @param height the height of the Frame
1747      */
1748     // TODO REMOVE ME (NO MORE USED IN JNI)
1749     public static void setFramePosition(int id, int x, int y, int width, int height) {
1750         /* Dimensions must be set before position beacause of PositionConverter */
1751         UIElementMapper.getCorrespondingUIElement(id).setDims(new Size(width, height));
1752         UIElementMapper.getCorrespondingUIElement(id).setPosition(new Position(x, y));
1753     }
1754
1755     /**
1756      * Get the position (in Scilab terms) of a Frame
1757      * @param id the id of the Frame
1758      * @return the position (X-coordinate, Y-coordinate, width, height) of the button
1759      */
1760     // TODO REMOVE ME (NO MORE USED IN JNI)
1761     public static int[] getFramePosition(int id) {
1762         int[] position = new int[POSITION_SIZE];
1763
1764         position[X_INDEX] = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getPosition().getX();
1765         position[Y_INDEX] = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getPosition().getY();
1766         position[WIDTH_INDEX] = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getDims().getWidth();
1767         position[HEIGHT_INDEX] = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getDims().getHeight();
1768
1769         return position;
1770     }
1771
1772     /***************************/
1773     /*                         */
1774     /* OBJECT ALIGNMENT BRIDGE */
1775     /*                         */
1776     /***************************/
1777
1778     /**
1779      * Set the horizontal alignment for the Widget text
1780      * @param id the id of the Widget
1781      * @param alignment the value for the alignment (See ScilabAlignment.java)
1782      */
1783     // TODO REMOVE ME (NO MORE USED IN JNI)
1784     public static void setWidgetHorizontalAlignment(int id, String alignment) {
1785         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setHorizontalAlignment(alignment);
1786     }
1787
1788     /**
1789      * Set the vertical alignment for the Widget text
1790      * @param id the id of the Widget
1791      * @param alignment the value for the alignment (See ScilabAlignment.java)
1792      */
1793     // TODO REMOVE ME (NO MORE USED IN JNI)
1794     public static void setWidgetVerticalAlignment(int id, String alignment) {
1795         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setVerticalAlignment(alignment);
1796     }
1797
1798     /**********************/
1799     /*                    */
1800     /* SLIDER STEP BRIDGE */
1801     /*                    */
1802     /**********************/
1803
1804     /**
1805      * Set the minor tick spacing for a Slider
1806      * @param id the id of the Slider
1807      * @param space the increment value
1808      */
1809     // TODO REMOVE ME (NO MORE USED IN JNI)
1810     public static void setSliderMinorTickSpacing(int id, int space) {
1811         ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setMinorTickSpacing(space);
1812     }
1813
1814     /**
1815      * Set the major tick spacing for a Slider
1816      * @param id the id of the Slider
1817      * @param space the increment value
1818      */
1819     // TODO REMOVE ME (NO MORE USED IN JNI)
1820     public static void setSliderMajorTickSpacing(int id, int space) {
1821         ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setMajorTickSpacing(space);
1822     }
1823
1824     /*************************/
1825     /*                       */
1826     /* SLIDER MIN/MAX BRIDGE */
1827     /*                       */
1828     /*************************/
1829
1830     /**
1831      * Set the minimum value of a Slider
1832      * @param id the id of the Slider
1833      * @param value the minimum value
1834      */
1835     // TODO REMOVE ME (NO MORE USED IN JNI)
1836     public static void setSliderMinValue(int id, int value) {
1837         ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setMinimumValue(value);
1838     }
1839
1840     /**
1841      * Set the maximum value of a Slider
1842      * @param id the id of the Widget
1843      * @param value the maximum value
1844      */
1845     // TODO REMOVE ME (NO MORE USED IN JNI)
1846     public static void setSliderMaxValue(int id, int value) {
1847         ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setMaximumValue(value);
1848     }
1849
1850     /*****************************/
1851     /*                           */
1852     /* SLIDER ORIENTATION BRIDGE */
1853     /*                           */
1854     /*****************************/
1855
1856     /**
1857      * Set the slider orientation to vertical
1858      * @param id the id of the slider
1859      */
1860     // TODO REMOVE ME (NO MORE USED IN JNI)
1861     public static void setSliderVertical(int id) {
1862         ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setVertical();
1863     }
1864
1865     /**
1866      * Set the slider orientation to horizontal
1867      * @param id the id of the slider
1868      */
1869     // TODO REMOVE ME (NO MORE USED IN JNI)
1870     public static void setSliderHorizontal(int id) {
1871         ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setHorizontal();
1872     }
1873
1874     /******************/
1875     /*                */
1876     /* LISTBOX BRIDGE */
1877     /*                */
1878     /******************/
1879
1880     /**
1881      * Set if more than one item can be selected in a ListBox
1882      * @param id the id of the ListBox
1883      * @param status true if multiple selection is enabled
1884      */
1885     // TODO REMOVE ME (NO MORE USED IN JNI)
1886     public static void setListBoxMultipleSelectionEnabled(int id, boolean status) {
1887         ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).setMultipleSelectionEnabled(status);
1888     }
1889
1890     /**
1891      * Get the text of all the list items
1892      * @param id the id of the ListBox
1893      * @return the text items
1894      * @see org.scilab.modules.gui.listbox.ListBox#getAllItemsText()
1895      */
1896     // TODO REMOVE ME (NO MORE USED IN JNI)
1897     public static String[] getListBoxAllItemsText(int id) {
1898         return ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).getAllItemsText();
1899     }
1900
1901     /**
1902      * Get the number of items in the list
1903      * @param id the id of the ListBox
1904      * @return the number of items
1905      * @see org.scilab.modules.gui.listbox.ListBox#getNumberOfItems()
1906      */
1907     // TODO REMOVE ME (NO MORE USED IN JNI)
1908     public static int getListBoxNumberOfItems(int id) {
1909         return ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).getNumberOfItems();
1910     }
1911
1912     /**
1913      * Set the text of the list items
1914      * @param id the id of the ListBox
1915      * @param text the text of the items
1916      * @see org.scilab.modules.gui.listbox.ListBox#setText(java.lang.String[])
1917      */
1918     // TODO REMOVE ME (NO MORE USED IN JNI)
1919     public static void setListBoxText(int id, String[] text) {
1920         ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).setText(text);
1921     }
1922
1923     /**
1924      * Adjusts the view so that the element given by index is displayed at the top of the ListBox.
1925      * @param id the id of the ListBox
1926      * @param index the index of the element to be displayed at the top of the ListBox.
1927      */
1928     // TODO REMOVE ME (NO MORE USED IN JNI)
1929     public static void setListBoxListBoxTop(int id, int index) {
1930         ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).setListBoxTop(index);
1931     }
1932
1933     /**
1934      * Gets the index of the element displayed at the top of the ListBox
1935      * @param id the id of the ListBox
1936      * @return the index of the element displayed at the top of the ListBox
1937      */
1938     // TODO REMOVE ME (NO MORE USED IN JNI)
1939     public static int getListBoxListBoxTop(int id) {
1940         return ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).getListBoxTop();
1941     }
1942
1943     /********************/
1944     /*                  */
1945     /* POPUPMENU BRIDGE */
1946     /*                  */
1947     /********************/
1948
1949     /**
1950      * Get the text of all the PopupMenu items
1951      * @param id the id of the PopupMenu
1952      * @return the text items
1953      * @see org.scilab.modules.gui.popupmenu.PopupMenu#getAllItemsText()
1954      */
1955     // TODO REMOVE ME (NO MORE USED IN JNI)
1956     public static String[] getPopupMenuAllItemsText(int id) {
1957         return ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).getAllItemsText();
1958     }
1959
1960     /**
1961      * Get the number of items in the PopupMenu
1962      * @param id the id of the PopupMenu
1963      * @return the number of items
1964      * @see org.scilab.modules.gui.popupmenu.PopupMenu#getNumberOfItems()
1965      */
1966     // TODO REMOVE ME (NO MORE USED IN JNI)
1967     public static int getPopupMenuNumberOfItems(int id) {
1968         return ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).getNumberOfItems();
1969     }
1970
1971     /**
1972      * Set the text of the PopupMenu items
1973      * @param id the id of the PopupMenu
1974      * @param text the text of the items
1975      * @see org.scilab.modules.gui.popupmenu.PopupMenu#setText(java.lang.String[])
1976      */
1977     // TODO REMOVE ME (NO MORE USED IN JNI)
1978     public static void setPopupMenuText(int id, String[] text) {
1979         ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).setText(text);
1980     }
1981
1982     /****************/
1983     /*              */
1984     /* VALUE BRIDGE */
1985     /*              */
1986     /****************/
1987
1988     /**
1989      * Set the selected indices of the ListBox
1990      * @param id the id of the ListBox
1991      * @param indices the indices of the items to be selected
1992      */
1993     // TODO REMOVE ME (NO MORE USED IN JNI)
1994     public static void setListBoxSelectedIndices(int id, int[] indices) {
1995         ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).setSelectedIndices(indices);
1996     }
1997
1998     /**
1999      * Get the selected indices of the ListBox
2000      * @param id the id of the ListBox
2001      * @return the indices of the items selected
2002      */
2003     // TODO REMOVE ME (NO MORE USED IN JNI)
2004     public static int[] getListBoxSelectedIndices(int id) {
2005         return ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectedIndices();
2006     }
2007
2008     /**
2009      * Get the number of items selected in the ListBox
2010      * @param id the id of the ListBox
2011      * @return the number of items selected
2012      */
2013     // TODO REMOVE ME (NO MORE USED IN JNI)
2014     public static int getListBoxSelectionSize(int id) {
2015         return ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectionSize();
2016     }
2017
2018     /**
2019      * Set the selected index of the PopupMenu
2020      * @param id the id of the PopupMenu
2021      * @param index the index of the item to be selected
2022      */
2023     // TODO REMOVE ME (NO MORE USED IN JNI)
2024     public static void setPopupMenuSelectedIndex(int id, int index) {
2025         ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).setUserSelectedIndex(index);
2026     }
2027
2028     /**
2029      * Get the selected index of the PopupMenu
2030      * @param id the id of the PopupMenu
2031      * @return the index of the item selected
2032      */
2033     // TODO REMOVE ME (NO MORE USED IN JNI)
2034     public static int getPopupMenuSelectedIndex(int id) {
2035         return ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).getUserSelectedIndex();
2036     }
2037
2038     /**
2039      * Get the current value of the Slider
2040      * @param id the id of the Slider
2041      * @return the current value of the Slider
2042      */
2043     // TODO REMOVE ME (NO MORE USED IN JNI)
2044     public static int getSliderValue(int id) {
2045         return ((Slider) UIElementMapper.getCorrespondingUIElement(id)).getValue();
2046     }
2047
2048     /**
2049      * Sets the current value of the Slider
2050      * @param id the id of the Slider
2051      * @param value the new value
2052      */
2053     // TODO REMOVE ME (NO MORE USED IN JNI)
2054     public static void setSliderValue(int id, int value) {
2055         ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setUserValue(value);
2056     }
2057
2058     /**
2059      * Set if the RadioButton is checked or not
2060      * @param id the id of the RadioButton
2061      * @param status true to set the RadioButton checked
2062      */
2063     // TODO REMOVE ME (NO MORE USED IN JNI)
2064     public static void setRadioButtonChecked(int id, boolean status) {
2065         ((RadioButton) UIElementMapper.getCorrespondingUIElement(id)).setChecked(status);
2066     }
2067
2068     /**
2069      * Get the status of the RadioButton
2070      * @param id the id of the RadioButton
2071      * @return true if the RadioButton is checked
2072      */
2073     // TODO REMOVE ME (NO MORE USED IN JNI)
2074     public static boolean isRadioButtonChecked(int id) {
2075         return ((RadioButton) UIElementMapper.getCorrespondingUIElement(id)).isChecked();
2076     }
2077
2078     /**
2079      * Set if the CheckBox is checked or not
2080      * @param id the id of the CheckBox
2081      * @param status true to set the CheckBox checked
2082      */
2083     // TODO REMOVE ME (NO MORE USED IN JNI)
2084     public static void setCheckBoxChecked(int id, boolean status) {
2085         ((CheckBox) UIElementMapper.getCorrespondingUIElement(id)).setChecked(status);
2086     }
2087
2088     /**
2089      * Get the status of the CheckBox
2090      * @param id the id of the CheckBox
2091      * @return true if the CheckBox is checked
2092      */
2093     // TODO REMOVE ME (NO MORE USED IN JNI)
2094     public static boolean isCheckBoxChecked(int id) {
2095         return ((CheckBox) UIElementMapper.getCorrespondingUIElement(id)).isChecked();
2096     }
2097
2098     /*****************/
2099     /*               */
2100     /* RELIEF BRIDGE */
2101     /*               */
2102     /*****************/
2103
2104     /**
2105      * Set the Relief of the Widget
2106      * @param id the id of the Widget
2107      * @param reliefType the type of the relief to set (See ScilabRelief.java)
2108      */
2109     // TODO REMOVE ME (NO MORE USED IN JNI)
2110     public static void setWidgetRelief(int id, String reliefType) {
2111         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setRelief(reliefType);
2112     }
2113
2114     /**
2115      * Set the Relief of the Frame
2116      * @param id the id of the Frame
2117      * @param reliefType the type of the relief to set (See ScilabRelief.java)
2118      */
2119     // TODO REMOVE ME (NO MORE USED IN JNI)
2120     public static void setFrameRelief(int id, String reliefType) {
2121         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setRelief(reliefType);
2122     }
2123
2124     /******************/
2125     /*                */
2126     /* TOOLBAR BRIDGE */
2127     /*                */
2128     /******************/
2129
2130     /**
2131      * Set the visibility of a Toolbar
2132      * @param parentUID the parent (figure or console) UID
2133      * @param status true to set the Toolbar visible
2134      */
2135     public static void setToolbarVisible(String parentUID, boolean status) {
2136         SwingScilabTab parentTab = (SwingScilabTab) SwingView.getFromId(parentUID);
2137         if (parentTab != null) {
2138             parentTab.getToolBar().getAsSimpleToolBar().setVisible(status);
2139             BarUpdater.updateBars(parentTab.getParentWindowId(), parentTab.getMenuBar(),
2140                                   parentTab.getToolBar(), parentTab.getInfoBar(), parentTab.getName(), parentTab.getWindowIcon());
2141         }
2142     }
2143
2144     /**
2145      * Get the visibility of a Toolbar
2146      * @param parentUID the parent (figure or console) UID
2147      * @return true to set the Toolbar visible
2148      */
2149     public static boolean isToolbarVisible(String parentUID) {
2150         SwingScilabTab parentTab = (SwingScilabTab) SwingView.getFromId(parentUID);
2151         if (parentTab != null) {
2152             return parentTab.getToolBar().getAsSimpleToolBar().isVisible();
2153         } else {
2154             return false;
2155         }
2156     }
2157
2158     /***********************/
2159     /*                     */
2160     /* EVENTHANDLER BRIDGE */
2161     /*                     */
2162     /***********************/
2163
2164     /**
2165      * Set the event handler of the figure
2166      * @param figNum the figure
2167      * @param command the name of the Scilab function to call
2168      */
2169     // TODO REMOVE ME (NO MORE USED IN JNI)
2170     public static void setEventHandler(int figNum, String command) {
2171         //FigureMapper.getCorrespondingFigure(figNum).getRendererProperties().setEventHandler(command);
2172     }
2173
2174     /**
2175      * Set the status of the event handler of the figure
2176      * @param figNum the figure
2177      * @param status is true to set the event handler active
2178      */
2179     // TODO REMOVE ME (NO MORE USED IN JNI)
2180     public static void setEventHandlerEnabled(int figNum, boolean status) {
2181         //FigureMapper.getCorrespondingFigure(figNum).getRendererProperties().setEventHandlerEnabled(status);
2182     }
2183
2184     /******************/
2185     /*                */
2186     /* WAITBAR BRIDGE */
2187     /*                */
2188     /******************/
2189
2190     /**
2191      * Set the WaitBar message (multi-line)
2192      * @param id the id of the waitBar
2193      * @param message the message of the waitBar
2194      */
2195     // TODO REMOVE ME (NO MORE USED IN JNI)
2196     public static void setWaitBarMessage(int id, String[] message) {
2197         ((WaitBar) UIElementMapper.getCorrespondingUIElement(id)).setMessage(message);
2198     }
2199
2200     /**
2201      * Set the WaitBar value
2202      * @param id the id of the waitBar
2203      * @param value the value of the waitBar
2204      */
2205     // TODO REMOVE ME (NO MORE USED IN JNI)
2206     public static void setWaitBarValue(int id, int value) {
2207         ((WaitBar) UIElementMapper.getCorrespondingUIElement(id)).setValue(value);
2208     }
2209
2210     /**
2211      * Destroy a WaitBar
2212      * @param id the id of the WaitBar to destroy
2213      */
2214     // TODO REMOVE ME (NO MORE USED IN JNI)
2215     public static void destroyWaitBar(int id) {
2216         ((WaitBar) UIElementMapper.getCorrespondingUIElement(id)).close();
2217     }
2218
2219     /**
2220      * Indicates if the total execution time is known
2221      * @param id the id of the WaitBar to destroy
2222      * @param status true if the total progress time in unknown
2223      */
2224     // TODO REMOVE ME (NO MORE USED IN JNI)
2225     public static void setWaitBarIndeterminateMode(int id, boolean status) {
2226         ((WaitBar) UIElementMapper.getCorrespondingUIElement(id)).setIndeterminateMode(status);
2227     }
2228
2229     /**********************/
2230     /*                    */
2231     /* HELPBROWSER BRIDGE */
2232     /*                    */
2233     /**********************/
2234
2235     /**
2236      * Launch Scilab help browser if not already created
2237      * @param helps help chapters and directories
2238      * @param language Scilab current language
2239      */
2240     public static void launchHelpBrowser(String[] helps, String language) {
2241         ScilabHelpBrowser.createHelpBrowser(helps, language);
2242         ScilabHelpBrowser.startHomePage();
2243     }
2244
2245     /**
2246      * Search a keyword in Scilab Help Browser
2247      * @param keyword the keyword to search
2248      * @param helps help chapters and directories
2249      * @param language Scilab current language
2250      * @param fullText true for a full-text search
2251      */
2252     public static void searchKeyword(String[] helps, String keyword, String language, boolean fullText) {
2253         if (fullText) {
2254             HelpBrowser helpBrowser = ScilabHelpBrowser.createHelpBrowser(helps, language);
2255             if (helpBrowser != null) {
2256                 helpBrowser.fullTextSearch(keyword);
2257             }
2258         } else {
2259             HelpBrowser helpBrowser = ScilabHelpBrowser.createHelpBrowser(helps, language);
2260             if (helpBrowser != null) {
2261                 helpBrowser.searchKeywork(keyword);
2262             }
2263         }
2264     }
2265
2266     /**
2267      * Open HelpBrowser on the page with the given xmlID
2268      * @param xmlID the xml id
2269      */
2270     public static void openHelp(String xmlID) {
2271         HelpBrowser helpBrowser = ScilabHelpBrowser.createHelpBrowser(null, ScilabCommons.getlanguage());
2272         if (helpBrowser != null) {
2273             helpBrowser.searchKeywork(xmlID);
2274         }
2275     }
2276
2277     /**
2278      * Close Scilab Help Browser
2279      */
2280     public static void closeHelpBrowser() {
2281         ScilabHelpBrowser.getHelpBrowser().close();
2282     }
2283
2284     /**
2285      * Show search field in Scilab Help Browser
2286      */
2287     public static void showSearchFieldInHelp() {
2288         ScilabHelpBrowser.getHelpBrowser().showSearchField();
2289     }
2290
2291     /**
2292      * Increase the font in the help viewer
2293      */
2294     public static void increaseFontInHelpViewer() {
2295         ScilabHelpBrowser.getHelpBrowser().increaseFont();
2296     }
2297
2298     /**
2299      * Decrease the font in the help viewer
2300      */
2301     public static void decreaseFontInHelpViewer() {
2302         ScilabHelpBrowser.getHelpBrowser().decreaseFont();
2303     }
2304
2305     /************/
2306     /*          */
2307     /* WEBLINKS */
2308     /*          */
2309     /************/
2310
2311     /**
2312      * Open a Browser on Scilab Web Site
2313      */
2314     public static void openScilabWebSite() {
2315         WebBrowser.openUrl("http://www.scilab.org/");
2316     }
2317
2318     /**
2319      * Open a Browser on Wiki Web Site
2320      */
2321     public static void openWiki() {
2322         WebBrowser.openUrl("http://wiki.scilab.org/");
2323     }
2324
2325     /**
2326      * Open a Browser on ATOMS Web Site
2327      */
2328     public static void openAtomsScilab() {
2329         WebBrowser.openUrl("http://atoms.scilab.org/");
2330     }
2331
2332     /**
2333      * Open a Browser on File Exchange Web Site
2334      */
2335     public static void openFileExchange() {
2336         WebBrowser.openUrl("http://fileexchange.scilab.org/");
2337     }
2338
2339     /**
2340      * Open a Browser on Bugzilla Web Site
2341      */
2342     public static void openBugzilla() {
2343         WebBrowser.openUrl("http://bugzilla.scilab.org/");
2344     }
2345
2346     /**
2347      * Open a Browser on Forge Web Site
2348      */
2349     public static void openForge() {
2350         WebBrowser.openUrl("http://forge.scilab.org/");
2351     }
2352
2353     /**
2354      * Open a Browser on Scilab Online Help
2355      */
2356     public static void openOnlineHelp() {
2357         WebBrowser.openUrl("http://help.scilab.org/");
2358     }
2359
2360     /**
2361      * Open a Browser on Mailing List info
2362      */
2363     public static void openMailingList() {
2364         WebBrowser.openUrl("http://www.scilab.org/communities/developer_zone/tools/mailing_list");
2365     }
2366
2367     /**
2368      * Open a Browser on Mailing List Archives
2369      */
2370     public static void openMailingListArchives() {
2371         WebBrowser.openUrl("http://mailinglists.scilab.org/");
2372     }
2373
2374     /**
2375      * Open a Browser on S/E
2376      */
2377     public static void openSE() {
2378         WebBrowser.openUrl("http://www.scilab-enterprises.com/");
2379     }
2380
2381     /***************************/
2382     /*                         */
2383     /* JAVA CALLBACKS FOR GUIS */
2384     /*                         */
2385     /***************************/
2386
2387     /**
2388      * Select all the console contents
2389      */
2390     public static void selectAllConsoleContents() {
2391         ScilabConsole.getConsole().selectAll();
2392     }
2393
2394     /**
2395      * Select all the console contents
2396      */
2397     public static void helpOnTheKeyword() {
2398         ScilabConsole.getConsole().helpOnTheKeyword();
2399     }
2400
2401     /**
2402      * Put the console selected text in the clipboard
2403      */
2404     public static void copyConsoleSelection() {
2405         ScilabConsole.getConsole().copyToClipboard();
2406     }
2407
2408     /**
2409      * Cut the console selected text in the clipboard
2410      */
2411     public static void cutConsoleSelection() {
2412         ScilabConsole.getConsole().cutSelection();
2413     }
2414
2415     /**
2416      * Paste clipboard contents in Console input line
2417      */
2418     public static void pasteClipboardIntoConsole() {
2419         ScilabConsole.getConsole().pasteClipboard();
2420     }
2421
2422     /**
2423      * Make the clipboard contents empty
2424      */
2425     public static void emptyClipboard() {
2426         Transferable contents = new StringSelection("");
2427         Toolkit.getDefaultToolkit().getSystemClipboard().setContents(contents, null);
2428     }
2429
2430     /**
2431      * Evaluate the selection with echo
2432      */
2433     public static void evaluateSelectionWithEcho() {
2434         ScilabConsole.getConsole().evaluateSelectionWithEcho();
2435     }
2436
2437     /**
2438      * Evaluate the selection with no echo
2439      */
2440     public static void evaluateSelectionWithNoEcho() {
2441         ScilabConsole.getConsole().evaluateSelectionWithNoEcho();
2442     }
2443
2444     /**
2445      * Opens a dialog to selected a new font for the console
2446      */
2447     public static void changeConsoleFont() {
2448         FontChooser fontChooser = ScilabFontChooser.createFontChooser(ScilabConsole.getConsole().getFont());
2449         fontChooser.displayAndWait();
2450
2451         Font selectedFont = fontChooser.getSelectedFont();
2452
2453         if (selectedFont != null) {
2454             /* Change console font */
2455             ScilabConsole.getConsole().setFont(selectedFont);
2456
2457             /* Save new settings */
2458             ConfigManager.saveFont(selectedFont);
2459         }
2460     }
2461
2462     /**
2463      * Unblock the console if it is in "Continue display..." mode
2464      */
2465     public static void unblockConsole() {
2466         SwingScilabConsole sciConsole = ((SwingScilabConsole) ScilabConsole.getConsole().getAsSimpleConsole());
2467         sciConsole.unblock();
2468     }
2469
2470     /**
2471      * Opens a dialog to selected a new Foreground Color for the console
2472      */
2473     public static void changeConsoleForeground() {
2474         ColorChooser colorChooser = ScilabColorChooser.createColorChooser(ScilabConsole.getConsole().getForeground());
2475         colorChooser.setTitle(Messages.gettext("Console Font..."));
2476         colorChooser.displayAndWait();
2477
2478         Color selectedColor = colorChooser.getSelectedColor();
2479
2480         if (selectedColor != null) {
2481             /* Change console foreground */
2482             ScilabConsole.getConsole().setForeground(selectedColor);
2483
2484             /* Save new settings */
2485             ConfigManager.saveConsoleForeground(selectedColor);
2486         }
2487     }
2488
2489     /**
2490      * Opens a dialog to selected a new Background Color for the console
2491      */
2492     public static void changeConsoleBackground() {
2493         ColorChooser colorChooser = ScilabColorChooser.createColorChooser(ScilabConsole.getConsole().getBackground());
2494         colorChooser.setTitle(Messages.gettext("Console Background..."));
2495         colorChooser.displayAndWait();
2496
2497         Color selectedColor = colorChooser.getSelectedColor();
2498
2499         if (selectedColor != null) {
2500             /* Change console background */
2501             ScilabConsole.getConsole().setBackground(selectedColor);
2502
2503             /* Save new settings */
2504             ConfigManager.saveConsoleBackground(selectedColor);
2505         }
2506     }
2507
2508     /**
2509      * Display a dialog to print the console text contents
2510      */
2511     public static void printConsoleContents() {
2512
2513         SciConsole scilabConsole = ((SciConsole) ScilabConsole.getConsole().getAsSimpleConsole());
2514         Document doc = ((JEditorPane) scilabConsole.getConfiguration().getOutputView()).getDocument();
2515         String textToPrint = null;
2516
2517         /* Text selected in the input */
2518         String strInputSelected = ((JTextPane) scilabConsole.getConfiguration().getInputCommandView()).getSelectedText();
2519         /* Text selected in the output */
2520         String strOutputSelected = ((JEditorPane) scilabConsole.getConfiguration().getOutputView()).getSelectedText();
2521
2522         try {
2523             textToPrint = doc.getText(0, doc.getLength());
2524         } catch (BadLocationException e) {
2525             e.printStackTrace();
2526         }
2527         if (strInputSelected != null) {
2528             printString(strInputSelected, new String(CONSOLE));
2529         } else if (strOutputSelected != null) {
2530             printString(strOutputSelected, new String(CONSOLE));
2531         } else {
2532             printString(textToPrint, new String(CONSOLE));
2533         }
2534     }
2535
2536     /**
2537      * Print a character string
2538      * @param theString the string to print
2539      * @param pageHeader header for printed pages
2540      * @return execution status
2541      */
2542     public static boolean printString(String theString, String pageHeader) {
2543         return PrinterHelper.printString(theString, pageHeader);
2544     }
2545
2546     /**
2547      * Display a dialog to print a file
2548      * @param fileName the name of the file
2549      * @return execution status
2550      */
2551     public static boolean printFile(String fileName) {
2552         return PrinterHelper.printFile(fileName);
2553     }
2554
2555     /**
2556      * Display a dialog to print a figure (Called from graphics figures menus)
2557      * @param figID the ID of the figure to print
2558      * @return execution status
2559      */
2560     public static boolean printFigure(String figID) {
2561         return printFigure(figID, true, true);
2562     }
2563
2564     /**
2565      * Display a dialog to print a figure
2566      * @param figID the ID of the figure to print
2567      * @param postScript true to print in postscript mode
2568      * @param displayDialog true to display a print setup dialog
2569      * @return execution status
2570      */
2571     public static boolean printFigure(String figID, boolean postScript, boolean displayDialog) {
2572         // Get the PrinterJob object
2573         PrinterJob printerJob = PrinterJob.getPrinterJob();
2574
2575         boolean userOK = true;
2576         if (displayDialog) {
2577             userOK = printerJob.printDialog(scilabPageFormat);
2578         }
2579
2580         if (userOK) {
2581             //If the OS is Windows
2582             if (isWindowsPlateform()) {
2583                 Figure figure = (Figure) GraphicController.getController().getObjectFromId(figID);
2584                 int figureID = figure.getId();
2585                 SwingScilabCanvas canvas;
2586                 canvas = ((SwingScilabTab) SwingView.getFromId(figID)).getContentCanvas();
2587                 ScilabPrint scilabPrint = new ScilabPrint(canvas.dumpAsBufferedImage(), printerJob, scilabPageFormat);
2588                 if (scilabPrint != null) {
2589                     return true;
2590                 } else {
2591                     return false;
2592                 }
2593
2594                 //If the OS is Linux
2595             } else {
2596                 DocFlavor printDocFlavor = DocFlavor.INPUT_STREAM.POSTSCRIPT;
2597                 String fileExtension = ".ps";
2598
2599                 try {
2600                     String tmpPrinterFile = File.createTempFile("scilabfigure", "").getAbsolutePath();
2601                     // Export image to PostScript
2602                     if (((PrintRequestAttribute) scilabPageFormat.get(OrientationRequested.class)) == OrientationRequested.PORTRAIT) {
2603                         FileExporter.fileExport(figID,
2604                                                 tmpPrinterFile + fileExtension,
2605                                                 "PS", 1, 0); // 1 is the quality. Useless in this context
2606                     } else {
2607                         FileExporter.fileExport(figID,
2608                                                 tmpPrinterFile + fileExtension,
2609                                                 "PS", 1, 1); // 1 is the quality. Useless in this context
2610                     }
2611
2612                     // Read file
2613                     FileInputStream psStream = null;
2614
2615                     try {
2616                         psStream = new FileInputStream(tmpPrinterFile + fileExtension);
2617                     } catch (FileNotFoundException ffne) {
2618                         ffne.printStackTrace();
2619                         return false;
2620                     }
2621
2622                     Doc myDoc = new SimpleDoc(psStream, printDocFlavor, null);
2623                     PrintService printService = printerJob.getPrintService();
2624
2625                     if (printService == null) {
2626                         // Could not find the print service
2627                         MessageBox messageBox = ScilabMessageBox.createMessageBox();
2628                         messageBox.setMessage(Messages.gettext("No print service found."));
2629                         messageBox.setModal(true);
2630                         messageBox.setIcon("error");
2631                         messageBox.displayAndWait();
2632                         return false;
2633                     }
2634                     DocPrintJob job = printService.createPrintJob();
2635
2636                     // Remove Orientation option from page setup because already managed in FileExporter
2637                     PrintRequestAttributeSet aset = new HashPrintRequestAttributeSet(scilabPageFormat);
2638                     aset.add(OrientationRequested.PORTRAIT);
2639                     job.print(myDoc, aset);
2640                     return true;
2641                 } catch (IOException e) {
2642                     System.err.println("Could not create temporary file " + e.getLocalizedMessage());
2643                     return false;
2644                 } catch (PrintException e) {
2645                     e.printStackTrace();
2646                     return false;
2647                 }
2648             }
2649         }
2650         return false;
2651     }
2652
2653     /**
2654      * Display a page setup dialog for printing
2655      * @return true if the user clicked the OK button
2656      */
2657     public static boolean pageSetup() {
2658         // Get the PrinterJob object
2659         PrinterJob job = PrinterJob.getPrinterJob();
2660
2661         // Get the default page format, then allow the user to modify it
2662         return (job.pageDialog(scilabPageFormat) != null);
2663     }
2664
2665     /***********************/
2666     /*                     */
2667     /* FONT CHOOSER BRIDGE */
2668     /*                     */
2669     /***********************/
2670
2671     /**
2672      * Set the default font name for a FileChooser
2673      * @param id the id of the FileChooser
2674      * @param fontName the name of the font
2675      */
2676     public static void setFontChooserFontName(int id, String fontName) {
2677         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultFontName(fontName);
2678     }
2679
2680     /**
2681      * Set the default font size for a FileChooser
2682      * @param id the id of the FileChooser
2683      * @param fontSize the size of the font
2684      */
2685     public static void setFontChooserFontSize(int id, int fontSize) {
2686         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultFontSize(fontSize);
2687     }
2688
2689     /**
2690      * Set the default bold attribute for a FileChooser
2691      * @param id the id of the FileChooser
2692      * @param bold the bold attribute of the font
2693      */
2694     public static void setFontChooserBold(int id, boolean bold) {
2695         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultBold(bold);
2696     }
2697
2698     /**
2699      * Set the default italic attribute for a FileChooser
2700      * @param id the id of the FileChooser
2701      * @param italic the italic attribute of the font
2702      */
2703     public static void setFontChooserItalic(int id, boolean italic) {
2704         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultItalic(italic);
2705     }
2706
2707     /**
2708      * Get the selected font name for a FileChooser
2709      * @param id the id of the FileChooser
2710      * @return the name of the font
2711      */
2712     public static String getFontChooserFontName(int id) {
2713         Font selectedFont = ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedFont();
2714         if (selectedFont != null) {
2715             return selectedFont.getFamily();
2716         } else {
2717             return "";
2718         }
2719     }
2720
2721     /**
2722      * Get the selected font size for a FileChooser
2723      * @param id the id of the FileChooser
2724      * @return the size of the font
2725      */
2726     public static int getFontChooserFontSize(int id) {
2727         return ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedFont().getSize();
2728     }
2729
2730     /**
2731      * Get the selected bold attribute for a FileChooser
2732      * @param id the id of the FileChooser
2733      * @return the bold attribute of the font
2734      */
2735     public static boolean getFontChooserBold(int id) {
2736         return ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedFont().isBold();
2737     }
2738
2739     /**
2740      * Get the selected italic attribute for a FileChooser
2741      * @param id the id of the FileChooser
2742      * @return the italic attribute of the font
2743      */
2744     public static boolean getFontChooserItalic(int id) {
2745         return ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedFont().isItalic();
2746     }
2747
2748     /**
2749      * Display this chooser and wait for user selection
2750      * @param id the id of the FontChooser
2751      */
2752     public static void fontChooserDisplayAndWait(int id) {
2753         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).displayAndWait();
2754     }
2755
2756     /************************/
2757     /*                      */
2758     /* COLOR CHOOSER BRIDGE */
2759     /*                      */
2760     /************************/
2761
2762     /**
2763      * Set the title of a ColorChooser
2764      * @param id the id of the ColorChooser
2765      * @param title the title
2766      */
2767     public static void setColorChooserTitle(int id, String title) {
2768         ((ColorChooser) UIElementMapper.getCorrespondingUIElement(id)).setTitle(title);
2769     }
2770
2771     /**
2772      * Set the default Color for a ColorChooser
2773      * @param id the id of the ColorChooser
2774      * @param rgb the default color
2775      */
2776     public static void setColorChooserDefaultColor(int id, int[] rgb) {
2777         ((ColorChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultColor(new Color(rgb[0], rgb[1], rgb[2]));
2778     }
2779
2780     /**
2781      * Get the selected Color for a ColorChooser
2782      * @param id the id of the ColorChooser
2783      * @return the selected color
2784      */
2785     public static int[] getColorChooserSelectedColor(int id) {
2786         Color selectedColor = ((ColorChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedColor();
2787         int[] returnedValues = new int[NB_COLORS];
2788         if (selectedColor != null) {
2789             returnedValues[0] = selectedColor.getRed();
2790             returnedValues[1] = selectedColor.getGreen();
2791             returnedValues[2] = selectedColor.getBlue();
2792         } else {
2793             returnedValues[0] = -1;
2794             returnedValues[1] = -1;
2795             returnedValues[2] = -1;
2796         }
2797         return returnedValues;
2798
2799     }
2800
2801     /**
2802      * Display this chooser and wait for user selection
2803      * @param id the id of the ColorChooser
2804      */
2805     public static void colorChooserDisplayAndWait(int id) {
2806         ((ColorChooser) UIElementMapper.getCorrespondingUIElement(id)).displayAndWait();
2807     }
2808
2809     /******************/
2810     /*                */
2811     /* WIDGET VISIBLE */
2812     /*                */
2813     /******************/
2814
2815     /**
2816      * Set the visibility of the Widget
2817      * @param id the id of the Widget
2818      * @param status the new status
2819      */
2820     // TODO REMOVE ME (NO MORE USED IN JNI)
2821     public static void setWidgetVisible(int id, boolean status) {
2822         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setVisible(status);
2823     }
2824
2825     /**
2826      * Set the visibility of the Frame
2827      * @param id the id of the Frame
2828      * @param status the new status
2829      */
2830     // TODO REMOVE ME (NO MORE USED IN JNI)
2831     public static void setFrameVisible(int id, boolean status) {
2832         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setVisible(status);
2833     }
2834
2835     /**
2836      * Get the visibility of the Widget
2837      * @param id the id of the Widget
2838      * @return the status
2839      */
2840     // TODO REMOVE ME (NO MORE USED IN JNI)
2841     public static boolean isWidgetVisible(int id) {
2842         return ((Widget) UIElementMapper.getCorrespondingUIElement(id)).isVisible();
2843     }
2844
2845     /**
2846      * Get the visibility of the Frame
2847      * @param id the id of the Frame
2848      * @return the status
2849      */
2850     // TODO REMOVE ME (NO MORE USED IN JNI)
2851     public static boolean isFrameVisible(int id) {
2852         return ((Frame) UIElementMapper.getCorrespondingUIElement(id)).isVisible();
2853     }
2854
2855     /*****************/
2856     /*               */
2857     /* WIDGET ENABLE */
2858     /*               */
2859     /*****************/
2860
2861     /**
2862      * Set the enable of the Widget
2863      * @param id the id of the Widget
2864      * @param status the new status
2865      */
2866     // TODO REMOVE ME (NO MORE USED IN JNI)
2867     public static void setWidgetEnable(int id, boolean status) {
2868         ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setEnabled(status);
2869     }
2870
2871     /**
2872      * Set the enable of the Frame
2873      * @param id the id of the Frame
2874      * @param status the new status
2875      */
2876     // TODO REMOVE ME (NO MORE USED IN JNI)
2877     public static void setFrameEnable(int id, boolean status) {
2878         ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setEnabled(status);
2879     }
2880
2881     /**
2882      * Get the enable of the Widget
2883      * @param id the id of the Widget
2884      * @return the status
2885      */
2886     // TODO REMOVE ME (NO MORE USED IN JNI)
2887     public static boolean isWidgetEnable(int id) {
2888         return ((Widget) UIElementMapper.getCorrespondingUIElement(id)).isEnabled();
2889     }
2890
2891     /**
2892      * Get the visibility of the Frame
2893      * @param id the id of the Frame
2894      * @return the status
2895      */
2896     // TODO REMOVE ME (NO MORE USED IN JNI)
2897     public static boolean isFrameEnable(int id) {
2898         return ((Frame) UIElementMapper.getCorrespondingUIElement(id)).isEnabled();
2899     }
2900
2901     /****************/
2902     /*              */
2903     /* MENU CHECKED */
2904     /*              */
2905     /****************/
2906
2907     /**
2908      * Set the Checked status of the Menu
2909      * @param id the id of the Menu
2910      * @param status the new status
2911      */
2912     // TODO REMOVE ME (NO MORE USED IN JNI)
2913     public static void setMenuChecked(int id, boolean status) {
2914         if (UIElementMapper.getCorrespondingUIElement(id) instanceof CheckBoxMenuItem) {
2915             ((CheckBoxMenuItem) UIElementMapper.getCorrespondingUIElement(id)).setChecked(status);
2916         } else if (UIElementMapper.getCorrespondingUIElement(id) instanceof MenuItem) {
2917             ((MenuItem) UIElementMapper.getCorrespondingUIElement(id)).setChecked(status);
2918         } else {
2919             ((Menu) UIElementMapper.getCorrespondingUIElement(id)).setChecked(status);
2920         }
2921     }
2922
2923     /**
2924      * Get the Checked status of the Menu
2925      * @param id the id of the Menu
2926      * @return the status
2927      */
2928     // TODO REMOVE ME (NO MORE USED IN JNI)
2929     public static boolean isMenuChecked(int id) {
2930         return ((Menu) UIElementMapper.getCorrespondingUIElement(id)).isChecked();
2931     }
2932
2933     /************************/
2934     /*                      */
2935     /* CLIPBOARD MANAGEMENT */
2936     /*                      */
2937     /************************/
2938
2939     /**
2940      * Get the contents of the clipboard
2941      * @return the string contained in the clipboard or null
2942      */
2943     public static String getClipboardContents() {
2944         // Gets the contents of the clipboard
2945         Toolkit toolkit = Toolkit.getDefaultToolkit();
2946         Clipboard systemClipboard = toolkit.getSystemClipboard();
2947         String clipboardContents = "";
2948
2949         // Verify that clibpboard data is of text type
2950         boolean dataAvailable;
2951         try {
2952             dataAvailable = systemClipboard.isDataFlavorAvailable(DataFlavor.stringFlavor);
2953         } catch (IllegalStateException exception) {
2954             return clipboardContents;
2955         }
2956
2957         // Exit if text data not available
2958         if (!dataAvailable) {
2959             return clipboardContents;
2960         }
2961
2962         // Read data
2963         try {
2964             clipboardContents = (String) systemClipboard.getData(DataFlavor.stringFlavor);
2965         } catch (UnsupportedFlavorException e1) {
2966             // Should never be here
2967             e1.printStackTrace();
2968         } catch (IOException e1) {
2969             // Should never be here
2970             e1.printStackTrace();
2971         }
2972
2973         return clipboardContents;
2974     }
2975
2976     /**
2977      * Set the contents of the clipboard
2978      * @param text the string to put in the clipboard
2979      */
2980     public static void setClipboardContents(String text) {
2981         Transferable contents = new StringSelection(text);
2982         Toolkit.getDefaultToolkit().getSystemClipboard().setContents(contents, null);
2983     }
2984
2985     /**
2986      * Copy figure to clipboard
2987      * @param figID the ID of the figure
2988      */
2989     public static void copyFigureToClipBoard(int figID) {
2990         Image figureImage = ImageExporter.imageExport(figID);
2991         Transferable clipboardImage = new ClipboardImage(figureImage);
2992         Toolkit.getDefaultToolkit().getSystemClipboard().setContents(clipboardImage, null);
2993     }
2994
2995     /**
2996      * Class used to store Images in the clipboard
2997      */
2998     public static class ClipboardImage implements Transferable {
2999         private final Image image;
3000
3001         /**
3002          * Default constructor
3003          * @param image the image
3004          */
3005         public ClipboardImage(Image image) {
3006             this.image = image;
3007         }
3008
3009         /**
3010          * DataFlavors of this transferable
3011          * @return the DataFlavors accepeted
3012          */
3013         @Override
3014         public DataFlavor[] getTransferDataFlavors() {
3015             return new DataFlavor[] {DataFlavor.imageFlavor};
3016         }
3017
3018         /**
3019          * Test supproted DataFlavors
3020          * @param flavor the flavor to test
3021          * @return true if the flavor is supported
3022          */
3023         @Override
3024         public boolean isDataFlavorSupported(DataFlavor flavor) {
3025             return DataFlavor.imageFlavor.equals(flavor);
3026         }
3027
3028         /**
3029          * Get the contents of this transferable
3030          * @param flavor the flavor to test
3031          * @return the contents
3032          * @throws UnsupportedFlavorException if the flavor is not supported by this transferable
3033          */
3034         @Override
3035         public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException {
3036             if (!DataFlavor.imageFlavor.equals(flavor)) {
3037                 throw new UnsupportedFlavorException(flavor);
3038             }
3039             return image;
3040         }
3041     }
3042
3043     /********/
3044     /*      */
3045     /* MISC */
3046     /*      */
3047     /********/
3048
3049     /**
3050      * Get the screen resolution
3051      * @return the number of dot per inch
3052      */
3053     public static int getScreenResolution() {
3054         return Toolkit.getDefaultToolkit().getScreenResolution();
3055     }
3056
3057     /**
3058      * Get the screen Width in pixels
3059      * @return the screen Width
3060      */
3061     public static double getScreenWidth() {
3062         return Toolkit.getDefaultToolkit().getScreenSize().getWidth();
3063     }
3064
3065     /**
3066      * Get the screen Height in pixels
3067      * @return the screen Height
3068      */
3069     public static double getScreenHeight() {
3070         return Toolkit.getDefaultToolkit().getScreenSize().getHeight();
3071     }
3072
3073     /**
3074      * Get the screen Depth
3075      * @return the screen Depth
3076      */
3077     public static int getScreenDepth() {
3078         return Toolkit.getDefaultToolkit().getColorModel().getPixelSize();
3079     }
3080
3081     /**
3082      * Give the focus to a uicontrol
3083      * @param uicontrolUID the uicontrolUID of the Widget
3084      */
3085     public static void requestFocus(String uicontrolUID) {
3086         SwingViewObject uicontrol = SwingView.getFromId(uicontrolUID);
3087         if (uicontrol instanceof SwingScilabFrame) {
3088             ((SwingScilabFrame) uicontrol).requestFocus();
3089         } else {
3090             ((Widget) uicontrol).requestFocus();
3091         }
3092
3093     }
3094
3095     /**
3096      * Raise the window specified by the user
3097      * @param id the id of the figure
3098      */
3099     public static void raiseWindow(int id) {
3100         /*((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(id).getRendererProperties()).getParentTab().getParentWindow().raise();
3101         ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(id).getRendererProperties()).getParentTab().setCurrent();*/
3102     }
3103
3104     /**
3105      * @return true if the os is windows, false otherwise
3106      */
3107     public static boolean isWindowsPlateform() {
3108         // get os name
3109         return System.getProperty("os.name").toLowerCase().contains("windows");
3110     }
3111
3112     /**
3113      * Change object used for graphic figure (GLCanvas or GLJPanel)
3114      * @param onOrOff true to set GLCanvas display
3115      */
3116     public static void useCanvasForDisplay(boolean onOrOff) {
3117         SwingScilabCanvasImpl.switchToGLCanvas(onOrOff);
3118     }
3119
3120     /**
3121      * Get object used for graphic figure (GLCanvas or GLJPanel)
3122      * @return true if GLCanvas display is set
3123      */
3124     public static boolean useCanvasForDisplay() {
3125         return SwingScilabCanvasImpl.isGLCanvasEnabled();
3126     }
3127
3128     /**
3129      * Display Scilab about box
3130      */
3131     public static void scilabAboutBox() {
3132         ScilabAboutBox.displayAndWait();
3133     }
3134
3135     /******************/
3136     /*                */
3137     /* UITABLE BRIDGE */
3138     /*                */
3139     /******************/
3140
3141     /**
3142      * Sets the column names for the uitable
3143      */
3144     // TODO REMOVE ME (NO MORE USED IN JNI)
3145     public static void setUiTableColnames(int id, String text) {
3146         //((UiTable) UIElementMapper.getCorrespondingUIElement(id)).setColnames(text);
3147     }
3148
3149     /**
3150      * Sets the row names for the uitable
3151      */
3152     // TODO REMOVE ME (NO MORE USED IN JNI)
3153     public static void setUiTableRownames(int id, String text) {
3154         //((UiTable) UIElementMapper.getCorrespondingUIElement(id)).setRownames(text);
3155     }
3156
3157     /**
3158      * Sets the data for the uitable
3159      */
3160     // TODO REMOVE ME (NO MORE USED IN JNI)
3161     public static void setUiTableData(int id, String text) {
3162         ((UiTable) UIElementMapper.getCorrespondingUIElement(id)).setData(text);
3163     }
3164
3165     /******************/
3166     /*                */
3167     /* UITABLE BRIDGE */
3168     /*                */
3169     /******************/
3170
3171     // TODO REMOVE ME (NO MORE USED IN JNI)
3172     public static void setUiTreeData(int id, String[] text) {
3173         ((UiDisplayTree) UIElementMapper.getCorrespondingUIElement(id)).setData(text);
3174     }
3175
3176     public static void fireClosingFinished(String figUID) {
3177         SwingScilabTab parentTab = (SwingScilabTab) SwingView.getFromId(figUID);
3178         ClosingOperationsManager.removeFromDunnoList(parentTab);
3179     }
3180 }