New Java Help Browser for Scilab.
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / bridge / ScilabBridge.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007 - INRIA - Vincent Couvert
4  * Copyright (C) 2007 - INRIA - Bruno Jofret
5  * 
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at    
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13
14
15 package org.scilab.modules.gui.bridge;
16
17 import java.awt.Color;
18 import java.awt.Font;
19
20 import javax.media.opengl.GL;
21
22 import org.scilab.modules.gui.canvas.Canvas;
23 import org.scilab.modules.gui.canvas.ScilabCanvasBridge;
24 import org.scilab.modules.gui.canvas.SimpleCanvas;
25 import org.scilab.modules.gui.checkbox.CheckBox;
26 import org.scilab.modules.gui.checkbox.ScilabCheckBoxBridge;
27 import org.scilab.modules.gui.checkbox.SimpleCheckBox;
28 import org.scilab.modules.gui.console.Console;
29 import org.scilab.modules.gui.console.ScilabConsoleBridge;
30 import org.scilab.modules.gui.console.SimpleConsole;
31 import org.scilab.modules.gui.contextmenu.ContextMenu;
32 import org.scilab.modules.gui.contextmenu.ScilabContextMenuBridge;
33 import org.scilab.modules.gui.contextmenu.SimpleContextMenu;
34 import org.scilab.modules.gui.editbox.EditBox;
35 import org.scilab.modules.gui.editbox.ScilabEditBoxBridge;
36 import org.scilab.modules.gui.editbox.SimpleEditBox;
37 import org.scilab.modules.gui.events.callback.CallBack;
38 import org.scilab.modules.gui.filechooser.FileChooser;
39 import org.scilab.modules.gui.filechooser.ScilabFileChooserBridge;
40 import org.scilab.modules.gui.filechooser.SimpleFileChooser;
41 import org.scilab.modules.gui.frame.Frame;
42 import org.scilab.modules.gui.frame.ScilabFrameBridge;
43 import org.scilab.modules.gui.frame.SimpleFrame;
44 import org.scilab.modules.gui.helpbrowser.HelpBrowser;
45 import org.scilab.modules.gui.helpbrowser.ScilabHelpBrowserBridge;
46 import org.scilab.modules.gui.helpbrowser.SimpleHelpBrowser;
47 import org.scilab.modules.gui.label.Label;
48 import org.scilab.modules.gui.label.ScilabLabelBridge;
49 import org.scilab.modules.gui.label.SimpleLabel;
50 import org.scilab.modules.gui.layout.BorderLayout;
51 import org.scilab.modules.gui.layout.FlowLayout;
52 import org.scilab.modules.gui.layout.ScilabBorderLayoutBridge;
53 import org.scilab.modules.gui.layout.ScilabFlowLayoutBridge;
54 import org.scilab.modules.gui.listbox.ListBox;
55 import org.scilab.modules.gui.listbox.ScilabListBoxBridge;
56 import org.scilab.modules.gui.listbox.SimpleListBox;
57 import org.scilab.modules.gui.menu.Menu;
58 import org.scilab.modules.gui.menu.ScilabMenuBridge;
59 import org.scilab.modules.gui.menu.SimpleMenu;
60 import org.scilab.modules.gui.menubar.MenuBar;
61 import org.scilab.modules.gui.menubar.ScilabMenuBarBridge;
62 import org.scilab.modules.gui.menubar.SimpleMenuBar;
63 import org.scilab.modules.gui.menuitem.MenuItem;
64 import org.scilab.modules.gui.menuitem.ScilabMenuItemBridge;
65 import org.scilab.modules.gui.menuitem.SimpleMenuItem;
66 import org.scilab.modules.gui.messagebox.MessageBox;
67 import org.scilab.modules.gui.messagebox.ScilabMessageBoxBridge;
68 import org.scilab.modules.gui.messagebox.SimpleMessageBox;
69 import org.scilab.modules.gui.popupmenu.PopupMenu;
70 import org.scilab.modules.gui.popupmenu.ScilabPopupMenuBridge;
71 import org.scilab.modules.gui.popupmenu.SimplePopupMenu;
72 import org.scilab.modules.gui.pushbutton.PushButton;
73 import org.scilab.modules.gui.pushbutton.ScilabPushButtonBridge;
74 import org.scilab.modules.gui.pushbutton.SimplePushButton;
75 import org.scilab.modules.gui.radiobutton.RadioButton;
76 import org.scilab.modules.gui.radiobutton.ScilabRadioButtonBridge;
77 import org.scilab.modules.gui.radiobutton.SimpleRadioButton;
78 import org.scilab.modules.gui.separator.ScilabSeparatorBridge;
79 import org.scilab.modules.gui.separator.Separator;
80 import org.scilab.modules.gui.slider.ScilabSliderBridge;
81 import org.scilab.modules.gui.slider.SimpleSlider;
82 import org.scilab.modules.gui.slider.Slider;
83 import org.scilab.modules.gui.tab.ScilabTabBridge;
84 import org.scilab.modules.gui.tab.SimpleTab;
85 import org.scilab.modules.gui.tab.Tab;
86 import org.scilab.modules.gui.textbox.ScilabTextBoxBridge;
87 import org.scilab.modules.gui.textbox.SimpleTextBox;
88 import org.scilab.modules.gui.textbox.TextBox;
89 import org.scilab.modules.gui.toolbar.ScilabToolBarBridge;
90 import org.scilab.modules.gui.toolbar.SimpleToolBar;
91 import org.scilab.modules.gui.toolbar.ToolBar;
92 import org.scilab.modules.gui.utils.Position;
93 import org.scilab.modules.gui.utils.Size;
94 import org.scilab.modules.gui.waitbar.ScilabWaitBarBridge;
95 import org.scilab.modules.gui.waitbar.SimpleWaitBar;
96 import org.scilab.modules.gui.waitbar.WaitBar;
97 import org.scilab.modules.gui.window.ScilabWindowBridge;
98 import org.scilab.modules.gui.window.SimpleWindow;
99 import org.scilab.modules.gui.window.Window;
100
101 /**
102  * Main bridge for Scilab Java GUIs
103  * @author Vincent COUVERT
104  * @author Bruno Jofret
105  */
106 public class ScilabBridge {
107
108         /**
109          * Constructor for ScilabBridge class
110          */
111         protected ScilabBridge() {
112                 throw new UnsupportedOperationException(); /* Prevents calls from subclass */
113         }
114
115         /*****************/
116         /* Window Bridge */
117         /*****************/
118
119         /**
120          * Creates a new window
121          * @return the created window
122          */
123         public static SimpleWindow createWindow() {
124                 return ScilabWindowBridge.createWindow();
125         }
126
127         /**
128          * Draws a window on screen
129          * @param window the window to be drawn
130          */
131         public static void draw(Window window) {
132                 ScilabWindowBridge.draw(window);
133         }
134
135         /**
136          * Gets the dimensions (width and height) of a window
137          * @param window the window we want to get the dimensions of
138          * @return dimensions of the window
139          */
140         public static Size getDims(Window window) {
141                 return ScilabWindowBridge.getDims(window);
142         }
143
144         /**
145          * Sets the dimensions (width and height) of a window
146          * @param window the window we want to set the dimensions of
147          * @param newWindowSize new dimensions of the window
148          */
149         public static void setDims(Window window, Size newWindowSize) {
150                 ScilabWindowBridge.setDims(window, newWindowSize);
151         }
152
153         /**
154          * Gets the position (X-coordinate and Y-coordinate) of a window
155          * @param window the window we want to get the position of
156          * @return position of the window
157          */
158         public static Position getPosition(Window window) {
159                 return ScilabWindowBridge.getPosition(window);
160         }
161
162         /**
163          * Sets the position (X-coordinate and Y-coordinate) of a window
164          * @param window the window we want to set the position of
165          * @param newWindowPosition new position of the window
166          */
167         public static void setPosition(Window window, Position newWindowPosition) {
168                 ScilabWindowBridge.setPosition(window, newWindowPosition);
169         }
170
171         /**
172          * Gets the title of a window
173          * @param window the window we want to get the title of
174          * @return the title of the window
175          */
176         public static String getTitle(Window window) {
177                 return ScilabWindowBridge.getTitle(window);
178         }
179
180         /**
181          * Sets the title of a window
182          * @param window the window we want to set the title of
183          * @param newWindowTitle the title to set for the window
184          */
185         public static void setTitle(Window window, String newWindowTitle) {
186                 ScilabWindowBridge.setTitle(window, newWindowTitle);
187         }
188
189         /**
190          * Gets the visibility status of a window
191          * @param window the window we want to get the status of
192          * @return visibility status (true if the window is visible, false if not)
193          */
194         public static boolean isVisible(Window window) {
195                 return ScilabWindowBridge.isVisible(window);
196         }
197
198         /**
199          * Sets the visibility status for a window
200          * @param window the window we want to set the visibility status of
201          * @param newVisibleState new visibility status for the window
202          *                      (true set the window visible, false to set the window invisible)
203          */
204         public static void setVisible(Window window, boolean newVisibleState) {
205                 ScilabWindowBridge.setVisible(window, newVisibleState);
206         }
207
208         /**
209          * Add a tab to a window
210          * @param window the window which we want to add the tab to
211          * @param newTab the tab to add to the window
212          */
213         public static void addTab(Window window, Tab newTab) {
214                 ScilabWindowBridge.addTab(window, newTab);
215         }
216         
217         /**
218          * Add a tab to a window
219          * @param window the window which we want to remove the tab from
220          * @param newTab the tab to add to the window
221          */
222         public static void removeTab(Window window, Tab newTab) {
223                 ScilabWindowBridge.removeTab(window, newTab);
224         }
225
226         /**
227          * Sets a MenuBar to a window
228          * @param window the window which we want to add the MeunBar to
229          * @param newMenuBar the MeunBar to add to the window
230          */
231         public static void addMenuBar(Window window, MenuBar newMenuBar) {
232                 ScilabWindowBridge.addMenuBar(window, newMenuBar);
233         }
234         
235         /**
236          * Sets a ToolBar to a window
237          * @param window the window which we want to add the ToolBar to
238          * @param newToolBar the ToolBar to add to the window
239          */
240         public static void addToolBar(Window window, ToolBar newToolBar) {
241                 ScilabWindowBridge.addToolBar(window, newToolBar);
242         }
243         
244         /**
245          * Sets a InfoBar to a window
246          * @param window the window which we want to add the InfoBar to
247          * @param newInfoBar the InfoBar to add to the window
248          */
249         public static void addInfoBar(Window window, TextBox newInfoBar) {
250                 ScilabWindowBridge.addInfoBar(window, newInfoBar);
251         }
252         
253         /*****************/
254         /* ToolBar Bridge */
255         /*****************/
256         
257         /**
258          * Creates a new ToolBar
259          * @return the created ToolBar
260          */
261         public static SimpleToolBar createToolBar() {
262                 return ScilabToolBarBridge.createToolBar();
263         }
264         
265         /**
266          * Add a PushButton to the ToolBar.
267          * @param toolBar the toolBar which we want to add the PushButton to
268          * @param pushButton the PushButton to add.
269          */
270         public static void add(ToolBar toolBar, PushButton pushButton) {
271                 ScilabToolBarBridge.add(toolBar, pushButton);
272         }
273
274         /**
275          * Add a Separator to a Toolbar
276          * @param toolbar the Toolbar which we want to add the Separator to
277          */
278         public static void addSeparator(ToolBar toolbar) {
279                 ScilabToolBarBridge.addSeparator(toolbar);
280         }
281
282         /**
283          * Set the visibility of the Toolbar
284          * @param toolbar the ToolBar
285          * @param newVisibleState true to set the toolbar visible
286          */
287         public static void setVisible(ToolBar toolbar, boolean newVisibleState) {
288                 ScilabToolBarBridge.setVisible(toolbar, newVisibleState);
289         }
290         
291         /**
292          * Get the visibility of the TooBar
293          * @param toolbar the ToolBar
294          * @return true if the ToolBar is Visible
295          */
296         public static boolean isVisible(ToolBar toolbar) {
297                 return ScilabToolBarBridge.isVisible(toolbar);
298         }
299
300         
301         /****************/
302         /* Frame Bridge */
303         /****************/
304
305         /**
306          * Creates a new Frame
307          * @return the created Frame
308          */
309         public static SimpleFrame createFrame() {
310                 return ScilabFrameBridge.createFrame();
311         }
312         
313         /**
314          * Sets the Text of a Frame
315          * @param frame the Frame we want to set the Text of
316          * @param newText the Text to set for the Frame
317          */
318         public static void setText(Frame frame, String newText) {
319                 ScilabFrameBridge.setText(frame, newText);
320         }
321         
322         /**
323          * Gets the text of an Frame
324          * @param frame the Frame we want to get the text of
325          * @return the text of the Frame
326          */
327         public static String getText(Frame frame) {
328                 return ScilabFrameBridge.getText(frame);
329         }
330         
331         /**
332          * Draws a Scilab Frame
333          * @param frame the Frame to draw
334          * @see org.scilab.modules.ihm.UIElement#draw()
335          */
336         public static void draw(Frame frame) {
337                 ScilabFrameBridge.draw(frame);
338         }
339
340         /**
341          * Gets the dimensions (width and height) of a Scilab Frame
342          * @param frame the Frame we want to get the dimensions of
343          * @return the size of the frame
344          * @see org.scilab.modules.ihm.UIElement#getDims()
345          */
346         public static Size getDims(Frame frame) {
347                 return ScilabFrameBridge.getDims(frame);
348         }
349
350         /**
351          * Gets the position (X-coordinate and Y-coordinate) of a Scilab frame
352          * @param frame the frame we want to get the position of
353          * @return the position of the frame
354          * @see org.scilab.modules.ihm.UIElement#getPosition()
355          */
356         public static Position getPosition(Frame frame) {
357                 return ScilabFrameBridge.getPosition(frame);
358         }
359
360         /**
361          * Gets the visibility status of a Scilab Frame
362          * @param frame the frame we want to get the visiblity status of
363          * @return the visibility status of the frame (true if the frame is visible, false if not)
364          * @see org.scilab.modules.ihm.UIElement#isVisible()
365          */
366         public static boolean isVisible(Frame frame) {
367                 return ScilabFrameBridge.isVisible(frame);
368         }
369
370         /**
371          * Sets the dimensions (width and height) of a Scilab Frame
372          * @param frame the frame we want to set the dimensions of
373          * @param newSize the size we want to set to the frame
374          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
375          */
376         public static void setDims(Frame frame, Size newSize) {
377                 ScilabFrameBridge.setDims(frame, newSize);
378         }
379
380         /**
381          * Sets the position (X-coordinate and Y-coordinate) of a Scilab frame
382          * @param frame the frame we want to set the position of
383          * @param newPosition the position we want to set to the frame
384          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
385          */
386         public static void setPosition(Frame frame, Position newPosition) {
387                 ScilabFrameBridge.setPosition(frame, newPosition);
388         }
389
390         /**
391          * Sets the visibility status of a Scilab Frame
392          * @param frame the frame we want to set the visiblity status of
393          * @param newVisibleState the visibility status we want to set to the frame (true to set the frame visible, false else)
394          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
395          */
396         public static void setVisible(Frame frame, boolean newVisibleState) {
397                 ScilabFrameBridge.setVisible(frame, newVisibleState);
398         }
399         
400         /**
401          * Set the Background color of the Frame
402          * @param frame the Frame we want to set the background of
403          * @param color the Color
404          */
405         public static void setBackground(Frame frame, Color color) {
406                 ScilabFrameBridge.setBackground(frame, color);
407         }
408
409         /**
410          * Get the Background color of the Frame
411          * @param frame the Frame we want to get the background of
412          * @return the Color
413          */
414         public static Color getBackground(Frame frame) {
415                 return ScilabFrameBridge.getBackground(frame);
416         }
417
418         /**
419          * Set the Foreground color of the Frame
420          * @param frame the Frame we want to set the foreground of
421          * @param color the Color
422          */
423         public static void setForeground(Frame frame, Color color) {
424                 ScilabFrameBridge.setForeground(frame, color);
425         }
426
427         /**
428          * Get the Foreground color of the Frame
429          * @param frame the Frame we want to get the foreground of
430          * @return the Color
431          */
432         public static Color getForeground(Frame frame) {
433                 return ScilabFrameBridge.getForeground(frame);
434         }
435
436         /**
437          * Set the font of the Frame.
438          * @param frame the Frame we want to set the font of
439          * @param font the font
440          */
441         public static void setFont(Frame frame, Font font) {
442                 ScilabFrameBridge.setFont(frame, font);
443         }
444         
445         /**
446          * Get the font of the Frame.
447          * @param frame the Frame we want to get the font of
448          * @return the font
449          */
450         public static Font getFont(Frame frame) {
451                 return ScilabFrameBridge.getFont(frame);
452         }
453
454         /**
455          * Set if the Frame is enabled or not
456          * @param frame the Frame we want to set the status of
457          * @param status true if the Frame is enabled
458          */
459         public static void setEnabled(Frame frame, boolean status) {
460                 ScilabFrameBridge.setEnabled(frame, status);
461         }
462         
463         /**
464          * Add a callback to the Frame
465          * @param frame the Frame we want to set the callback of
466          * @param callback the callback to set
467          */
468         public static void setCallback(Frame frame, CallBack callback) {
469                 ScilabFrameBridge.setCallback(frame, callback);
470         }
471
472         /**
473          * Set the Relief of the Frame
474          * @param frame the Frame we want to set the Relief of
475          * @param reliefType the type of the relief to set (See ScilabRelief.java)
476          */
477         public static void setRelief(Frame frame, String reliefType) {
478                 ScilabFrameBridge.setRelief(frame, reliefType);
479         }
480
481         /**
482          * Delete the Frame
483          * @param frame the frame to be destroyed
484          */
485         public static void destroy(Frame frame) {
486                 ScilabFrameBridge.destroy(frame);
487         }
488
489         /**************/
490         /* Tab Bridge */
491         /**************/
492
493         /**
494          * Creates a Scilab tab
495          * @param name the name of the tab (used to identify it)
496          * @return the created tab
497          */
498         public static SimpleTab createTab(String name) {
499                 return ScilabTabBridge.createTab(name);
500         }
501
502         /**
503          * Draws a tab on screen
504          * @param tab the tab to be drawn
505          */
506         public static void draw(Tab tab) {
507                 ScilabTabBridge.draw(tab);
508         }
509
510         /**
511          * Gets the dimensions (width and height) of a tab
512          * @param tab the tab we want to get the dimensions of
513          * @return the dimensions of the tab
514          */
515         public static Size getDims(Tab tab) {
516                 return ScilabTabBridge.getDims(tab);
517         }
518
519         /**
520          * Sets the dimensions (width and height) of a tab
521          * @param tab the tab we want to set the dimensions of
522          * @param newTabSize new dimensions of the tab
523          */
524         public static void setDims(Tab tab, Size newTabSize) {
525                 ScilabTabBridge.setDims(tab, newTabSize);
526         }
527
528         /**
529          * Gets the position (X-coordinate and Y-coordinate) of a tab
530          * @param tab the tab we want to get the position of
531          * @return position of the tab
532          */
533         public static Position getPosition(Tab tab) {
534                 return ScilabTabBridge.getPosition(tab);
535         }
536
537         /**
538          * Sets the position (X-coordinate and Y-coordinate) of a tab
539          * @param tab the tab we want to set the position of
540          * @param newTabPosition new position of the tab
541          */
542         public static void setPosition(Tab tab, Position newTabPosition) {
543                 ScilabTabBridge.setPosition(tab, newTabPosition);
544         }
545
546         /**
547          * Gets the Name of a tab
548          * @param tab the tab we want to get the Name of
549          * @return the Name of the tab
550          */
551         public static String getName(Tab tab) {
552                 return ScilabTabBridge.getName(tab);
553         }
554
555         /**
556          * Sets the name of a tab
557          * @param tab the tab we want to set the name of
558          * @param newTabName the name to set for the tab
559          */
560         public static void setName(Tab tab, String newTabName) {
561                 ScilabTabBridge.setName(tab, newTabName);
562         }
563
564         /**
565          * Gets the visibility status of a tab
566          * @param tab the tab we want to get the status of
567          * @return visibility status (true if the tab is visible, false if not)
568          */
569         public static boolean isVisible(Tab tab) {
570                 return ScilabTabBridge.isVisible(tab);
571         }
572
573         /**
574          * Sets the visibility status of a tab
575          * @param tab the tab we want to set the visibility status of
576          * @param newVisibleState new visibility status for the tab
577          *                      (true set the tab visible, false to set the tab invisible)
578          */
579         public static void setVisible(Tab tab, boolean newVisibleState) {
580                 ScilabTabBridge.setVisible(tab, newVisibleState);
581         }
582
583         /**
584          * Add a member (dockable element) to a tab and returns the index of this member
585          * @param tab the tab where we want to add the member
586          * @param member the member to add
587          * @return index of member
588          */
589         public static int addMember(Tab tab, Frame member) {
590                 return ScilabTabBridge.addMember(tab, member);
591         }
592
593         /**
594          * Add a member (dockable element) to a tab and returns the index of this member
595          * @param tab the tab where we want to add the member
596          * @param member the member to add
597          * @return index of member
598          */
599         public static int addMember(Tab tab, Console member) {
600                 return ScilabTabBridge.addMember(tab, member);
601         }
602
603         /**
604          * We want to be able to add directly a HelpBrowser in a Tab.
605          * @param tab the tab where we want to add the member
606          * @param member the member to add
607          * @return the position of the HelpBrowser in the member list.
608          */
609         public static int addMember(Tab tab, HelpBrowser member) {
610                 return ScilabTabBridge.addMember(tab, member);
611         }
612         
613         /**
614          * Add a member (dockable element) to a tab and returns the index of this member
615          * @param tab the tab where we want to add the member
616          * @param member the member to add
617          * @return index of member
618          */
619         public static int addMember(Tab tab, Canvas member) {
620                 return ScilabTabBridge.addMember(tab, member);
621         }
622         
623         /**
624          * Sets a MenuBar to a tab
625          * @param tab the tab which we want to add the MenuBar to
626          * @param newMenuBar the MenuBar to add to the tab
627          */
628         public static void addMenuBar(Tab tab, MenuBar newMenuBar) {
629                 ScilabTabBridge.addMenuBar(tab, newMenuBar);
630         }
631         
632         /**
633          * Add a member (dockable element) to a tab and returns the index of this member
634          * @param tab the tab which we want to add the pushbutton to
635          * @param member the pushbutton to add
636          * @return the position of the pushbutton in the member list.
637          */
638         public static int addMember(Tab tab, PushButton member) {
639                 return ScilabTabBridge.addMember(tab, member);
640         }
641         
642         /**
643          * Add a member (dockable element) to a tab and returns the index of this member
644          * @param tab the tab which we want to add the EditBox to
645          * @param member the editbox to add
646          * @return the position of the editbox in the member list.
647          */
648         public static int addMember(Tab tab, EditBox member) {
649                 return ScilabTabBridge.addMember(tab, member);
650         }
651         
652         /**
653          * Add a member (dockable element) to a tab and returns the index of this member
654          * @param tab the tab which we want to add the Label to
655          * @param member the label to add
656          * @return the position of the label in the member list.
657          */
658         public static int addMember(Tab tab, Label member) {
659                 return ScilabTabBridge.addMember(tab, member);
660         }
661         
662         /**
663          * Add a member (dockable element) to a tab and returns the index of this member
664          * @param tab the tab which we want to add the CheckBox to
665          * @param member the checkbox to add
666          * @return the position of the checkbox in the member list.
667          */
668         public static int addMember(Tab tab, CheckBox member) {
669                 return ScilabTabBridge.addMember(tab, member);
670         }
671         
672         /**
673          * Add a member (dockable element) to a tab and returns the index of this member
674          * @param tab the tab which we want to add the RadioButton to
675          * @param member the RadioButton to add
676          * @return the position of the RadioButton in the member list.
677          */
678         public static int addMember(Tab tab, RadioButton member) {
679                 return ScilabTabBridge.addMember(tab, member);
680         }
681         
682         /**
683          * Add a member (dockable element) to a tab and returns the index of this member
684          * @param tab the tab which we want to add the Slider to
685          * @param member the Slider to add
686          * @return the position of the Slider in the member list.
687          */
688         public static int addMember(Tab tab, Slider member) {
689                 return ScilabTabBridge.addMember(tab, member);
690         }
691         
692         /**
693          * Add a member (dockable element) to a tab and returns the index of this member
694          * @param tab the tab which we want to add the ListBox to
695          * @param member the ListBox to add
696          * @return the position of the ListBox in the member list.
697          */
698         public static int addMember(Tab tab, ListBox member) {
699                 return ScilabTabBridge.addMember(tab, member);
700         }
701         
702         /**
703          * Add a member (dockable element) to a tab and returns the index of this member
704          * @param tab the tab which we want to add the PopupMenu to
705          * @param member the PopupMenu to add
706          * @return the position of the PopupMenu in the member list.
707          */
708         public static int addMember(Tab tab, PopupMenu member) {
709                 return ScilabTabBridge.addMember(tab, member);
710         }
711         
712         /**
713          * Remove a member (dockable element) to a tab and returns the index of this member
714          * @param tab the tab where we want to add the member
715          * @param member the member to add
716          */
717         public static void removeMember(Tab tab, Canvas member) {
718                 ScilabTabBridge.removeMember(tab, member);
719         }
720         
721         /**
722          * Get the current status of the Tab in its parent
723          * @param tab the tab we want to get the status of
724          * @return true is the tab is the tab currently displayed in its parent
725          */
726         public static boolean isCurrentTab(Tab tab) {
727                 return ScilabTabBridge.isCurrentTab(tab);
728         }
729
730         /**
731          * Set the parent window id for this tab
732          * @param tab the tab we want to set the parent window id of
733          * @param id the id of the parent window
734          */
735         public static void setParentWindowId(Tab tab, int id) {
736                 ScilabTabBridge.setParentWindowId(tab, id);
737         }
738         
739         /**
740          * Get the parent window id for this tab
741          * @param tab the tab we want to get the parent window id of
742          * @return the id of the parent window
743          */
744         public static int getParentWindowId(Tab tab) {
745                 return ScilabTabBridge.getParentWindowId(tab);
746         }
747         
748         /**
749          * Set the callback of the tab
750          * @param tab the tab which we want to set the callback of
751          * @param callback the CallBack to set
752          */
753         public static void setCallback(Tab tab, CallBack callback) {
754                 ScilabTabBridge.setCallback(tab, callback);
755         }
756         
757         /******************/
758         /* Console Bridge */
759         /******************/
760
761         /**
762          * Creates a Scilab Console
763          * @return the created console
764          */
765         public static SimpleConsole createConsole() {
766                 return ScilabConsoleBridge.createConsole();
767         }
768
769         /**
770          * Displays data in the console
771          * @param console the console to display the data in
772          * @param dataToDisplay the data to be displayed
773          * @see org.scilab.modules.console.HelpBrowser#display()
774          */
775         public static void display(Console console, String dataToDisplay) {
776                 ScilabConsoleBridge.display(console, dataToDisplay);
777         }
778
779         /**
780          * Reads input data in the console
781          * @param console the console to read the data from
782          * @return the data entered by the user
783          * @see org.scilab.modules.console.HelpBrowser#readLine()
784          */
785         public static String readLine(Console console) {
786                 return ScilabConsoleBridge.readLine(console);
787         }
788
789         /**
790          * Draw a console
791          * @param console the console to draw
792          * @see org.scilab.modules.ihm.UIElement#draw()
793          */
794         public static void draw(Console console) {
795                 ScilabConsoleBridge.draw(console);
796         }
797
798         /**
799          * Gets the dimensions (width and height) of a Scilab console
800          * @param console the console which we want to get the dimensions of
801          * @return the size of the console
802          * @see org.scilab.modules.ihm.UIElement#getDims()
803          */
804         public static Size getDims(Console console) {
805                 return ScilabConsoleBridge.getDims(console);
806         }
807
808         /**
809          * Gets the position (X-coordinate and Y-coordinates) of a Scilab console
810          * @param console the console which we want to get the position of
811          * @return the position of the console
812          * @see org.scilab.modules.ihm.UIElement#getPosition()
813          */
814         public static Position getPosition(Console console) {
815                 return ScilabConsoleBridge.getPosition(console);
816         }
817
818         /**
819          * Gets the visibility status of a console
820          * @param console the console which we want to get the visibility status of
821          * @return the visibility status of the console (true if the console is visible, false if not)
822          * @see org.scilab.modules.ihm.UIElement#isVisible()
823          */
824         public static boolean isVisible(Console console) {
825                 return ScilabConsoleBridge.isVisible(console);
826         }
827
828         /**
829          * Sets the visibility status of a console
830          * @param console the console which we want to get the visibility status of
831          * @param newVisibleState the visibility status we want to set to the console (true to set the console visible, false else)
832          * @see org.scilab.modules.ihm.UIElement#isVisible()
833          */
834         public static void setVisible(Console console, boolean newVisibleState) {
835                 ScilabConsoleBridge.setVisible(console, newVisibleState);
836         }
837         
838         /**
839          * Sets the dimensions (width and height) of a Scilab console
840          * @param console the console which we want to set the dimensions of
841          * @param newSize the size we want to set to the console
842          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
843          */
844         public static void setDims(Console console, Size newSize) {
845                 ScilabConsoleBridge.setDims(console, newSize);
846         }
847
848         /**
849          * Sets the position (X-coordinate and Y-coordinate) of a Scilab console
850          * @param console the console which we want to set the position of
851          * @param newPosition the position we want to set to the console
852          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
853          */
854         public static void setPosition(Console console, Position newPosition) {
855                 ScilabConsoleBridge.setPosition(console, newPosition);
856         }
857
858         /**
859          * Sets the visibility status of a Scilab console
860          * @param console the console which we want to set the visibility status of
861          * @param newVisibleState the visibility status we want to set to the console
862          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
863          */
864         public static void setPosition(Console console, boolean newVisibleState) {
865                 ScilabConsoleBridge.setVisible(console, newVisibleState);
866         }
867
868         /**
869          * Clears the console (no more scroll history and prompt on top left corner)
870          * @param console the console to be cleared
871          */
872         public static void clear(Console console) {
873                 ScilabConsoleBridge.clear(console);
874         }
875         
876         /**
877    * Clears lines from the end of the output view
878    * @param console the console to be cleared
879    * @param nbLines the number of lines to be deleted
880    */
881   public static void clear(Console console, int nbLines) {
882                 ScilabConsoleBridge.clear(console, nbLines);
883         }
884         
885         /**
886    * Puts the prompt in the top left corner of the console
887    * @param console the console used
888    */
889   public static void toHome(Console console) {
890         ScilabConsoleBridge.toHome(console);
891   }
892         
893         /**
894          * Reads one user input char
895          * @param console the console used to get the char
896          * @return the data entered by the user
897          * @see fr.scilab.console.HelpBrowser#getCharWithoutOutput()
898          */
899         public static int getCharWithoutOutput(Console console) {
900                 return ScilabConsoleBridge.getCharWithoutOutput(console);
901         }
902
903         /**
904            * Sets the prompt displayed in the console
905            * @param console the console where the prompt is set
906            * @param prompt the prompt to be displayed in the console
907            */
908         public static void setPrompt(Console console, String prompt) {
909                 ScilabConsoleBridge.setPrompt(console, prompt);
910         }
911         
912         /**
913          * Updates Scilab internal variables containing the size of the console
914          * These variables are used to format data before displaying it
915          * @param console object we want to get the size of
916          */
917         public static void scilabLinesUpdate(Console console) {
918                 ScilabConsoleBridge.scilabLinesUpdate(console);
919         }
920
921         /**
922          * Get the current status of the console
923          * If the prompt view is visible, Scilab is waiting for commands
924          * @param console object we want to get the status of
925          * @return true is Scilab is waiting for commands
926          */
927         public static boolean isWaitingForInput(Console console) {
928                 return ScilabConsoleBridge.isWaitingForInput(console);
929         }
930
931         /**
932          * Clear the commands history
933          * @param console the console we want to clear the history of 
934          */
935         public static void clearHistory(Console console) {
936                 ScilabConsoleBridge.clearHistory(console);
937         }
938         
939         /*****************/
940         /* Canvas Bridge */
941         /*****************/
942
943         /**
944          * Creates a Scilab Canvas
945          * @param figureIndex index of the displayed figure
946          * @return the created canvas
947          */
948         public static SimpleCanvas createCanvas(int figureIndex) {
949                 return ScilabCanvasBridge.createCanvas(figureIndex);
950         }
951
952         /**
953          * Draws a Scilab canvas
954          * @param canvas the canvas to draw
955          * @see org.scilab.modules.ihm.UIElement#draw()
956          */
957         public static void draw(Canvas canvas) {
958                 ScilabCanvasBridge.draw(canvas);
959         }
960
961         /**
962          * Gets the dimensions (width and height) of a Scilab Canvas
963          * @param canvas the canvas we want to get the dimensions of
964          * @return the size of the canvas
965          * @see org.scilab.modules.ihm.UIElement#getDims()
966          */
967         public static Size getDims(Canvas canvas) {
968                 return ScilabCanvasBridge.getDims(canvas);
969         }
970
971         /**
972          * Gets the position (X-coordinate and Y-coordinate) of a Scilab canvas
973          * @param canvas the canvas we want to get the position of
974          * @return the position of the canvas
975          * @see org.scilab.modules.ihm.UIElement#getPosition()
976          */
977         public static Position getPosition(Canvas canvas) {
978                 return ScilabCanvasBridge.getPosition(canvas);
979         }
980
981         /**
982          * Gets the visibility status of a Scilab Canvas
983          * @param canvas the canvas we want to get the visiblity status of
984          * @return the visibility status of the canvas (true if the canvas is visible, false if not)
985          * @see org.scilab.modules.ihm.UIElement#isVisible()
986          */
987         public static boolean isVisible(Canvas canvas) {
988                 return ScilabCanvasBridge.isVisible(canvas);
989         }
990
991         /**
992          * Sets the dimensions (width and height) of a Scilab Canvas
993          * @param canvas the canvas we want to set the dimensions of
994          * @param newSize the size we want to set to the canvas
995          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
996          */
997         public static void setDims(Canvas canvas, Size newSize) {
998                 ScilabCanvasBridge.setDims(canvas, newSize);
999         }
1000
1001         /**
1002          * Sets the position (X-coordinate and Y-coordinate) of a Scilab canvas
1003          * @param canvas the canvas we want to set the position of
1004          * @param newPosition the position we want to set to the canvas
1005          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
1006          */
1007         public static void setPosition(Canvas canvas, Position newPosition) {
1008                 ScilabCanvasBridge.setPosition(canvas, newPosition);
1009         }
1010
1011         /**
1012          * Sets the visibility status of a Scilab Canvas
1013          * @param canvas the canvas we want to set the visiblity status of
1014          * @param newVisibleState the visibility status we want to set to the canvas (true to set the canvas visible, false else)
1015          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
1016          */
1017         public static void setVisible(Canvas canvas, boolean newVisibleState) {
1018                 ScilabCanvasBridge.setVisible(canvas, newVisibleState);
1019         }
1020         
1021         /**
1022          * @param canvas the canvas we want to display
1023          */
1024         public static void display(Canvas canvas) {
1025                 ScilabCanvasBridge.display(canvas);
1026         }
1027         
1028         /**
1029          * @param canvas the canvas we want to get the GL object from
1030          * @return a GL object
1031          */
1032         public static GL getGL(Canvas canvas) {
1033                 return ScilabCanvasBridge.getGL(canvas);
1034         }
1035         
1036         /**
1037          * @param canvas the canvas of which we want to set the swap buffer mode.
1038          * @param onOrOff set wether the swap buffer mode is on or off.
1039          */
1040         public static void setAutoSwapBufferMode(Canvas canvas, boolean onOrOff) {
1041                 ScilabCanvasBridge.setAutoSwapBufferMode(canvas, onOrOff);
1042         }
1043         
1044         /**
1045          * @param canvas the canvas from which we want to retrieve the swap buffer mode.
1046          * @return set wether the swap buffer mode is on or off.
1047          */
1048         public static boolean getAutoSwapBufferMode(Canvas canvas) {
1049                 return ScilabCanvasBridge.getAutoSwapBufferMode(canvas);
1050         }
1051         
1052         /**
1053          * @param canvas the canvas we want to repaint
1054          */
1055         public static void repaint(Canvas canvas) {
1056                 ScilabCanvasBridge.repaint(canvas);
1057         }
1058         
1059         /**
1060          * Specify wether the canvas should fit the parent tab size
1061          * (and consequently the scrollpane size) or not
1062          * @param onOrOff true to enable autoresize mode
1063          * @param canvas the canvas we want to repaint
1064          */
1065         public static void setAutoResizeMode(Canvas canvas, boolean onOrOff) {
1066                 ScilabCanvasBridge.setAutoResizeMode(canvas, onOrOff);
1067         }
1068         
1069         /**
1070          * @return wether the resize mode is on or off
1071          * @param canvas the canvas we want to repaint
1072          */
1073         public static boolean getAutoResizeMode(Canvas canvas) {
1074                 return ScilabCanvasBridge.getAutoResizeMode(canvas);
1075         }
1076         
1077         /**
1078          * Get the part of the canvas which is currently viewed
1079          * @param canvas the canvas we want to repaint
1080          * @return [x,y,w,h] array
1081          */
1082         public static int[] getViewingRegion(Canvas canvas) {
1083                 return ScilabCanvasBridge.getViewingRegion(canvas);
1084         }
1085         
1086         /**
1087          * Specify a new viewport for the canvas
1088          * For SwingScilabCanvas viewport can not be modified
1089          * since it match the parent tab size
1090          * @param canvas the canvas we want to repaint
1091          * @param posX X coordinate of upper left point of the viewport within the canvas
1092          * @param posY Y coordinate of upper left point of the viewport within the canvas
1093          * @param width width of the viewport
1094          * @param height height of the viewport
1095          */
1096         public static void setViewingRegion(Canvas canvas, int posX, int posY, int width, int height) {
1097                 ScilabCanvasBridge.setViewingRegion(canvas, posX, posY, width, height);
1098         }
1099         
1100         /**
1101          * Set the background of the Canvas.
1102          * @param canvas the canvas we want to modify
1103          * @param red red channel
1104          * @param green green channel 
1105          * @param blue blue channel
1106          */
1107         public static void setBackgroundColor(Canvas canvas, double red, double green, double blue) {
1108                 ScilabCanvasBridge.setBackgroundColor(canvas, red, green, blue);
1109         }
1110         
1111         /**
1112          * Set the event handler of the Canvas
1113          * @param canvas the Canvas
1114          * @param command the name of the Scilab function to call
1115          */
1116         public static void setEventHandler(Canvas canvas, String command) {
1117                 ScilabCanvasBridge.setEventHandler(canvas, command);
1118         }
1119
1120         /**
1121          * Set the status of the event handler of the Canvas
1122          * @param canvas the Canvas
1123          * @param status is true to set the event handler active
1124          */
1125         public static void setEventHandlerEnabled(Canvas canvas, boolean status) {
1126                 ScilabCanvasBridge.setEventHandlerEnabled(canvas, status);
1127         }
1128         
1129         /*****************/
1130         /* MenuBar Bridge */
1131         /*****************/
1132
1133         /**
1134          * Creates a new MenuBar
1135          * @return the created MenuBar
1136          */
1137         public static SimpleMenuBar createMenuBar() {
1138                 return ScilabMenuBarBridge.createMenuBar();
1139         }
1140         
1141         /**
1142          * Append a Menu to a MenuBar
1143          * @param menuBar the MenuBar which we want to add the newMenu to
1144          * @param newMenu the Menu to add to the MenuBar
1145          */
1146         public static void add(MenuBar menuBar, Menu newMenu) {
1147                 ScilabMenuBarBridge.add(menuBar, newMenu);
1148         }
1149         
1150         /*****************/
1151         /* MenuItem Bridge */
1152         /*****************/
1153
1154         /**
1155          * Creates a new MenuItem
1156          * @return the created MenuItem
1157          */
1158         public static SimpleMenuItem createMenuItem() {
1159                 return ScilabMenuItemBridge.createMenuItem();
1160         }
1161         
1162         /**
1163          * Sets the Text of a MenuItem
1164          * @param menuItem the MenuItem we want to set the Text of
1165          * @param newText the Text to set for the MenuItem
1166          */
1167         public static void setText(MenuItem menuItem, String newText) {
1168                 ScilabMenuItemBridge.setText(menuItem, newText);
1169         }
1170         
1171         /**
1172          * set a mnemonic to a MenuItem
1173          * @param menuItem the MenuItem which we want to add the mnemonic to
1174          * @param mnemonic the mnemonic to add to the MenuItem
1175          */
1176         public static void setMnemonic(MenuItem menuItem, char mnemonic) {
1177                 ScilabMenuItemBridge.setMnemonic(menuItem, mnemonic);
1178         }
1179         
1180         /**
1181          * Add a callback to the menu, this callback is a Scilab command
1182          * @param menuItem the MenuItem which we want to add the mnemonic to
1183          * @param callback the CallBack to set.
1184          */
1185         public static void setCallback(MenuItem menuItem, CallBack callback) {
1186                 ScilabMenuItemBridge.setCallback(menuItem, callback);
1187         }
1188
1189         /**
1190          * Set if the menu item is enabled or not
1191          * @param menuItem the MenuItem which we want to add the mnemonic to
1192          * @param status true if the menu item is enabled
1193          */
1194         public static void setEnabled(MenuItem menuItem, boolean status) {
1195                 ScilabMenuItemBridge.setEnabled(menuItem, status);
1196         }
1197         
1198         /**
1199          * Get the text to a MenuItem
1200          * @param menuItem the MenuItem which we want to get the text of
1201          * @return the text of the MenuItem
1202          */
1203         public static String getText(MenuItem menuItem) {
1204                 return ScilabMenuItemBridge.getText(menuItem);
1205         }
1206         
1207         /**
1208          * set a mnemonic to a MenuItem
1209          * @param menuItem the MenuItem which we want to set the mnemonic to
1210          * @param mnemonic the new mnemonic to set to the MenuItem
1211          */
1212         public static void setMnemonic(MenuItem menuItem, int mnemonic) {
1213                 ScilabMenuItemBridge.setMnemonic(menuItem, mnemonic);
1214         }
1215
1216         /**
1217          * Sets the visibility status of a Scilab MenuItem
1218          * @param menuItem the MenuItem we want to set the visiblity status of
1219          * @param newVisibleState the visibility status we want to set to the MenuItem (true to set the MenuItem visible, false else)
1220          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
1221          */
1222         public static void setVisible(MenuItem menuItem, boolean newVisibleState) {
1223                 ScilabMenuItemBridge.setVisible(menuItem, newVisibleState);
1224         }
1225
1226         /**
1227          * Gets the visibility status of a Scilab MenuItem
1228          * @param menuItem the MenuItem we want to get the visiblity status of
1229          * @return the visibility status of the MenuItem (true if the MenuItem is visible, false if not)
1230          * @see org.scilab.modules.ihm.UIElement#isVisible()
1231          */
1232         public static boolean isVisible(MenuItem menuItem) {
1233                 return ScilabMenuItemBridge.isVisible(menuItem);
1234         }
1235
1236         /**
1237          * Set the Background color of the MenuItem
1238          * @param menuItem the MenuItem we want to set the background of
1239          * @param color the Color
1240          */
1241         public static void setBackground(MenuItem menuItem, Color color) {
1242                 ScilabMenuItemBridge.setBackground(menuItem, color);
1243         }
1244         
1245         /**
1246          * Get the Background color of the MenuItem
1247          * @param menuItem the MenuItem we want to get the background of
1248          * @return the Color
1249          */
1250         public static Color getBackground(MenuItem menuItem) {
1251                 return ScilabMenuItemBridge.getBackground(menuItem);
1252         }
1253
1254         /**
1255          * Set the Foreground color of the MenuItem
1256          * @param menuItem the MenuItem we want to set the foreground of
1257          * @param color the Color
1258          */
1259         public static void setForeground(MenuItem menuItem, Color color) {
1260                 ScilabMenuItemBridge.setForeground(menuItem, color);
1261         }
1262         
1263         /**
1264          * Get the Foreground color of the MenuItem
1265          * @param menuItem the MenuItem we want to get the foreground of
1266          * @return the Color
1267          */
1268         public static Color getForeground(MenuItem menuItem) {
1269                 return ScilabMenuItemBridge.getForeground(menuItem);
1270         }
1271
1272         /**
1273          * Set the font of the MenuItem.
1274          * @param menuItem the MenuItem we want to set the font of
1275          * @param font the font
1276          */
1277         public static void setFont(MenuItem menuItem, Font font) {
1278                 ScilabMenuItemBridge.setFont(menuItem, font);
1279         }
1280         
1281         /**
1282          * Get the font of the MenuItem.
1283          * @param menuItem the MenuItem we want to get the font of
1284          * @return the font
1285          */
1286         public static Font getFont(MenuItem menuItem) {
1287                 return ScilabMenuItemBridge.getFont(menuItem);
1288         }
1289
1290         /**
1291          * Set the horizontal alignment for the MenuItem text
1292          * @param menuItem the MenuItem we want to set the alignment of
1293          * @param alignment the value for the alignment (See ScilabAlignment.java)
1294          */
1295         public static void setHorizontalAlignment(MenuItem menuItem, String alignment) {
1296                 ScilabMenuItemBridge.setHorizontalAlignment(menuItem, alignment);
1297         }
1298
1299         /**
1300          * Set the vertical alignment for the MenuItem text
1301          * @param menuItem the MenuItem we want to set the alignment of
1302          * @param alignment the value for the alignment (See ScilabAlignment.java)
1303          */
1304         public static void setVerticalAlignment(MenuItem menuItem, String alignment) {
1305                 ScilabMenuItemBridge.setVerticalAlignment(menuItem, alignment);
1306         }
1307
1308         /**
1309          * Set the Relief of the MenuItem
1310          * @param menuItem the MenuItem which we want to set the Relief of
1311          * @param reliefType the type of the relief to set (See ScilabRelief.java)
1312          */
1313         public static void setRelief(MenuItem menuItem, String reliefType) {
1314                 ScilabMenuItemBridge.setRelief(menuItem, reliefType);
1315         }
1316
1317         /**
1318          * Add a MenuItem to the MenuItem
1319          * @param parentMenuItem the MenuItem where we want to add a MenuItem
1320          * @param childMenuItem the MenuItem we want to add
1321          */
1322         public static void add(MenuItem parentMenuItem, MenuItem childMenuItem) {
1323                 ScilabMenuItemBridge.add(parentMenuItem, childMenuItem);
1324         }
1325
1326         /**
1327          * Add a Menu to the MenuItem
1328          * @param parentMenuItem the MenuItem where we want to add a MenuItem
1329          * @param childMenu the Menu we want to add
1330          */
1331         public static void add(MenuItem parentMenuItem, Menu childMenu) {
1332                 ScilabMenuItemBridge.add(parentMenuItem, childMenu);
1333         }
1334
1335         /**
1336          * Destroy the MenuItem
1337          * @param menuItem the MenuItem to be destroyed
1338          */
1339         public static void destroy(MenuItem menuItem) {
1340                 ScilabMenuItemBridge.destroy(menuItem);
1341         }
1342
1343         /*****************/
1344         /* Menu Bridge */
1345         /*****************/
1346
1347         /**
1348          * Creates a new Menu
1349          * @return the created Menu
1350          */
1351         public static SimpleMenu createMenu() {
1352                 return ScilabMenuBridge.createMenu();
1353         }
1354         
1355         /**
1356          * Append a MenuItem to a Menu
1357          * @param menu the Menu which we want to add the MenuItem to
1358          * @param newMenuItem the MenuItem to add to the Menu
1359          */
1360         public static void add(Menu menu, MenuItem newMenuItem) {
1361                 ScilabMenuBridge.add(menu, newMenuItem);
1362         }
1363         
1364         /**
1365          * Append a Menu to a Menu
1366          * @param menu the Menu which we want to append the Menu to
1367          * @param newSubMenu the Menu to append to the Menu
1368          */
1369         public static void add(Menu menu, Menu newSubMenu) {
1370                 ScilabMenuBridge.add(menu, newSubMenu);
1371         }
1372         
1373         /**
1374          * set a text to a menu
1375          * @param menu the Menu which we want to set the text to
1376          * @param newText the new text to set to the menu
1377          */
1378         public static void setText(Menu menu, String newText) {
1379                 ScilabMenuBridge.setText(menu, newText);
1380         }
1381         
1382         /**
1383          * Get the text to a menu
1384          * @param menu the Menu which we want to get the text of
1385          * @return the text of the menu
1386          */
1387         public static String getText(Menu menu) {
1388                 return ScilabMenuBridge.getText(menu);
1389         }
1390         
1391         /**
1392          * set a mnemonic to a menu
1393          * @param menu the Menu which we want to set the mnemonic to
1394          * @param mnemonic the new mnemonic to set to the menu
1395          */
1396         public static void setMnemonic(Menu menu, int mnemonic) {
1397                 ScilabMenuBridge.setMnemonic(menu, mnemonic);
1398         }
1399         
1400         /**
1401          * Add a Separator to a Menu
1402          * @param menu the Menu which we want to add the Separator to
1403          */
1404         public static void addSeparator(Menu menu) {
1405                 ScilabMenuBridge.addSeparator(menu);
1406         }
1407
1408         /**
1409          * Set if the menu is enabled or not
1410          * @param menu the menu which we want to add the mnemonic to
1411          * @param status true if the menu item is enabled
1412          */
1413         public static void setEnabled(Menu menu, boolean status) {
1414                 ScilabMenuBridge.setEnabled(menu, status);
1415         }
1416
1417         /**
1418          * Sets the visibility status of a Scilab menu
1419          * @param menu the menu we want to set the visiblity status of
1420          * @param newVisibleState the visibility status we want to set to the menu (true to set the menu visible, false else)
1421          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
1422          */
1423         public static void setVisible(Menu menu, boolean newVisibleState) {
1424                 ScilabMenuBridge.setVisible(menu, newVisibleState);
1425         }
1426
1427         /**
1428          * Gets the visibility status of a Scilab Menu
1429          * @param menu the menu we want to get the visiblity status of
1430          * @return the visibility status of the menu (true if the menu is visible, false if not)
1431          * @see org.scilab.modules.ihm.UIElement#isVisible()
1432          */
1433         public static boolean isVisible(Menu menu) {
1434                 return ScilabMenuBridge.isVisible(menu);
1435         }
1436
1437         /**
1438          * Set the Background color of the menu
1439          * @param menu the menu we want to set the background of
1440          * @param color the Color
1441          */
1442         public static void setBackground(Menu menu, Color color) {
1443                 ScilabMenuBridge.setBackground(menu, color);
1444         }
1445         
1446         /**
1447          * Get the Background color of the menu
1448          * @param menu the menu we want to get the background of
1449          * @return the Color
1450          */
1451         public static Color getBackground(Menu menu) {
1452                 return ScilabMenuBridge.getBackground(menu);
1453         }
1454
1455         /**
1456          * Set the Foreground color of the menu
1457          * @param menu the menu we want to set the foreground of
1458          * @param color the Color
1459          */
1460         public static void setForeground(Menu menu, Color color) {
1461                 ScilabMenuBridge.setForeground(menu, color);
1462         }
1463         
1464         /**
1465          * Get the Foreground color of the menu
1466          * @param menu the menu we want to get the foreground of
1467          * @return the Color
1468          */
1469         public static Color getForeground(Menu menu) {
1470                 return ScilabMenuBridge.getForeground(menu);
1471         }
1472
1473         /**
1474          * Set the font of the menu.
1475          * @param menu the menu we want to set the font of
1476          * @param font the font
1477          */
1478         public static void setFont(Menu menu, Font font) {
1479                 ScilabMenuBridge.setFont(menu, font);
1480         }
1481         
1482         /**
1483          * Get the font of the menu.
1484          * @param menu the menu we want to get the font of
1485          * @return the font
1486          */
1487         public static Font getFont(Menu menu) {
1488                 return ScilabMenuBridge.getFont(menu);
1489         }
1490
1491         /**
1492          * Add a callback to the menu, this callback is a Scilab command
1493          * @param menu the menu we want to set the callback of
1494          * @param callback the CallBack to set.
1495          */
1496         public static void setCallback(Menu menu, CallBack callback) {
1497                 ScilabMenuBridge.setCallback(menu, callback);
1498         }
1499
1500         /**
1501          * Set the horizontal alignment for the Menu text
1502          * @param menu the Menu we want to set the alignment of
1503          * @param alignment the value for the alignment (See ScilabAlignment.java)
1504          */
1505         public static void setHorizontalAlignment(Menu menu, String alignment) {
1506                 ScilabMenuBridge.setHorizontalAlignment(menu, alignment);
1507         }
1508
1509         /**
1510          * Set the vertical alignment for the Menu text
1511          * @param menu the Menu we want to set the alignment of
1512          * @param alignment the value for the alignment (See ScilabAlignment.java)
1513          */
1514         public static void setVerticalAlignment(Menu menu, String alignment) {
1515                 ScilabMenuBridge.setVerticalAlignment(menu, alignment);
1516         }
1517
1518         /**
1519          * Set the Relief of the Menu
1520          * @param menu the Menu which we want to set the Relief of
1521          * @param reliefType the type of the relief to set (See ScilabRelief.java)
1522          */
1523         public static void setRelief(Menu menu, String reliefType) {
1524                 ScilabMenuBridge.setRelief(menu, reliefType);
1525         }
1526
1527         /**
1528          * Delete the Menu
1529          * @param menu the Menu to be destroyed
1530          */
1531         public static void destroy(Menu menu) {
1532                 ScilabMenuBridge.destroy(menu);
1533         }
1534
1535         /**********************/
1536         /* ContextMenu Bridge */
1537         /**********************/
1538
1539         /**
1540          * Creates a new ContextMenu
1541          * @return the created ContextMenu
1542          */
1543         public static SimpleContextMenu createContextMenu() {
1544                 return ScilabContextMenuBridge.createContextMenu();
1545         }
1546         
1547         /**
1548          * Append a MenuItem to a ContextMenu
1549          * @param contextMenu the ContextMenu which we want to add the MenuItem to
1550          * @param newMenuItem the MenuItem to add to the ContextMenu
1551          */
1552         public static void add(ContextMenu contextMenu, MenuItem newMenuItem) {
1553                 ScilabContextMenuBridge.add(contextMenu, newMenuItem);
1554         }
1555         
1556         /**
1557          * Append a Menu to a ContextMenu
1558          * @param contextMenu the ContextMenu which we want to add the MenuItem to
1559          * @param newMenu the Menu to add to the ContextMenu
1560          */
1561         public static void add(ContextMenu contextMenu, Menu newMenu) {
1562                 ScilabContextMenuBridge.add(contextMenu, newMenu);
1563         }
1564         
1565         /**
1566          * set a text to a ContextMenu
1567          * @param contextMenu the Menu which we want to set the text to
1568          * @param newText the new text to set to the contextMenu
1569          */
1570         public static void setText(ContextMenu contextMenu, String newText) {
1571                 ScilabContextMenuBridge.setText(contextMenu, newText);
1572         }
1573         
1574         /**
1575          * Get the text to a contextMenu
1576          * @param contextMenu the ContextMenu which we want to get the text of
1577          * @return the text of the contextMenu
1578          */
1579         public static String getText(ContextMenu contextMenu) {
1580                 return ScilabContextMenuBridge.getText(contextMenu);
1581         }
1582
1583         /**
1584          * Set if the contextMenu is enabled or not
1585          * @param contextMenu the contextMenu which we want to add the mnemonic to
1586          * @param status true if the contextMenu item is enabled
1587          */
1588         public static void setEnabled(ContextMenu contextMenu, boolean status) {
1589                 ScilabContextMenuBridge.setEnabled(contextMenu, status);
1590         }
1591
1592         /**
1593          * Sets the visibility status of a Scilab contextMenu
1594          * @param contextMenu the contextMenu we want to set the visiblity status of
1595          * @param newVisibleState the visibility status we want to set to the contextMenu (true to set the contextMenu visible, false else)
1596          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
1597          */
1598         public static void setVisible(ContextMenu contextMenu, boolean newVisibleState) {
1599                 ScilabContextMenuBridge.setVisible(contextMenu, newVisibleState);
1600         }
1601
1602         /**
1603          * Gets the visibility status of a Scilab ContextMenu
1604          * @param contextMenu the contextMenu we want to get the visiblity status of
1605          * @return the visibility status of the contextMenu (true if the contextMenu is visible, false if not)
1606          * @see org.scilab.modules.ihm.UIElement#isVisible()
1607          */
1608         public static boolean isVisible(ContextMenu contextMenu) {
1609                 return ScilabContextMenuBridge.isVisible(contextMenu);
1610         }
1611
1612         /**
1613          * Set the Background color of the contextMenu
1614          * @param contextMenu the contextMenu we want to set the background of
1615          * @param color the Color
1616          */
1617         public static void setBackground(ContextMenu contextMenu, Color color) {
1618                 ScilabContextMenuBridge.setBackground(contextMenu, color);
1619         }
1620         
1621         /**
1622          * Get the Background color of the contextMenu
1623          * @param contextMenu the contextMenu we want to get the background of
1624          * @return the Color
1625          */
1626         public static Color getBackground(ContextMenu contextMenu) {
1627                 return ScilabContextMenuBridge.getBackground(contextMenu);
1628         }
1629
1630         /**
1631          * Set the Foreground color of the contextMenu
1632          * @param contextMenu the contextMenu we want to set the foreground of
1633          * @param color the Color
1634          */
1635         public static void setForeground(ContextMenu contextMenu, Color color) {
1636                 ScilabContextMenuBridge.setForeground(contextMenu, color);
1637         }
1638         
1639         /**
1640          * Get the Foreground color of the contextMenu
1641          * @param contextMenu the contextMenu we want to get the foreground of
1642          * @return the Color
1643          */
1644         public static Color getForeground(ContextMenu contextMenu) {
1645                 return ScilabContextMenuBridge.getForeground(contextMenu);
1646         }
1647
1648         /**
1649          * Set the font of the contextMenu.
1650          * @param contextMenu the contextMenu we want to set the font of
1651          * @param font the font
1652          */
1653         public static void setFont(ContextMenu contextMenu, Font font) {
1654                 ScilabContextMenuBridge.setFont(contextMenu, font);
1655         }
1656         
1657         /**
1658          * Get the font of the contextMenu.
1659          * @param contextMenu the contextMenu we want to get the font of
1660          * @return the font
1661          */
1662         public static Font getFont(ContextMenu contextMenu) {
1663                 return ScilabContextMenuBridge.getFont(contextMenu);
1664         }
1665
1666         /**
1667          * Add a callback to the contextMenu, this callback is a Scilab command
1668          * @param contextMenu the contextMenu we want to set the callback of
1669          * @param callback the CallBack to set.
1670          */
1671         public static void setCallback(ContextMenu contextMenu, CallBack callback) {
1672                 ScilabContextMenuBridge.setCallback(contextMenu, callback);
1673         }
1674
1675         /**
1676          * Set the horizontal alignment for the ContextMenu text
1677          * @param contextMenu the ContextMenu we want to set the alignment of
1678          * @param alignment the value for the alignment (See ScilabAlignment.java)
1679          */
1680         public static void setHorizontalAlignment(ContextMenu contextMenu, String alignment) {
1681                 ScilabContextMenuBridge.setHorizontalAlignment(contextMenu, alignment);
1682         }
1683
1684         /**
1685          * Set the vertical alignment for the ContextMenu text
1686          * @param contextMenu the ContextMenu we want to set the alignment of
1687          * @param alignment the value for the alignment (See ScilabAlignment.java)
1688          */
1689         public static void setVerticalAlignment(ContextMenu contextMenu, String alignment) {
1690                 ScilabContextMenuBridge.setVerticalAlignment(contextMenu, alignment);
1691         }
1692
1693         /**
1694          * Set the Relief of the ContextMenu
1695          * @param contextMenu the ContextMenu which we want to set the Relief of
1696          * @param reliefType the type of the relief to set (See ScilabRelief.java)
1697          */
1698         public static void setRelief(ContextMenu contextMenu, String reliefType) {
1699                 ScilabContextMenuBridge.setRelief(contextMenu, reliefType);
1700         }
1701
1702         /**
1703          * Delete the ContextMenu
1704          * @param contextMenu the ContextMenu to be destroyed
1705          */
1706         public static void destroy(ContextMenu contextMenu) {
1707                 ScilabContextMenuBridge.destroy(contextMenu);
1708         }
1709
1710         /********************/
1711         /* Separator Bridge */
1712         /********************/
1713
1714         /**
1715          * Creates a new Separator
1716          * @return the created Separator
1717          */
1718         public static Separator createSeparator() {
1719                 return ScilabSeparatorBridge.createSeparator();
1720         }
1721         
1722         /*****************/
1723         /* PushButton Bridge */
1724         /*****************/
1725
1726         /**
1727          * Creates a new PushButton
1728          * @return the created PushButton
1729          */
1730         public static SimplePushButton createPushButton() {
1731                 return ScilabPushButtonBridge.createPushButton();
1732         }
1733         
1734         /**
1735          * Draws a pushButton on screen
1736          * @param pushButton the pushButton to be drawn
1737          */
1738         public static void draw(PushButton pushButton) {
1739                 ScilabPushButtonBridge.draw(pushButton);
1740         }
1741
1742         /**
1743          * Gets the dimensions (width and height) of a pushButton
1744          * @param pushButton the pushButton we want to get the dimensions of
1745          * @return dimensions of the pushButton
1746          */
1747         public static Size getDims(PushButton pushButton) {
1748                 return ScilabPushButtonBridge.getDims(pushButton);
1749         }
1750
1751         /**
1752          * Sets the dimensions (width and height) of a pushButton
1753          * @param pushButton the pushButton we want to set the dimensions of
1754          * @param newSize new dimensions of the pushButton
1755          */
1756         public static void setDims(PushButton pushButton, Size newSize) {
1757                 ScilabPushButtonBridge.setDims(pushButton, newSize);
1758         }
1759
1760         /**
1761          * Gets the position (X-coordinate and Y-coordinate) of a pushButton
1762          * @param pushButton the pushButton we want to get the position of
1763          * @return position of the pushButton
1764          */
1765         public static Position getPosition(PushButton pushButton) {
1766                 return ScilabPushButtonBridge.getPosition(pushButton);
1767         }
1768
1769         /**
1770          * Sets the position (X-coordinate and Y-coordinate) of a pushButton
1771          * @param pushButton the pushButton we want to set the position of
1772          * @param newPosition new position of the pushButton
1773          */
1774         public static void setPosition(PushButton pushButton, Position newPosition) {
1775                 ScilabPushButtonBridge.setPosition(pushButton, newPosition);
1776         }
1777
1778         /**
1779          * Gets the visibility status of a pushButton
1780          * @param pushButton the pushButton we want to get the status of
1781          * @return visibility status (true if the pushButton is visible, false if not)
1782          */
1783         public static boolean isVisible(PushButton pushButton) {
1784                 return ScilabPushButtonBridge.isVisible(pushButton);
1785         }
1786
1787         /**
1788          * Sets the visibility status for a pushButton
1789          * @param pushButton the pushButton we want to set the visibility status of
1790          * @param newVisibleState new visibility status for the pushButton
1791          *                      (true set the pushButton visible, false to set the pushButton invisible)
1792          */
1793         public static void setVisible(PushButton pushButton, boolean newVisibleState) {
1794                 ScilabPushButtonBridge.setVisible(pushButton, newVisibleState);
1795         }
1796         
1797         /**
1798          * Sets the Text of a PushButton
1799          * @param pushButton the PushButton we want to set the Text of
1800          * @param newText the Text to set for the PushButton
1801          */
1802         public static void setText(PushButton pushButton, String newText) {
1803                 ScilabPushButtonBridge.setText(pushButton, newText);
1804         }
1805         
1806         /**
1807          * Gets the Text of a PushButton
1808          * @param pushButton the PushButton we want to get the Text of
1809          * @return the Text of the PushButton
1810          */
1811         public static String getText(PushButton pushButton) {
1812                 return ScilabPushButtonBridge.getText(pushButton);
1813         }
1814         
1815         /**
1816          * Sets the icon of a PushButton
1817          * @param pushButton the PushButton we want to set the icon of
1818          * @param filename the path to the icon image to set to the PushButton
1819          */
1820         public static void setIcon(PushButton pushButton, String filename) {
1821                 ScilabPushButtonBridge.setIcon(pushButton, filename);
1822         }
1823         
1824         /**
1825          * Add a callback to the pushbutton
1826          * @param pushButton the PushButton we want to set the callback of
1827          * @param callback the CallBack to set.
1828          */
1829         public static void setCallback(PushButton pushButton, CallBack callback) {
1830                 ScilabPushButtonBridge.setCallback(pushButton, callback);
1831         }
1832
1833         /**
1834          * Set if the pushbutton is enabled or not
1835          * @param pushButton the PushButton we want to set the status of
1836          * @param status true if the pushbutton is enabled
1837          */
1838         public static void setEnabled(PushButton pushButton, boolean status) {
1839                 ScilabPushButtonBridge.setEnabled(pushButton, status);
1840         }
1841         
1842         /**
1843          * Set the Background color of the pushbutton
1844          * @param pushButton the PushButton we want to set the background of
1845          * @param color the Color
1846          */
1847         public static void setBackground(PushButton pushButton, Color color) {
1848                 ScilabPushButtonBridge.setBackground(pushButton, color);
1849         }
1850
1851         /**
1852          * Get the Background color of the pushbutton
1853          * @param pushButton the PushButton we want to get the background of
1854          * @return the Color
1855          */
1856         public static Color getBackground(PushButton pushButton) {
1857                 return ScilabPushButtonBridge.getBackground(pushButton);
1858         }
1859
1860         /**
1861          * Set the Foreground color of the pushbutton
1862          * @param pushButton the PushButton we want to set the foreground of
1863          * @param color the Color
1864          */
1865         public static void setForeground(PushButton pushButton, Color color) {
1866                 ScilabPushButtonBridge.setForeground(pushButton, color);
1867         }
1868
1869         /**
1870          * Get the Foreground color of the pushbutton
1871          * @param pushButton the PushButton we want to get the foreground of
1872          * @return the Color
1873          */
1874         public static Color getForeground(PushButton pushButton) {
1875                 return ScilabPushButtonBridge.getForeground(pushButton);
1876         }
1877
1878         /**
1879          * Set the font of the pushbutton.
1880          * @param pushButton the pushbutton we want to set the font of
1881          * @param font the font
1882          */
1883         public static void setFont(PushButton pushButton, Font font) {
1884                 ScilabPushButtonBridge.setFont(pushButton, font);
1885         }
1886         
1887         /**
1888          * Get the font of the pushbutton.
1889          * @param pushButton the pushbutton we want to get the font of
1890          * @return the font
1891          */
1892         public static Font getFont(PushButton pushButton) {
1893                 return ScilabPushButtonBridge.getFont(pushButton);
1894         }
1895
1896         /**
1897          * Set the horizontal alignment for the PushButton text
1898          * @param pushButton the PushButton we want to set the alignment of
1899          * @param alignment the value for the alignment (See ScilabAlignment.java)
1900          */
1901         public static void setHorizontalAlignment(PushButton pushButton, String alignment) {
1902                 ScilabPushButtonBridge.setHorizontalAlignment(pushButton, alignment);
1903         }
1904
1905         /**
1906          * Set the vertical alignment for the PushButton text
1907          * @param pushButton the PushButton we want to set the alignment of
1908          * @param alignment the value for the alignment (See ScilabAlignment.java)
1909          */
1910         public static void setVerticalAlignment(PushButton pushButton, String alignment) {
1911                 ScilabPushButtonBridge.setVerticalAlignment(pushButton, alignment);
1912         }
1913
1914         /**
1915          * Set the Relief of the PushButton
1916          * @param pushButton the PushButton which we want to set the Relief of
1917          * @param reliefType the type of the relief to set (See ScilabRelief.java)
1918          */
1919         public static void setRelief(PushButton pushButton, String reliefType) {
1920                 ScilabPushButtonBridge.setRelief(pushButton, reliefType);
1921         }
1922
1923         /**
1924          * Delete the PushButton
1925          * @param pushButton the PushButton to be destroyed
1926          */
1927         public static void destroy(PushButton pushButton) {
1928                 ScilabPushButtonBridge.destroy(pushButton);
1929         }
1930
1931         /**
1932          * Set the string to be displayed when the mouse cursor is over the PushButton
1933          * @param pushButton the PushButton
1934          * @param toolTipText the string to set
1935          */
1936         public static void setToolTipText(PushButton pushButton, String toolTipText) {
1937                 ScilabPushButtonBridge.setToolTipText(pushButton, toolTipText);
1938         }
1939         
1940         /******************/
1941         /* TextBox Bridge */
1942         /******************/
1943
1944         /**
1945          * Creates a new TextBox
1946          * @return the created TextBox
1947          */
1948         public static SimpleTextBox createTextBox() {
1949                 return ScilabTextBoxBridge.createTextBox();
1950         }
1951         
1952         /**
1953          * Sets the Text of a TextBox
1954          * @param textBox the TextBox we want to set the Text of
1955          * @param newText the Text to set for the TextBox
1956          */
1957         public static void setText(TextBox textBox, String newText) {
1958                 ScilabTextBoxBridge.setText(textBox, newText);
1959         }
1960         
1961         /**
1962          * Gets the text of an TextBox
1963          * @param textBox the TextBox we want to get the text of
1964          * @return the text of the TextBox
1965          */
1966         public static String getText(TextBox textBox) {
1967                 return ScilabTextBoxBridge.getText(textBox);
1968         }
1969         
1970         /**
1971          * Draws a Scilab TextBox
1972          * @param textBox the TextBox to draw
1973          * @see org.scilab.modules.ihm.UIElement#draw()
1974          */
1975         public static void draw(TextBox textBox) {
1976                 ScilabTextBoxBridge.draw(textBox);
1977         }
1978
1979         /**
1980          * Gets the dimensions (width and height) of a Scilab TextBox
1981          * @param textBox the TextBox we want to get the dimensions of
1982          * @return the size of the textBox
1983          * @see org.scilab.modules.ihm.UIElement#getDims()
1984          */
1985         public static Size getDims(TextBox textBox) {
1986                 return ScilabTextBoxBridge.getDims(textBox);
1987         }
1988
1989         /**
1990          * Gets the position (X-coordinate and Y-coordinate) of a Scilab textBox
1991          * @param textBox the textBox we want to get the position of
1992          * @return the position of the textBox
1993          * @see org.scilab.modules.ihm.UIElement#getPosition()
1994          */
1995         public static Position getPosition(TextBox textBox) {
1996                 return ScilabTextBoxBridge.getPosition(textBox);
1997         }
1998
1999         /**
2000          * Gets the visibility status of a Scilab TextBox
2001          * @param textBox the textBox we want to get the visiblity status of
2002          * @return the visibility status of the textBox (true if the textBox is visible, false if not)
2003          * @see org.scilab.modules.ihm.UIElement#isVisible()
2004          */
2005         public static boolean isVisible(TextBox textBox) {
2006                 return ScilabTextBoxBridge.isVisible(textBox);
2007         }
2008
2009         /**
2010          * Sets the dimensions (width and height) of a Scilab TextBox
2011          * @param textBox the textBox we want to set the dimensions of
2012          * @param newSize the size we want to set to the textBox
2013          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
2014          */
2015         public static void setDims(TextBox textBox, Size newSize) {
2016                 ScilabTextBoxBridge.setDims(textBox, newSize);
2017         }
2018
2019         /**
2020          * Sets the position (X-coordinate and Y-coordinate) of a Scilab textBox
2021          * @param textBox the textBox we want to set the position of
2022          * @param newPosition the position we want to set to the textBox
2023          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
2024          */
2025         public static void setPosition(TextBox textBox, Position newPosition) {
2026                 ScilabTextBoxBridge.setPosition(textBox, newPosition);
2027         }
2028
2029         /**
2030          * Sets the visibility status of a Scilab TextBox
2031          * @param textBox the textBox we want to set the visiblity status of
2032          * @param newVisibleState the visibility status we want to set to the textBox (true to set the textBox visible, false else)
2033          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
2034          */
2035         public static void setVisible(TextBox textBox, boolean newVisibleState) {
2036                 ScilabTextBoxBridge.setVisible(textBox, newVisibleState);
2037         }
2038
2039         /**
2040          * Set the Background color of the textbox
2041          * @param textBox the textbox we want to set the background of
2042          * @param color the Color
2043          */
2044         public static void setBackground(TextBox textBox, Color color) {
2045                 ScilabTextBoxBridge.setBackground(textBox, color);
2046         }
2047
2048         /**
2049          * Get the Background color of the textbox
2050          * @param textBox the textbox we want to get the background of
2051          * @return the Color
2052          */
2053         public static Color getBackground(TextBox textBox) {
2054                 return ScilabTextBoxBridge.getBackground(textBox);
2055         }
2056
2057         /**
2058          * Set the Foreground color of the textbox
2059          * @param textBox the textbox we want to set the foreground of
2060          * @param color the Color
2061          */
2062         public static void setForeground(TextBox textBox, Color color) {
2063                 ScilabTextBoxBridge.setForeground(textBox, color);
2064         }
2065
2066         /**
2067          * Get the Foreground color of the textbox
2068          * @param textBox the textbox we want to get the foreground of
2069          * @return the Color
2070          */
2071         public static Color getForeground(TextBox textBox) {
2072                 return ScilabTextBoxBridge.getForeground(textBox);
2073         }
2074
2075         /**
2076          * Set the font of the textbox.
2077          * @param textBox the textbox we want to set the font of
2078          * @param font the font
2079          */
2080         public static void setFont(TextBox textBox, Font font) {
2081                 ScilabTextBoxBridge.setFont(textBox, font);
2082         }
2083         
2084         /**
2085          * Get the font of the textbox.
2086          * @param textBox the textbox we want to get the font of
2087          * @return the font
2088          */
2089         public static Font getFont(TextBox textBox) {
2090                 return ScilabTextBoxBridge.getFont(textBox);
2091         }
2092
2093         /**
2094          * Add a callback to the TextBox
2095          * @param textBox the TextBox we want to set the callback of
2096          * @param callback the CallBack to set.
2097          */
2098         public static void setCallback(TextBox textBox, CallBack callback) {
2099                 ScilabTextBoxBridge.setCallback(textBox, callback);
2100         }
2101
2102         /**
2103          * Set the horizontal alignment for the TextBox text
2104          * @param textBox the TextBox we want to set the alignment of
2105          * @param alignment the value for the alignment (See ScilabAlignment.java)
2106          */
2107         public static void setHorizontalAlignment(TextBox textBox, String alignment) {
2108                 ScilabTextBoxBridge.setHorizontalAlignment(textBox, alignment);
2109         }
2110
2111         /**
2112          * Set the vertical alignment for the TextBox text
2113          * @param textBox the TextBox we want to set the alignment of
2114          * @param alignment the value for the alignment (See ScilabAlignment.java)
2115          */
2116         public static void setVerticalAlignment(TextBox textBox, String alignment) {
2117                 ScilabTextBoxBridge.setVerticalAlignment(textBox, alignment);
2118         }
2119
2120         /**
2121          * Set the Relief of the TextBox
2122          * @param textBox the TextBox which we want to set the Relief of
2123          * @param reliefType the type of the relief to set (See ScilabRelief.java)
2124          */
2125         public static void setRelief(TextBox textBox, String reliefType) {
2126                 ScilabTextBoxBridge.setRelief(textBox, reliefType);
2127         }
2128
2129         /**
2130          * Delete the TextBox
2131          * @param textBox the TextBox to be destroyed
2132          */
2133         public static void destroy(TextBox textBox) {
2134                 ScilabTextBoxBridge.destroy(textBox);
2135         }
2136
2137         /******************/
2138         /* EditBox Bridge */
2139         /******************/
2140
2141         /**
2142          * Creates a new EditBox
2143          * @return the created EditBox
2144          */
2145         public static SimpleEditBox createEditBox() {
2146                 return ScilabEditBoxBridge.createEditBox();
2147         }
2148         
2149         /**
2150          * Sets the Text of a EditBox
2151          * @param editBox the EditBox we want to set the Text of
2152          * @param newText the Text to set for the EditBox
2153          */
2154         public static void setText(EditBox editBox, String newText) {
2155                 ScilabEditBoxBridge.setText(editBox, newText);
2156         }
2157         
2158         /**
2159          * Gets the text of an EditBox
2160          * @param editBox the EditBox we want to get the text of
2161          * @return the text of the EditBox
2162          */
2163         public static String getText(EditBox editBox) {
2164                 return ScilabEditBoxBridge.getText(editBox);
2165         }
2166         
2167         /**
2168          * Draws a Scilab EditBox
2169          * @param editBox the EditBox to draw
2170          * @see org.scilab.modules.ihm.UIElement#draw()
2171          */
2172         public static void draw(EditBox editBox) {
2173                 ScilabEditBoxBridge.draw(editBox);
2174         }
2175
2176         /**
2177          * Gets the dimensions (width and height) of a Scilab EditBox
2178          * @param editBox the EditBox we want to get the dimensions of
2179          * @return the size of the editBox
2180          * @see org.scilab.modules.ihm.UIElement#getDims()
2181          */
2182         public static Size getDims(EditBox editBox) {
2183                 return ScilabEditBoxBridge.getDims(editBox);
2184         }
2185
2186         /**
2187          * Gets the position (X-coordinate and Y-coordinate) of a Scilab editBox
2188          * @param editBox the editBox we want to get the position of
2189          * @return the position of the editBox
2190          * @see org.scilab.modules.ihm.UIElement#getPosition()
2191          */
2192         public static Position getPosition(EditBox editBox) {
2193                 return ScilabEditBoxBridge.getPosition(editBox);
2194         }
2195
2196         /**
2197          * Gets the visibility status of a Scilab EditBox
2198          * @param editBox the editBox we want to get the visiblity status of
2199          * @return the visibility status of the editBox (true if the editBox is visible, false if not)
2200          * @see org.scilab.modules.ihm.UIElement#isVisible()
2201          */
2202         public static boolean isVisible(EditBox editBox) {
2203                 return ScilabEditBoxBridge.isVisible(editBox);
2204         }
2205
2206         /**
2207          * Sets the dimensions (width and height) of a Scilab EditBox
2208          * @param editBox the editBox we want to set the dimensions of
2209          * @param newSize the size we want to set to the editBox
2210          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
2211          */
2212         public static void setDims(EditBox editBox, Size newSize) {
2213                 ScilabEditBoxBridge.setDims(editBox, newSize);
2214         }
2215
2216         /**
2217          * Sets the position (X-coordinate and Y-coordinate) of a Scilab editBox
2218          * @param editBox the editBox we want to set the position of
2219          * @param newPosition the position we want to set to the editBox
2220          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
2221          */
2222         public static void setPosition(EditBox editBox, Position newPosition) {
2223                 ScilabEditBoxBridge.setPosition(editBox, newPosition);
2224         }
2225
2226         /**
2227          * Sets the visibility status of a Scilab EditBox
2228          * @param editBox the editBox we want to set the visiblity status of
2229          * @param newVisibleState the visibility status we want to set to the editBox (true to set the editBox visible, false else)
2230          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
2231          */
2232         public static void setVisible(EditBox editBox, boolean newVisibleState) {
2233                 ScilabEditBoxBridge.setVisible(editBox, newVisibleState);
2234         }
2235         
2236         /**
2237          * Set the Background color of the EditBox
2238          * @param editBox the EditBox we want to set the background of
2239          * @param color the Color
2240          */
2241         public static void setBackground(EditBox editBox, Color color) {
2242                 ScilabEditBoxBridge.setBackground(editBox, color);
2243         }
2244
2245         /**
2246          * Get the Background color of the EditBox
2247          * @param editBox the EditBox we want to get the background of
2248          * @return the Color
2249          */
2250         public static Color getBackground(EditBox editBox) {
2251                 return ScilabEditBoxBridge.getBackground(editBox);
2252         }
2253
2254         /**
2255          * Set the Foreground color of the EditBox
2256          * @param editBox the EditBox we want to set the foreground of
2257          * @param color the Color
2258          */
2259         public static void setForeground(EditBox editBox, Color color) {
2260                 ScilabEditBoxBridge.setForeground(editBox, color);
2261         }
2262
2263         /**
2264          * Get the Foreground color of the EditBox
2265          * @param editBox the EditBox we want to get the foreground of
2266          * @return the Color
2267          */
2268         public static Color getForeground(EditBox editBox) {
2269                 return ScilabEditBoxBridge.getForeground(editBox);
2270         }
2271
2272         /**
2273          * Set the font of the EditBox.
2274          * @param editBox the EditBox we want to set the font of
2275          * @param font the font
2276          */
2277         public static void setFont(EditBox editBox, Font font) {
2278                 ScilabEditBoxBridge.setFont(editBox, font);
2279         }
2280         
2281         /**
2282          * Get the font of the EditBox.
2283          * @param editBox the EditBox we want to get the font of
2284          * @return the font
2285          */
2286         public static Font getFont(EditBox editBox) {
2287                 return ScilabEditBoxBridge.getFont(editBox);
2288         }
2289
2290         /**
2291          * Set if the EditBox is enabled or not
2292          * @param editBox the EditBox we want to set the status of
2293          * @param status true if the EditBox is enabled
2294          */
2295         public static void setEnabled(EditBox editBox, boolean status) {
2296                 ScilabEditBoxBridge.setEnabled(editBox, status);
2297         }
2298         
2299         /**
2300          * Add a callback to the EditBox
2301          * @param editBox the EditBox we want to set the callback of
2302          * @param callback the Callback to set.
2303          */
2304         public static void setCallback(EditBox editBox, CallBack callback) {
2305                 ScilabEditBoxBridge.setCallback(editBox, callback);
2306         }
2307
2308         /**
2309          * Set the horizontal alignment for the EditBox text
2310          * @param editBox the EditBox we want to set the alignment of
2311          * @param alignment the value for the alignment (See ScilabAlignment.java)
2312          */
2313         public static void setHorizontalAlignment(EditBox editBox, String alignment) {
2314                 ScilabEditBoxBridge.setHorizontalAlignment(editBox, alignment);
2315         }
2316
2317         /**
2318          * Set the vertical alignment for the EditBox text
2319          * @param editBox the EditBox we want to set the alignment of
2320          * @param alignment the value for the alignment (See ScilabAlignment.java)
2321          */
2322         public static void setVerticalAlignment(EditBox editBox, String alignment) {
2323                 ScilabEditBoxBridge.setVerticalAlignment(editBox, alignment);
2324         }
2325
2326         /**
2327          * Set the Relief of the EditBox
2328          * @param editBox the EditBox which we want to set the Relief of
2329          * @param reliefType the type of the relief to set (See ScilabRelief.java)
2330          */
2331         public static void setRelief(EditBox editBox, String reliefType) {
2332                 ScilabEditBoxBridge.setRelief(editBox, reliefType);
2333         }
2334
2335         /**
2336          * Delete the EditBox
2337          * @param editBox the EditBox to be destroyed
2338          */
2339         public static void destroy(EditBox editBox) {
2340                 ScilabEditBoxBridge.destroy(editBox);
2341         }
2342         /****************/
2343         /* Label Bridge */
2344         /****************/
2345
2346         /**
2347          * Creates a new Label
2348          * @return the created Label
2349          */
2350         public static SimpleLabel createLabel() {
2351                 return ScilabLabelBridge.createLabel();
2352         }
2353         
2354         /**
2355          * Sets the Text of a Label
2356          * @param label the Label we want to set the Text of
2357          * @param newText the Text to set for the Label
2358          */
2359         public static void setText(Label label, String newText) {
2360                 ScilabLabelBridge.setText(label, newText);
2361         }
2362         
2363         /**
2364          * Gets the text of an Label
2365          * @param label the Label we want to get the text of
2366          * @return the text of the Label
2367          */
2368         public static String getText(Label label) {
2369                 return ScilabLabelBridge.getText(label);
2370         }
2371         
2372         /**
2373          * Draws a Scilab Label
2374          * @param label the Label to draw
2375          * @see org.scilab.modules.ihm.UIElement#draw()
2376          */
2377         public static void draw(Label label) {
2378                 ScilabLabelBridge.draw(label);
2379         }
2380
2381         /**
2382          * Gets the dimensions (width and height) of a Scilab Label
2383          * @param label the Label we want to get the dimensions of
2384          * @return the size of the label
2385          * @see org.scilab.modules.ihm.UIElement#getDims()
2386          */
2387         public static Size getDims(Label label) {
2388                 return ScilabLabelBridge.getDims(label);
2389         }
2390
2391         /**
2392          * Gets the position (X-coordinate and Y-coordinate) of a Scilab label
2393          * @param label the label we want to get the position of
2394          * @return the position of the label
2395          * @see org.scilab.modules.ihm.UIElement#getPosition()
2396          */
2397         public static Position getPosition(Label label) {
2398                 return ScilabLabelBridge.getPosition(label);
2399         }
2400
2401         /**
2402          * Gets the visibility status of a Scilab Label
2403          * @param label the label we want to get the visiblity status of
2404          * @return the visibility status of the label (true if the label is visible, false if not)
2405          * @see org.scilab.modules.ihm.UIElement#isVisible()
2406          */
2407         public static boolean isVisible(Label label) {
2408                 return ScilabLabelBridge.isVisible(label);
2409         }
2410
2411         /**
2412          * Sets the dimensions (width and height) of a Scilab Label
2413          * @param label the label we want to set the dimensions of
2414          * @param newSize the size we want to set to the label
2415          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
2416          */
2417         public static void setDims(Label label, Size newSize) {
2418                 ScilabLabelBridge.setDims(label, newSize);
2419         }
2420
2421         /**
2422          * Sets the position (X-coordinate and Y-coordinate) of a Scilab label
2423          * @param label the label we want to set the position of
2424          * @param newPosition the position we want to set to the label
2425          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
2426          */
2427         public static void setPosition(Label label, Position newPosition) {
2428                 ScilabLabelBridge.setPosition(label, newPosition);
2429         }
2430
2431         /**
2432          * Sets the visibility status of a Scilab Label
2433          * @param label the label we want to set the visiblity status of
2434          * @param newVisibleState the visibility status we want to set to the label (true to set the label visible, false else)
2435          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
2436          */
2437         public static void setVisible(Label label, boolean newVisibleState) {
2438                 ScilabLabelBridge.setVisible(label, newVisibleState);
2439         }
2440         
2441         /**
2442          * Set the Background color of the Label
2443          * @param label the Label we want to set the background of
2444          * @param color the Color
2445          */
2446         public static void setBackground(Label label, Color color) {
2447                 ScilabLabelBridge.setBackground(label, color);
2448         }
2449
2450         /**
2451          * Get the Background color of the Label
2452          * @param label the Label we want to get the background of
2453          * @return the Color
2454          */
2455         public static Color getBackground(Label label) {
2456                 return ScilabLabelBridge.getBackground(label);
2457         }
2458
2459         /**
2460          * Set the Foreground color of the Label
2461          * @param label the Label we want to set the foreground of
2462          * @param color the Color
2463          */
2464         public static void setForeground(Label label, Color color) {
2465                 ScilabLabelBridge.setForeground(label, color);
2466         }
2467
2468         /**
2469          * Get the Foreground color of the Label
2470          * @param label the Label we want to get the foreground of
2471          * @return the Color
2472          */
2473         public static Color getForeground(Label label) {
2474                 return ScilabLabelBridge.getForeground(label);
2475         }
2476
2477         /**
2478          * Set the font of the Label.
2479          * @param label the Label we want to set the font of
2480          * @param font the font
2481          */
2482         public static void setFont(Label label, Font font) {
2483                 ScilabLabelBridge.setFont(label, font);
2484         }
2485         
2486         /**
2487          * Get the font of the Label.
2488          * @param label the Label we want to get the font of
2489          * @return the font
2490          */
2491         public static Font getFont(Label label) {
2492                 return ScilabLabelBridge.getFont(label);
2493         }
2494
2495         /**
2496          * Set if the Label is enabled or not
2497          * @param label the Label we want to set the status of
2498          * @param status true if the Label is enabled
2499          */
2500         public static void setEnabled(Label label, boolean status) {
2501                 ScilabLabelBridge.setEnabled(label, status);
2502         }
2503         
2504         /**
2505          * Add a callback to the Label
2506          * @param label the Label we want to set the callback of
2507          * @param callback the Callback to set.
2508          */
2509         public static void setCallback(Label label, CallBack callback) {
2510                 ScilabLabelBridge.setCallback(label, callback);
2511         }
2512
2513         /**
2514          * Set the horizontal alignment for the Label text
2515          * @param label the Label we want to set the alignment of
2516          * @param alignment the value for the alignment (See ScilabAlignment.java)
2517          */
2518         public static void setHorizontalAlignment(Label label, String alignment) {
2519                 ScilabLabelBridge.setHorizontalAlignment(label, alignment);
2520         }
2521
2522         /**
2523          * Set the vertical alignment for the Label text
2524          * @param label the Label we want to set the alignment of
2525          * @param alignment the value for the alignment (See ScilabAlignment.java)
2526          */
2527         public static void setVerticalAlignment(Label label, String alignment) {
2528                 ScilabLabelBridge.setVerticalAlignment(label, alignment);
2529         }
2530         
2531         /**
2532          * Set the Relief of the Label
2533          * @param label the Label which we want to set the Relief of
2534          * @param reliefType the type of the relief to set (See ScilabRelief.java)
2535          */
2536         public static void setRelief(Label label, String reliefType) {
2537                 ScilabLabelBridge.setRelief(label, reliefType);
2538         }
2539
2540         /**
2541          * Delete the Label
2542          * @param label the Label to be destroyed
2543          */
2544         public static void destroy(Label label) {
2545                 ScilabLabelBridge.destroy(label);
2546         }
2547
2548         /*******************/
2549         /* CheckBox Bridge */
2550         /*******************/
2551
2552         /**
2553          * Creates a new CheckBox
2554          * @return the created CheckBox
2555          */
2556         public static SimpleCheckBox createCheckBox() {
2557                 return ScilabCheckBoxBridge.createCheckBox();
2558         }
2559         
2560         /**
2561          * Sets the Text of a CheckBox
2562          * @param checkBox the CheckBox we want to set the Text of
2563          * @param newText the Text to set for the CheckBox
2564          */
2565         public static void setText(CheckBox checkBox, String newText) {
2566                 ScilabCheckBoxBridge.setText(checkBox, newText);
2567         }
2568         
2569         /**
2570          * Gets the text of an CheckBox
2571          * @param checkBox the CheckBox we want to get the text of
2572          * @return the text of the CheckBox
2573          */
2574         public static String getText(CheckBox checkBox) {
2575                 return ScilabCheckBoxBridge.getText(checkBox);
2576         }
2577         
2578         /**
2579          * Draws a Scilab CheckBox
2580          * @param checkBox the CheckBox to draw
2581          * @see org.scilab.modules.ihm.UIElement#draw()
2582          */
2583         public static void draw(CheckBox checkBox) {
2584                 ScilabCheckBoxBridge.draw(checkBox);
2585         }
2586
2587         /**
2588          * Gets the dimensions (width and height) of a Scilab CheckBox
2589          * @param checkBox the CheckBox we want to get the dimensions of
2590          * @return the size of the checkBox
2591          * @see org.scilab.modules.ihm.UIElement#getDims()
2592          */
2593         public static Size getDims(CheckBox checkBox) {
2594                 return ScilabCheckBoxBridge.getDims(checkBox);
2595         }
2596
2597         /**
2598          * Gets the position (X-coordinate and Y-coordinate) of a Scilab checkBox
2599          * @param checkBox the checkBox we want to get the position of
2600          * @return the position of the checkBox
2601          * @see org.scilab.modules.ihm.UIElement#getPosition()
2602          */
2603         public static Position getPosition(CheckBox checkBox) {
2604                 return ScilabCheckBoxBridge.getPosition(checkBox);
2605         }
2606
2607         /**
2608          * Gets the visibility status of a Scilab CheckBox
2609          * @param checkBox the checkBox we want to get the visiblity status of
2610          * @return the visibility status of the checkBox (true if the checkBox is visible, false if not)
2611          * @see org.scilab.modules.ihm.UIElement#isVisible()
2612          */
2613         public static boolean isVisible(CheckBox checkBox) {
2614                 return ScilabCheckBoxBridge.isVisible(checkBox);
2615         }
2616
2617         /**
2618          * Sets the dimensions (width and height) of a Scilab CheckBox
2619          * @param checkBox the checkBox we want to set the dimensions of
2620          * @param newSize the size we want to set to the checkBox
2621          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
2622          */
2623         public static void setDims(CheckBox checkBox, Size newSize) {
2624                 ScilabCheckBoxBridge.setDims(checkBox, newSize);
2625         }
2626
2627         /**
2628          * Sets the position (X-coordinate and Y-coordinate) of a Scilab checkBox
2629          * @param checkBox the checkBox we want to set the position of
2630          * @param newPosition the position we want to set to the checkBox
2631          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
2632          */
2633         public static void setPosition(CheckBox checkBox, Position newPosition) {
2634                 ScilabCheckBoxBridge.setPosition(checkBox, newPosition);
2635         }
2636
2637         /**
2638          * Sets the visibility status of a Scilab CheckBox
2639          * @param checkBox the checkBox we want to set the visiblity status of
2640          * @param newVisibleState the visibility status we want to set to the checkBox (true to set the checkBox visible, false else)
2641          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
2642          */
2643         public static void setVisible(CheckBox checkBox, boolean newVisibleState) {
2644                 ScilabCheckBoxBridge.setVisible(checkBox, newVisibleState);
2645         }
2646         
2647         /**
2648          * Set the Background color of the CheckBox
2649          * @param checkBox the CheckBox we want to set the background of
2650          * @param color the Color
2651          */
2652         public static void setBackground(CheckBox checkBox, Color color) {
2653                 ScilabCheckBoxBridge.setBackground(checkBox, color);
2654         }
2655
2656         /**
2657          * Get the Background color of the CheckBox
2658          * @param checkBox the CheckBox we want to get the background of
2659          * @return the Color
2660          */
2661         public static Color getBackground(CheckBox checkBox) {
2662                 return ScilabCheckBoxBridge.getBackground(checkBox);
2663         }
2664
2665         /**
2666          * Set the Foreground color of the CheckBox
2667          * @param checkBox the CheckBox we want to set the foreground of
2668          * @param color the Color
2669          */
2670         public static void setForeground(CheckBox checkBox, Color color) {
2671                 ScilabCheckBoxBridge.setForeground(checkBox, color);
2672         }
2673
2674         /**
2675          * Get the Foreground color of the CheckBox
2676          * @param checkBox the CheckBox we want to get the foreground of
2677          * @return the Color
2678          */
2679         public static Color getForeground(CheckBox checkBox) {
2680                 return ScilabCheckBoxBridge.getForeground(checkBox);
2681         }
2682
2683         /**
2684          * Set the font of the CheckBox.
2685          * @param checkBox the CheckBox we want to set the font of
2686          * @param font the font
2687          */
2688         public static void setFont(CheckBox checkBox, Font font) {
2689                 ScilabCheckBoxBridge.setFont(checkBox, font);
2690         }
2691         
2692         /**
2693          * Get the font of the CheckBox.
2694          * @param checkBox the CheckBox we want to get the font of
2695          * @return the font
2696          */
2697         public static Font getFont(CheckBox checkBox) {
2698                 return ScilabCheckBoxBridge.getFont(checkBox);
2699         }
2700
2701         /**
2702          * Set if the CheckBox is enabled or not
2703          * @param checkBox the CheckBox we want to set the status of
2704          * @param status true if the CheckBox is enabled
2705          */
2706         public static void setEnabled(CheckBox checkBox, boolean status) {
2707                 ScilabCheckBoxBridge.setEnabled(checkBox, status);
2708         }
2709         
2710         /**
2711          * Add a callback to the CheckBox
2712          * @param checkBox the CheckBox we want to set the callback of
2713          * @param callback the CallBack to set.
2714          */
2715         public static void setCallback(CheckBox checkBox, CallBack callback) {
2716                 ScilabCheckBoxBridge.setCallback(checkBox, callback);
2717         }
2718
2719         /**
2720          * Set the horizontal alignment for the CheckBox text
2721          * @param checkBox the CheckBox we want to set the alignment of
2722          * @param alignment the value for the alignment (See ScilabAlignment.java)
2723          */
2724         public static void setHorizontalAlignment(CheckBox checkBox, String alignment) {
2725                 ScilabCheckBoxBridge.setHorizontalAlignment(checkBox, alignment);
2726         }
2727
2728         /**
2729          * Set the vertical alignment for the CheckBox text
2730          * @param checkBox the CheckBox we want to set the alignment of
2731          * @param alignment the value for the alignment (See ScilabAlignment.java)
2732          */
2733         public static void setVerticalAlignment(CheckBox checkBox, String alignment) {
2734                 ScilabCheckBoxBridge.setVerticalAlignment(checkBox, alignment);
2735         }
2736
2737         /**
2738          * Set if the CheckBox is checked or not
2739          * @param checkBox the CheckBox we want to set the status of
2740          * @param status true to set the CheckBox checked
2741          */
2742         public static void setChecked(CheckBox checkBox, boolean status) {
2743                 ScilabCheckBoxBridge.setChecked(checkBox, status);
2744         }
2745         
2746         /**
2747          * Get the status of the CheckBox
2748          * @param checkBox the CheckBox we want to get the status of
2749          * @return true if the CheckBox is checked
2750          */
2751         public static boolean isChecked(CheckBox checkBox) {
2752                 return ScilabCheckBoxBridge.isChecked(checkBox);
2753         }
2754
2755         /**
2756          * Set the Relief of the CheckBox
2757          * @param checkBox the CheckBox which we want to set the Relief of
2758          * @param reliefType the type of the relief to set (See ScilabRelief.java)
2759          */
2760         public static void setRelief(CheckBox checkBox, String reliefType) {
2761                 ScilabCheckBoxBridge.setRelief(checkBox, reliefType);
2762         }
2763
2764         /**
2765          * Delete the CheckBox
2766          * @param checkBox the CheckBox to be destroyed
2767          */
2768         public static void destroy(CheckBox checkBox) {
2769                 ScilabCheckBoxBridge.destroy(checkBox);
2770         }
2771
2772         /**********************/
2773         /* RadioButton Bridge */
2774         /**********************/
2775
2776         /**
2777          * Creates a new RadioButton
2778          * @return the created RadioButton
2779          */
2780         public static SimpleRadioButton createRadioButton() {
2781                 return ScilabRadioButtonBridge.createRadioButton();
2782         }
2783         
2784         /**
2785          * Sets the Text of a RadioButton
2786          * @param radioButton the RadioButton we want to set the Text of
2787          * @param newText the Text to set for the RadioButton
2788          */
2789         public static void setText(RadioButton radioButton, String newText) {
2790                 ScilabRadioButtonBridge.setText(radioButton, newText);
2791         }
2792         
2793         /**
2794          * Gets the text of an RadioButton
2795          * @param radioButton the RadioButton we want to get the text of
2796          * @return the text of the RadioButton
2797          */
2798         public static String getText(RadioButton radioButton) {
2799                 return ScilabRadioButtonBridge.getText(radioButton);
2800         }
2801         
2802         /**
2803          * Draws a Scilab RadioButton
2804          * @param radioButton the RadioButton to draw
2805          * @see org.scilab.modules.ihm.UIElement#draw()
2806          */
2807         public static void draw(RadioButton radioButton) {
2808                 ScilabRadioButtonBridge.draw(radioButton);
2809         }
2810
2811         /**
2812          * Gets the dimensions (width and height) of a Scilab RadioButton
2813          * @param radioButton the RadioButton we want to get the dimensions of
2814          * @return the size of the radioButton
2815          * @see org.scilab.modules.ihm.UIElement#getDims()
2816          */
2817         public static Size getDims(RadioButton radioButton) {
2818                 return ScilabRadioButtonBridge.getDims(radioButton);
2819         }
2820
2821         /**
2822          * Gets the position (X-coordinate and Y-coordinate) of a Scilab radioButton
2823          * @param radioButton the radioButton we want to get the position of
2824          * @return the position of the radioButton
2825          * @see org.scilab.modules.ihm.UIElement#getPosition()
2826          */
2827         public static Position getPosition(RadioButton radioButton) {
2828                 return ScilabRadioButtonBridge.getPosition(radioButton);
2829         }
2830
2831         /**
2832          * Gets the visibility status of a Scilab RadioButton
2833          * @param radioButton the radioButton we want to get the visiblity status of
2834          * @return the visibility status of the radioButton (true if the radioButton is visible, false if not)
2835          * @see org.scilab.modules.ihm.UIElement#isVisible()
2836          */
2837         public static boolean isVisible(RadioButton radioButton) {
2838                 return ScilabRadioButtonBridge.isVisible(radioButton);
2839         }
2840
2841         /**
2842          * Sets the dimensions (width and height) of a Scilab RadioButton
2843          * @param radioButton the radioButton we want to set the dimensions of
2844          * @param newSize the size we want to set to the radioButton
2845          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
2846          */
2847         public static void setDims(RadioButton radioButton, Size newSize) {
2848                 ScilabRadioButtonBridge.setDims(radioButton, newSize);
2849         }
2850
2851         /**
2852          * Sets the position (X-coordinate and Y-coordinate) of a Scilab radioButton
2853          * @param radioButton the radioButton we want to set the position of
2854          * @param newPosition the position we want to set to the radioButton
2855          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
2856          */
2857         public static void setPosition(RadioButton radioButton, Position newPosition) {
2858                 ScilabRadioButtonBridge.setPosition(radioButton, newPosition);
2859         }
2860
2861         /**
2862          * Sets the visibility status of a Scilab RadioButton
2863          * @param radioButton the radioButton we want to set the visiblity status of
2864          * @param newVisibleState the visibility status we want to set to the radioButton (true to set the radioButton visible, false else)
2865          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
2866          */
2867         public static void setVisible(RadioButton radioButton, boolean newVisibleState) {
2868                 ScilabRadioButtonBridge.setVisible(radioButton, newVisibleState);
2869         }
2870         
2871         /**
2872          * Set the Background color of the RadioButton
2873          * @param radioButton the RadioButton we want to set the background of
2874          * @param color the Color
2875          */
2876         public static void setBackground(RadioButton radioButton, Color color) {
2877                 ScilabRadioButtonBridge.setBackground(radioButton, color);
2878         }
2879
2880         /**
2881          * Get the Background color of the RadioButton
2882          * @param radioButton the RadioButton we want to get the background of
2883          * @return the Color
2884          */
2885         public static Color getBackground(RadioButton radioButton) {
2886                 return ScilabRadioButtonBridge.getBackground(radioButton);
2887         }
2888
2889         /**
2890          * Set the Foreground color of the RadioButton
2891          * @param radioButton the RadioButton we want to set the foreground of
2892          * @param color the Color
2893          */
2894         public static void setForeground(RadioButton radioButton, Color color) {
2895                 ScilabRadioButtonBridge.setForeground(radioButton, color);
2896         }
2897
2898         /**
2899          * Get the Foreground color of the RadioButton
2900          * @param radioButton the RadioButton we want to get the foreground of
2901          * @return the Color
2902          */
2903         public static Color getForeground(RadioButton radioButton) {
2904                 return ScilabRadioButtonBridge.getForeground(radioButton);
2905         }
2906
2907         /**
2908          * Set the font of the RadioButton.
2909          * @param radioButton the RadioButton we want to set the font of
2910          * @param font the font
2911          */
2912         public static void setFont(RadioButton radioButton, Font font) {
2913                 ScilabRadioButtonBridge.setFont(radioButton, font);
2914         }
2915         
2916         /**
2917          * Get the font of the RadioButton.
2918          * @param radioButton the RadioButton we want to get the font of
2919          * @return the font
2920          */
2921         public static Font getFont(RadioButton radioButton) {
2922                 return ScilabRadioButtonBridge.getFont(radioButton);
2923         }
2924
2925         /**
2926          * Set if the RadioButton is enabled or not
2927          * @param radioButton the RadioButton we want to set the status of
2928          * @param status true if the RadioButton is enabled
2929          */
2930         public static void setEnabled(RadioButton radioButton, boolean status) {
2931                 ScilabRadioButtonBridge.setEnabled(radioButton, status);
2932         }
2933         
2934         /**
2935          * Add a callback to the RadioButton
2936          * @param radioButton the RadioButton we want to set the callback of
2937          * @param callback the callback to set.
2938          */
2939         public static void setCallback(RadioButton radioButton, CallBack callback) {
2940                 ScilabRadioButtonBridge.setCallback(radioButton, callback);
2941         }
2942
2943         /**
2944          * Set the horizontal alignment for the RadioButton text
2945          * @param radioButton the RadioButton we want to set the alignment of
2946          * @param alignment the value for the alignment (See ScilabAlignment.java)
2947          */
2948         public static void setHorizontalAlignment(RadioButton radioButton, String alignment) {
2949                 ScilabRadioButtonBridge.setHorizontalAlignment(radioButton, alignment);
2950         }
2951
2952         /**
2953          * Set the vertical alignment for the RadioButton text
2954          * @param radioButton the RadioButton we want to set the alignment of
2955          * @param alignment the value for the alignment (See ScilabAlignment.java)
2956          */
2957         public static void setVerticalAlignment(RadioButton radioButton, String alignment) {
2958                 ScilabRadioButtonBridge.setVerticalAlignment(radioButton, alignment);
2959         }
2960
2961         /**
2962          * Set if the RadioButton is checked or not
2963          * @param radioButton the RadioButton we want to set the status of
2964          * @param status true to set the RadioButon checked
2965          */
2966         public static void setChecked(RadioButton radioButton, boolean status) {
2967                 ScilabRadioButtonBridge.setChecked(radioButton, status);
2968         }
2969         
2970         /**
2971          * Get the status of the RadioButton
2972          * @param radioButton the RadioButton we want to get the status of
2973          * @return true if the RadioButton is checked
2974          */
2975         public static boolean isChecked(RadioButton radioButton) {
2976                 return ScilabRadioButtonBridge.isChecked(radioButton);
2977         }
2978
2979         /**
2980          * Set the Relief of the RadioButton
2981          * @param radioButton the RadioButton which we want to set the Relief of
2982          * @param reliefType the type of the relief to set (See ScilabRelief.java)
2983          */
2984         public static void setRelief(RadioButton radioButton, String reliefType) {
2985                 ScilabRadioButtonBridge.setRelief(radioButton, reliefType);
2986         }
2987
2988         /**
2989          * Delete the RadioButton
2990          * @param radioButton the RadioButton to be destroyed
2991          */
2992         public static void destroy(RadioButton radioButton) {
2993                 ScilabRadioButtonBridge.destroy(radioButton);
2994         }
2995
2996         /*****************/
2997         /* Slider Bridge */
2998         /*****************/
2999
3000         /**
3001          * Creates a new Slider
3002          * @return the created Slider
3003          */
3004         public static SimpleSlider createSlider() {
3005                 return ScilabSliderBridge.createSlider();
3006         }
3007         
3008         /**
3009          * Sets the Text of a Slider
3010          * @param slider the Slider we want to set the Text of
3011          * @param newText the Text to set for the Slider
3012          */
3013         public static void setText(Slider slider, String newText) {
3014                 ScilabSliderBridge.setText(slider, newText);
3015         }
3016         
3017         /**
3018          * Gets the text of an Slider
3019          * @param slider the Slider we want to get the text of
3020          * @return the text of the Slider
3021          */
3022         public static String getText(Slider slider) {
3023                 return ScilabSliderBridge.getText(slider);
3024         }
3025         
3026         /**
3027          * Draws a Scilab Slider
3028          * @param slider the Slider to draw
3029          * @see org.scilab.modules.ihm.UIElement#draw()
3030          */
3031         public static void draw(Slider slider) {
3032                 ScilabSliderBridge.draw(slider);
3033         }
3034
3035         /**
3036          * Gets the dimensions (width and height) of a Scilab Slider
3037          * @param slider the Slider we want to get the dimensions of
3038          * @return the size of the slider
3039          * @see org.scilab.modules.ihm.UIElement#getDims()
3040          */
3041         public static Size getDims(Slider slider) {
3042                 return ScilabSliderBridge.getDims(slider);
3043         }
3044
3045         /**
3046          * Gets the position (X-coordinate and Y-coordinate) of a Scilab slider
3047          * @param slider the slider we want to get the position of
3048          * @return the position of the slider
3049          * @see org.scilab.modules.ihm.UIElement#getPosition()
3050          */
3051         public static Position getPosition(Slider slider) {
3052                 return ScilabSliderBridge.getPosition(slider);
3053         }
3054
3055         /**
3056          * Gets the visibility status of a Scilab Slider
3057          * @param slider the slider we want to get the visiblity status of
3058          * @return the visibility status of the slider (true if the slider is visible, false if not)
3059          * @see org.scilab.modules.ihm.UIElement#isVisible()
3060          */
3061         public static boolean isVisible(Slider slider) {
3062                 return ScilabSliderBridge.isVisible(slider);
3063         }
3064
3065         /**
3066          * Sets the dimensions (width and height) of a Scilab Slider
3067          * @param slider the slider we want to set the dimensions of
3068          * @param newSize the size we want to set to the slider
3069          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
3070          */
3071         public static void setDims(Slider slider, Size newSize) {
3072                 ScilabSliderBridge.setDims(slider, newSize);
3073         }
3074
3075         /**
3076          * Sets the position (X-coordinate and Y-coordinate) of a Scilab slider
3077          * @param slider the slider we want to set the position of
3078          * @param newPosition the position we want to set to the slider
3079          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
3080          */
3081         public static void setPosition(Slider slider, Position newPosition) {
3082                 ScilabSliderBridge.setPosition(slider, newPosition);
3083         }
3084
3085         /**
3086          * Sets the visibility status of a Scilab Slider
3087          * @param slider the slider we want to set the visiblity status of
3088          * @param newVisibleState the visibility status we want to set to the slider (true to set the slider visible, false else)
3089          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
3090          */
3091         public static void setVisible(Slider slider, boolean newVisibleState) {
3092                 ScilabSliderBridge.setVisible(slider, newVisibleState);
3093         }
3094         
3095         /**
3096          * Set the Background color of the Slider
3097          * @param slider the Slider we want to set the background of
3098          * @param color the Color
3099          */
3100         public static void setBackground(Slider slider, Color color) {
3101                 ScilabSliderBridge.setBackground(slider, color);
3102         }
3103
3104         /**
3105          * Get the Background color of the Slider
3106          * @param slider the Slider we want to get the background of
3107          * @return the Color
3108          */
3109         public static Color getBackground(Slider slider) {
3110                 return ScilabSliderBridge.getBackground(slider);
3111         }
3112
3113         /**
3114          * Set the Foreground color of the Slider
3115          * @param slider the Slider we want to set the foreground of
3116          * @param color the Color
3117          */
3118         public static void setForeground(Slider slider, Color color) {
3119                 ScilabSliderBridge.setForeground(slider, color);
3120         }
3121
3122         /**
3123          * Get the Foreground color of the Slider
3124          * @param slider the Slider we want to get the foreground of
3125          * @return the Color
3126          */
3127         public static Color getForeground(Slider slider) {
3128                 return ScilabSliderBridge.getForeground(slider);
3129         }
3130
3131         /**
3132          * Set the font of the Slider.
3133          * @param slider the Slider we want to set the font of
3134          * @param font the font
3135          */
3136         public static void setFont(Slider slider, Font font) {
3137                 ScilabSliderBridge.setFont(slider, font);
3138         }
3139         
3140         /**
3141          * Get the font of the Slider.
3142          * @param slider the Slider we want to get the font of
3143          * @return the font
3144          */
3145         public static Font getFont(Slider slider) {
3146                 return ScilabSliderBridge.getFont(slider);
3147         }
3148
3149         /**
3150          * Set if the Slider is enabled or not
3151          * @param slider the Slider we want to set the status of
3152          * @param status true if the Slider is enabled
3153          */
3154         public static void setEnabled(Slider slider, boolean status) {
3155                 ScilabSliderBridge.setEnabled(slider, status);
3156         }
3157         
3158         /**
3159          * Add a callback to the Slider
3160          * @param slider the Slider we want to set the callback of
3161          * @param callback the CallBack to set.
3162          */
3163         public static void setCallback(Slider slider, CallBack callback) {
3164                 ScilabSliderBridge.setCallback(slider, callback);
3165         }
3166
3167         /**
3168          * Set the horizontal alignment for the Slider text
3169          * @param slider the Slider we want to set the alignment of
3170          * @param alignment the value for the alignment (See ScilabAlignment.java)
3171          */
3172         public static void setHorizontalAlignment(Slider slider, String alignment) {
3173                 ScilabSliderBridge.setHorizontalAlignment(slider, alignment);
3174         }
3175
3176         /**
3177          * Set the vertical alignment for the Slider text
3178          * @param slider the Slider we want to set the alignment of
3179          * @param alignment the value for the alignment (See ScilabAlignment.java)
3180          */
3181         public static void setVerticalAlignment(Slider slider, String alignment) {
3182                 ScilabSliderBridge.setVerticalAlignment(slider, alignment);
3183         }
3184
3185         /**
3186          * Set the minor tick spacing for a Slider
3187          * @param slider the Slider we want to set the spacing of
3188          * @param space the increment value
3189          */
3190         public static void setMinorTickSpacing(Slider slider, int space) {
3191                 ScilabSliderBridge.setMinorTickSpacing(slider, space);  
3192         }
3193
3194         /**
3195          * Set the major tick spacing for a Slider
3196          * @param slider the Slider we want to set the spacing of
3197          * @param space the increment value
3198          */
3199         public static void setMajorTickSpacing(Slider slider, int space) {
3200                 ScilabSliderBridge.setMajorTickSpacing(slider, space);  
3201         }
3202
3203         /**
3204          * Set the minimum value of a Slider
3205          * @param slider the Slider we want to set the minimum value of
3206          * @param value the minimum value
3207          */
3208         public static void setMinimumValue(Slider slider, int value) {
3209                 ScilabSliderBridge.setMinimumValue(slider, value);      
3210         }
3211
3212         /**
3213          * Set the maximum value of a Slider
3214          * @param slider the Slider we want to set the maximum value of
3215          * @param value the maximum value
3216          */
3217         public static void setMaximumValue(Slider slider, int value) {
3218                 ScilabSliderBridge.setMaximumValue(slider, value);      
3219         }
3220
3221         /**
3222          * Get the current value of the Slider
3223          * @param slider the Slider we want to get the value of
3224          * @return the current value of the Slider
3225          */
3226         public static int getValue(Slider slider) {
3227                 return ScilabSliderBridge.getValue(slider);     
3228         }
3229         
3230         /**
3231          * Sets the current value of the Slider
3232          * @param slider the Slider we want to set the value of
3233          * @param value the new value
3234          */
3235         public static void setValue(Slider slider, int value) {
3236                 ScilabSliderBridge.setValue(slider, value);     
3237         }
3238
3239         /**
3240          * Set the Relief of the Slider
3241          * @param slider the Slider which we want to set the Relief of
3242          * @param reliefType the type of the relief to set (See ScilabRelief.java)
3243          */
3244         public static void setRelief(Slider slider, String reliefType) {
3245                 ScilabSliderBridge.setRelief(slider, reliefType);
3246         }
3247
3248         /**
3249          * Set the slider orientation to vertical
3250          * @param slider the slider we want to set the orientation of
3251          */
3252         public static void setVertical(Slider slider) {
3253                 ScilabSliderBridge.setVertical(slider);
3254         }
3255
3256         /**
3257          * Set the slider orientation to horizontal
3258          * @param slider the slider we want to set the orientation of
3259          */
3260         public static void setHorizontal(Slider slider) {
3261                 ScilabSliderBridge.setHorizontal(slider);
3262         }
3263
3264         /**
3265          * Delete the Slider
3266          * @param slider the Slider to be destroyed
3267          */
3268         public static void destroy(Slider slider) {
3269                 ScilabSliderBridge.destroy(slider);
3270         }
3271
3272         /******************/
3273         /* ListBox Bridge */
3274         /******************/
3275
3276         /**
3277          * Creates a new ListBox
3278          * @return the created ListBox
3279          */
3280         public static SimpleListBox createListBox() {
3281                 return ScilabListBoxBridge.createListBox();
3282         }
3283         
3284         /**
3285          * Sets the Text of a ListBox
3286          * @param listBox the ListBox we want to set the Text of
3287          * @param newText the Text to set for the ListBox
3288          */
3289         public static void setText(ListBox listBox, String newText) {
3290                 ScilabListBoxBridge.setText(listBox, newText);
3291         }
3292         
3293         /**
3294          * Gets the text of an ListBox
3295          * @param listBox the ListBox we want to get the text of
3296          * @return the text of the ListBox
3297          */
3298         public static String getText(ListBox listBox) {
3299                 return ScilabListBoxBridge.getText(listBox);
3300         }
3301         
3302         /**
3303          * Draws a Scilab ListBox
3304          * @param listBox the ListBox to draw
3305          * @see org.scilab.modules.ihm.UIElement#draw()
3306          */
3307         public static void draw(ListBox listBox) {
3308                 ScilabListBoxBridge.draw(listBox);
3309         }
3310
3311         /**
3312          * Gets the dimensions (width and height) of a Scilab ListBox
3313          * @param listBox the ListBox we want to get the dimensions of
3314          * @return the size of the listBox
3315          * @see org.scilab.modules.ihm.UIElement#getDims()
3316          */
3317         public static Size getDims(ListBox listBox) {
3318                 return ScilabListBoxBridge.getDims(listBox);
3319         }
3320
3321         /**
3322          * Gets the position (X-coordinate and Y-coordinate) of a Scilab listBox
3323          * @param listBox the listBox we want to get the position of
3324          * @return the position of the listBox
3325          * @see org.scilab.modules.ihm.UIElement#getPosition()
3326          */
3327         public static Position getPosition(ListBox listBox) {
3328                 return ScilabListBoxBridge.getPosition(listBox);
3329         }
3330
3331         /**
3332          * Gets the visibility status of a Scilab ListBox
3333          * @param listBox the listBox we want to get the visiblity status of
3334          * @return the visibility status of the listBox (true if the listBox is visible, false if not)
3335          * @see org.scilab.modules.ihm.UIElement#isVisible()
3336          */
3337         public static boolean isVisible(ListBox listBox) {
3338                 return ScilabListBoxBridge.isVisible(listBox);
3339         }
3340
3341         /**
3342          * Sets the dimensions (width and height) of a Scilab ListBox
3343          * @param listBox the listBox we want to set the dimensions of
3344          * @param newSize the size we want to set to the listBox
3345          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
3346          */
3347         public static void setDims(ListBox listBox, Size newSize) {
3348                 ScilabListBoxBridge.setDims(listBox, newSize);
3349         }
3350
3351         /**
3352          * Sets the position (X-coordinate and Y-coordinate) of a Scilab listBox
3353          * @param listBox the listBox we want to set the position of
3354          * @param newPosition the position we want to set to the listBox
3355          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
3356          */
3357         public static void setPosition(ListBox listBox, Position newPosition) {
3358                 ScilabListBoxBridge.setPosition(listBox, newPosition);
3359         }
3360
3361         /**
3362          * Sets the visibility status of a Scilab ListBox
3363          * @param listBox the listBox we want to set the visiblity status of
3364          * @param newVisibleState the visibility status we want to set to the listBox (true to set the listBox visible, false else)
3365          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
3366          */
3367         public static void setVisible(ListBox listBox, boolean newVisibleState) {
3368                 ScilabListBoxBridge.setVisible(listBox, newVisibleState);
3369         }
3370         
3371         /**
3372          * Set the Background color of the ListBox
3373          * @param listBox the ListBox we want to set the background of
3374          * @param color the Color
3375          */
3376         public static void setBackground(ListBox listBox, Color color) {
3377                 ScilabListBoxBridge.setBackground(listBox, color);
3378         }
3379
3380         /**
3381          * Get the Background color of the ListBox
3382          * @param listBox the ListBox we want to get the background of
3383          * @return the Color
3384          */
3385         public static Color getBackground(ListBox listBox) {
3386                 return ScilabListBoxBridge.getBackground(listBox);
3387         }
3388
3389         /**
3390          * Set the Foreground color of the ListBox
3391          * @param listBox the ListBox we want to set the foreground of
3392          * @param color the Color
3393          */
3394         public static void setForeground(ListBox listBox, Color color) {
3395                 ScilabListBoxBridge.setForeground(listBox, color);
3396         }
3397
3398         /**
3399          * Get the Foreground color of the ListBox
3400          * @param listBox the ListBox we want to get the foreground of
3401          * @return the Color
3402          */
3403         public static Color getForeground(ListBox listBox) {
3404                 return ScilabListBoxBridge.getForeground(listBox);
3405         }
3406
3407         /**
3408          * Set the font of the ListBox.
3409          * @param listBox the ListBox we want to set the font of
3410          * @param font the font
3411          */
3412         public static void setFont(ListBox listBox, Font font) {
3413                 ScilabListBoxBridge.setFont(listBox, font);
3414         }
3415         
3416         /**
3417          * Get the font of the ListBox.
3418          * @param listBox the ListBox we want to get the font of
3419          * @return the font
3420          */
3421         public static Font getFont(ListBox listBox) {
3422                 return ScilabListBoxBridge.getFont(listBox);
3423         }
3424
3425         /**
3426          * Set if the ListBox is enabled or not
3427          * @param listBox the ListBox we want to set the status of
3428          * @param status true if the ListBox is enabled
3429          */
3430         public static void setEnabled(ListBox listBox, boolean status) {
3431                 ScilabListBoxBridge.setEnabled(listBox, status);
3432         }
3433         
3434         /**
3435          * Add a callback to the ListBox
3436          * @param listBox the ListBox we want to set the callback of
3437          * @param callback the Callback to set.
3438          */
3439         public static void setCallback(ListBox listBox, CallBack callback) {
3440                 ScilabListBoxBridge.setCallback(listBox, callback);
3441         }
3442
3443
3444         /**
3445          * Set the horizontal alignment for the ListBox text
3446          * @param listBox the ListBox we want to set the alignment of
3447          * @param alignment the value for the alignment (See ScilabAlignment.java)
3448          */
3449         public static void setHorizontalAlignment(ListBox listBox, String alignment) {
3450                 ScilabListBoxBridge.setHorizontalAlignment(listBox, alignment);
3451         }
3452
3453         /**
3454          * Set the vertical alignment for the ListBox text
3455          * @param listBox the ListBox we want to set the alignment of
3456          * @param alignment the value for the alignment (See ScilabAlignment.java)
3457          */
3458         public static void setVerticalAlignment(ListBox listBox, String alignment) {
3459                 ScilabListBoxBridge.setVerticalAlignment(listBox, alignment);
3460         }
3461
3462         /**
3463          * Set if more than one item can be selected in a ListBox
3464          * @param listBox the ListBox we want to set the status of
3465          * @param status true if multiple selection is enabled
3466          */
3467         public static void setMultipleSelectionEnabled(ListBox listBox, boolean status) {
3468                 ScilabListBoxBridge.setMultipleSelectionEnabled(listBox, status);
3469         }
3470
3471         /**
3472          * Set the selected indices of the ListBox
3473          * @param listBox the ListBox we want to set the selected indices of
3474          * @param indices the indices of the items to be selected
3475          */
3476         public static void setSelectedIndices(ListBox listBox, int[] indices) {
3477                 ScilabListBoxBridge.setSelectedIndices(listBox, indices);
3478         }
3479         
3480         /**
3481          * Get the selected indices of the ListBox
3482          * @param listBox the ListBox we want to get the selected indices of
3483          * @return the indices of the items selected
3484          */
3485         public static int[] getSelectedIndices(ListBox listBox) {
3486                 return ScilabListBoxBridge.getSelectedIndices(listBox);
3487         }
3488
3489         /**
3490          * Get the number of items selected in the ListBox
3491          * @param listBox the ListBox we want to get the selection size of
3492          * @return the number of items selected
3493          */
3494         public static int getSelectionSize(ListBox listBox) {
3495                 return ScilabListBoxBridge.getSelectionSize(listBox);
3496         }
3497
3498         /**
3499          * Get the text of all the list items
3500          * @param listBox the ListBox we want to get the items text of
3501          * @return the text items
3502          * @see org.scilab.modules.gui.listbox.ListBox#getAllItemsText()
3503          */
3504         public static String[] getAllItemsText(ListBox listBox) {
3505                 return ScilabListBoxBridge.getAllItemsText(listBox);
3506         }
3507
3508         /**
3509          * Get the number of items in the list
3510          * @param listBox the ListBox we want to get the items number of
3511          * @return the number of items
3512          * @see org.scilab.modules.gui.listbox.ListBox#getNumberOfItems()
3513          */
3514         public static int getNumberOfItems(ListBox listBox) {
3515                 return ScilabListBoxBridge.getNumberOfItems(listBox);
3516         }
3517
3518         /**
3519          * Set the text of the list items
3520          * @param listBox the ListBox we want to set the items text of
3521          * @param text the text of the items
3522          * @see org.scilab.modules.gui.listbox.ListBox#setText(java.lang.String[])
3523          */
3524         public static void setText(ListBox listBox, String[] text) {
3525                 ScilabListBoxBridge.setText(listBox, text);
3526         }
3527
3528         /**
3529          * Set the Relief of the ListBox
3530          * @param listBox the ListBox which we want to set the Relief of
3531          * @param reliefType the type of the relief to set (See ScilabRelief.java)
3532          */
3533         public static void setRelief(ListBox listBox, String reliefType) {
3534                 ScilabListBoxBridge.setRelief(listBox, reliefType);
3535         }
3536
3537         /**
3538          * Delete the ListBox
3539          * @param listBox the ListBox to be destroyed
3540          */
3541         public static void destroy(ListBox listBox) {
3542                 ScilabListBoxBridge.destroy(listBox);
3543         }
3544
3545         /********************/
3546         /* PopupMenu Bridge */
3547         /********************/
3548
3549         /**
3550          * Creates a new PopupMenu
3551          * @return the created PopupMenu
3552          */
3553         public static SimplePopupMenu createPopupMenu() {
3554                 return ScilabPopupMenuBridge.createPopupMenu();
3555         }
3556         
3557         /**
3558          * Sets the Text of a PopupMenu
3559          * @param popupMenu the PopupMenu we want to set the Text of
3560          * @param newText the Text to set for the PopupMenu
3561          */
3562         public static void setText(PopupMenu popupMenu, String newText) {
3563                 ScilabPopupMenuBridge.setText(popupMenu, newText);
3564         }
3565         
3566         /**
3567          * Gets the text of an PopupMenu
3568          * @param popupMenu the PopupMenu we want to get the text of
3569          * @return the text of the PopupMenu
3570          */
3571         public static String getText(PopupMenu popupMenu) {
3572                 return ScilabPopupMenuBridge.getText(popupMenu);
3573         }
3574         
3575         /**
3576          * Draws a Scilab PopupMenu
3577          * @param popupMenu the PopupMenu to draw
3578          * @see org.scilab.modules.ihm.UIElement#draw()
3579          */
3580         public static void draw(PopupMenu popupMenu) {
3581                 ScilabPopupMenuBridge.draw(popupMenu);
3582         }
3583
3584         /**
3585          * Gets the dimensions (width and height) of a Scilab PopupMenu
3586          * @param popupMenu the PopupMenu we want to get the dimensions of
3587          * @return the size of the popupMenu
3588          * @see org.scilab.modules.ihm.UIElement#getDims()
3589          */
3590         public static Size getDims(PopupMenu popupMenu) {
3591                 return ScilabPopupMenuBridge.getDims(popupMenu);
3592         }
3593
3594         /**
3595          * Gets the position (X-coordinate and Y-coordinate) of a Scilab popupMenu
3596          * @param popupMenu the popupMenu we want to get the position of
3597          * @return the position of the popupMenu
3598          * @see org.scilab.modules.ihm.UIElement#getPosition()
3599          */
3600         public static Position getPosition(PopupMenu popupMenu) {
3601                 return ScilabPopupMenuBridge.getPosition(popupMenu);
3602         }
3603
3604         /**
3605          * Gets the visibility status of a Scilab PopupMenu
3606          * @param popupMenu the popupMenu we want to get the visiblity status of
3607          * @return the visibility status of the popupMenu (true if the popupMenu is visible, false if not)
3608          * @see org.scilab.modules.ihm.UIElement#isVisible()
3609          */
3610         public static boolean isVisible(PopupMenu popupMenu) {
3611                 return ScilabPopupMenuBridge.isVisible(popupMenu);
3612         }
3613
3614         /**
3615          * Sets the dimensions (width and height) of a Scilab PopupMenu
3616          * @param popupMenu the popupMenu we want to set the dimensions of
3617          * @param newSize the size we want to set to the popupMenu
3618          * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
3619          */
3620         public static void setDims(PopupMenu popupMenu, Size newSize) {
3621                 ScilabPopupMenuBridge.setDims(popupMenu, newSize);
3622         }
3623
3624         /**
3625          * Sets the position (X-coordinate and Y-coordinate) of a Scilab popupMenu
3626          * @param popupMenu the popupMenu we want to set the position of
3627          * @param newPosition the position we want to set to the popupMenu
3628          * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
3629          */
3630         public static void setPosition(PopupMenu popupMenu, Position newPosition) {
3631                 ScilabPopupMenuBridge.setPosition(popupMenu, newPosition);
3632         }
3633
3634         /**
3635          * Sets the visibility status of a Scilab PopupMenu
3636          * @param popupMenu the popupMenu we want to set the visiblity status of
3637          * @param newVisibleState the visibility status we want to set to the popupMenu (true to set the popupMenu visible, false else)
3638          * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
3639          */
3640         public static void setVisible(PopupMenu popupMenu, boolean newVisibleState) {
3641                 ScilabPopupMenuBridge.setVisible(popupMenu, newVisibleState);
3642         }
3643         
3644         /**
3645          * Set the Background color of the PopupMenu
3646          * @param popupMenu the PopupMenu we want to set the background of
3647          * @param color the Color
3648          */
3649         public static void setBackground(PopupMenu popupMenu, Color color) {
3650                 ScilabPopupMenuBridge.setBackground(popupMenu, color);
3651         }
3652
3653         /**
3654          * Get the Background color of the PopupMenu
3655          * @param popupMenu the PopupMenu we want to get the background of
3656          * @return the Color
3657          */
3658         public static Color getBackground(PopupMenu popupMenu) {
3659                 return ScilabPopupMenuBridge.getBackground(popupMenu);
3660         }
3661
3662         /**
3663          * Set the Foreground color of the PopupMenu
3664          * @param popupMenu the PopupMenu we want to set the foreground of
3665          * @param color the Color
3666          */
3667         public static void setForeground(PopupMenu popupMenu, Color color) {
3668                 ScilabPopupMenuBridge.setForeground(popupMenu, color);
3669         }
3670
3671         /**
3672          * Get the Foreground color of the PopupMenu
3673          * @param popupMenu the PopupMenu we want to get the foreground of
3674          * @return the Color
3675          */
3676         public static Color getForeground(PopupMenu popupMenu) {
3677                 return ScilabPopupMenuBridge.getForeground(popupMenu);
3678         }
3679
3680         /**
3681          * Set the font of the PopupMenu.
3682          * @param popupMenu the PopupMenu we want to set the font of
3683          * @param font the font
3684          */
3685         public static void setFont(PopupMenu popupMenu, Font font) {
3686                 ScilabPopupMenuBridge.setFont(popupMenu, font);
3687         }
3688         
3689         /**
3690          * Get the font of the PopupMenu.
3691          * @param popupMenu the PopupMenu we want to get the font of
3692          * @return the font
3693          */
3694         public static Font getFont(PopupMenu popupMenu) {
3695                 return ScilabPopupMenuBridge.getFont(popupMenu);
3696         }
3697
3698         /**
3699          * Set if the PopupMenu is enabled or not
3700          * @param popupMenu the PopupMenu we want to set the status of
3701          * @param status true if the PopupMenu is enabled
3702          */
3703         public static void setEnabled(PopupMenu popupMenu, boolean status) {
3704                 ScilabPopupMenuBridge.setEnabled(popupMenu, status);
3705         }
3706         
3707         /**
3708          * Add a callback to the PopupMenu
3709          * @param popupMenu the PopupMenu we want to set the callback of
3710          * @param callback the CallBack to set.
3711          */
3712         public static void setCallback(PopupMenu popupMenu, CallBack callback) {
3713                 ScilabPopupMenuBridge.setCallback(popupMenu, callback);
3714         }
3715
3716         /**
3717          * Set the horizontal alignment for the PopupMenu text
3718          * @param popupMenu the PopupMenu we want to set the alignment of
3719          * @param alignment the value for the alignment (See ScilabAlignment.java)
3720          */
3721         public static void setHorizontalAlignment(PopupMenu popupMenu, String alignment) {
3722                 ScilabPopupMenuBridge.setHorizontalAlignment(popupMenu, alignment);
3723         }
3724
3725         /**
3726          * Set the vertical alignment for the PopupMenu text
3727          * @param popupMenu the PopupMenu we want to set the alignment of
3728          * @param alignment the value for the alignment (See ScilabAlignment.java)
3729          */
3730         public static void setVerticalAlignment(PopupMenu popupMenu, String alignment) {
3731                 ScilabPopupMenuBridge.setVerticalAlignment(popupMenu, alignment);
3732         }
3733
3734         /**
3735          * Set the selected index of the ListBox
3736          * @param popupMenu the PopupMenu we want to set the selected index of
3737          * @param index the index of the item to be selected
3738          */
3739         public static void setSelectedIndex(PopupMenu popupMenu, int index) {
3740                 ScilabPopupMenuBridge.setSelectedIndex(popupMenu, index);
3741         }
3742         
3743         /**
3744          * Get the selected index of the ListBox
3745          * @param popupMenu the PopupMenu we want to get the selected index of
3746          * @return the index of the item selected
3747          */
3748         public static int getSelectedIndex(PopupMenu popupMenu) {
3749                 return ScilabPopupMenuBridge.getSelectedIndex(popupMenu);
3750         }
3751         
3752         /**
3753          * Get the text of all the PopupMenu items
3754          * @param popupMenu the PopupMenu we want to get the items of
3755          * @return the text items
3756          */
3757         public static String[] getAllItemsText(PopupMenu popupMenu) {
3758                 return ScilabPopupMenuBridge.getAllItemsText(popupMenu);
3759         }
3760
3761         /**
3762          * Get the number of items in the PopupMenu
3763          * @param popupMenu the PopupMenu we want to get the items number of
3764          * @return the number of items
3765          */
3766         public static int getNumberOfItems(PopupMenu popupMenu) {
3767                 return ScilabPopupMenuBridge.getNumberOfItems(popupMenu);
3768         }
3769
3770         /**
3771          * Set the text of the PopupMenu items
3772          * @param popupMenu the PopupMenu we want to set the text items of
3773          * @param text the text of the items
3774          */
3775         public static void setText(PopupMenu popupMenu, String[] text) {
3776                 ScilabPopupMenuBridge.setText(popupMenu, text);
3777         }
3778
3779         /**
3780          * Set the Relief of the PopupMenu
3781          * @param popupMenu the PopupMenu which we want to set the Relief of
3782          * @param reliefType the type of the relief to set (See ScilabRelief.java)
3783          */
3784         public static void setRelief(PopupMenu popupMenu, String reliefType) {
3785                 ScilabPopupMenuBridge.setRelief(popupMenu, reliefType);
3786         }
3787
3788         /**
3789          * Delete the PopupMenu
3790          * @param popupMenu the PopupMenu to be destroyed
3791          */
3792         public static void destroy(PopupMenu popupMenu) {
3793                 ScilabPopupMenuBridge.destroy(popupMenu);
3794         }
3795
3796         /*********************/
3797         /* FlowLayout Bridge */
3798         /*********************/
3799         /**
3800          * Creates a new FlowLayout
3801          * @return the created FlowLayout
3802          */
3803         public static FlowLayout createFlowLayout() {
3804                 return ScilabFlowLayoutBridge.createFlowLayout();
3805         }
3806         
3807         /***********************/
3808         /* BorderLayout Bridge */
3809         /***********************/
3810         /**
3811          * Creates a new BorderLayout
3812          * @return the created BorderLayout
3813          */
3814         public static BorderLayout createBorderLayout() {
3815                 return ScilabBorderLayoutBridge.createBorderLayout();
3816         }
3817         
3818         /***********************/
3819         /* FileChooser Bridge */
3820         /***********************/
3821
3822         /**
3823          * Create a new FileChooser
3824          * @return the created FileChooser
3825          */
3826         public static SimpleFileChooser createFileChooser() {
3827                 return ScilabFileChooserBridge.createFileChooser();
3828         }
3829         
3830         /**
3831          * Set the title of the file chooser
3832          * @param fileChooser the file chooser we want to set the title of
3833          * @param title the title to set
3834          */
3835         public static void setTitle(FileChooser fileChooser, String title) {
3836                 ScilabFileChooserBridge.setTitle(fileChooser, title);
3837         }
3838         
3839         /**
3840          * Set the mask for files to choose
3841          * @param fileChooser the file chooser we want to set the mask of
3842          * @param mask the mask to set
3843          */
3844         public static void setMask(FileChooser fileChooser, String mask) {
3845                 ScilabFileChooserBridge.setMask(fileChooser, mask);
3846         }
3847         
3848         /**
3849          * Set the initial directory used for file search
3850          * @param fileChooser the file chooser we want to set the initial directory of
3851          * @param path the default path
3852          */
3853         public static void setInitialDirectory(FileChooser fileChooser, String path) {
3854                 ScilabFileChooserBridge.setInitialDirectory(fileChooser, path);
3855         }
3856
3857         /**
3858          * Display this chooser and wait for user selection 
3859          * @param fileChooser the file chooser we want to display
3860          */
3861         public static void displayAndWait(FileChooser fileChooser) {
3862                 ScilabFileChooserBridge.displayAndWait(fileChooser);
3863         }
3864         
3865         /**
3866          * Get the number of files selected
3867          * @param fileChooser the file chooser we want to get the selection size of
3868          * @return the number of files selected
3869          */
3870         public static int getSelectionSize(FileChooser fileChooser) {
3871                 return ScilabFileChooserBridge.getSelectionSize(fileChooser);
3872         }
3873         
3874         /**
3875          * Get the names of selected files
3876          * @param fileChooser the file chooser we want to get the selection of 
3877          * @return the names of selected files
3878          */
3879         public static String[] getSelection(FileChooser fileChooser) {
3880                 return ScilabFileChooserBridge.getSelection(fileChooser);
3881         }
3882         
3883         /**
3884          * Set the flag indicating that we want only select directories
3885          * @param fileChooser the file chooser we want to set the flag of 
3886          */
3887         public static void setDirectorySelectionOnly(FileChooser fileChooser) {
3888                 ScilabFileChooserBridge.setDirectorySelectionOnly(fileChooser);
3889         }
3890
3891         /**
3892          * Set the flag indicating that we want only select files
3893          * @param fileChooser the file chooser we want to set the flag of 
3894          */
3895         public static void setFileSelectionOnly(FileChooser fileChooser) {
3896                 ScilabFileChooserBridge.setFileSelectionOnly(fileChooser);
3897         }
3898
3899         /*********************/
3900         /* MessageBox Bridge */
3901         /*********************/
3902
3903         /**
3904          * Create a new MessageBox
3905          * @return the created MessageBox
3906          */
3907         public static SimpleMessageBox createMessageBox() {
3908                 return ScilabMessageBoxBridge.createMessageBox();
3909         }
3910         
3911         /**
3912          * Set the title of the MessageBox
3913          * @param messageBox the MessageBox we want to set the title of
3914          * @param title the title to set
3915          */
3916         public static void setTitle(MessageBox messageBox, String title) {
3917                 ScilabMessageBoxBridge.setTitle(messageBox, title);
3918         }
3919         
3920         /**
3921          * Set the message of the MessageBox
3922          * @param messageBox the MessageBox we want to set the mask of
3923          * @param message the message to set
3924          */
3925         public static void setMessage(MessageBox messageBox, String message) {
3926                 ScilabMessageBoxBridge.setMessage(messageBox, message);
3927         }
3928
3929         /**
3930          * Set the message of the MessageBox (multi-line)
3931          * @param messageBox the MessageBox we want to set the mask of
3932          * @param message the message to set
3933          */
3934         public static void setMessage(MessageBox messageBox, String[] message) {
3935                 ScilabMessageBoxBridge.setMessage(messageBox, message);
3936         }
3937
3938         /**
3939          * Display this MessageBox and wait for user selection 
3940          * @param messageBox the MessageBox we want to display
3941          */
3942         public static void displayAndWait(MessageBox messageBox) {
3943                 ScilabMessageBoxBridge.displayAndWait(messageBox);
3944         }
3945         
3946         /**
3947          * Get the index of the button clicked
3948          * @param messageBox the MessageBox we want to get the answer of
3949          * @return the index of the button clicked
3950          */
3951         public static int getSelectedButton(MessageBox messageBox) {
3952                 return ScilabMessageBoxBridge.getSelectedButton(messageBox);
3953         }
3954         
3955         /**
3956          * Set the indices of the default selected buttons (x_choices)
3957          * @param messageBox the MessageBox we want to set the defaults of
3958          * @param indices the indices of the default selected buttons
3959          */
3960         public static void setDefaultSelectedButtons(MessageBox messageBox, int[] indices) {
3961                 ScilabMessageBoxBridge.setDefaultSelectedButtons(messageBox, indices);
3962         }
3963         
3964         /**
3965          * Get the indices of the user selected buttons (x_choices)
3966          * @param messageBox the MessageBox we want to set the defaults of
3967          * @return the indices of the default selected buttons
3968          */
3969         public static int[] getUserSelectedButtons(MessageBox messageBox) {
3970                 return ScilabMessageBoxBridge.getUserSelectedButtons(messageBox);
3971         }
3972         
3973         /**
3974          * Set the labels of the buttons in the MessageBox
3975          * @param messageBox the MessageBox we want to set the buttons labels of
3976          * @param labels the labels of the buttons
3977          */
3978         public static void setButtonsLabels(MessageBox messageBox, String[] labels) {
3979                 ScilabMessageBoxBridge.setButtonsLabels(messageBox, labels);
3980         }
3981
3982         /**
3983          * Set the initial values of the editable zone in the MessageBox
3984          * @param messageBox the MessageBox we want to set the initial value of
3985          * @param value the initial values
3986          */
3987         public static void setInitialValue(MessageBox messageBox, String[] value) {
3988                 ScilabMessageBoxBridge.setInitialValue(messageBox, value);
3989         }
3990
3991         /**
3992          * Get the value of the editable zone in the MessageBox
3993          * @param messageBox the MessageBox we want to get the value of
3994          * @return the value
3995          */
3996         public static String[] getValue(MessageBox messageBox) {
3997                 return ScilabMessageBoxBridge.getValue(messageBox);
3998         }
3999
4000         /**
4001          * Get the size of the value of the editable zone in the MessageBox
4002          * @param messageBox the MessageBox we want to get the value size of
4003          * @return the value size
4004          */
4005         public static int getValueSize(MessageBox messageBox) {
4006                 return ScilabMessageBoxBridge.getValueSize(messageBox);
4007         }
4008
4009         /**
4010          * Set the items of the listbox in the MessageBox
4011          * @param messageBox the MessageBox we want to set the items of
4012          * @param items the items to set
4013          */
4014         public static void setListBoxItems(MessageBox messageBox, String[] items) {
4015                 ScilabMessageBoxBridge.setListBoxItems(messageBox, items);
4016         }
4017         
4018         /**
4019          * Get the index of the selected item in the listbox in the MessageBox
4020          * @param messageBox the MessageBox we want to get the selected item of
4021          * @return the index
4022          */
4023         public static int getSelectedItem(MessageBox messageBox) {
4024                 return ScilabMessageBoxBridge.getSelectedItem(messageBox);
4025         }
4026
4027         /**
4028          * Set the name of the lines labels in the editable zone in the MessageBox
4029          * @param messageBox the MessageBox we want to set the labels
4030          * @param labels the labels
4031          */
4032         public static void setLineLabels(MessageBox messageBox, String[] labels) {
4033                 ScilabMessageBoxBridge.setLineLabels(messageBox, labels);
4034         }
4035         
4036         /**
4037          * Set the name of the columns labels in the editable zone in the MessageBox
4038          * @param messageBox the MessageBox we want to set the labels
4039          * @param labels the labels
4040          */
4041         public static void setColumnLabels(MessageBox messageBox, String[] labels) {
4042                 ScilabMessageBoxBridge.setColumnLabels(messageBox, labels);
4043         }
4044         
4045         /**
4046          * Set the default values of a multi-value editable zone in the MessageBox
4047          * @param messageBox the MessageBox we want to set the default values
4048          * @param values the values
4049          */
4050         public static void setDefaultInput(MessageBox messageBox, String[] values) {
4051                 ScilabMessageBoxBridge.setDefaultInput(messageBox, values);
4052         }
4053
4054         /**
4055          * Set a MessageBox modal or not
4056          * @param messageBox the MessageBox we want to set the modality of
4057          * @param status true to set the MessageBox modal and false else
4058          */
4059         public static void setModal(MessageBox messageBox, boolean status) {
4060                 ScilabMessageBoxBridge.setModal(messageBox, status);
4061         }
4062
4063         /**
4064          * Set the MessageBox icon
4065          * @param messageBox the MessageBox we want to set the icon of
4066          * @param name the name of the icon
4067          */
4068         public static void setIcon(MessageBox messageBox, String name) {
4069                 ScilabMessageBoxBridge.setIcon(messageBox, name);
4070         }
4071
4072         /******************/
4073         /* WaitBar Bridge */
4074         /******************/
4075
4076         /**
4077          * Create a new WaitBar
4078          * @return the created WaitBar
4079          */
4080         public static SimpleWaitBar createWaitBar() {
4081                 return ScilabWaitBarBridge.createWaitBar();
4082         }
4083
4084         /**
4085          * Set the title of the WaitBar
4086          * @param waitBar the WaitBar
4087          * @param title the title to set
4088          */
4089         public static void setTitle(WaitBar waitBar, String title) {
4090                 ScilabWaitBarBridge.setTitle(waitBar, title);
4091         }
4092         
4093         /**
4094          * Set the message of the WaitBar
4095          * @param waitBar the WaitBar
4096          * @param message the message to set
4097          */
4098         public static void setMessage(WaitBar waitBar, String[] message) {
4099                 ScilabWaitBarBridge.setMessage(waitBar, message);
4100         }
4101         
4102         /**
4103          * Set the current value of the WaitBar
4104          * @param waitBar the WaitBar
4105          * @param value the value to set
4106          */
4107         public static void setValue(WaitBar waitBar, int value) {
4108                 ScilabWaitBarBridge.setValue(waitBar, value);
4109         };
4110         
4111         /**
4112          * Close the WaitBar
4113          * @param waitBar the WaitBar
4114          */
4115         public static void close(WaitBar waitBar) {
4116                 ScilabWaitBarBridge.close(waitBar);
4117         }
4118         
4119         /**
4120          * Indicates if the total execution time is known
4121          * @param waitBar the WaitBar
4122          * @param status true if the total progress time in unknown
4123          */
4124         public static void setIndeterminateMode(WaitBar waitBar, boolean status) {
4125                 ScilabWaitBarBridge.setIndeterminateMode(waitBar, status);
4126         }
4127
4128         /***********************/
4129         /* Help Browser Bridge */
4130         /***********************/
4131
4132         /**
4133          * Create a new Help Browser
4134          * @return the created Help Browser
4135          */
4136         public static SimpleHelpBrowser createHelpBrowser() {
4137                 return ScilabHelpBrowserBridge.createHelpBrowser();
4138         }
4139
4140         /**
4141          * Display the Help Browser
4142          * @param browser the Help Browser
4143          */
4144         public static void display(HelpBrowser browser) {
4145                 ScilabHelpBrowserBridge.display(browser);
4146         }
4147         
4148         /**
4149          * Display the matching items for a specified keyword
4150          * @param browser the Help Browser
4151          * @param keyword the keyword
4152          * @return true if the keyword exists
4153          */
4154         public static boolean searchKeywork(HelpBrowser browser, String keyword) {
4155                 return ScilabHelpBrowserBridge.searchKeywork(browser, keyword);
4156         }
4157         
4158         /**
4159          * Close the HelpBrowser
4160          * @param browser the Help Browser
4161          */
4162         public static void close(HelpBrowser browser) {
4163                 ScilabHelpBrowserBridge.close(browser);
4164         }
4165
4166
4167 }