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