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