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