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