New Java Help Browser for Scilab.
[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 - INRIA - Vincent COUVERT
4  * 
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at    
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13
14 package org.scilab.modules.gui.bridge;
15
16 import java.awt.Color;
17 import java.awt.Font;
18
19 import org.scilab.modules.gui.checkbox.CheckBox;
20 import org.scilab.modules.gui.checkbox.ScilabCheckBox;
21 import org.scilab.modules.gui.console.ScilabConsole;
22 import org.scilab.modules.gui.contextmenu.ContextMenu;
23 import org.scilab.modules.gui.contextmenu.ScilabContextMenu;
24 import org.scilab.modules.gui.editbox.EditBox;
25 import org.scilab.modules.gui.editbox.ScilabEditBox;
26 import org.scilab.modules.gui.events.callback.CallBack;
27 import org.scilab.modules.gui.filechooser.FileChooser;
28 import org.scilab.modules.gui.filechooser.ScilabFileChooser;
29 import org.scilab.modules.gui.frame.Frame;
30 import org.scilab.modules.gui.frame.ScilabFrame;
31 import org.scilab.modules.gui.graphicWindow.ScilabRendererProperties;
32 import org.scilab.modules.gui.helpbrowser.ScilabHelpBrowser;
33 import org.scilab.modules.gui.label.Label;
34 import org.scilab.modules.gui.label.ScilabLabel;
35 import org.scilab.modules.gui.listbox.ListBox;
36 import org.scilab.modules.gui.listbox.ScilabListBox;
37 import org.scilab.modules.gui.menu.Menu;
38 import org.scilab.modules.gui.menu.ScilabMenu;
39 import org.scilab.modules.gui.menubar.MenuBar;
40 import org.scilab.modules.gui.menubar.ScilabMenuBar;
41 import org.scilab.modules.gui.menuitem.MenuItem;
42 import org.scilab.modules.gui.menuitem.ScilabMenuItem;
43 import org.scilab.modules.gui.messagebox.MessageBox;
44 import org.scilab.modules.gui.messagebox.ScilabMessageBox;
45 import org.scilab.modules.gui.popupmenu.PopupMenu;
46 import org.scilab.modules.gui.popupmenu.ScilabPopupMenu;
47 import org.scilab.modules.gui.pushbutton.PushButton;
48 import org.scilab.modules.gui.pushbutton.ScilabPushButton;
49 import org.scilab.modules.gui.radiobutton.RadioButton;
50 import org.scilab.modules.gui.radiobutton.ScilabRadioButton;
51 import org.scilab.modules.gui.slider.ScilabSlider;
52 import org.scilab.modules.gui.slider.Slider;
53 import org.scilab.modules.gui.tab.Tab;
54 import org.scilab.modules.gui.utils.Position;
55 import org.scilab.modules.gui.utils.ScilabRelief;
56 import org.scilab.modules.gui.utils.Size;
57 import org.scilab.modules.gui.utils.UIElementMapper;
58 import org.scilab.modules.gui.waitbar.ScilabWaitBar;
59 import org.scilab.modules.gui.waitbar.WaitBar;
60 import org.scilab.modules.gui.widget.Widget;
61 import org.scilab.modules.gui.window.ScilabWindow;
62 import org.scilab.modules.gui.window.Window;
63 import org.scilab.modules.renderer.FigureMapper;
64
65 /**
66  * This class is used to call Scilab GUIs objects from Scilab
67  * @author Vincent COUVERT
68  */
69 public class CallScilabBridge {
70         
71         private static final int NB_COLORS = 3;
72         
73         private static final int POSITION_SIZE = 4;
74         
75         private static final int X_INDEX = 0;
76         private static final int Y_INDEX = 1;
77         private static final int WIDTH_INDEX = 2;
78         private static final int HEIGHT_INDEX = 3;
79         
80         private static final String NORMALFONT = "normal";
81         private static final String OBLIQUEFONT = "oblique";
82         private static final String ITALICFONT = "italic";
83         private static final String BOLDFONT = "bold";
84         private static final int DEFAULTFONTSIZE = 12;
85         private static final String DEFAULTFONTNAME = "helvetica";
86
87         private static final double DEFAULT_RED_BACKGROUND = 0.8 * 255;
88         private static final double DEFAULT_GREEN_BACKGROUND = 0.8 * 255;
89         private static final double DEFAULT_BLUE_BACKGROUND = 0.8 * 255;
90         
91         private static final double BUTTON_RED_BACKGROUND = 0.6 * 255;
92         private static final double BUTTON_GREEN_BACKGROUND = 0.6 * 255;
93         private static final double BUTTON_BLUE_BACKGROUND = 0.6 * 255;
94         
95         private static final double DEFAULT_RED_FOREGROUND = 0;
96         private static final double DEFAULT_GREEN_FOREGROUND = 0;
97         private static final double DEFAULT_BLUE_FOREGROUND = 0;
98         /**
99          * Constructor
100          */
101         protected CallScilabBridge() {
102                 throw new UnsupportedOperationException(); /* Prevents calls from subclass */
103         }
104         
105         /******************/
106         /*                */  
107         /* CONSOLE BRIDGE */
108         /*                */  
109         /******************/
110         
111         /**
112          * Read a line from the Console
113          * @return the line read
114          */
115         public static String readLine() {
116                 return ScilabConsole.getConsole().readLine();
117         }
118         
119         /**
120          * Display a line in the Console
121          * @param dataToDisplay the line to display
122          */
123         public static void display(String dataToDisplay) {
124                 ScilabConsole.getConsole().display(dataToDisplay);
125         }
126         
127         /**
128          * Get the status of the Console
129          * @return true if the console is at the prompt
130          */
131         public static boolean isWaitingForInput() {
132                 return ScilabConsole.getConsole().isWaitingForInput();
133         }
134
135         /**
136          * Update the number of lines and columns that Scilab use to format data to display
137          */
138         public static void scilabLinesUpdate() {
139                 ScilabConsole.getConsole().scilabLinesUpdate();
140         }
141         
142         /**
143          * Clear the Console
144          */
145         public static void clear() {
146                 ScilabConsole.getConsole().clear();
147         }
148         
149         /**
150          * Clear some lines in the Console
151          * @param nbLines the number of lines to clear
152          */
153         public static void clear(int nbLines) {
154                 ScilabConsole.getConsole().clear(nbLines);
155         }
156         
157         /**
158          * Get a char to know if the user wants more data to be displayed
159          * @return the user answer
160          */
161         public static int getCharWithoutOutput() {
162                 return ScilabConsole.getConsole().getAsSimpleConsole().getCharWithoutOutput();
163         }
164         
165         /**
166          * Put the prompt on the top left corner
167          */
168         public static void toHome() {
169                 ScilabConsole.getConsole().toHome();
170         }
171         
172         /**
173          * Set the contents of the prompt
174          * @param prompt the content to set (default is -->)
175          */
176         public static void setPrompt(String prompt) {
177                 ScilabConsole.getConsole().setPrompt(prompt);
178         }
179         
180         /**
181          * Clear the commands history 
182          */
183         public static void clearHistory() {
184                 ScilabConsole.getConsole().clearHistory();
185         }
186
187         /**************************/
188         /*                        */
189         /* OBJECT CREATION BRIDGE */
190         /*                        */
191         /**************************/
192         
193         /**
194          * Create a new Window in Scilab GUIs
195          * @return the ID of the window in the UIElementMapper
196          */
197         public static int newWindow() {
198                 Window window = ScilabWindow.createWindow();
199                 return UIElementMapper.add(window);
200         }
201
202         /**
203          * Create a new Menubar in Scilab GUIs
204          * @return the ID of the Menubar in the UIElementMapper
205          */
206         public static int newMenuBar() {
207                 MenuBar menuBar = ScilabMenuBar.createMenuBar();
208                 return UIElementMapper.add(menuBar);
209         }
210
211         /**
212          * Create a new Menu in Scilab GUIs
213          * @return the ID of the menu in the UIElementMapper
214          */
215         public static int newMenu() {
216                 MenuItem menuItem = ScilabMenuItem.createMenuItem();
217                 return UIElementMapper.add(menuItem);
218         }
219         
220         /**
221          * Create a new ContextMenu in Scilab GUIs
222          * @return the ID of the ContextMenu in the UIElementMapper
223          */
224         public static int newContextMenu() {
225                 ContextMenu contextMenu = ScilabContextMenu.createContextMenu();
226                 return UIElementMapper.add(contextMenu);
227         }
228         
229         /**
230          * Create a new File Chooser in Scilab GUIs
231          * @return the ID of the File Chooser in the UIElementMapper
232          */
233         public static int newFileChooser() {
234                 FileChooser fileChooser = ScilabFileChooser.createFileChooser();
235                 return UIElementMapper.add(fileChooser);
236         }
237         
238         /**
239          * Create a new MessageBox in Scilab GUIs
240          * @return the ID of the MessageBox in the UIElementMapper
241          */
242         public static int newMessageBox() {
243                 MessageBox messageBox = ScilabMessageBox.createMessageBox();
244                 return UIElementMapper.add(messageBox);
245         }
246         
247         /**
248          * Create a new WaitBar in Scilab GUIs
249          * @return the ID of the WaitBar in the UIElementMapper
250          */
251         public static int newWaitBar() {
252                 WaitBar waitBar = ScilabWaitBar.createWaitBar();
253                 return UIElementMapper.add(waitBar);
254         }
255         
256         /**
257          * Create a new PushButton in Scilab GUIs
258          * @return the ID of the PushButton in the UIElementMapper
259          */
260         public static int newPushButton() {
261                 PushButton pushButton = ScilabPushButton.createPushButton();
262                 int id = UIElementMapper.add(pushButton);
263                 
264                 /* Default font */
265                 setWidgetFontName(id, DEFAULTFONTNAME);
266                 setWidgetFontWeight(id, NORMALFONT);
267                 setWidgetFontSize(id, DEFAULTFONTSIZE);
268                 
269                 setWidgetRelief(id, ScilabRelief.RAISED);
270                 
271                 /* Default colors */
272                 setWidgetBackgroundColor(id, (int) BUTTON_RED_BACKGROUND, (int) BUTTON_GREEN_BACKGROUND, (int) BUTTON_BLUE_BACKGROUND);
273                 setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
274                 return id;
275         }
276
277         /**
278          * Create a new EditBox in Scilab GUIs
279          * @return the ID of the Edit in the UIElementMapper
280          */
281         public static int newEditBox() {
282                 EditBox editBox = ScilabEditBox.createEditBox();
283                 int id = UIElementMapper.add(editBox);
284                 
285                 /* Default font */
286                 setWidgetFontName(id, DEFAULTFONTNAME);
287                 setWidgetFontWeight(id, NORMALFONT);
288                 setWidgetFontSize(id, DEFAULTFONTSIZE);
289                 
290                 setWidgetRelief(id, ScilabRelief.SUNKEN);
291                 
292                 /* Default colors */
293                 setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
294                 setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
295                 return id;
296         }
297
298         /**
299          * Create a new Label in Scilab GUIs
300          * @return the ID of the Label in the UIElementMapper
301          */
302         public static int newLabel() {
303                 Label label = ScilabLabel.createLabel();
304                 int id = UIElementMapper.add(label);
305                 
306                 /* Default font */
307                 setWidgetFontName(id, DEFAULTFONTNAME);
308                 setWidgetFontWeight(id, NORMALFONT);
309                 setWidgetFontSize(id, DEFAULTFONTSIZE);
310                 
311                 setWidgetRelief(id, ScilabRelief.FLAT);
312                 
313                 /* Default colors */
314                 setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
315                 setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
316                 return id;
317         }
318
319         /**
320          * Create a new CheckBox in Scilab GUIs
321          * @return the ID of the CheckBox in the UIElementMapper
322          */
323         public static int newCheckBox() {
324                 CheckBox checkBox = ScilabCheckBox.createCheckBox();
325                 int id = UIElementMapper.add(checkBox);
326                 
327                 /* Default font */
328                 setWidgetFontName(id, DEFAULTFONTNAME);
329                 setWidgetFontWeight(id, NORMALFONT);
330                 setWidgetFontSize(id, DEFAULTFONTSIZE);
331
332                 setWidgetRelief(id, ScilabRelief.FLAT);
333                 
334                 /* Default colors */
335                 setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
336                 setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
337                 return id;
338         }
339
340         /**
341          * Create a new RadioButton in Scilab GUIs
342          * @return the ID of the RadioButton in the UIElementMapper
343          */
344         public static int newRadioButton() {
345                 RadioButton radioButton = ScilabRadioButton.createRadioButton();
346                 int id = UIElementMapper.add(radioButton);
347
348                 /* Default font */
349                 setWidgetFontName(id, DEFAULTFONTNAME);
350                 setWidgetFontWeight(id, NORMALFONT);
351                 setWidgetFontSize(id, DEFAULTFONTSIZE);
352
353                 setWidgetRelief(id, ScilabRelief.FLAT);
354                 
355                 /* Default colors */
356                 setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
357                 setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
358                 return id;
359         }
360
361         /**
362          * Create a new Slider in Scilab GUIs
363          * @return the ID of the Slider in the UIElementMapper
364          */
365         public static int newSlider() {
366                 Slider slider = ScilabSlider.createSlider();
367                 int id = UIElementMapper.add(slider);
368
369                 /* Default font */
370                 /* Set a default font because is null when JScrollBar is created */
371                 slider.setFont(new Font(DEFAULTFONTNAME, Font.PLAIN, DEFAULTFONTSIZE));
372                 setWidgetFontName(id, DEFAULTFONTNAME);
373                 setWidgetFontWeight(id, NORMALFONT);
374                 setWidgetFontSize(id, DEFAULTFONTSIZE);
375                 
376                 setWidgetRelief(id, ScilabRelief.FLAT);
377                 
378                 /* Default colors */
379                 setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
380                 setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
381                 
382                 slider.setText(""); /* Because Name property is null at creation */
383                 slider.setMinimumValue(0);
384                 slider.setMaximumValue(1);
385                 slider.setValue(0);
386                 
387                 return id;
388         }
389
390         /**
391          * Create a new ListBox in Scilab GUIs
392          * @return the ID of the ListBox in the UIElementMapper
393          */
394         public static int newListBox() {
395                 ListBox listBox = ScilabListBox.createListBox();
396                 int id = UIElementMapper.add(listBox);
397
398                 /* Default font */
399                 setWidgetFontName(id, DEFAULTFONTNAME);
400                 setWidgetFontWeight(id, NORMALFONT);
401                 setWidgetFontSize(id, DEFAULTFONTSIZE);
402                 
403                 setWidgetRelief(id, ScilabRelief.FLAT);
404
405                 /* Default colors */
406                 setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
407                 setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
408                 return id;
409         }
410
411         /**
412          * Create a new PopupMenu in Scilab GUIs
413          * @return the ID of the PopupMenu in the UIElementMapper
414          */
415         public static int newPopupMenu() {
416                 PopupMenu popupMenu = ScilabPopupMenu.createPopupMenu();
417                 int id = UIElementMapper.add(popupMenu);
418
419                 /* Default font */
420                 setWidgetFontName(id, DEFAULTFONTNAME);
421                 setWidgetFontWeight(id, NORMALFONT);
422                 setWidgetFontSize(id, DEFAULTFONTSIZE);
423                 
424                 setWidgetRelief(id, ScilabRelief.FLAT);
425                 
426                 /* Default colors */
427                 setWidgetBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
428                 setWidgetForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
429                 return id;
430         }
431
432         /**
433          * Create a new Frame in Scilab GUIs
434          * @return the ID of the Frame in the UIElementMapper
435          */
436         public static int newFrame() {
437                 Frame frame = ScilabFrame.createFrame();
438                 int id = UIElementMapper.add(frame);
439
440                 /* Default font */
441                 setFrameFontName(id, DEFAULTFONTNAME);
442                 setFrameFontWeight(id, NORMALFONT);
443                 setFrameFontSize(id, DEFAULTFONTSIZE);
444                 
445                 setFrameRelief(id, ScilabRelief.RIDGE);
446                 
447                 /* Default colors */
448                 setFrameBackgroundColor(id, (int) DEFAULT_RED_BACKGROUND, (int) DEFAULT_GREEN_BACKGROUND, (int) DEFAULT_BLUE_BACKGROUND);
449                 setFrameForegroundColor(id, (int) DEFAULT_RED_FOREGROUND, (int) DEFAULT_GREEN_FOREGROUND, (int) DEFAULT_BLUE_FOREGROUND);
450                 
451                 frame.setText(""); /* Because Name property is null at creation */
452                 return id;
453         }
454         
455         /**
456          * Create a new ContextMenu in Scilab GUIs
457          * and wait for a user answer
458          * @param id the id of the Context Menu
459          * @return the item of the menu selected
460          */
461         public static String displayAndWaitContextMenu(int id) {
462                 return ((ContextMenu) UIElementMapper.getCorrespondingUIElement(id)).getAsSimpleContextMenu().displayAndWait();
463         }
464
465         /**
466          * Destroy a Widget
467          * @param id the id of the Widget to destroy
468          */
469         public static void destroyWidget(int id) {
470                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).destroy();
471         }
472
473         /**
474          * Destroy a Frame
475          * @param id the id of the Frame to destroy
476          */
477         public static void destroyFrame(int id) {
478                 ((Frame) UIElementMapper.getCorrespondingUIElement(id)).destroy();
479         }
480
481         /****************************/
482         /*                          */
483         /* OBJECT DIMENSIONS BRIDGE */
484         /*                          */
485         /****************************/
486         
487         /**
488          * Set the dimensions of an object in Scilab GUIs
489          * @param objID the ID of the object in the UIElementMapper
490          * @param width the width of the object
491          * @param height the height of the object
492          */
493         public static void setDims(int objID, int width, int height) {
494                 UIElementMapper.getCorrespondingUIElement(objID).setDims(new Size(width, height));
495         }
496         
497         /**********************/
498         /*                    */
499         /* OBJECT TEXT BRIDGE */
500         /*                    */
501         /**********************/
502         
503         /**
504          * Set the text of a widget in Scilab GUIs
505          * @param objID the ID of the Widget in the UIElementMapper
506          * @param text the text to set to the widget
507          */
508         public static void setWidgetText(int objID, String text) {
509                 ((Widget) UIElementMapper.getCorrespondingUIElement(objID)).setText(text);
510         }
511         
512         /**
513          * Get the text of a widget in Scilab GUIs
514          * @param objID the ID of the Widget in the UIElementMapper
515          * @return the text of the widget
516          */
517         public static String getWidgetText(int objID) {
518                 return ((Widget) UIElementMapper.getCorrespondingUIElement(objID)).getText();
519         }
520
521         /**
522          * Set the text of a Frame in Scilab GUIs
523          * @param objID the ID of the Widget in the UIElementMapper
524          * @param text the text to set to the Frame
525          */
526         public static void setFrameText(int objID, String text) {
527                 ((Frame) UIElementMapper.getCorrespondingUIElement(objID)).setText(text);
528         }
529         
530         /**
531          * Get the text of a Frame in Scilab GUIs
532          * @param objID the ID of the Frame in the UIElementMapper
533          * @return the text of the Frame
534          */
535         public static String getFrameText(int objID) {
536                 return ((Frame) UIElementMapper.getCorrespondingUIElement(objID)).getText();
537         }
538
539         /******************/
540         /*                */
541         /* PARENT SETTING */
542         /*                */
543         /******************/
544
545         /**
546          * Set a figure as parent for an UIElement
547          * @param figureID the ID of the figure in the FigureMapper
548          * @param objID the ID of the object in the UIElementMapper
549          */
550         public static void setFigureAsParent(int figureID, int objID) {
551                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
552
553                 if (UIElementMapper.getCorrespondingUIElement(objID) instanceof Menu) {
554                         // Add the menu to the tab
555                         parentTab.getMenuBar().add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
556                 } else {
557                         // obj is a MenuItem that has to be converted to a Menu
558                         MenuItem menuItem = (MenuItem) UIElementMapper.getCorrespondingUIElement(objID);
559                         
560                         Menu menuToAdd = ScilabMenu.createMenu();
561                         UIElementMapper.removeMapping(objID);
562                         UIElementMapper.addMapping(objID, menuToAdd);
563                         // Copy all properties from MenuItem to Menu
564                         menuToAdd.setText(menuItem.getText());
565                         // TODO Add other properties
566                         
567                         // Add the menu to the tab
568                         parentTab.getMenuBar().add(menuToAdd);
569                 }
570         }
571         
572         /**
573          * Set a figure as parent for a PushButton
574          * @param figureID the ID of the figure in the FigureMapper
575          * @param objID the ID of the PushButton in the UIElementMapper
576          */
577         public static void setPushButtonParent(int figureID, int objID) {
578                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
579                 PushButton pushButton = (PushButton) UIElementMapper.getCorrespondingUIElement(objID);
580                 ScilabBridge.addMember(parentTab, pushButton);
581         }
582
583         /**
584          * Set a figure as parent for a EditBox
585          * @param figureID the ID of the figure in the FigureMapper
586          * @param objID the ID of the PushButton in the UIElementMapper
587          */
588         public static void setEditBoxParent(int figureID, int objID) {
589                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
590                 EditBox editBox = (EditBox) UIElementMapper.getCorrespondingUIElement(objID);
591                 ScilabBridge.addMember(parentTab, editBox);
592         }
593
594         /**
595          * Set a figure as parent for a Label
596          * @param figureID the ID of the figure in the FigureMapper
597          * @param objID the ID of the PushButton in the UIElementMapper
598          */
599         public static void setLabelParent(int figureID, int objID) {
600                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
601                 Label label = (Label) UIElementMapper.getCorrespondingUIElement(objID);
602                 ScilabBridge.addMember(parentTab, label);
603         }
604
605         /**
606          * Set a figure as parent for a CheckBox
607          * @param figureID the ID of the figure in the FigureMapper
608          * @param objID the ID of the PushButton in the UIElementMapper
609          */
610         public static void setCheckBoxParent(int figureID, int objID) {
611                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
612                 CheckBox checkBox = (CheckBox) UIElementMapper.getCorrespondingUIElement(objID);
613                 ScilabBridge.addMember(parentTab, checkBox);
614         }
615
616         /**
617          * Set a figure as parent for a RadioButton
618          * @param figureID the ID of the figure in the FigureMapper
619          * @param objID the ID of the PushButton in the UIElementMapper
620          */
621         public static void setRadioButtonParent(int figureID, int objID) {
622                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
623                 RadioButton radioButton = (RadioButton) UIElementMapper.getCorrespondingUIElement(objID);
624                 ScilabBridge.addMember(parentTab, radioButton);
625         }
626
627         /**
628          * Set a figure as parent for a Slider
629          * @param figureID the ID of the figure in the FigureMapper
630          * @param objID the ID of the PushButton in the UIElementMapper
631          */
632         public static void setSliderParent(int figureID, int objID) {
633                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
634                 Slider slider = (Slider) UIElementMapper.getCorrespondingUIElement(objID);
635                 ScilabBridge.addMember(parentTab, slider);
636         }
637
638         /**
639          * Set a figure as parent for a ListBox
640          * @param figureID the ID of the figure in the FigureMapper
641          * @param objID the ID of the ListBox in the UIElementMapper
642          */
643         public static void setListBoxParent(int figureID, int objID) {
644                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
645                 ListBox listBox = (ListBox) UIElementMapper.getCorrespondingUIElement(objID);
646                 ScilabBridge.addMember(parentTab, listBox);
647         }
648
649         /**
650          * Set a figure as parent for a PopupMenu
651          * @param figureID the ID of the figure in the FigureMapper
652          * @param objID the ID of the PopupMenu in the UIElementMapper
653          */
654         public static void setPopupMenuParent(int figureID, int objID) {
655                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
656                 PopupMenu popupMenu = (PopupMenu) UIElementMapper.getCorrespondingUIElement(objID);
657                 ScilabBridge.addMember(parentTab, popupMenu);
658         }
659
660         /**
661          * Set a figure as parent for a Frame
662          * @param figureID the ID of the figure in the FigureMapper
663          * @param objID the ID of the PopupMenu in the UIElementMapper
664          */
665         public static void setFrameParent(int figureID, int objID) {
666                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
667                 Frame frame = (Frame) UIElementMapper.getCorrespondingUIElement(objID);
668                 ScilabBridge.addMember(parentTab, frame);
669         }
670
671         /**
672          * Set root Scilab object (the console tab) as the parent of the menu
673          * @param objID the id of the menu
674          */
675         public static void setRootAsParent(int objID) {
676                 if (UIElementMapper.getCorrespondingUIElement(objID) instanceof Menu) {
677                         // Add the menu to the tab
678                         ScilabConsole.getConsole().getMenuBar().add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
679                 } else {
680                         // obj is a MenuItem that has top be converted to a Menu
681                         MenuItem menuItem = (MenuItem) UIElementMapper.getCorrespondingUIElement(objID);
682                         
683                         Menu menuToAdd = ScilabMenu.createMenu();
684                         UIElementMapper.removeMapping(objID);
685                         UIElementMapper.addMapping(objID, menuToAdd);
686                         // Copy all properties from MenuItem to Menu
687                         menuToAdd.setText(menuItem.getText());
688                         // TODO Add other properties
689
690                         ScilabConsole.getConsole().getMenuBar().add(menuToAdd);
691                 }
692         }
693         
694         /**
695          * Set an other menu as the parent of the menu
696          * @param menuID the id of the parent menu
697          * @param objID the id of the menu
698          */
699         public static void setMenuAsParent(int menuID, int objID) {
700
701                 if (UIElementMapper.getCorrespondingUIElement(menuID) instanceof Menu) {
702                         Menu parentMenu = (Menu) UIElementMapper.getCorrespondingUIElement(menuID);
703                         
704                         if (UIElementMapper.getCorrespondingUIElement(objID) instanceof Menu) {
705                                 parentMenu.add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
706                         } else if (UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem) {
707                                 parentMenu.add((MenuItem) UIElementMapper.getCorrespondingUIElement(objID));                            
708                         }
709                 } else if (UIElementMapper.getCorrespondingUIElement(menuID) instanceof MenuItem) {
710                         MenuItem parentMenu = (MenuItem) UIElementMapper.getCorrespondingUIElement(menuID);
711                         
712                         if (UIElementMapper.getCorrespondingUIElement(objID) instanceof Menu) {
713                                 parentMenu.add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
714                         } else if (UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem) {
715                                 parentMenu.add((MenuItem) UIElementMapper.getCorrespondingUIElement(objID));                            
716                         }
717                 } else if (UIElementMapper.getCorrespondingUIElement(menuID) instanceof ContextMenu) {
718                         ContextMenu parentMenu = (ContextMenu) UIElementMapper.getCorrespondingUIElement(menuID);
719                         
720                         if (UIElementMapper.getCorrespondingUIElement(objID) instanceof Menu) {
721                                 parentMenu.add((Menu) UIElementMapper.getCorrespondingUIElement(objID));
722                         } else if (UIElementMapper.getCorrespondingUIElement(objID) instanceof MenuItem) {
723                                 parentMenu.add((MenuItem) UIElementMapper.getCorrespondingUIElement(objID));                            
724                         }
725                 }
726         }
727         
728         /*******************/
729         /*                 */
730         /* OBJECT CALLBACK */
731         /*                 */
732         /*******************/
733         
734         /**
735          * Set a callback for a Widget
736          * @param objID the ID of the object in the UIElementMapper
737          * @param callbackString the text of the callback
738          * @param callbackType the type of the callback
739          */
740         public static void setWidgetCallback(int objID, String callbackString, int callbackType) {
741                 ((Widget) UIElementMapper.getCorrespondingUIElement(objID)).setCallback(CallBack.createCallback(callbackString, callbackType));
742         }
743         
744         /**
745          * Set a callback for a Frame
746          * @param objID the ID of the object in the UIElementMapper
747          * @param callbackString the text of the callback
748          * @param callbackType the type of the callback
749          */
750         public static void setFrameCallback(int objID, String callbackString, int callbackType) {
751                 System.out.println("setFrameCallback is not implemented");
752         }
753         
754         /************************/
755         /*                      */
756         /* ENABLE/DISABLE MENUS */
757         /*                      */
758         /************************/
759
760         /**
761          * Disable a menu of a Scilab figure giving its name
762          * @param figureID the id of the figure
763          * @param menuName the name of the menu
764          * @param status true to set the menu enabled
765          */
766         public static void setFigureMenuEnabled(int figureID, String menuName, boolean status) {
767                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
768                 
769                 MenuBar figureMenuBar = parentTab.getMenuBar();
770                 
771                 figureMenuBar.getAsSimpleMenuBar().setMenuEnabled(menuName, status);
772         }
773
774         /**
775          * Disable a MenuItem of a Scilab figure giving its parent name and position
776          * @param figureID the id of the figure
777          * @param parentMenuName the name of the parent menu
778          * @param menuItemPosition the name of the parent menu
779          * @param status true to set the menu enabled
780          */
781         public static void setFigureSubMenuEnabled(int figureID, String parentMenuName, int menuItemPosition, boolean status) {
782                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
783                 
784                 MenuBar figureMenuBar = parentTab.getMenuBar();
785                 
786                 figureMenuBar.getAsSimpleMenuBar().setSubMenuEnabled(parentMenuName, menuItemPosition, status);
787         }
788
789         /**
790          * Disable a menu of a Scilab root window giving its name
791          * @param menuName the name of the menu
792          * @param status true to set the menu enabled
793          */
794         public static void setRootMenuEnabled(String menuName, boolean status) {
795                 ScilabConsole.getConsole().getMenuBar().getAsSimpleMenuBar().setMenuEnabled(menuName, status);
796         }
797         
798         /**
799          * Disable a MenuItem of a Scilab root window giving its parent name and position
800          * @param parentMenuName the name of the parent menu
801          * @param menuItemPosition the name of the parent menu
802          * @param status true to set the menu enabled
803          */
804         public static void setRootSubMenuEnabled(String parentMenuName, int menuItemPosition, boolean status) {
805                 ScilabConsole.getConsole().getMenuBar().getAsSimpleMenuBar().setSubMenuEnabled(parentMenuName, menuItemPosition, status);
806         }
807         
808         /****************/
809         /*              */
810         /* REMOVE MENUS */
811         /*              */
812         /****************/
813
814         /**
815          * Delete a menu of a Scilab figure giving its name
816          * @param figureID the id of the figure
817          * @param menuName the name of the menu
818          */
819         public static void removeFigureMenu(int figureID, String menuName) {
820                 Tab parentTab = ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figureID).getRendererProperties()).getParentTab();
821                 
822                 MenuBar figureMenuBar = parentTab.getMenuBar();
823                 
824                 figureMenuBar.getAsSimpleMenuBar().removeMenu(menuName);
825         }
826
827         /**
828          * Delete a menu of a Scilab root window giving its name
829          * @param menuName the name of the menu
830          */
831         public static void removeRootMenu(String menuName) {
832                 ScilabConsole.getConsole().getMenuBar().getAsSimpleMenuBar().removeMenu(menuName);
833         }
834         
835         /***********************/
836         /*                     */
837         /* FILE CHOOSER BRIDGE */
838         /*                     */
839         /***********************/
840         
841         /**
842          * Set the file chooser title 
843          * @param id the id of the fileChooser
844          * @param title the title of the fileChooser
845          */
846         public static void setFileChooserTitle(int id, String title) {
847                 ((FileChooser) UIElementMapper.getCorrespondingUIElement(id)).setTitle(title);
848         }
849         
850         /**
851          * Set the initial directory used for file search
852          * @param id the id of the fileChooser
853          * @param path the default path
854          */
855         public static void setFileChooserInitialDirectory(int id, String path) {
856                 ((FileChooser) UIElementMapper.getCorrespondingUIElement(id)).setInitialDirectory(path);
857         }
858
859         /**
860          * Set the mask for files that can be selected
861          * @param id the id of the fileChooser
862          * @param mask the mask to apply
863          */
864         public static void setFileChooserMask(int id, String mask) {
865                 ((FileChooser) UIElementMapper.getCorrespondingUIElement(id)).setMask(mask);
866         }
867
868         /**
869          * Display this chooser and wait for user selection 
870          * @param id the id of the fileChooser
871          */
872         public static void fileChooserDisplayAndWait(int id) {
873                 ((FileChooser) UIElementMapper.getCorrespondingUIElement(id)).displayAndWait();
874         }
875         
876         /**
877          * Get the number of files selected
878          * @param id the id of the fileChooser
879          * @return the number of files selected
880          */
881         public static int getFileChooserSelectionSize(int id) {
882                 return ((FileChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectionSize();
883         }
884         
885         /**
886          * Get the names of selected files
887          * @param id the id of the fileChooser
888          * @return the names of selected files
889          */
890         public static String[] getFileChooserSelection(int id) {
891                 return ((FileChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelection();
892         }
893         
894         /**
895          * Set the flag indicating that we want only select directories
896          * @param id the id of the fileChooser
897          */
898         public static void setFileChooserDirectorySelectionOnly(int id) {
899                 ((FileChooser) UIElementMapper.getCorrespondingUIElement(id)).setDirectorySelectionOnly();
900         }
901
902         /**
903          * Set the flag indicating that we want only select files
904          * @param id the id of the fileChooser
905          */
906         public static void setFileChooserFileSelectionOnly(int id) {
907                 ((FileChooser) UIElementMapper.getCorrespondingUIElement(id)).setFileSelectionOnly();
908         }
909         
910         /**********************/
911         /*                    */
912         /* MESSAGE BOX BRIDGE */
913         /*                    */
914         /**********************/
915         
916         /**
917          * Set the MessageBox title 
918          * @param id the id of the messageBox
919          * @param title the title of the messageBox
920          */
921         public static void setMessageBoxTitle(int id, String title) {
922                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setTitle(title);
923         }
924         
925         /**
926          * Set the MessageBox message 
927          * @param id the id of the messageBox
928          * @param message the message of the messageBox
929          */
930         public static void setMessageBoxMessage(int id, String message) {
931                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setMessage(message);
932         }
933
934         /**
935          * Set the MessageBox message (multi-line)
936          * @param id the id of the messageBox
937          * @param message the message of the messageBox
938          */
939         public static void setMessageBoxMessage(int id, String[] message) {
940                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setMessage(message);
941         }
942
943         /**
944          * Display this chooser and wait for user selection 
945          * @param id the id of the messageBox
946          */
947         public static void messageBoxDisplayAndWait(int id) {
948                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).displayAndWait();
949         }
950         
951         /**
952          * Get the index of the selected button
953          * @param id the id of the messageBox
954          * @return the index of the selected button
955          */
956         public static int getMessageBoxSelectedButton(int id) {
957                 return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectedButton();
958         }
959
960         /**
961          * Set the indices of the default selected buttons (x_choices)
962          * @param id the id of the MessageBox  
963          * @param indices the indices of the default selected buttons
964          */
965         public static void setMessageBoxDefaultSelectedButtons(int id, int[] indices) {
966                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setDefaultSelectedButtons(indices);
967         }
968
969         /**
970          * Get the indices of the user selected buttons (x_choices)
971          * @param id the id of the MessageBox  
972          * @return the indices of the user selected buttons
973          */
974         public static int[] getMessageBoxUserSelectedButtons(int id) {
975                 return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getUserSelectedButtons();
976         }
977
978         /**
979          * Set the labels of the buttons in the MessageBox
980          * @param id the id of the MessageBox
981          * @param labels the labels of the buttons
982          */
983         public static void setMessageBoxButtonsLabels(int id, String[] labels) {
984                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setButtonsLabels(labels);
985         }
986
987         /**
988          * Set the initial value for the editable part of the MessageBox
989          * @param id the id of the MessageBox
990          * @param value the initial value
991          */
992         public static void setMessageBoxInitialValue(int id, String[] value) {
993                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setInitialValue(value);
994         }
995
996         /**
997          * Get the value of the editable zone in the MessageBox
998          * @param id the id of the MessageBox
999          * @return the value
1000          */
1001         public static String[] getMessageBoxValue(int id) {
1002                 return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getValue();
1003         }
1004         
1005         /**
1006          * Get the size of the value of the editable zone in the MessageBox
1007          * @param id the id of the MessageBox
1008          * @return the value size
1009          */
1010         public static int getMessageBoxValueSize(int id) {
1011                 return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getValueSize();
1012         }
1013
1014         /**
1015          * Set the items of the listbox in the MessageBox
1016          * @param id the id of the MessageBox
1017          * @param items the items to set
1018          */
1019         public static void setMessageBoxListBoxItems(int id, String[] items) {
1020                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setListBoxItems(items);
1021         }
1022
1023         /**
1024          * Get the index of the selected item in the listbox in the MessageBox
1025          * @param id the id of the MessageBox
1026          * @return the index
1027          */
1028         public static int getMessageBoxSelectedItem(int id) {
1029                 return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectedItem();
1030         }
1031         
1032         /**
1033          * Set the name of the lines labels in the editable zone in the MessageBox
1034          * @param id the id of the MessageBox
1035          * @param labels the labels
1036          */
1037         public static void setMessageBoxLineLabels(int id, String[] labels) {
1038                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setLineLabels(labels);
1039         }
1040         
1041         /**
1042          * Set the name of the columns labels in the editable zone in the MessageBox
1043          * @param id the id of the MessageBox
1044          * @param labels the labels
1045          */
1046         public static void setMessageBoxColumnLabels(int id, String[] labels) {
1047                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setColumnLabels(labels);
1048         }
1049         
1050         /**
1051          * Set the default values of a multi-value editable zone in the MessageBox
1052          * @param id the id of the MessageBox
1053          * @param values the values
1054          */
1055         public static void setMessageBoxDefaultInput(int id, String[] values) {
1056                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setDefaultInput(values);
1057         }
1058
1059         /**
1060          * Set a MessageBox modal or not
1061          * @param id the id of the MessageBox
1062          * @param status true to set the MessageBox modal and false else
1063          */
1064         public static void setMessageBoxModal(int id, boolean status) {
1065                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setModal(status);
1066         }
1067         
1068         /**
1069          * Set the MessageBox icon
1070          * @param id the id of the MessageBox
1071          * @param name the name of the icon
1072          */
1073         public static void setMessageBoxIcon(int id, String name) {
1074                 ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setIcon(name);
1075         }
1076         
1077         /************************/
1078         /*                      */
1079         /* OBJECT COLORS BRIDGE */
1080         /*                      */
1081         /************************/
1082         
1083         /**
1084          * Set the background color of a Widget
1085          * @param id the id of the Widget
1086          * @param red the red value for the color
1087          * @param green the green value for the color
1088          * @param blue the blue value for the color
1089          */
1090         public static void setWidgetBackgroundColor(int id, int red, int green, int blue) {
1091                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setBackground(new Color(red, green, blue));
1092         }
1093         
1094         /**
1095          * Get the background color of a widget 
1096          * @param id the id of the widget
1097          * @return the color [R, G, B]
1098          */
1099         public static int[] getWidgetBackgroundColor(int id) {
1100                 Color tmpColor = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getBackground();
1101                 int[] color = new int[NB_COLORS];
1102                 color[0] = tmpColor.getRed();
1103                 color[1] = tmpColor.getGreen();
1104                 color[2] = tmpColor.getBlue();
1105                 return color;
1106         }
1107         
1108         /**
1109          * Set the foreground color of a Widget
1110          * @param id the id of the Widget
1111          * @param red the red value for the color
1112          * @param green the green value for the color
1113          * @param blue the blue value for the color
1114          */
1115         public static void setWidgetForegroundColor(int id, int red, int green, int blue) {
1116                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setForeground(new Color(red, green, blue));
1117         }
1118         
1119         /**
1120          * Get the foreground color of a Widget 
1121          * @param id the id of the Widget
1122          * @return the color [R, G, B]
1123          */
1124         public static int[] getWidgetForegroundColor(int id) {
1125                 Color tmpColor = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getForeground();
1126                 int[] color = new int[NB_COLORS];
1127                 color[0] = tmpColor.getRed();
1128                 color[1] = tmpColor.getGreen();
1129                 color[2] = tmpColor.getBlue();
1130                 return color;
1131         }
1132
1133         /**
1134          * Set the background color of a Frame
1135          * @param id the id of the Frame
1136          * @param red the red value for the color
1137          * @param green the green value for the color
1138          * @param blue the blue value for the color
1139          */
1140         public static void setFrameBackgroundColor(int id, int red, int green, int blue) {
1141                 ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setBackground(new Color(red, green, blue));
1142         }
1143         
1144         /**
1145          * Get the background color of a Frame 
1146          * @param id the id of the Frame
1147          * @return the color [R, G, B]
1148          */
1149         public static int[] getFrameBackgroundColor(int id) {
1150                 Color tmpColor = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getBackground();
1151                 int[] color = new int[NB_COLORS];
1152                 color[0] = tmpColor.getRed();
1153                 color[1] = tmpColor.getGreen();
1154                 color[2] = tmpColor.getBlue();
1155                 return color;
1156         }
1157         
1158         /**
1159          * Set the foreground color of a Frame
1160          * @param id the id of the Frame
1161          * @param red the red value for the color
1162          * @param green the green value for the color
1163          * @param blue the blue value for the color
1164          */
1165         public static void setFrameForegroundColor(int id, int red, int green, int blue) {
1166                 ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setForeground(new Color(red, green, blue));
1167         }
1168         
1169         /**
1170          * Get the foreground color of a Frame 
1171          * @param id the id of the Frame
1172          * @return the color [R, G, B]
1173          */
1174         public static int[] getFrameForegroundColor(int id) {
1175                 Color tmpColor = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getForeground();
1176                 int[] color = new int[NB_COLORS];
1177                 color[0] = tmpColor.getRed();
1178                 color[1] = tmpColor.getGreen();
1179                 color[2] = tmpColor.getBlue();
1180                 return color;
1181         }
1182
1183         /**********************/
1184         /*                    */
1185         /* OBJECT FONT BRIDGE */
1186         /*                    */
1187         /**********************/
1188
1189         /**
1190          * Set the name of a Widget font
1191          * @param id the id of the Widget
1192          * @param name the name of the Widget font
1193          */
1194         public static void setWidgetFontName(int id, String name) {
1195                 Font font = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1196                 font = new Font(name, font.getStyle(), font.getSize());
1197                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1198         }
1199
1200         /**
1201          * Get the name of a Widget font
1202          * @param id the id of the Widget
1203          * @return the name of the Widget font
1204          */
1205         public static String getWidgetFontName(int id) {
1206                 return ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont().getName();
1207         }
1208
1209         /**
1210          * Set the weight of a Widget font
1211          * @param id the id of the Widget
1212          * @param weight the weight of the Widget font
1213          */
1214         public static void setWidgetFontWeight(int id, String weight) {
1215                 Font font = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1216
1217                 if (weight.equals(BOLDFONT)) {
1218                         if (font.isItalic()) {
1219                                 font = new Font(font.getName(), Font.ITALIC + Font.BOLD, font.getSize());
1220                         } else {
1221                                 font = new Font(font.getName(), Font.BOLD, font.getSize());
1222                         }
1223                 } else {
1224                         if (font.isItalic()) {
1225                                 font = new Font(font.getName(), Font.ITALIC, font.getSize());
1226                         } else {
1227                                 font = new Font(font.getName(), Font.PLAIN, font.getSize());
1228                         }
1229                 }
1230
1231                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1232         }
1233         
1234         /**
1235          * Set the angle of a Widget font
1236          * @param id the id of the Widget
1237          * @param angle the angle of the Widget font
1238          */
1239         public static void setWidgetFontAngle(int id, String angle) {
1240                 Font font = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1241
1242                 if (angle.equals(ITALICFONT) || angle.equals(OBLIQUEFONT)) {
1243                         if (font.isBold()) {
1244                                 font = new Font(font.getName(), Font.ITALIC + Font.BOLD, font.getSize());
1245                         } else {
1246                                 font = new Font(font.getName(), Font.ITALIC, font.getSize());
1247                         }
1248                 } else {
1249                         if (font.isBold()) {
1250                                 font = new Font(font.getName(), Font.BOLD, font.getSize());
1251                         } else {
1252                                 font = new Font(font.getName(), Font.PLAIN, font.getSize());
1253                         }
1254                 }
1255
1256                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1257         }
1258         
1259         /**
1260          * Set the size of a Widget font
1261          * @param id the id of the Widget
1262          * @param size the size of the Widget font
1263          */
1264         public static void setWidgetFontSize(int id, int size) {
1265                 Font font = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1266                 font = new Font(font.getName(), font.getStyle(), size);
1267                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1268         }
1269
1270         /**
1271          * Get the size of a Widget font
1272          * @param id the id of the Widget
1273          * @return the size of the Widget font
1274          */
1275         public static int getWidgetFontSize(int id) {
1276                 return ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getFont().getSize();
1277         }
1278
1279         /**
1280          * Set the weight of a Frame font
1281          * @param id the id of the Frame
1282          * @param weight the weight of the Frame font
1283          */
1284         public static void setFrameFontWeight(int id, String weight) {
1285                 Font font = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1286
1287                 if (weight.equals(BOLDFONT)) {
1288                         if (font.isItalic()) {
1289                                 font = new Font(font.getName(), Font.ITALIC + Font.BOLD, font.getSize());
1290                         } else {
1291                                 font = new Font(font.getName(), Font.BOLD, font.getSize());
1292                         }
1293                 } else {
1294                         if (font.isItalic()) {
1295                                 font = new Font(font.getName(), Font.ITALIC, font.getSize());
1296                         } else {
1297                                 font = new Font(font.getName(), Font.PLAIN, font.getSize());
1298                         }
1299                 }
1300
1301                 ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1302         }
1303         
1304         /**
1305          * Set the angle of a Frame font
1306          * @param id the id of the Frame
1307          * @param angle the angle of the Frame font
1308          */
1309         public static void setFrameFontAngle(int id, String angle) {
1310                 Font font = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1311
1312                 if (angle.equals(ITALICFONT) || angle.equals(OBLIQUEFONT)) {
1313                         if (font.isBold()) {
1314                                 font = new Font(font.getName(), Font.ITALIC + Font.BOLD, font.getSize());
1315                         } else {
1316                                 font = new Font(font.getName(), Font.ITALIC, font.getSize());
1317                         }
1318                 } else {
1319                         if (font.isBold()) {
1320                                 font = new Font(font.getName(), Font.BOLD, font.getSize());
1321                         } else {
1322                                 font = new Font(font.getName(), Font.PLAIN, font.getSize());
1323                         }
1324                 }
1325
1326                 ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1327         }
1328         
1329         /**
1330          * Set the size of a Frame font
1331          * @param id the id of the Frame
1332          * @param size the size of the Frame font
1333          */
1334         public static void setFrameFontSize(int id, int size) {
1335                 Font font = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1336                 font = new Font(font.getName(), font.getStyle(), size);
1337                 ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1338         }
1339
1340         /**
1341          * Get the size of a Frame font
1342          * @param id the id of the Frame
1343          * @return the size of the Frame font
1344          */
1345         public static int getFrameFontSize(int id) {
1346                 return ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont().getSize();
1347         }
1348
1349         /**
1350          * Set the name of a Frame font
1351          * @param id the id of the Frame
1352          * @param name the name of the Frame font
1353          */
1354         public static void setFrameFontName(int id, String name) {
1355                 Font font = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont();
1356                 font = new Font(name, font.getStyle(), font.getSize());
1357                 ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setFont(font);
1358         }
1359
1360         /**
1361          * Get the name of a Frame font
1362          * @param id the id of the Frame
1363          * @return the name of the Frame font
1364          */
1365         public static String getFrameFontName(int id) {
1366                 return ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getFont().getName();
1367         }
1368
1369         /**************************/
1370         /*                        */
1371         /* OBJECT POSITION BRIDGE */
1372         /*                        */
1373         /**************************/
1374         
1375         /**
1376          * Set the position (in Scilab terms) of a Widget 
1377          * @param id the id of the Widget
1378          * @param x the X-coordinate for the Widget
1379          * @param y the Y-coordinate for the Widget
1380          * @param width the width of the Widget
1381          * @param height the height of the Widget
1382          */
1383         public static void setWidgetPosition(int id, int x, int y, int width, int height) {
1384                 UIElementMapper.getCorrespondingUIElement(id).setPosition(new Position(x, y));
1385                 UIElementMapper.getCorrespondingUIElement(id).setDims(new Size(width, height));
1386         }
1387         
1388         /**
1389          * Get the position (in Scilab terms) of a widget 
1390          * @param id the id of the widget
1391          * @return the position (X-coordinate, Y-coordinate, width, height) of the button
1392          */
1393         public static int[] getWidgetPosition(int id) {
1394                 int[] position = new int[POSITION_SIZE];
1395                 
1396                 position[X_INDEX] = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getPosition().getX();
1397                 position[Y_INDEX] = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getPosition().getY();
1398                 position[WIDTH_INDEX] = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getDims().getWidth();
1399                 position[HEIGHT_INDEX] = ((Widget) UIElementMapper.getCorrespondingUIElement(id)).getDims().getHeight();
1400                 
1401                 return position;
1402         }
1403         
1404         /**
1405          * Set the position (in Scilab terms) of a Frame 
1406          * @param id the id of the Frame
1407          * @param x the X-coordinate for the Frame
1408          * @param y the Y-coordinate for the Frame
1409          * @param width the width of the Frame
1410          * @param height the height of the Frame
1411          */
1412         public static void setFramePosition(int id, int x, int y, int width, int height) {
1413                 UIElementMapper.getCorrespondingUIElement(id).setPosition(new Position(x, y));
1414                 UIElementMapper.getCorrespondingUIElement(id).setDims(new Size(width, height));
1415         }
1416         
1417         /**
1418          * Get the position (in Scilab terms) of a Frame 
1419          * @param id the id of the Frame
1420          * @return the position (X-coordinate, Y-coordinate, width, height) of the button
1421          */
1422         public static int[] getFramePosition(int id) {
1423                 int[] position = new int[POSITION_SIZE];
1424                 
1425                 position[X_INDEX] = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getPosition().getX();
1426                 position[Y_INDEX] = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getPosition().getY();
1427                 position[WIDTH_INDEX] = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getDims().getWidth();
1428                 position[HEIGHT_INDEX] = ((Frame) UIElementMapper.getCorrespondingUIElement(id)).getDims().getHeight();
1429                 
1430                 return position;
1431         }
1432         
1433         /***************************/
1434         /*                         */
1435         /* OBJECT ALIGNMENT BRIDGE */
1436         /*                         */
1437         /***************************/
1438
1439         /**
1440          * Set the horizontal alignment for the Widget text
1441          * @param id the id of the Widget
1442          * @param alignment the value for the alignment (See ScilabAlignment.java)
1443          */
1444         public static void setWidgetHorizontalAlignment(int id, String alignment) {
1445                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setHorizontalAlignment(alignment);
1446         }
1447
1448         /**
1449          * Set the vertical alignment for the Widget text
1450          * @param id the id of the Widget
1451          * @param alignment the value for the alignment (See ScilabAlignment.java)
1452          */
1453         public static void setWidgetVerticalAlignment(int id, String alignment) {
1454                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setVerticalAlignment(alignment);
1455         }
1456         
1457         /**********************/
1458         /*                    */
1459         /* SLIDER STEP BRIDGE */
1460         /*                    */
1461         /**********************/
1462
1463         /**
1464          * Set the minor tick spacing for a Slider
1465          * @param id the id of the Slider
1466          * @param space the increment value
1467          */
1468         public static void setSliderMinorTickSpacing(int id, int space) {
1469                 ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setMinorTickSpacing(space);
1470         }
1471
1472         /**
1473          * Set the major tick spacing for a Slider
1474          * @param id the id of the Slider
1475          * @param space the increment value
1476          */
1477         public static void setSliderMajorTickSpacing(int id, int space) {
1478                 ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setMajorTickSpacing(space);
1479         }
1480         
1481         /*************************/
1482         /*                       */
1483         /* SLIDER MIN/MAX BRIDGE */
1484         /*                       */
1485         /*************************/
1486
1487         /**
1488          * Set the minimum value of a Slider
1489          * @param id the id of the Slider
1490          * @param value the minimum value
1491          */
1492         public static void setSliderMinValue(int id, int value) {
1493                 ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setMinimumValue(value);
1494         }
1495
1496         /**
1497          * Set the maximum value of a Slider
1498          * @param id the id of the Widget
1499          * @param value the maximum value
1500          */
1501         public static void setSliderMaxValue(int id, int value) {
1502                 ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setMaximumValue(value);
1503         }
1504         
1505         /*****************************/
1506         /*                           */
1507         /* SLIDER ORIENTATION BRIDGE */
1508         /*                           */
1509         /*****************************/
1510         
1511         /**
1512          * Set the slider orientation to vertical
1513          * @param id the id of the slider
1514          */
1515         public static void setSliderVertical(int id) {
1516                 ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setVertical();
1517         }
1518
1519         /**
1520          * Set the slider orientation to horizontal
1521          * @param id the id of the slider
1522          */
1523         public static void setSliderHorizontal(int id) {
1524                 ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setHorizontal();
1525         }
1526
1527         /******************/
1528         /*                */
1529         /* LISTBOX BRIDGE */
1530         /*                */
1531         /******************/
1532
1533         /**
1534          * Set if more than one item can be selected in a ListBox
1535          * @param id the id of the ListBox
1536          * @param status true if multiple selection is enabled
1537          */
1538         public static void setListBoxMultipleSelectionEnabled(int id, boolean status) {
1539                 ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).setMultipleSelectionEnabled(status);
1540         }
1541
1542         /**
1543          * Get the text of all the list items
1544          * @param id the id of the ListBox
1545          * @return the text items
1546          * @see org.scilab.modules.gui.listbox.ListBox#getAllItemsText()
1547          */
1548         public static String[] getListBoxAllItemsText(int id) {
1549                 return ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).getAllItemsText();
1550         }
1551
1552         /**
1553          * Get the number of items in the list
1554          * @param id the id of the ListBox
1555          * @return the number of items
1556          * @see org.scilab.modules.gui.listbox.ListBox#getNumberOfItems()
1557          */
1558         public static int getListBoxNumberOfItems(int id) {
1559                 return ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).getNumberOfItems();
1560         }
1561
1562         /**
1563          * Set the text of the list items
1564          * @param id the id of the ListBox
1565          * @param text the text of the items
1566          * @see org.scilab.modules.gui.listbox.ListBox#setText(java.lang.String[])
1567          */
1568         public static void setListBoxText(int id, String[] text) {
1569                 ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).setText(text);
1570         }
1571
1572         /********************/
1573         /*                  */
1574         /* POPUPMENU BRIDGE */
1575         /*                  */
1576         /********************/
1577
1578         /**
1579          * Get the text of all the PopupMenu items
1580          * @param id the id of the PopupMenu
1581          * @return the text items
1582          * @see org.scilab.modules.gui.popupmenu.PopupMenu#getAllItemsText()
1583          */
1584         public static String[] getPopupMenuAllItemsText(int id) {
1585                 return ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).getAllItemsText();
1586         }
1587
1588         /**
1589          * Get the number of items in the PopupMenu
1590          * @param id the id of the PopupMenu
1591          * @return the number of items
1592          * @see org.scilab.modules.gui.popupmenu.PopupMenu#getNumberOfItems()
1593          */
1594         public static int getPopupMenuNumberOfItems(int id) {
1595                 return ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).getNumberOfItems();
1596         }
1597
1598         /**
1599          * Set the text of the PopupMenu items
1600          * @param id the id of the PopupMenu
1601          * @param text the text of the items
1602          * @see org.scilab.modules.gui.popupmenu.PopupMenu#setText(java.lang.String[])
1603          */
1604         public static void setPopupMenuText(int id, String[] text) {
1605                 ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).setText(text);
1606         }
1607
1608         /****************/
1609         /*              */
1610         /* VALUE BRIDGE */
1611         /*              */
1612         /****************/
1613
1614         /**
1615          * Set the selected indices of the ListBox
1616          * @param id the id of the ListBox
1617          * @param indices the indices of the items to be selected
1618          */
1619         public static void setListBoxSelectedIndices(int id, int[] indices) {
1620                 ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).setSelectedIndices(indices);
1621         }
1622         
1623         /**
1624          * Get the selected indices of the ListBox
1625          * @param id the id of the ListBox
1626          * @return the indices of the items selected
1627          */
1628         public static int[] getListBoxSelectedIndices(int id) {
1629                 return ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectedIndices();
1630         }
1631
1632         /**
1633          * Get the number of items selected in the ListBox
1634          * @param id the id of the ListBox
1635          * @return the number of items selected
1636          */
1637         public static int getListBoxSelectionSize(int id) {
1638                 return ((ListBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectionSize();
1639         }
1640
1641         /**
1642          * Set the selected index of the PopupMenu
1643          * @param id the id of the PopupMenu
1644          * @param index the index of the item to be selected
1645          */
1646         public static void setPopupMenuSelectedIndex(int id, int index) {
1647                 ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).setSelectedIndex(index);
1648         }
1649         
1650         /**
1651          * Get the selected index of the PopupMenu
1652          * @param id the id of the PopupMenu
1653          * @return the index of the item selected
1654          */
1655         public static int getPopupMenuSelectedIndex(int id) {
1656                 return ((PopupMenu) UIElementMapper.getCorrespondingUIElement(id)).getSelectedIndex();
1657         }
1658
1659         /**
1660          * Get the current value of the Slider
1661          * @param id the id of the Slider
1662          * @return the current value of the Slider
1663          */
1664         public static int getSliderValue(int id) {
1665                 return ((Slider) UIElementMapper.getCorrespondingUIElement(id)).getValue();
1666         }
1667         
1668         /**
1669          * Sets the current value of the Slider
1670          * @param id the id of the Slider
1671          * @param value the new value
1672          */
1673         public static void setSliderValue(int id, int value) {
1674                 ((Slider) UIElementMapper.getCorrespondingUIElement(id)).setValue(value);               
1675         }
1676
1677         /**
1678          * Set if the RadioButton is checked or not
1679          * @param id the id of the RadioButton
1680          * @param status true to set the RadioButton checked
1681          */
1682         public static void setRadioButtonChecked(int id, boolean status) {
1683                 ((RadioButton) UIElementMapper.getCorrespondingUIElement(id)).setChecked(status);
1684         }
1685         
1686         /**
1687          * Get the status of the RadioButton
1688          * @param id the id of the RadioButton
1689          * @return true if the RadioButton is checked
1690          */
1691         public static boolean isRadioButtonChecked(int id) {
1692                 return ((RadioButton) UIElementMapper.getCorrespondingUIElement(id)).isChecked();
1693         }
1694
1695         /**
1696          * Set if the CheckBox is checked or not
1697          * @param id the id of the CheckBox
1698          * @param status true to set the CheckBox checked
1699          */
1700         public static void setCheckBoxChecked(int id, boolean status) {
1701                 ((CheckBox) UIElementMapper.getCorrespondingUIElement(id)).setChecked(status);
1702         }
1703         
1704         /**
1705          * Get the status of the CheckBox
1706          * @param id the id of the CheckBox
1707          * @return true if the CheckBox is checked
1708          */
1709         public static boolean isCheckBoxChecked(int id) {
1710                 return ((CheckBox) UIElementMapper.getCorrespondingUIElement(id)).isChecked();
1711         }
1712         
1713         /*****************/
1714         /*               */
1715         /* RELIEF BRIDGE */
1716         /*               */
1717         /*****************/
1718
1719         /**
1720          * Set the Relief of the Widget
1721          * @param id the id of the Widget
1722          * @param reliefType the type of the relief to set (See ScilabRelief.java)
1723          */
1724         public static void setWidgetRelief(int id, String reliefType) {
1725                 ((Widget) UIElementMapper.getCorrespondingUIElement(id)).setRelief(reliefType);
1726         }
1727
1728         /**
1729          * Set the Relief of the Frame
1730          * @param id the id of the Frame
1731          * @param reliefType the type of the relief to set (See ScilabRelief.java)
1732          */
1733         public static void setFrameRelief(int id, String reliefType) {
1734                 ((Frame) UIElementMapper.getCorrespondingUIElement(id)).setRelief(reliefType);
1735         }
1736         
1737         /******************/
1738         /*                */
1739         /* TOOLBAR BRIDGE */
1740         /*                */
1741         /******************/
1742         
1743         /**
1744          * Set the visibility of a Toolbar
1745          * @param figNum the parentfigure
1746          * @param status true to set the Toolbar visible
1747          */
1748         public static void setToolbarVisible(int figNum, boolean status) {
1749                 if (figNum == -1) {
1750                         ScilabConsole.getConsole().getToolBar().setVisible(status);
1751                 } else {
1752                         ((ScilabRendererProperties) FigureMapper
1753                                         .getCorrespondingFigure(figNum).getRendererProperties()).getParentTab().getToolBar().setVisible(status);
1754                 }
1755         }
1756
1757         /**
1758          * Get the visibility of a Toolbar
1759          * @param figNum the parentfigure
1760          * @return true to set the Toolbar visible
1761          */
1762         public static boolean isToolbarVisible(int figNum) {
1763                 if (figNum == -1) {
1764                         return ScilabConsole.getConsole().getToolBar().isVisible();
1765                 } else {
1766                         return ((ScilabRendererProperties) FigureMapper
1767                                         .getCorrespondingFigure(figNum).getRendererProperties()).getParentTab().getToolBar().isVisible();
1768                 }
1769         }
1770         
1771         /***********************/
1772         /*                     */
1773         /* EVENTHANDLER BRIDGE */
1774         /*                     */
1775         /***********************/
1776         
1777         /**
1778          * Set the event handler of the figure
1779          * @param figNum the figure
1780          * @param command the name of the Scilab function to call
1781          */
1782         public static void setEventHandler(int figNum, String command) {
1783                 ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figNum).getRendererProperties()).getCanvas().setEventHandler(command);
1784         }
1785         
1786         /**
1787          * Set the status of the event handler of the figure
1788          * @param figNum the figure
1789          * @param status is true to set the event handler active
1790          */
1791         public static void setEventHandlerEnabled(int figNum, boolean status) {
1792                 ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(figNum)
1793                                 .getRendererProperties()).getCanvas().setEventHandlerEnabled(status);
1794         }
1795         
1796         /******************/
1797         /*                */
1798         /* WAITBAR BRIDGE */
1799         /*                */
1800         /******************/
1801         
1802         /**
1803          * Set the WaitBar message (multi-line)
1804          * @param id the id of the waitBar
1805          * @param message the message of the waitBar
1806          */
1807         public static void setWaitBarMessage(int id, String[] message) {
1808                 ((WaitBar) UIElementMapper.getCorrespondingUIElement(id)).setMessage(message);
1809         }
1810
1811         /**
1812          * Set the WaitBar value
1813          * @param id the id of the waitBar
1814          * @param value the value of the waitBar
1815          */
1816         public static void setWaitBarValue(int id, int value) {
1817                 ((WaitBar) UIElementMapper.getCorrespondingUIElement(id)).setValue(value);
1818         }
1819
1820         /**
1821          * Destroy a WaitBar
1822          * @param id the id of the WaitBar to destroy
1823          */
1824         public static void destroyWaitBar(int id) {
1825                 ((WaitBar) UIElementMapper.getCorrespondingUIElement(id)).close();
1826         }
1827         
1828         /**
1829          * Indicates if the total execution time is known
1830          * @param id the id of the WaitBar to destroy
1831          * @param status true if the total progress time in unknown
1832          */
1833         public static void setWaitBarIndeterminateMode(int id, boolean status) {
1834                 ((WaitBar) UIElementMapper.getCorrespondingUIElement(id)).setIndeterminateMode(status);
1835         }
1836         
1837         /**********************/
1838         /*                    */
1839         /* HELPBROWSER BRIDGE */
1840         /*                    */
1841         /**********************/
1842         
1843         /**
1844          * Launch Scilab help browser if not already created
1845          */
1846         public static void launchHelpBrowser() {
1847                 ScilabHelpBrowser.createHelpBrowser();
1848         }
1849         
1850         /**
1851          * Search a keyword in Scilab Help Browser
1852          * @param keyword the keyword to search
1853          * @return true if the keyword is a function name
1854          */
1855         public static boolean searchKeyword(String keyword) {
1856                 return ScilabHelpBrowser.createHelpBrowser().searchKeywork(keyword);
1857         }
1858
1859         /**
1860          * Close Scilab Help Browser
1861          */
1862         public static void closeHelpBrowser() {
1863                 ScilabHelpBrowser.getHelpBrowser().close();
1864         }
1865
1866 }