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