[Clean] Remove old ScilabUiTable
[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  * Copyright (C) 2010 - DIGITEO - Vincent COUVERT
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13  */
14
15
16 package org.scilab.modules.gui.bridge;
17
18 import java.awt.Color;
19 import java.awt.Cursor;
20 import java.awt.Font;
21 import java.awt.image.BufferedImage;
22
23 import javax.media.opengl.GL;
24
25 import org.scilab.modules.gui.canvas.Canvas;
26 import org.scilab.modules.gui.canvas.ScilabCanvas;
27 import org.scilab.modules.gui.canvas.ScilabCanvasBridge;
28 import org.scilab.modules.gui.canvas.SimpleCanvas;
29 import org.scilab.modules.gui.checkboxmenuitem.CheckBoxMenuItem;
30 import org.scilab.modules.gui.checkboxmenuitem.ScilabCheckBoxMenuItemBridge;
31 import org.scilab.modules.gui.checkboxmenuitem.SimpleCheckBoxMenuItem;
32 import org.scilab.modules.gui.colorchooser.ColorChooser;
33 import org.scilab.modules.gui.colorchooser.ScilabColorChooserBridge;
34 import org.scilab.modules.gui.colorchooser.SimpleColorChooser;
35 import org.scilab.modules.gui.console.Console;
36 import org.scilab.modules.gui.console.ScilabConsole;
37 import org.scilab.modules.gui.console.ScilabConsoleBridge;
38 import org.scilab.modules.gui.console.SimpleConsole;
39 import org.scilab.modules.gui.contextmenu.ContextMenu;
40 import org.scilab.modules.gui.contextmenu.ScilabContextMenuBridge;
41 import org.scilab.modules.gui.contextmenu.SimpleContextMenu;
42 import org.scilab.modules.gui.events.callback.CommonCallBack;
43 import org.scilab.modules.gui.filechooser.FileChooser;
44 import org.scilab.modules.gui.filechooser.ScilabFileChooserBridge;
45 import org.scilab.modules.gui.filechooser.SimpleFileChooser;
46 import org.scilab.modules.gui.fontchooser.FontChooser;
47 import org.scilab.modules.gui.fontchooser.ScilabFontChooserBridge;
48 import org.scilab.modules.gui.fontchooser.SimpleFontChooser;
49 import org.scilab.modules.gui.helpbrowser.HelpBrowser;
50 import org.scilab.modules.gui.helpbrowser.ScilabHelpBrowserBridge;
51 import org.scilab.modules.gui.helpbrowser.SimpleHelpBrowser;
52 import org.scilab.modules.gui.menu.Menu;
53 import org.scilab.modules.gui.menu.ScilabMenuBridge;
54 import org.scilab.modules.gui.menu.SimpleMenu;
55 import org.scilab.modules.gui.menubar.MenuBar;
56 import org.scilab.modules.gui.menubar.ScilabMenuBarBridge;
57 import org.scilab.modules.gui.menubar.SimpleMenuBar;
58 import org.scilab.modules.gui.menuitem.MenuItem;
59 import org.scilab.modules.gui.menuitem.ScilabMenuItemBridge;
60 import org.scilab.modules.gui.menuitem.SimpleMenuItem;
61 import org.scilab.modules.gui.messagebox.MessageBox;
62 import org.scilab.modules.gui.messagebox.ScilabMessageBoxBridge;
63 import org.scilab.modules.gui.messagebox.SimpleMessageBox;
64 import org.scilab.modules.gui.separator.ScilabSeparatorBridge;
65 import org.scilab.modules.gui.separator.Separator;
66 import org.scilab.modules.gui.tab.ScilabTabBridge;
67 import org.scilab.modules.gui.tab.SimpleTab;
68 import org.scilab.modules.gui.tab.Tab;
69 import org.scilab.modules.gui.textbox.ScilabTextBoxBridge;
70 import org.scilab.modules.gui.textbox.SimpleTextBox;
71 import org.scilab.modules.gui.textbox.TextBox;
72 import org.scilab.modules.gui.toolbar.ScilabToolBarBridge;
73 import org.scilab.modules.gui.toolbar.SimpleToolBar;
74 import org.scilab.modules.gui.toolbar.ToolBar;
75 import org.scilab.modules.gui.tree.ScilabTreeBridge;
76 import org.scilab.modules.gui.tree.SimpleTree;
77 import org.scilab.modules.gui.tree.Tree;
78 import org.scilab.modules.gui.uidisplaytree.ScilabUiDisplayTreeBridge;
79 import org.scilab.modules.gui.uidisplaytree.SimpleUiDisplayTree;
80 import org.scilab.modules.gui.uidisplaytree.UiDisplayTree;
81 import org.scilab.modules.gui.utils.Position;
82 import org.scilab.modules.gui.utils.Size;
83 import org.scilab.modules.gui.window.ScilabWindowBridge;
84 import org.scilab.modules.gui.window.SimpleWindow;
85 import org.scilab.modules.gui.window.Window;
86
87 /**
88  * Main bridge for Scilab Java GUIs
89  * @author Vincent COUVERT
90  * @author Bruno Jofret
91  */
92 public class ScilabBridge {
93
94     /**
95      * Constructor for ScilabBridge class
96      */
97     protected ScilabBridge() {
98         throw new UnsupportedOperationException(); /* Prevents calls from subclass */
99     }
100
101     /*****************/
102     /* Window Bridge */
103     /*****************/
104
105     /**
106      * Creates a new window
107      * @return the created window
108      */
109     public static SimpleWindow createWindow() {
110         return ScilabWindowBridge.createWindow();
111     }
112
113     /**
114      * Draws a window on screen
115      * @param window the window to be drawn
116      */
117     public static void draw(Window window) {
118         ScilabWindowBridge.draw(window);
119     }
120
121     /**
122      * Deiconify the window and put it in front of other window
123      * @param window the window to raise
124      */
125     public static void raise(Window window) {
126         ScilabWindowBridge.raise(window);
127     }
128
129     /**
130      * Gets the dimensions (width and height) of a window
131      * @param window the window we want to get the dimensions of
132      * @return dimensions of the window
133      */
134     public static Size getDims(Window window) {
135         return ScilabWindowBridge.getDims(window);
136     }
137
138     /**
139      * Sets the dimensions (width and height) of a window
140      * @param window the window we want to set the dimensions of
141      * @param newWindowSize new dimensions of the window
142      */
143     public static void setDims(Window window, Size newWindowSize) {
144         ScilabWindowBridge.setDims(window, newWindowSize);
145     }
146
147     /**
148      * Gets the position (X-coordinate and Y-coordinate) of a window
149      * @param window the window we want to get the position of
150      * @return position of the window
151      */
152     public static Position getPosition(Window window) {
153         return ScilabWindowBridge.getPosition(window);
154     }
155
156     /**
157      * Sets the position (X-coordinate and Y-coordinate) of a window
158      * @param window the window we want to set the position of
159      * @param newWindowPosition new position of the window
160      */
161     public static void setPosition(Window window, Position newWindowPosition) {
162         ScilabWindowBridge.setPosition(window, newWindowPosition);
163     }
164
165     /**
166      * Gets the title of a window
167      * @param window the window we want to get the title of
168      * @return the title of the window
169      */
170     public static String getTitle(Window window) {
171         return ScilabWindowBridge.getTitle(window);
172     }
173
174     /**
175      * Sets the title of a window
176      * @param window the window we want to set the title of
177      * @param newWindowTitle the title to set for the window
178      */
179     public static void setTitle(Window window, String newWindowTitle) {
180         ScilabWindowBridge.setTitle(window, newWindowTitle);
181     }
182
183     /**
184      * Gets the visibility status of a window
185      * @param window the window we want to get the status of
186      * @return visibility status (true if the window is visible, false if not)
187      */
188     public static boolean isVisible(Window window) {
189         return ScilabWindowBridge.isVisible(window);
190     }
191
192     /**
193      * Sets the visibility status for a window
194      * @param window the window we want to set the visibility status of
195      * @param newVisibleState new visibility status for the window
196      *                  (true set the window visible, false to set the window invisible)
197      */
198     public static void setVisible(Window window, boolean newVisibleState) {
199         ScilabWindowBridge.setVisible(window, newVisibleState);
200     }
201
202     /**
203      * Add a tab to a window
204      * @param window the window which we want to add the tab to
205      * @param newTab the tab to add to the window
206      */
207     public static void addTab(Window window, Tab newTab) {
208         ScilabWindowBridge.addTab(window, newTab);
209     }
210
211     /**
212      * Add a tab to a window
213      * @param window the window which we want to remove the tab from
214      * @param newTab the tab to add to the window
215      */
216     public static void removeTab(Window window, Tab newTab) {
217         ScilabWindowBridge.removeTab(window, newTab);
218     }
219
220     /**
221      * Sets a MenuBar to a window
222      * @param window the window which we want to add the MeunBar to
223      * @param newMenuBar the MeunBar to add to the window
224      */
225     public static void addMenuBar(Window window, MenuBar newMenuBar) {
226         ScilabWindowBridge.addMenuBar(window, newMenuBar);
227     }
228
229     /**
230      * Sets a ToolBar to a window
231      * @param window the window which we want to add the ToolBar to
232      * @param newToolBar the ToolBar to add to the window
233      */
234     public static void addToolBar(Window window, ToolBar newToolBar) {
235         ScilabWindowBridge.addToolBar(window, newToolBar);
236     }
237
238     /**
239      * Sets a InfoBar to a window
240      * @param window the window which we want to add the InfoBar to
241      * @param newInfoBar the InfoBar to add to the window
242      */
243     public static void addInfoBar(Window window, TextBox newInfoBar) {
244         ScilabWindowBridge.addInfoBar(window, newInfoBar);
245     }
246
247     /**
248      * @param window window from which we want the information
249      * @return number of objects (tabs) docked in this window
250      */
251     public static int getNbDockedObjects(Window window) {
252         return ScilabWindowBridge.getNbDockedObjects(window);
253     }
254
255     /**
256      * Update the dimension of the window and its component.
257      * Only useful when the window is not yet visible
258      * @param window window to update
259      */
260     public static void updateDimensions(Window window) {
261         ScilabWindowBridge.updateDimensions(window);
262     }
263
264     /**
265      * DeIconify Window
266      * @param window window to update
267      */
268     public static void windowDeiconified(Window window) {
269         ScilabWindowBridge.windowDeiconified(window);
270     }
271
272     /**
273      * Iconify Window
274      * @param window window to update
275      */
276     public static void windowIconified(Window window) {
277         ScilabWindowBridge.windowIconified(window);
278     }
279
280     /**
281      * Maximized Window
282      * @param window window to update
283      */
284     public static void windowMaximized(Window window) {
285         ScilabWindowBridge.windowMaximized(window);
286     }
287
288     /**
289      * Window is in the "normal" state.
290      * @param window window to update
291      */
292     public static void windowNormal(Window window) {
293         ScilabWindowBridge.windowNormal(window);
294     }
295
296
297
298     /*****************/
299     /* ToolBar Bridge */
300     /*****************/
301
302     /**
303      * Creates a new ToolBar
304      * @return the created ToolBar
305      */
306     public static SimpleToolBar createToolBar() {
307         return ScilabToolBarBridge.createToolBar();
308     }
309
310     /**
311      * Add a Separator to a Toolbar
312      * @param toolbar the Toolbar which we want to add the Separator to
313      */
314     public static void addSeparator(ToolBar toolbar) {
315         ScilabToolBarBridge.addSeparator(toolbar);
316     }
317
318     /**
319      * Set the visibility of the Toolbar
320      * @param toolbar the ToolBar
321      * @param newVisibleState true to set the toolbar visible
322      */
323     public static void setVisible(ToolBar toolbar, boolean newVisibleState) {
324         ScilabToolBarBridge.setVisible(toolbar, newVisibleState);
325     }
326
327     /**
328      * Get the visibility of the TooBar
329      * @param toolbar the ToolBar
330      * @return true if the ToolBar is Visible
331      */
332     public static boolean isVisible(ToolBar toolbar) {
333         return ScilabToolBarBridge.isVisible(toolbar);
334     }
335
336     /**************/
337     /* Tab Bridge */
338     /**************/
339
340     /**
341      * Creates a Scilab tab
342      * @param name the name of the tab (used to identify it)
343      * @return the created tab
344      */
345     public static SimpleTab createTab(String name) {
346         return ScilabTabBridge.createTab(name);
347     }
348
349     /**
350      * Creates a Scilab tab
351      * @param name the name of the tab
352      * @param uuid an uuid to identify the tab
353      * @return the created tab
354      */
355     public static SimpleTab createTab(String name, String uuid) {
356         return ScilabTabBridge.createTab(name, uuid);
357     }
358
359     /**
360      * Creates a Scilab tab able to create graphics
361      * @param name the name of the tab (used to identify it)
362      * @param figureId index of the created figure
363      * @return the created tab
364      */
365     public static SimpleTab createTab(String name, int figureId) {
366         return ScilabTabBridge.createTab(name, figureId);
367     }
368
369     /**
370      * Draws a tab on screen
371      * @param tab the tab to be drawn
372      */
373     public static void draw(Tab tab) {
374         ScilabTabBridge.draw(tab);
375     }
376
377     /**
378      * Gets the dimensions (width and height) of a tab
379      * @param tab the tab we want to get the dimensions of
380      * @return the dimensions of the tab
381      */
382     public static Size getDims(Tab tab) {
383         return ScilabTabBridge.getDims(tab);
384     }
385
386     /**
387      * Sets the dimensions (width and height) of a tab
388      * @param tab the tab we want to set the dimensions of
389      * @param newTabSize new dimensions of the tab
390      */
391     public static void setDims(Tab tab, Size newTabSize) {
392         ScilabTabBridge.setDims(tab, newTabSize);
393     }
394
395     /**
396      * Gets the position (X-coordinate and Y-coordinate) of a tab
397      * @param tab the tab we want to get the position of
398      * @return position of the tab
399      */
400     public static Position getPosition(Tab tab) {
401         return ScilabTabBridge.getPosition(tab);
402     }
403
404     /**
405      * Sets the position (X-coordinate and Y-coordinate) of a tab
406      * @param tab the tab we want to set the position of
407      * @param newTabPosition new position of the tab
408      */
409     public static void setPosition(Tab tab, Position newTabPosition) {
410         ScilabTabBridge.setPosition(tab, newTabPosition);
411     }
412
413     /**
414      * Gets the Name of a tab
415      * @param tab the tab we want to get the Name of
416      * @return the Name of the tab
417      */
418     public static String getName(Tab tab) {
419         return ScilabTabBridge.getName(tab);
420     }
421
422     /**
423      * Sets the name of a tab
424      * @param tab the tab we want to set the name of
425      * @param newTabName the name to set for the tab
426      */
427     public static void setName(Tab tab, String newTabName) {
428         ScilabTabBridge.setName(tab, newTabName);
429     }
430
431     /**
432      * Gets the visibility status of a tab
433      * @param tab the tab we want to get the status of
434      * @return visibility status (true if the tab is visible, false if not)
435      */
436     public static boolean isVisible(Tab tab) {
437         return ScilabTabBridge.isVisible(tab);
438     }
439
440     /**
441      * Sets the visibility status of a tab
442      * @param tab the tab we want to set the visibility status of
443      * @param newVisibleState new visibility status for the tab
444      *                  (true set the tab visible, false to set the tab invisible)
445      */
446     public static void setVisible(Tab tab, boolean newVisibleState) {
447         ScilabTabBridge.setVisible(tab, newVisibleState);
448     }
449
450     /**
451      * Add a member (dockable element) to a tab and returns the index of this member
452      * @param tab the tab where we want to add the member
453      * @param member the member to add
454      * @return index of member
455      */
456     public static int addMember(Tab tab, Console member) {
457         return ScilabTabBridge.addMember(tab, member);
458     }
459
460     /**
461      * We want to be able to add directly a HelpBrowser in a Tab.
462      * @param tab the tab where we want to add the member
463      * @param member the member to add
464      * @return the position of the HelpBrowser in the member list.
465      */
466     public static int addMember(Tab tab, HelpBrowser member) {
467         return ScilabTabBridge.addMember(tab, member);
468     }
469
470     /**
471      * Add a member (dockable element) to a tab and returns the index of this member
472      * @param tab the tab where we want to add the member
473      * @param member the member to add
474      * @return index of member
475      */
476     public static int addMember(Tab tab, Canvas member) {
477         return ScilabTabBridge.addMember(tab, member);
478     }
479
480     /**
481      * Sets a MenuBar to a tab
482      * @param tab the tab which we want to add the MenuBar to
483      * @param newMenuBar the MenuBar to add to the tab
484      */
485     public static void addMenuBar(Tab tab, MenuBar newMenuBar) {
486         ScilabTabBridge.addMenuBar(tab, newMenuBar);
487     }
488
489     /**
490      * Add a member (dockable element) to a tab and returns the index of this member
491      * @param tab the tab which we want to add the Tree Overview to
492      * @param member the Tree Overview to add
493      * @return the position of the Tree Overview in the member list.
494      */
495     public static int addMember(Tab tab, Tree member) {
496         return ScilabTabBridge.addMember(tab, member);
497     }
498
499     public static int addMember(Tab tab, UiDisplayTree member) {
500         return ScilabTabBridge.addMember(tab, member);
501     }
502     public static void removeMember(Tab tab, UiDisplayTree member) {
503         ScilabTabBridge.removeMember(tab, member);
504     }
505
506     /**
507      * Remove a member (dockable element) to a tab and returns the index of this member
508      * @param tab the tab where we want to add the member
509      * @param member the member to add
510      */
511     public static void removeMember(Tab tab, Canvas member) {
512         ScilabTabBridge.removeMember(tab, member);
513     }
514
515     /**
516      * Get the current status of the Tab in its parent
517      * @param tab the tab we want to get the status of
518      * @return true is the tab is the tab currently displayed in its parent
519      */
520     public static boolean isCurrentTab(Tab tab) {
521         return ScilabTabBridge.isCurrentTab(tab);
522     }
523
524     /**
525      * Set the parent window id for this tab
526      * @param tab the tab we want to set the parent window id of
527      * @param id the id of the parent window
528      */
529     public static void setParentWindowId(Tab tab, int id) {
530         ScilabTabBridge.setParentWindowId(tab, id);
531     }
532
533     /**
534      * Get the parent window id for this tab
535      * @param tab the tab we want to get the parent window id of
536      * @return the id of the parent window
537      */
538     public static int getParentWindowId(Tab tab) {
539         return ScilabTabBridge.getParentWindowId(tab);
540     }
541
542     /**
543      * Set the callback of the tab
544      * @param tab the tab which we want to set the callback of
545      * @param callback the CallBack to set
546      */
547     public static void setCallback(Tab tab, CommonCallBack callback) {
548         ScilabTabBridge.setCallback(tab, callback);
549     }
550
551     /**
552      * Set this tab as the current tab of its parent Window
553      * @param tab the tab
554      */
555     public static void setCurrent(Tab tab) {
556         ScilabTabBridge.setCurrent(tab);
557     }
558
559     /**
560      * Set the background color of a tab.
561      * @param tab tab to modify
562      * @param red red channel of the color
563      * @param green green channel
564      * @param blue blue channel
565      */
566     public static void setBackground(Tab tab, double red, double green, double blue) {
567         ScilabTabBridge.setBackground(tab, red, green, blue);
568     }
569
570     /**
571      * Specify whether the canvas should fit the parent tab size
572      * (and consequently the scrollpane size) or not
573      * @param tab tab to modify
574      * @param onOrOff true to enable autoresize mode
575      */
576     public static void setAutoResizeMode(Tab tab, boolean onOrOff) {
577         ScilabTabBridge.setAutoResizeMode(tab, onOrOff);
578     }
579
580     /**
581      * @param tab tab to modify
582      * @return whether the resize mode is on or off
583      */
584     public static boolean getAutoResizeMode(Tab tab) {
585         return ScilabTabBridge.getAutoResizeMode(tab);
586     }
587
588     /**
589      * Get the part of the axes which is currently viewed
590      * @param tab tab to modify
591      * @return [x,y,w,h] array
592      */
593     public static int[] getViewingRegion(Tab tab) {
594         return ScilabTabBridge.getViewingRegion(tab);
595     }
596
597     /**
598      * Specify a new viewport for the axes
599      * Only works if autoresize mode is off
600      * @param tab tab to modify
601      * @param posX X coordinate of upper left point of the viewport within the canvas
602      * @param posY Y coordinate of upper left point of the viewport within the canvas
603      * @param width width of the viewport
604      * @param height height of the viewport
605      */
606     public static void setViewingRegion(Tab tab, int posX, int posY, int width, int height) {
607         ScilabTabBridge.setViewingRegion(tab, posX, posY, width, height);
608     }
609
610
611     /**
612      * @param tab tab to modify
613      * @return size of the axes in pixels
614      */
615     public static Size getAxesSize(Tab tab) {
616         return ScilabTabBridge.getAxesSize(tab);
617     }
618
619
620     /**
621      * @param tab tab to modify
622      * @param newSize set a new axes size
623      */
624     public static void setAxesSize(Tab tab, Size newSize) {
625         ScilabTabBridge.setAxesSize(tab, newSize);
626     }
627
628     /**
629      * Set the event handler of the Axes
630      * @param tab tab to modify
631      * @param command the name of the Scilab function to call
632      */
633     public static void setEventHandler(Tab tab, String command) {
634         ScilabTabBridge.setEventHandler(tab, command);
635     }
636
637     /**
638      * Set the status of the event handler of the Axes
639      * @param tab tab to modify
640      * @param status is true to set the event handler active
641      */
642     public static void setEventHandlerEnabled(Tab tab, boolean status) {
643         ScilabTabBridge.setEventHandlerEnabled(tab, status);
644     }
645
646
647
648     /******************/
649     /* Console Bridge */
650     /******************/
651
652     /**
653      * Creates a Scilab Console
654      * @return the created console
655      */
656     public static SimpleConsole createConsole() {
657         return ScilabConsoleBridge.createConsole();
658     }
659
660     /**
661      * Displays data in the console
662      * @param console the console to display the data in
663      * @param dataToDisplay the data to be displayed
664      * @see org.scilab.modules.console.HelpBrowser#display()
665      */
666     public static void display(Console console, String dataToDisplay) {
667         ScilabConsoleBridge.display(console, dataToDisplay);
668     }
669
670     /**
671      * Reads input data in the console
672      * @param console the console to read the data from
673      * @return the data entered by the user
674      * @see org.scilab.modules.console.HelpBrowser#readLine()
675      */
676     public static String readLine(Console console) {
677         return ScilabConsoleBridge.readLine(console);
678     }
679
680     /**
681      * Draw a console
682      * @param console the console to draw
683      * @see org.scilab.modules.ihm.UIElement#draw()
684      */
685     public static void draw(Console console) {
686         ScilabConsoleBridge.draw(console);
687     }
688
689     /**
690      * Gets the dimensions (width and height) of a Scilab console
691      * @param console the console which we want to get the dimensions of
692      * @return the size of the console
693      * @see org.scilab.modules.ihm.UIElement#getDims()
694      */
695     public static Size getDims(Console console) {
696         return ScilabConsoleBridge.getDims(console);
697     }
698
699     /**
700      * Gets the position (X-coordinate and Y-coordinates) of a Scilab console
701      * @param console the console which we want to get the position of
702      * @return the position of the console
703      * @see org.scilab.modules.ihm.UIElement#getPosition()
704      */
705     public static Position getPosition(Console console) {
706         return ScilabConsoleBridge.getPosition(console);
707     }
708
709     /**
710      * Gets the visibility status of a console
711      * @param console the console which we want to get the visibility status of
712      * @return the visibility status of the console (true if the console is visible, false if not)
713      * @see org.scilab.modules.ihm.UIElement#isVisible()
714      */
715     public static boolean isVisible(Console console) {
716         return ScilabConsoleBridge.isVisible(console);
717     }
718
719     /**
720      * Sets the visibility status of a console
721      * @param console the console which we want to get the visibility status of
722      * @param newVisibleState the visibility status we want to set to the console (true to set the console visible, false else)
723      * @see org.scilab.modules.ihm.UIElement#isVisible()
724      */
725     public static void setVisible(Console console, boolean newVisibleState) {
726         ScilabConsoleBridge.setVisible(console, newVisibleState);
727     }
728
729     /**
730      * Sets the dimensions (width and height) of a Scilab console
731      * @param console the console which we want to set the dimensions of
732      * @param newSize the size we want to set to the console
733      * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
734      */
735     public static void setDims(Console console, Size newSize) {
736         ScilabConsoleBridge.setDims(console, newSize);
737     }
738
739     /**
740      * Sets the position (X-coordinate and Y-coordinate) of a Scilab console
741      * @param console the console which we want to set the position of
742      * @param newPosition the position we want to set to the console
743      * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
744      */
745     public static void setPosition(Console console, Position newPosition) {
746         ScilabConsoleBridge.setPosition(console, newPosition);
747     }
748
749     /**
750      * Sets the visibility status of a Scilab console
751      * @param console the console which we want to set the visibility status of
752      * @param newVisibleState the visibility status we want to set to the console
753      * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
754      */
755     public static void setPosition(Console console, boolean newVisibleState) {
756         ScilabConsoleBridge.setVisible(console, newVisibleState);
757     }
758
759     /**
760      * Clears the console (no more scroll history and prompt on top left corner)
761      * @param console the console to be cleared
762      */
763     public static void clear(Console console) {
764         ScilabConsoleBridge.clear(console);
765     }
766
767     /**
768      * Clears lines from the end of the output view
769      * @param console the console to be cleared
770      * @param nbLines the number of lines to be deleted
771      */
772     public static void clear(Console console, int nbLines) {
773         ScilabConsoleBridge.clear(console, nbLines);
774     }
775
776     /**
777      * Puts the prompt in the top left corner of the console
778      * @param console the console used
779      */
780     public static void toHome(Console console) {
781         ScilabConsoleBridge.toHome(console);
782     }
783
784     /**
785      * Reads one user input char
786      * @param console the console used to get the char
787      * @return the data entered by the user
788      * @see fr.scilab.console.HelpBrowser#getCharWithoutOutput()
789      */
790     public static int getCharWithoutOutput(Console console) {
791         return ScilabConsoleBridge.getCharWithoutOutput(console);
792     }
793
794     /**
795      * Sets the prompt displayed in the console
796      * @param console the console where the prompt is set
797      * @param prompt the prompt to be displayed in the console
798      */
799     public static void setPrompt(Console console, String prompt) {
800         ScilabConsoleBridge.setPrompt(console, prompt);
801     }
802
803     /**
804      * Updates Scilab internal variables containing the size of the console
805      * These variables are used to format data before displaying it
806      * @param console object we want to get the size of
807      */
808     public static void scilabLinesUpdate(Console console) {
809         ScilabConsoleBridge.scilabLinesUpdate(console);
810     }
811
812     /**
813      * Get the current status of the console
814      * If the prompt view is visible, Scilab is waiting for commands
815      * @param console object we want to get the status of
816      * @return true is Scilab is waiting for commands
817      */
818     public static boolean isWaitingForInput(Console console) {
819         return ScilabConsoleBridge.isWaitingForInput(console);
820     }
821
822     /**
823      * Clear the commands history
824      * @param console the console we want to clear the history of
825      */
826     public static void clearHistory(Console console) {
827         ScilabConsoleBridge.clearHistory(console);
828     }
829
830     /**
831      * Select all the console contents
832      * @param console the console
833      */
834     public static void selectAll(Console console) {
835         ScilabConsoleBridge.selectAll(console);
836     }
837
838     /**
839      * Put the console selected text in the clipboard
840      * @param console the console
841      */
842     public static void copyToClipboard(Console console) {
843         ScilabConsoleBridge.copyToClipboard(console);
844     }
845
846     /**
847      * Paste clipboard contents in Console input line
848      * @param console the console
849      */
850     public static void pasteClipboard(Console console) {
851         ScilabConsoleBridge.pasteClipboard(console);
852     }
853
854     /**
855      * Cut selected text in the Console input line
856      * @param console the console
857      */
858     public static void cutSelection(Console console) {
859         ScilabConsoleBridge.cutSelection(console);
860     }
861
862     /**
863      * Set the font of the Console
864      * @param console the console
865      * @param font the font to set
866      */
867     public static void setFont(Console console, Font font) {
868         ScilabConsoleBridge.setFont(console, font);
869     }
870
871     /**
872      * Get the font of the Console
873      * @param console the console
874      * @return the font
875      */
876     public static Font getFont(Console console) {
877         return ScilabConsoleBridge.getFont(console);
878     }
879
880     /**
881      * Get the Foreground Color of the Console
882      * @param console the console
883      * @return the Foreground Color
884      */
885     public static Color getForeground(Console console) {
886         return ScilabConsoleBridge.getForeground(console);
887     }
888
889     /**
890      * Get the Background Color of the Console
891      * @param console the console
892      * @return the Background Color
893      */
894     public static Color getBackground(Console console) {
895         return ScilabConsoleBridge.getBackground(console);
896     }
897
898     /**
899      * Set the Foreground Color of the Console
900      * @param console the console
901      * @param color the Foreground Color
902      */
903     public static void setForeground(Console console, Color color) {
904         ScilabConsoleBridge.setForeground(console, color);
905     }
906
907     /**
908      * Set the Background Color of the Console
909      * @param console the console
910      * @param color the Background Color
911      */
912     public static void setBackground(Console console, Color color) {
913         ScilabConsoleBridge.setBackground(console, color);
914     }
915
916     /**
917      * Set the maximum number of lines stored in the Output
918      * @param console the console
919      * @param nbLines the number of lines
920      */
921     public static void setMaxOutputSize(Console console, int nbLines) {
922         ScilabConsoleBridge.setMaxOutputSize(console, nbLines);
923     }
924
925     /**
926      * Set the cursor pointer over the Console
927      * @param console the console
928      * @param cursor the Cursor to set
929      */
930     public static void setCursor(Console console, Cursor cursor) {
931         ScilabConsoleBridge.setCursor(console, cursor);
932     }
933
934     /*****************/
935     /* Canvas Bridge */
936     /*****************/
937
938     /**
939      * Creates a Scilab Canvas
940      * @param figureIndex index of the displayed figure
941      * @param antialiasingQuality Specify the number of pass to use for antialiasing.
942      *                            If its value is 0, then antialiasing is disable.
943      * @return the created canvas
944      */
945     public static SimpleCanvas createCanvas(int figureIndex, int antialiasingQuality) {
946         return ScilabCanvasBridge.createCanvas(figureIndex, antialiasingQuality);
947     }
948
949     /**
950      * Draws a Scilab canvas
951      * @param canvas the canvas to draw
952      * @see org.scilab.modules.ihm.UIElement#draw()
953      */
954     public static void draw(Canvas canvas) {
955         ScilabCanvasBridge.draw(canvas);
956     }
957
958     /**
959      * Gets the dimensions (width and height) of a Scilab Canvas
960      * @param canvas the canvas we want to get the dimensions of
961      * @return the size of the canvas
962      * @see org.scilab.modules.ihm.UIElement#getDims()
963      */
964     public static Size getDims(Canvas canvas) {
965         return ScilabCanvasBridge.getDims(canvas);
966     }
967
968     /**
969      * Gets the position (X-coordinate and Y-coordinate) of a Scilab canvas
970      * @param canvas the canvas we want to get the position of
971      * @return the position of the canvas
972      * @see org.scilab.modules.ihm.UIElement#getPosition()
973      */
974     public static Position getPosition(Canvas canvas) {
975         return ScilabCanvasBridge.getPosition(canvas);
976     }
977
978     /**
979      * Gets the visibility status of a Scilab Canvas
980      * @param canvas the canvas we want to get the visiblity status of
981      * @return the visibility status of the canvas (true if the canvas is visible, false if not)
982      * @see org.scilab.modules.ihm.UIElement#isVisible()
983      */
984     public static boolean isVisible(Canvas canvas) {
985         return ScilabCanvasBridge.isVisible(canvas);
986     }
987
988     /**
989      * Sets the dimensions (width and height) of a Scilab Canvas
990      * @param canvas the canvas we want to set the dimensions of
991      * @param newSize the size we want to set to the canvas
992      * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
993      */
994     public static void setDims(Canvas canvas, Size newSize) {
995         ScilabCanvasBridge.setDims(canvas, newSize);
996     }
997
998     /**
999      * Sets the position (X-coordinate and Y-coordinate) of a Scilab canvas
1000      * @param canvas the canvas we want to set the position of
1001      * @param newPosition the position we want to set to the canvas
1002      * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
1003      */
1004     public static void setPosition(Canvas canvas, Position newPosition) {
1005         ScilabCanvasBridge.setPosition(canvas, newPosition);
1006     }
1007
1008     /**
1009      * Sets the visibility status of a Scilab Canvas
1010      * @param canvas the canvas we want to set the visiblity status of
1011      * @param newVisibleState the visibility status we want to set to the canvas (true to set the canvas visible, false else)
1012      * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
1013      */
1014     public static void setVisible(Canvas canvas, boolean newVisibleState) {
1015         ScilabCanvasBridge.setVisible(canvas, newVisibleState);
1016     }
1017
1018     /**
1019      * @param canvas the canvas we want to display
1020      */
1021     public static void display(Canvas canvas) {
1022         ScilabCanvasBridge.display(canvas);
1023     }
1024
1025     /**
1026      * @param canvas the canvas we want to get the GL object from
1027      * @return a GL object
1028      */
1029     public static GL getGL(Canvas canvas) {
1030         return ScilabCanvasBridge.getGL(canvas);
1031     }
1032
1033     /**
1034      * @param canvas the canvas of which we want to set the swap buffer mode.
1035      * @param onOrOff set wether the swap buffer mode is on or off.
1036      */
1037     public static void setAutoSwapBufferMode(Canvas canvas, boolean onOrOff) {
1038         ScilabCanvasBridge.setAutoSwapBufferMode(canvas, onOrOff);
1039     }
1040
1041     /**
1042      * @param canvas the canvas from which we want to retrieve the swap buffer mode.
1043      * @return set wether the swap buffer mode is on or off.
1044      */
1045     public static boolean getAutoSwapBufferMode(Canvas canvas) {
1046         return ScilabCanvasBridge.getAutoSwapBufferMode(canvas);
1047     }
1048
1049     /**
1050      * @param canvas the canvas we want to repaint
1051      */
1052     public static void repaint(Canvas canvas) {
1053         ScilabCanvasBridge.repaint(canvas);
1054     }
1055
1056
1057     /**
1058      * Set the background of the Canvas.
1059      * @param canvas the canvas we want to modify
1060      * @param red red channel
1061      * @param green green channel
1062      * @param blue blue channel
1063      */
1064     public static void setBackgroundColor(Canvas canvas, double red, double green, double blue) {
1065         ScilabCanvasBridge.setBackgroundColor(canvas, red, green, blue);
1066     }
1067
1068     /**
1069      * Disable the canvas before closing
1070      * @param canvas canvas to close
1071      */
1072     public static void close(Canvas canvas) {
1073         ScilabCanvasBridge.close(canvas);
1074     }
1075
1076     /**
1077      * Dump the scilabCanvas to an BufferedImage
1078      * @param scilabCanvas ScilabCanvas
1079      * @return a BufferedImage
1080      */
1081     public static BufferedImage dumpAsBufferedImage(ScilabCanvas scilabCanvas) {
1082         return ScilabCanvasBridge.dumpAsBufferedImage(scilabCanvas);
1083     }
1084
1085     /**
1086      * Set double buffer mode on or Off
1087      * @param useSingleBuffer if true use single buffer if false use double buffering
1088      * @param canvas canvas to modify
1089      */
1090     public static void setSingleBuffered(Canvas canvas, boolean useSingleBuffer) {
1091         ScilabCanvasBridge.setSingleBuffered(canvas, useSingleBuffer);
1092     }
1093
1094     /*****************/
1095     /* MenuBar Bridge */
1096     /*****************/
1097
1098     /**
1099      * Creates a new MenuBar
1100      * @return the created MenuBar
1101      */
1102     public static SimpleMenuBar createMenuBar() {
1103         return ScilabMenuBarBridge.createMenuBar();
1104     }
1105
1106     /**
1107      * Append a Menu to a MenuBar
1108      * @param menuBar the MenuBar which we want to add the newMenu to
1109      * @param newMenu the Menu to add to the MenuBar
1110      */
1111     public static void add(MenuBar menuBar, Menu newMenu) {
1112         ScilabMenuBarBridge.add(menuBar, newMenu);
1113     }
1114
1115     /*****************/
1116     /* MenuItem Bridge */
1117     /*****************/
1118
1119     /**
1120      * Creates a new MenuItem
1121      * @return the created MenuItem
1122      */
1123     public static SimpleMenuItem createMenuItem() {
1124         return createMenuItem(true);
1125     }
1126
1127     /**
1128      * Creates a new MenuItem
1129      * @param autoCheckedMode if false, menu checking is managed by the user (and not automatically by Java)
1130      * @return the created MenuItem
1131      */
1132     public static SimpleMenuItem createMenuItem(boolean autoCheckedMode) {
1133         return ScilabMenuItemBridge.createMenuItem(autoCheckedMode);
1134     }
1135
1136     /**
1137      * Sets the Text of a MenuItem
1138      * @param menuItem the MenuItem we want to set the Text of
1139      * @param newText the Text to set for the MenuItem
1140      */
1141     public static void setText(MenuItem menuItem, String newText) {
1142         ScilabMenuItemBridge.setText(menuItem, newText);
1143     }
1144
1145     /**
1146      * set a mnemonic to a MenuItem
1147      * @param menuItem the MenuItem which we want to add the mnemonic to
1148      * @param mnemonic the mnemonic to add to the MenuItem
1149      */
1150     public static void setMnemonic(MenuItem menuItem, char mnemonic) {
1151         ScilabMenuItemBridge.setMnemonic(menuItem, mnemonic);
1152     }
1153
1154     /**
1155      * Add a callback to the menu, this callback is a Scilab command
1156      * @param menuItem the MenuItem which we want to add the mnemonic to
1157      * @param callback the CallBack to set.
1158      */
1159     public static void setCallback(MenuItem menuItem, CommonCallBack callback) {
1160         ScilabMenuItemBridge.setCallback(menuItem, callback);
1161     }
1162
1163     /**
1164      * Set if the menu item is enabled or not
1165      * @param menuItem the MenuItem which we want to set the status of
1166      * @param status true if the menu item is enabled
1167      */
1168     public static void setEnabled(MenuItem menuItem, boolean status) {
1169         ScilabMenuItemBridge.setEnabled(menuItem, status);
1170     }
1171
1172     /**
1173      * Get the enable status of a MenuItem
1174      * @param menuItem the MenuItem which we want to get the status of
1175      * @return the enable status of the MenuItem (true if the MenuItem is enabled, false if not)
1176      */
1177     public static boolean isEnabled(MenuItem menuItem) {
1178         return ScilabMenuItemBridge.isEnabled(menuItem);
1179     }
1180
1181     /**
1182      * Get the text to a MenuItem
1183      * @param menuItem the MenuItem which we want to get the text of
1184      * @return the text of the MenuItem
1185      */
1186     public static String getText(MenuItem menuItem) {
1187         return ScilabMenuItemBridge.getText(menuItem);
1188     }
1189
1190     /**
1191      * set a mnemonic to a MenuItem
1192      * @param menuItem the MenuItem which we want to set the mnemonic to
1193      * @param mnemonic the new mnemonic to set to the MenuItem
1194      */
1195     public static void setMnemonic(MenuItem menuItem, int mnemonic) {
1196         ScilabMenuItemBridge.setMnemonic(menuItem, mnemonic);
1197     }
1198
1199     /**
1200      * Sets the visibility status of a Scilab MenuItem
1201      * @param menuItem the MenuItem we want to set the visiblity status of
1202      * @param newVisibleState the visibility status we want to set to the MenuItem (true to set the MenuItem visible, false else)
1203      * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
1204      */
1205     public static void setVisible(MenuItem menuItem, boolean newVisibleState) {
1206         ScilabMenuItemBridge.setVisible(menuItem, newVisibleState);
1207     }
1208
1209     /**
1210      * Gets the visibility status of a Scilab MenuItem
1211      * @param menuItem the MenuItem we want to get the visiblity status of
1212      * @return the visibility status of the MenuItem (true if the MenuItem is visible, false if not)
1213      * @see org.scilab.modules.ihm.UIElement#isVisible()
1214      */
1215     public static boolean isVisible(MenuItem menuItem) {
1216         return ScilabMenuItemBridge.isVisible(menuItem);
1217     }
1218
1219     /**
1220      * Set the Background color of the MenuItem
1221      * @param menuItem the MenuItem we want to set the background of
1222      * @param color the Color
1223      */
1224     public static void setBackground(MenuItem menuItem, Color color) {
1225         ScilabMenuItemBridge.setBackground(menuItem, color);
1226     }
1227
1228     /**
1229      * Get the Background color of the MenuItem
1230      * @param menuItem the MenuItem we want to get the background of
1231      * @return the Color
1232      */
1233     public static Color getBackground(MenuItem menuItem) {
1234         return ScilabMenuItemBridge.getBackground(menuItem);
1235     }
1236
1237     /**
1238      * Set the Foreground color of the MenuItem
1239      * @param menuItem the MenuItem we want to set the foreground of
1240      * @param color the Color
1241      */
1242     public static void setForeground(MenuItem menuItem, Color color) {
1243         ScilabMenuItemBridge.setForeground(menuItem, color);
1244     }
1245
1246     /**
1247      * Get the Foreground color of the MenuItem
1248      * @param menuItem the MenuItem we want to get the foreground of
1249      * @return the Color
1250      */
1251     public static Color getForeground(MenuItem menuItem) {
1252         return ScilabMenuItemBridge.getForeground(menuItem);
1253     }
1254
1255     /**
1256      * Set the font of the MenuItem.
1257      * @param menuItem the MenuItem we want to set the font of
1258      * @param font the font
1259      */
1260     public static void setFont(MenuItem menuItem, Font font) {
1261         ScilabMenuItemBridge.setFont(menuItem, font);
1262     }
1263
1264     /**
1265      * Get the font of the MenuItem.
1266      * @param menuItem the MenuItem we want to get the font of
1267      * @return the font
1268      */
1269     public static Font getFont(MenuItem menuItem) {
1270         return ScilabMenuItemBridge.getFont(menuItem);
1271     }
1272
1273     /**
1274      * Set the horizontal alignment for the MenuItem text
1275      * @param menuItem the MenuItem we want to set the alignment of
1276      * @param alignment the value for the alignment (See ScilabAlignment.java)
1277      */
1278     public static void setHorizontalAlignment(MenuItem menuItem, String alignment) {
1279         ScilabMenuItemBridge.setHorizontalAlignment(menuItem, alignment);
1280     }
1281
1282     /**
1283      * Set the vertical alignment for the MenuItem text
1284      * @param menuItem the MenuItem we want to set the alignment of
1285      * @param alignment the value for the alignment (See ScilabAlignment.java)
1286      */
1287     public static void setVerticalAlignment(MenuItem menuItem, String alignment) {
1288         ScilabMenuItemBridge.setVerticalAlignment(menuItem, alignment);
1289     }
1290
1291     /**
1292      * Set the Relief of the MenuItem
1293      * @param menuItem the MenuItem which we want to set the Relief of
1294      * @param reliefType the type of the relief to set (See ScilabRelief.java)
1295      */
1296     public static void setRelief(MenuItem menuItem, String reliefType) {
1297         ScilabMenuItemBridge.setRelief(menuItem, reliefType);
1298     }
1299
1300     /**
1301      * Add a MenuItem to the MenuItem
1302      * @param parentMenuItem the MenuItem where we want to add a MenuItem
1303      * @param childMenuItem the MenuItem we want to add
1304      */
1305     public static void add(MenuItem parentMenuItem, MenuItem childMenuItem) {
1306         ScilabMenuItemBridge.add(parentMenuItem, childMenuItem);
1307     }
1308
1309     /**
1310      * Add a Menu to the MenuItem
1311      * @param parentMenuItem the MenuItem where we want to add a MenuItem
1312      * @param childMenu the Menu we want to add
1313      */
1314     public static void add(MenuItem parentMenuItem, Menu childMenu) {
1315         ScilabMenuItemBridge.add(parentMenuItem, childMenu);
1316     }
1317
1318     /**
1319      * Destroy the MenuItem
1320      * @param menuItem the MenuItem to be destroyed
1321      */
1322     public static void destroy(MenuItem menuItem) {
1323         ScilabMenuItemBridge.destroy(menuItem);
1324     }
1325
1326     /**
1327      * Give the focus to the MenuItem
1328      * @param menuItem the MenuItem
1329      */
1330     public static void requestFocus(MenuItem menuItem) {
1331         ScilabMenuItemBridge.requestFocus(menuItem);
1332     }
1333
1334     /**
1335      * Retrieve the CallBack associated to this MenuItem
1336      * @param menuItem the MenuItem
1337      * @return the CallBack
1338      */
1339     public static CommonCallBack getCallback(MenuItem menuItem) {
1340         return ScilabMenuItemBridge.getCallback(menuItem);
1341     }
1342
1343     /**
1344      * Set if the MenuItem is checked or not
1345      * @param menuItem the MenuItem
1346      * @param status true if the MenuItem is checked
1347      */
1348     public static void setChecked(MenuItem menuItem, boolean status) {
1349         ScilabMenuItemBridge.setChecked(menuItem, status);
1350     }
1351
1352     /**
1353      * Get if the MenuItem is checked or not
1354      * @param menuItem the MenuItem
1355      * @return true if the MenuItem is checked
1356      */
1357     public static boolean isChecked(MenuItem menuItem) {
1358         return ScilabMenuItemBridge.isChecked(menuItem);
1359     }
1360
1361     /****************************/
1362     /* CheckBox MenuItem Bridge */
1363     /****************************/
1364
1365     /**
1366      * Creates a new CheckBoxMenuItem
1367      * @return the created CheckBoxMenuItem
1368      */
1369     public static SimpleCheckBoxMenuItem createCheckBoxMenuItem() {
1370         return createCheckBoxMenuItem(true);
1371     }
1372
1373     /**
1374      * Creates a new CheckBoxMenuItem
1375      * @param autoCheckedMode if false, menu checking is managed by the user (and not automatically by Java)
1376      * @return the created CheckBoxMenuItem
1377      */
1378     public static SimpleCheckBoxMenuItem createCheckBoxMenuItem(boolean autoCheckedMode) {
1379         return ScilabCheckBoxMenuItemBridge.createCheckBoxMenuItem(autoCheckedMode);
1380     }
1381
1382     /**
1383      * Add a MenuItem to the CheckBoxMenuItem
1384      * @param parentMenuItem the MenuItem where we want to add a CheckBoxMenuItem
1385      * @param childMenuItem the MenuItem we want to add
1386      */
1387     public static void add(CheckBoxMenuItem parentMenuItem, MenuItem childMenuItem) {
1388         ScilabMenuItemBridge.add(parentMenuItem, childMenuItem);
1389     }
1390
1391     /**
1392      * Sets the Text of a CheckBoxMenuItem
1393      * @param checkBoxMenuItem the CheckBoxMenuItem we want to set the Text of
1394      * @param newText the Text to set for the CheckBoxMenuItem
1395      */
1396     public static void setText(CheckBoxMenuItem checkBoxMenuItem, String newText) {
1397         ScilabCheckBoxMenuItemBridge.setText(checkBoxMenuItem, newText);
1398     }
1399
1400     /**
1401      * set a mnemonic to a CheckBoxMenuItem
1402      * @param checkBoxMenuItem the CheckBoxMenuItem which we want to add the mnemonic to
1403      * @param mnemonic the mnemonic to add to the CheckBoxMenuItem
1404      */
1405     public static void setMnemonic(CheckBoxMenuItem checkBoxMenuItem, char mnemonic) {
1406         ScilabCheckBoxMenuItemBridge.setMnemonic(checkBoxMenuItem, mnemonic);
1407     }
1408
1409     /**
1410      * Add a callback to the menu, this callback is a Scilab command
1411      * @param checkBoxMenuItem the CheckBoxMenuItem which we want to add the mnemonic to
1412      * @param callback the CallBack to set.
1413      */
1414     public static void setCallback(CheckBoxMenuItem checkBoxMenuItem, CommonCallBack callback) {
1415         ScilabCheckBoxMenuItemBridge.setCallback(checkBoxMenuItem, callback);
1416     }
1417
1418     /**
1419      * Set if the menu item is enabled or not
1420      * @param checkBoxMenuItem the CheckBoxMenuItem which we want to set the status of
1421      * @param status true if the menu item is enabled
1422      */
1423     public static void setEnabled(CheckBoxMenuItem checkBoxMenuItem, boolean status) {
1424         ScilabCheckBoxMenuItemBridge.setEnabled(checkBoxMenuItem, status);
1425     }
1426
1427     /**
1428      * Get the enable status of a CheckBoxMenuItem
1429      * @param checkBoxMenuItem the CheckBoxMenuItem which we want to get the status of
1430      * @return the enable status of the CheckBoxMenuItem (true if the CheckBoxMenuItem is enabled, false if not)
1431      */
1432     public static boolean isEnabled(CheckBoxMenuItem checkBoxMenuItem) {
1433         return ScilabCheckBoxMenuItemBridge.isEnabled(checkBoxMenuItem);
1434     }
1435
1436     /**
1437      * Get the text to a CheckBoxMenuItem
1438      * @param checkBoxMenuItem the CheckBoxMenuItem which we want to get the text of
1439      * @return the text of the CheckBoxMenuItem
1440      */
1441     public static String getText(CheckBoxMenuItem checkBoxMenuItem) {
1442         return ScilabCheckBoxMenuItemBridge.getText(checkBoxMenuItem);
1443     }
1444
1445     /**
1446      * set a mnemonic to a CheckBoxMenuItem
1447      * @param checkBoxMenuItem the CheckBoxMenuItem which we want to set the mnemonic to
1448      * @param mnemonic the new mnemonic to set to the CheckBoxMenuItem
1449      */
1450     public static void setMnemonic(CheckBoxMenuItem checkBoxMenuItem, int mnemonic) {
1451         ScilabCheckBoxMenuItemBridge.setMnemonic(checkBoxMenuItem, mnemonic);
1452     }
1453
1454     /**
1455      * Sets the visibility status of a Scilab CheckBoxMenuItem
1456      * @param checkBoxMenuItem the CheckBoxMenuItem we want to set the visiblity status of
1457      * @param newVisibleState the visibility status we want to set to the CheckBoxMenuItem (true to set the CheckBoxMenuItem visible, false else)
1458      * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
1459      */
1460     public static void setVisible(CheckBoxMenuItem checkBoxMenuItem, boolean newVisibleState) {
1461         ScilabCheckBoxMenuItemBridge.setVisible(checkBoxMenuItem, newVisibleState);
1462     }
1463
1464     /**
1465      * Gets the visibility status of a Scilab CheckBoxMenuItem
1466      * @param checkBoxMenuItem the CheckBoxMenuItem we want to get the visiblity status of
1467      * @return the visibility status of the CheckBoxMenuItem (true if the CheckBoxMenuItem is visible, false if not)
1468      * @see org.scilab.modules.ihm.UIElement#isVisible()
1469      */
1470     public static boolean isVisible(CheckBoxMenuItem checkBoxMenuItem) {
1471         return ScilabCheckBoxMenuItemBridge.isVisible(checkBoxMenuItem);
1472     }
1473
1474     /**
1475      * Set the Background color of the CheckBoxMenuItem
1476      * @param checkBoxMenuItem the CheckBoxMenuItem we want to set the background of
1477      * @param color the Color
1478      */
1479     public static void setBackground(CheckBoxMenuItem checkBoxMenuItem, Color color) {
1480         ScilabCheckBoxMenuItemBridge.setBackground(checkBoxMenuItem, color);
1481     }
1482
1483     /**
1484      * Get the Background color of the CheckBoxMenuItem
1485      * @param checkBoxMenuItem the CheckBoxMenuItem we want to get the background of
1486      * @return the Color
1487      */
1488     public static Color getBackground(CheckBoxMenuItem checkBoxMenuItem) {
1489         return ScilabCheckBoxMenuItemBridge.getBackground(checkBoxMenuItem);
1490     }
1491
1492     /**
1493      * Set the Foreground color of the CheckBoxMenuItem
1494      * @param checkBoxMenuItem the CheckBoxMenuItem we want to set the foreground of
1495      * @param color the Color
1496      */
1497     public static void setForeground(CheckBoxMenuItem checkBoxMenuItem, Color color) {
1498         ScilabCheckBoxMenuItemBridge.setForeground(checkBoxMenuItem, color);
1499     }
1500
1501     /**
1502      * Get the Foreground color of the CheckBoxMenuItem
1503      * @param checkBoxMenuItem the CheckBoxMenuItem we want to get the foreground of
1504      * @return the Color
1505      */
1506     public static Color getForeground(CheckBoxMenuItem checkBoxMenuItem) {
1507         return ScilabCheckBoxMenuItemBridge.getForeground(checkBoxMenuItem);
1508     }
1509
1510     /**
1511      * Set the font of the CheckBoxMenuItem.
1512      * @param checkBoxMenuItem the CheckBoxMenuItem we want to set the font of
1513      * @param font the font
1514      */
1515     public static void setFont(CheckBoxMenuItem checkBoxMenuItem, Font font) {
1516         ScilabCheckBoxMenuItemBridge.setFont(checkBoxMenuItem, font);
1517     }
1518
1519     /**
1520      * Get the font of the CheckBoxMenuItem.
1521      * @param checkBoxMenuItem the CheckBoxMenuItem we want to get the font of
1522      * @return the font
1523      */
1524     public static Font getFont(CheckBoxMenuItem checkBoxMenuItem) {
1525         return ScilabCheckBoxMenuItemBridge.getFont(checkBoxMenuItem);
1526     }
1527
1528     /**
1529      * Set the horizontal alignment for the CheckBoxMenuItem text
1530      * @param checkBoxMenuItem the CheckBoxMenuItem we want to set the alignment of
1531      * @param alignment the value for the alignment (See ScilabAlignment.java)
1532      */
1533     public static void setHorizontalAlignment(CheckBoxMenuItem checkBoxMenuItem, String alignment) {
1534         ScilabCheckBoxMenuItemBridge.setHorizontalAlignment(checkBoxMenuItem, alignment);
1535     }
1536
1537     /**
1538      * Set the vertical alignment for the CheckBoxMenuItem text
1539      * @param checkBoxMenuItem the CheckBoxMenuItem we want to set the alignment of
1540      * @param alignment the value for the alignment (See ScilabAlignment.java)
1541      */
1542     public static void setVerticalAlignment(CheckBoxMenuItem checkBoxMenuItem, String alignment) {
1543         ScilabCheckBoxMenuItemBridge.setVerticalAlignment(checkBoxMenuItem, alignment);
1544     }
1545
1546     /**
1547      * Set the Relief of the CheckBoxMenuItem
1548      * @param checkBoxMenuItem the CheckBoxMenuItem which we want to set the Relief of
1549      * @param reliefType the type of the relief to set (See ScilabRelief.java)
1550      */
1551     public static void setRelief(CheckBoxMenuItem checkBoxMenuItem, String reliefType) {
1552         ScilabCheckBoxMenuItemBridge.setRelief(checkBoxMenuItem, reliefType);
1553     }
1554
1555     /**
1556      * Add a CheckBoxMenuItem to the CheckBoxMenuItem
1557      * @param parentCheckBoxMenuItem the CheckBoxMenuItem where we want to add a CheckBoxMenuItem
1558      * @param childCheckBoxMenuItem the CheckBoxMenuItem we want to add
1559      */
1560     public static void add(CheckBoxMenuItem parentCheckBoxMenuItem, CheckBoxMenuItem childCheckBoxMenuItem) {
1561         ScilabCheckBoxMenuItemBridge.add(parentCheckBoxMenuItem, childCheckBoxMenuItem);
1562     }
1563
1564     /**
1565      * Add a Menu to the CheckBoxMenuItem
1566      * @param parentCheckBoxMenuItem the CheckBoxMenuItem where we want to add a CheckBoxMenuItem
1567      * @param childMenu the Menu we want to add
1568      */
1569     public static void add(CheckBoxMenuItem parentCheckBoxMenuItem, Menu childMenu) {
1570         ScilabCheckBoxMenuItemBridge.add(parentCheckBoxMenuItem, childMenu);
1571     }
1572
1573     /**
1574      * Destroy the CheckBoxMenuItem
1575      * @param checkBoxMenuItem the CheckBoxMenuItem to be destroyed
1576      */
1577     public static void destroy(CheckBoxMenuItem checkBoxMenuItem) {
1578         ScilabCheckBoxMenuItemBridge.destroy(checkBoxMenuItem);
1579     }
1580
1581     /**
1582      * Give the focus to the CheckBoxMenuItem
1583      * @param checkBoxMenuItem the CheckBoxMenuItem
1584      */
1585     public static void requestFocus(CheckBoxMenuItem checkBoxMenuItem) {
1586         ScilabCheckBoxMenuItemBridge.requestFocus(checkBoxMenuItem);
1587     }
1588
1589     /**
1590      * Retrieve the CallBack associated to this CheckBoxMenuItem
1591      * @param checkBoxMenuItem the CheckBoxMenuItem
1592      * @return the CallBack
1593      */
1594     public static CommonCallBack getCallback(CheckBoxMenuItem checkBoxMenuItem) {
1595         return ScilabCheckBoxMenuItemBridge.getCallback(checkBoxMenuItem);
1596     }
1597
1598     /**
1599      * Set if the CheckBoxMenuItem is checked or not
1600      * @param checkBoxMenuItem the CheckBoxMenuItem
1601      * @param status true if the CheckBoxMenuItem is checked
1602      */
1603     public static void setChecked(CheckBoxMenuItem checkBoxMenuItem, boolean status) {
1604         ScilabCheckBoxMenuItemBridge.setChecked(checkBoxMenuItem, status);
1605     }
1606
1607     /**
1608      * Get if the CheckBoxMenuItem is checked or not
1609      * @param checkBoxMenuItem the CheckBoxMenuItem
1610      * @return true if the CheckBoxMenuItem is checked
1611      */
1612     public static boolean isChecked(CheckBoxMenuItem checkBoxMenuItem) {
1613         return ScilabCheckBoxMenuItemBridge.isChecked(checkBoxMenuItem);
1614     }
1615
1616     /*****************/
1617     /* Menu Bridge */
1618     /*****************/
1619
1620     /**
1621      * Creates a new Menu
1622      * @return the created Menu
1623      */
1624     public static SimpleMenu createMenu() {
1625         return ScilabMenuBridge.createMenu();
1626     }
1627
1628     /**
1629      * Retrieve the CallBack associated to this Menu
1630      * @param menu the Menu
1631      * @return the CallBack
1632      */
1633     public static CommonCallBack getCallback(Menu menu) {
1634         return ScilabMenuBridge.getCallback(menu);
1635     }
1636
1637     /**
1638      * Append a MenuItem to a Menu
1639      * @param menu the Menu which we want to add the MenuItem to
1640      * @param newMenuItem the MenuItem to add to the Menu
1641      */
1642     public static void add(Menu menu, MenuItem newMenuItem) {
1643         ScilabMenuBridge.add(menu, newMenuItem);
1644     }
1645
1646     /**
1647      * Append a CheckBoxMenuItem to a Menu
1648      * @param menu the Menu which we want to add the CheckBoxMenuItem to
1649      * @param newCheckBoxMenuItem the MenuItem to add to the Menu
1650      */
1651     public static void add(Menu menu, CheckBoxMenuItem newCheckBoxMenuItem) {
1652         ScilabMenuBridge.add(menu, newCheckBoxMenuItem);
1653     }
1654
1655     /**
1656      * Append a Menu to a Menu
1657      * @param menu the Menu which we want to append the Menu to
1658      * @param newSubMenu the Menu to append to the Menu
1659      */
1660     public static void add(Menu menu, Menu newSubMenu) {
1661         ScilabMenuBridge.add(menu, newSubMenu);
1662     }
1663
1664     /**
1665      * set a text to a menu
1666      * @param menu the Menu which we want to set the text to
1667      * @param newText the new text to set to the menu
1668      */
1669     public static void setText(Menu menu, String newText) {
1670         ScilabMenuBridge.setText(menu, newText);
1671     }
1672
1673     /**
1674      * Get the text to a menu
1675      * @param menu the Menu which we want to get the text of
1676      * @return the text of the menu
1677      */
1678     public static String getText(Menu menu) {
1679         return ScilabMenuBridge.getText(menu);
1680     }
1681
1682     /**
1683      * set a mnemonic to a menu
1684      * @param menu the Menu which we want to set the mnemonic to
1685      * @param mnemonic the new mnemonic to set to the menu
1686      */
1687     public static void setMnemonic(Menu menu, int mnemonic) {
1688         ScilabMenuBridge.setMnemonic(menu, mnemonic);
1689     }
1690
1691     /**
1692      * Add a Separator to a Menu
1693      * @param menu the Menu which we want to add the Separator to
1694      */
1695     public static void addSeparator(Menu menu) {
1696         ScilabMenuBridge.addSeparator(menu);
1697     }
1698
1699     /**
1700      * Set if the menu is enabled or not
1701      * @param menu the menu which we want to set the status of
1702      * @param status true if the menu item is enabled
1703      */
1704     public static void setEnabled(Menu menu, boolean status) {
1705         ScilabMenuBridge.setEnabled(menu, status);
1706     }
1707
1708     /**
1709      * Gets the enable status of a Menu
1710      * @param menu the menu which we want to get the status of
1711      * @return the enable status of the Menu (true if the Menu is enabled, false if not)
1712      */
1713     public static boolean isEnabled(Menu menu) {
1714         return ScilabMenuBridge.isEnabled(menu);
1715     }
1716
1717     /**
1718      * Sets the visibility status of a Scilab menu
1719      * @param menu the menu we want to set the visiblity status of
1720      * @param newVisibleState the visibility status we want to set to the menu (true to set the menu visible, false else)
1721      * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
1722      */
1723     public static void setVisible(Menu menu, boolean newVisibleState) {
1724         ScilabMenuBridge.setVisible(menu, newVisibleState);
1725     }
1726
1727     /**
1728      * Gets the visibility status of a Scilab Menu
1729      * @param menu the menu we want to get the visiblity status of
1730      * @return the visibility status of the menu (true if the menu is visible, false if not)
1731      * @see org.scilab.modules.ihm.UIElement#isVisible()
1732      */
1733     public static boolean isVisible(Menu menu) {
1734         return ScilabMenuBridge.isVisible(menu);
1735     }
1736
1737     /**
1738      * Set the Background color of the menu
1739      * @param menu the menu we want to set the background of
1740      * @param color the Color
1741      */
1742     public static void setBackground(Menu menu, Color color) {
1743         ScilabMenuBridge.setBackground(menu, color);
1744     }
1745
1746     /**
1747      * Get the Background color of the menu
1748      * @param menu the menu we want to get the background of
1749      * @return the Color
1750      */
1751     public static Color getBackground(Menu menu) {
1752         return ScilabMenuBridge.getBackground(menu);
1753     }
1754
1755     /**
1756      * Set the Foreground color of the menu
1757      * @param menu the menu we want to set the foreground of
1758      * @param color the Color
1759      */
1760     public static void setForeground(Menu menu, Color color) {
1761         ScilabMenuBridge.setForeground(menu, color);
1762     }
1763
1764     /**
1765      * Get the Foreground color of the menu
1766      * @param menu the menu we want to get the foreground of
1767      * @return the Color
1768      */
1769     public static Color getForeground(Menu menu) {
1770         return ScilabMenuBridge.getForeground(menu);
1771     }
1772
1773     /**
1774      * Set the font of the menu.
1775      * @param menu the menu we want to set the font of
1776      * @param font the font
1777      */
1778     public static void setFont(Menu menu, Font font) {
1779         ScilabMenuBridge.setFont(menu, font);
1780     }
1781
1782     /**
1783      * Get the font of the menu.
1784      * @param menu the menu we want to get the font of
1785      * @return the font
1786      */
1787     public static Font getFont(Menu menu) {
1788         return ScilabMenuBridge.getFont(menu);
1789     }
1790
1791     /**
1792      * Add a callback to the menu, this callback is a Scilab command
1793      * @param menu the menu we want to set the callback of
1794      * @param callback the CallBack to set.
1795      */
1796     public static void setCallback(Menu menu, CommonCallBack callback) {
1797         ScilabMenuBridge.setCallback(menu, callback);
1798     }
1799
1800     /**
1801      * Set the horizontal alignment for the Menu text
1802      * @param menu the Menu we want to set the alignment of
1803      * @param alignment the value for the alignment (See ScilabAlignment.java)
1804      */
1805     public static void setHorizontalAlignment(Menu menu, String alignment) {
1806         ScilabMenuBridge.setHorizontalAlignment(menu, alignment);
1807     }
1808
1809     /**
1810      * Set the vertical alignment for the Menu text
1811      * @param menu the Menu we want to set the alignment of
1812      * @param alignment the value for the alignment (See ScilabAlignment.java)
1813      */
1814     public static void setVerticalAlignment(Menu menu, String alignment) {
1815         ScilabMenuBridge.setVerticalAlignment(menu, alignment);
1816     }
1817
1818     /**
1819      * Set the Relief of the Menu
1820      * @param menu the Menu which we want to set the Relief of
1821      * @param reliefType the type of the relief to set (See ScilabRelief.java)
1822      */
1823     public static void setRelief(Menu menu, String reliefType) {
1824         ScilabMenuBridge.setRelief(menu, reliefType);
1825     }
1826
1827     /**
1828      * Delete the Menu
1829      * @param menu the Menu to be destroyed
1830      */
1831     public static void destroy(Menu menu) {
1832         ScilabMenuBridge.destroy(menu);
1833     }
1834
1835     /**
1836      * Give the focus to the Menu
1837      * @param menu the Menu
1838      */
1839     public static void requestFocus(Menu menu) {
1840         ScilabMenuBridge.requestFocus(menu);
1841     }
1842
1843     /**
1844      * Set if the Menu is checked or not
1845      * @param menu the Menu
1846      * @param status true if the Menu is checked
1847      */
1848     public static void setChecked(Menu menu, boolean status) {
1849         ScilabMenuBridge.setChecked(menu, status);
1850     }
1851
1852     /**
1853      * Get if the Menu is checked or not
1854      * @param menu the Menu
1855      * @return true if the Menu is checked
1856      */
1857     public static boolean isChecked(Menu menu) {
1858         return ScilabMenuBridge.isChecked(menu);
1859     }
1860
1861     /**********************/
1862     /* ContextMenu Bridge */
1863     /**********************/
1864
1865     /**
1866      * Creates a new ContextMenu
1867      * @return the created ContextMenu
1868      */
1869     public static SimpleContextMenu createContextMenu() {
1870         return ScilabContextMenuBridge.createContextMenu();
1871     }
1872
1873     /**
1874      * Append a MenuItem to a ContextMenu
1875      * @param contextMenu the ContextMenu which we want to add the MenuItem to
1876      * @param newMenuItem the MenuItem to add to the ContextMenu
1877      */
1878     public static void add(ContextMenu contextMenu, MenuItem newMenuItem) {
1879         ScilabContextMenuBridge.add(contextMenu, newMenuItem);
1880     }
1881
1882     /**
1883      * Append a Menu to a ContextMenu
1884      * @param contextMenu the ContextMenu which we want to add the MenuItem to
1885      * @param newMenu the Menu to add to the ContextMenu
1886      */
1887     public static void add(ContextMenu contextMenu, Menu newMenu) {
1888         ScilabContextMenuBridge.add(contextMenu, newMenu);
1889     }
1890
1891     /**
1892      * set a text to a ContextMenu
1893      * @param contextMenu the Menu which we want to set the text to
1894      * @param newText the new text to set to the contextMenu
1895      */
1896     public static void setText(ContextMenu contextMenu, String newText) {
1897         ScilabContextMenuBridge.setText(contextMenu, newText);
1898     }
1899
1900     /**
1901      * Get the text to a contextMenu
1902      * @param contextMenu the ContextMenu which we want to get the text of
1903      * @return the text of the contextMenu
1904      */
1905     public static String getText(ContextMenu contextMenu) {
1906         return ScilabContextMenuBridge.getText(contextMenu);
1907     }
1908
1909     /**
1910      * Set if the contextMenu is enabled or not
1911      * @param contextMenu the contextMenu which we want to set the status of
1912      * @param status true if the contextMenu item is enabled
1913      */
1914     public static void setEnabled(ContextMenu contextMenu, boolean status) {
1915         ScilabContextMenuBridge.setEnabled(contextMenu, status);
1916     }
1917
1918     /**
1919      * Gets the enable status of a ContextMenu
1920      * @param contextMenu the contextMenu which we want to get the status of
1921      * @return the enable status of the ContextMenu (true if the ContextMenu is enabled, false if not)
1922      */
1923     public static boolean isEnabled(ContextMenu contextMenu) {
1924         return ScilabContextMenuBridge.isEnabled(contextMenu);
1925     }
1926
1927     /**
1928      * Sets the visibility status of a Scilab contextMenu
1929      * @param contextMenu the contextMenu we want to set the visiblity status of
1930      * @param newVisibleState the visibility status we want to set to the contextMenu (true to set the contextMenu visible, false else)
1931      * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
1932      */
1933     public static void setVisible(ContextMenu contextMenu, boolean newVisibleState) {
1934         ScilabContextMenuBridge.setVisible(contextMenu, newVisibleState);
1935     }
1936
1937     /**
1938      * Gets the visibility status of a Scilab ContextMenu
1939      * @param contextMenu the contextMenu we want to get the visiblity status of
1940      * @return the visibility status of the contextMenu (true if the contextMenu is visible, false if not)
1941      * @see org.scilab.modules.ihm.UIElement#isVisible()
1942      */
1943     public static boolean isVisible(ContextMenu contextMenu) {
1944         return ScilabContextMenuBridge.isVisible(contextMenu);
1945     }
1946
1947     /**
1948      * Set the Background color of the contextMenu
1949      * @param contextMenu the contextMenu we want to set the background of
1950      * @param color the Color
1951      */
1952     public static void setBackground(ContextMenu contextMenu, Color color) {
1953         ScilabContextMenuBridge.setBackground(contextMenu, color);
1954     }
1955
1956     /**
1957      * Get the Background color of the contextMenu
1958      * @param contextMenu the contextMenu we want to get the background of
1959      * @return the Color
1960      */
1961     public static Color getBackground(ContextMenu contextMenu) {
1962         return ScilabContextMenuBridge.getBackground(contextMenu);
1963     }
1964
1965     /**
1966      * Set the Foreground color of the contextMenu
1967      * @param contextMenu the contextMenu we want to set the foreground of
1968      * @param color the Color
1969      */
1970     public static void setForeground(ContextMenu contextMenu, Color color) {
1971         ScilabContextMenuBridge.setForeground(contextMenu, color);
1972     }
1973
1974     /**
1975      * Get the Foreground color of the contextMenu
1976      * @param contextMenu the contextMenu we want to get the foreground of
1977      * @return the Color
1978      */
1979     public static Color getForeground(ContextMenu contextMenu) {
1980         return ScilabContextMenuBridge.getForeground(contextMenu);
1981     }
1982
1983     /**
1984      * Set the font of the contextMenu.
1985      * @param contextMenu the contextMenu we want to set the font of
1986      * @param font the font
1987      */
1988     public static void setFont(ContextMenu contextMenu, Font font) {
1989         ScilabContextMenuBridge.setFont(contextMenu, font);
1990     }
1991
1992     /**
1993      * Get the font of the contextMenu.
1994      * @param contextMenu the contextMenu we want to get the font of
1995      * @return the font
1996      */
1997     public static Font getFont(ContextMenu contextMenu) {
1998         return ScilabContextMenuBridge.getFont(contextMenu);
1999     }
2000
2001     /**
2002      * Add a callback to the contextMenu, this callback is a Scilab command
2003      * @param contextMenu the contextMenu we want to set the callback of
2004      * @param callback the CallBack to set.
2005      */
2006     public static void setCallback(ContextMenu contextMenu, CommonCallBack callback) {
2007         ScilabContextMenuBridge.setCallback(contextMenu, callback);
2008     }
2009
2010     /**
2011      * Set the horizontal alignment for the ContextMenu text
2012      * @param contextMenu the ContextMenu we want to set the alignment of
2013      * @param alignment the value for the alignment (See ScilabAlignment.java)
2014      */
2015     public static void setHorizontalAlignment(ContextMenu contextMenu, String alignment) {
2016         ScilabContextMenuBridge.setHorizontalAlignment(contextMenu, alignment);
2017     }
2018
2019     /**
2020      * Set the vertical alignment for the ContextMenu text
2021      * @param contextMenu the ContextMenu we want to set the alignment of
2022      * @param alignment the value for the alignment (See ScilabAlignment.java)
2023      */
2024     public static void setVerticalAlignment(ContextMenu contextMenu, String alignment) {
2025         ScilabContextMenuBridge.setVerticalAlignment(contextMenu, alignment);
2026     }
2027
2028     /**
2029      * Set the Relief of the ContextMenu
2030      * @param contextMenu the ContextMenu which we want to set the Relief of
2031      * @param reliefType the type of the relief to set (See ScilabRelief.java)
2032      */
2033     public static void setRelief(ContextMenu contextMenu, String reliefType) {
2034         ScilabContextMenuBridge.setRelief(contextMenu, reliefType);
2035     }
2036
2037     /**
2038      * Delete the ContextMenu
2039      * @param contextMenu the ContextMenu to be destroyed
2040      */
2041     public static void destroy(ContextMenu contextMenu) {
2042         ScilabContextMenuBridge.destroy(contextMenu);
2043     }
2044
2045     /**
2046      * Give the focus to the ContextMenu
2047      * @param contextMenu the ContextMenu
2048      */
2049     public static void requestFocus(ContextMenu contextMenu) {
2050         ScilabContextMenuBridge.requestFocus(contextMenu);
2051     }
2052
2053     /********************/
2054     /* Separator Bridge */
2055     /********************/
2056
2057     /**
2058      * Creates a new Separator
2059      * @return the created Separator
2060      */
2061     public static Separator createSeparator() {
2062         return ScilabSeparatorBridge.createSeparator();
2063     }
2064
2065     /******************/
2066     /* TextBox Bridge */
2067     /******************/
2068
2069     /**
2070      * Creates a new TextBox
2071      * @return the created TextBox
2072      */
2073     public static SimpleTextBox createTextBox() {
2074         return ScilabTextBoxBridge.createTextBox();
2075     }
2076
2077     /**
2078      * Sets the Text of a TextBox
2079      * @param textBox the TextBox we want to set the Text of
2080      * @param newText the Text to set for the TextBox
2081      */
2082     public static void setText(TextBox textBox, String newText) {
2083         ScilabTextBoxBridge.setText(textBox, newText);
2084     }
2085
2086     /**
2087      * Gets the text of an TextBox
2088      * @param textBox the TextBox we want to get the text of
2089      * @return the text of the TextBox
2090      */
2091     public static String getText(TextBox textBox) {
2092         return ScilabTextBoxBridge.getText(textBox);
2093     }
2094
2095     /**
2096      * Draws a Scilab TextBox
2097      * @param textBox the TextBox to draw
2098      * @see org.scilab.modules.ihm.UIElement#draw()
2099      */
2100     public static void draw(TextBox textBox) {
2101         ScilabTextBoxBridge.draw(textBox);
2102     }
2103
2104     /**
2105      * Gets the dimensions (width and height) of a Scilab TextBox
2106      * @param textBox the TextBox we want to get the dimensions of
2107      * @return the size of the textBox
2108      * @see org.scilab.modules.ihm.UIElement#getDims()
2109      */
2110     public static Size getDims(TextBox textBox) {
2111         return ScilabTextBoxBridge.getDims(textBox);
2112     }
2113
2114     /**
2115      * Gets the position (X-coordinate and Y-coordinate) of a Scilab textBox
2116      * @param textBox the textBox we want to get the position of
2117      * @return the position of the textBox
2118      * @see org.scilab.modules.ihm.UIElement#getPosition()
2119      */
2120     public static Position getPosition(TextBox textBox) {
2121         return ScilabTextBoxBridge.getPosition(textBox);
2122     }
2123
2124     /**
2125      * Gets the visibility status of a Scilab TextBox
2126      * @param textBox the textBox we want to get the visiblity status of
2127      * @return the visibility status of the textBox (true if the textBox is visible, false if not)
2128      * @see org.scilab.modules.ihm.UIElement#isVisible()
2129      */
2130     public static boolean isVisible(TextBox textBox) {
2131         return ScilabTextBoxBridge.isVisible(textBox);
2132     }
2133
2134     /**
2135      * Set the status of the TextBox
2136      * @param textBox the textBox we want to set the status of
2137      * @param status true if the TextBox is enabled
2138      * @see org.scilab.modules.gui.widget.Widget#setEnabled(boolean)
2139      */
2140     public static void setEnabled(TextBox textBox, boolean status) {
2141         ScilabTextBoxBridge.setEnabled(textBox, status);
2142     }
2143
2144     /**
2145      * Gets the enable status of a TextBox
2146      * @param textBox the textBox we want to get the status of
2147      * @return the enable status of the TextBox (true if the TextBox is enabled, false if not)
2148      */
2149     public static boolean isEnabled(TextBox textBox) {
2150         return ScilabTextBoxBridge.isEnabled(textBox);
2151     }
2152
2153     /**
2154      * Sets the dimensions (width and height) of a Scilab TextBox
2155      * @param textBox the textBox we want to set the dimensions of
2156      * @param newSize the size we want to set to the textBox
2157      * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
2158      */
2159     public static void setDims(TextBox textBox, Size newSize) {
2160         ScilabTextBoxBridge.setDims(textBox, newSize);
2161     }
2162
2163     /**
2164      * Sets the position (X-coordinate and Y-coordinate) of a Scilab textBox
2165      * @param textBox the textBox we want to set the position of
2166      * @param newPosition the position we want to set to the textBox
2167      * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
2168      */
2169     public static void setPosition(TextBox textBox, Position newPosition) {
2170         ScilabTextBoxBridge.setPosition(textBox, newPosition);
2171     }
2172
2173     /**
2174      * Sets the visibility status of a Scilab TextBox
2175      * @param textBox the textBox we want to set the visiblity status of
2176      * @param newVisibleState the visibility status we want to set to the textBox (true to set the textBox visible, false else)
2177      * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
2178      */
2179     public static void setVisible(TextBox textBox, boolean newVisibleState) {
2180         ScilabTextBoxBridge.setVisible(textBox, newVisibleState);
2181     }
2182
2183     /**
2184      * Set the Background color of the textbox
2185      * @param textBox the textbox we want to set the background of
2186      * @param color the Color
2187      */
2188     public static void setBackground(TextBox textBox, Color color) {
2189         ScilabTextBoxBridge.setBackground(textBox, color);
2190     }
2191
2192     /**
2193      * Get the Background color of the textbox
2194      * @param textBox the textbox we want to get the background of
2195      * @return the Color
2196      */
2197     public static Color getBackground(TextBox textBox) {
2198         return ScilabTextBoxBridge.getBackground(textBox);
2199     }
2200
2201     /**
2202      * Set the Foreground color of the textbox
2203      * @param textBox the textbox we want to set the foreground of
2204      * @param color the Color
2205      */
2206     public static void setForeground(TextBox textBox, Color color) {
2207         ScilabTextBoxBridge.setForeground(textBox, color);
2208     }
2209
2210     /**
2211      * Get the Foreground color of the textbox
2212      * @param textBox the textbox we want to get the foreground of
2213      * @return the Color
2214      */
2215     public static Color getForeground(TextBox textBox) {
2216         return ScilabTextBoxBridge.getForeground(textBox);
2217     }
2218
2219     /**
2220      * Set the font of the textbox.
2221      * @param textBox the textbox we want to set the font of
2222      * @param font the font
2223      */
2224     public static void setFont(TextBox textBox, Font font) {
2225         ScilabTextBoxBridge.setFont(textBox, font);
2226     }
2227
2228     /**
2229      * Get the font of the textbox.
2230      * @param textBox the textbox we want to get the font of
2231      * @return the font
2232      */
2233     public static Font getFont(TextBox textBox) {
2234         return ScilabTextBoxBridge.getFont(textBox);
2235     }
2236
2237     /**
2238      * Add a callback to the TextBox
2239      * @param textBox the TextBox we want to set the callback of
2240      * @param callback the CallBack to set.
2241      */
2242     public static void setCallback(TextBox textBox, CommonCallBack callback) {
2243         ScilabTextBoxBridge.setCallback(textBox, callback);
2244     }
2245
2246     /**
2247      * Set the horizontal alignment for the TextBox text
2248      * @param textBox the TextBox we want to set the alignment of
2249      * @param alignment the value for the alignment (See ScilabAlignment.java)
2250      */
2251     public static void setHorizontalAlignment(TextBox textBox, String alignment) {
2252         ScilabTextBoxBridge.setHorizontalAlignment(textBox, alignment);
2253     }
2254
2255     /**
2256      * Set the vertical alignment for the TextBox text
2257      * @param textBox the TextBox we want to set the alignment of
2258      * @param alignment the value for the alignment (See ScilabAlignment.java)
2259      */
2260     public static void setVerticalAlignment(TextBox textBox, String alignment) {
2261         ScilabTextBoxBridge.setVerticalAlignment(textBox, alignment);
2262     }
2263
2264     /**
2265      * Set the Relief of the TextBox
2266      * @param textBox the TextBox which we want to set the Relief of
2267      * @param reliefType the type of the relief to set (See ScilabRelief.java)
2268      */
2269     public static void setRelief(TextBox textBox, String reliefType) {
2270         ScilabTextBoxBridge.setRelief(textBox, reliefType);
2271     }
2272
2273     /**
2274      * Delete the TextBox
2275      * @param textBox the TextBox to be destroyed
2276      */
2277     public static void destroy(TextBox textBox) {
2278         ScilabTextBoxBridge.destroy(textBox);
2279     }
2280
2281     /**
2282      * Give the focus to the TextBox
2283      * @param textBox the TextBox
2284      */
2285     public static void requestFocus(TextBox textBox) {
2286         ScilabTextBoxBridge.requestFocus(textBox);
2287     }
2288
2289     /***********************/
2290     /* FileChooser Bridge */
2291     /***********************/
2292
2293     /**
2294      * Create a new FileChooser
2295      * @return the created FileChooser
2296      */
2297     public static SimpleFileChooser createFileChooser() {
2298         return ScilabFileChooserBridge.createFileChooser();
2299     }
2300
2301     /**
2302      * Create a new ExportFileChooser
2303      * @param figureID exported figure id
2304      * @return the created ExportFileChooser
2305      */
2306     public static SimpleFileChooser createExportFileChooser(Integer figureUID) {
2307         return ScilabFileChooserBridge.createExportFileChooser(figureUID);
2308     }
2309
2310     /**
2311      * Set the title of the file chooser
2312      * @param fileChooser the file chooser we want to set the title of
2313      * @param title the title to set
2314      */
2315     public static void setTitle(FileChooser fileChooser, String title) {
2316         ScilabFileChooserBridge.setTitle(fileChooser, title);
2317     }
2318
2319     /**
2320      * Set the initial directory used for file search
2321      * @param fileChooser the file chooser we want to set the initial directory of
2322      * @param path the default path
2323      */
2324     public static void setInitialDirectory(FileChooser fileChooser, String path) {
2325         ScilabFileChooserBridge.setInitialDirectory(fileChooser, path);
2326     }
2327
2328     /**
2329      * Display this chooser and wait for user selection
2330      * @param fileChooser the file chooser we want to display
2331      */
2332     public static void displayAndWait(FileChooser fileChooser) {
2333         ScilabFileChooserBridge.displayAndWait(fileChooser);
2334     }
2335
2336     /**
2337      * Get the number of files selected
2338      * @param fileChooser the file chooser we want to get the selection size of
2339      * @return the number of files selected
2340      */
2341     public static int getSelectionSize(FileChooser fileChooser) {
2342         return ScilabFileChooserBridge.getSelectionSize(fileChooser);
2343     }
2344
2345     /**
2346      * Get the names of selected files
2347      * @param fileChooser the file chooser we want to get the selection of
2348      * @return the names of selected files
2349      */
2350     public static String[] getSelection(FileChooser fileChooser) {
2351         return ScilabFileChooserBridge.getSelection(fileChooser);
2352     }
2353
2354     /**
2355      * Get the names of selected files
2356      * @param fileChooser the file chooser we want to get the selection of
2357      * @return the names of selected files
2358      */
2359     public static String[] getSelectionFileNames(FileChooser fileChooser) {
2360         return ScilabFileChooserBridge.getSelectionFileNames(fileChooser);
2361     }
2362
2363     /**
2364      * Set the flag indicating that we want only select directories
2365      * @param fileChooser the file chooser we want to set the flag of
2366      */
2367     public static void setDirectorySelectionOnly(FileChooser fileChooser) {
2368         ScilabFileChooserBridge.setDirectorySelectionOnly(fileChooser);
2369     }
2370
2371     /**
2372      * We customize the file chooser for the graphic export
2373      * by adding format selection
2374      */
2375     public static void exportCustomFileChooser() {
2376         ScilabFileChooserBridge.createFileChooser();
2377     }
2378
2379     /**
2380      * Enable the multiple selection
2381      * @param fileChooser the file chooser we want to get the  muliple selection
2382      * @param multipleSelection boolean for the multiple selection
2383      */
2384     public static void setMultipleSelection(FileChooser fileChooser, boolean multipleSelection) {
2385         ScilabFileChooserBridge.setMultipleSelection(fileChooser, multipleSelection);
2386     }
2387
2388     /**
2389      * Get the path name of selected files
2390      * @param fileChooser the file chooser we want to get the path of selectd files
2391      * @return the path of selected files
2392      */
2393     public static String getSelectionPathName(FileChooser fileChooser) {
2394         return ScilabFileChooserBridge.getSelectionPathName(fileChooser);
2395     }
2396
2397     /**
2398      * Set the dialog type (save or open a file ?)
2399      * @param fileChooser the file chooser we want to get the filter indexs
2400      * @param dialogType the dialog type
2401      */
2402     public static void setUiDialogType(FileChooser fileChooser, int dialogType) {
2403         ScilabFileChooserBridge.setUiDialogType(fileChooser, dialogType);
2404     }
2405
2406     /*********************/
2407     /* MessageBox Bridge */
2408     /*********************/
2409
2410     /**
2411      * Create a new MessageBox
2412      * @return the created MessageBox
2413      */
2414     public static SimpleMessageBox createMessageBox() {
2415         return ScilabMessageBoxBridge.createMessageBox();
2416     }
2417
2418     /**
2419      * Set the title of the MessageBox
2420      * @param messageBox the MessageBox we want to set the title of
2421      * @param title the title to set
2422      */
2423     public static void setTitle(MessageBox messageBox, String title) {
2424         ScilabMessageBoxBridge.setTitle(messageBox, title);
2425     }
2426
2427     /**
2428      * Set the message of the MessageBox
2429      * @param messageBox the MessageBox we want to set the mask of
2430      * @param message the message to set
2431      */
2432     public static void setMessage(MessageBox messageBox, String message) {
2433         ScilabMessageBoxBridge.setMessage(messageBox, message);
2434     }
2435
2436     /**
2437      * Set the message of the MessageBox (multi-line)
2438      * @param messageBox the MessageBox we want to set the mask of
2439      * @param message the message to set
2440      */
2441     public static void setMessage(MessageBox messageBox, String[] message) {
2442         ScilabMessageBoxBridge.setMessage(messageBox, message);
2443     }
2444
2445     /**
2446      * Display this MessageBox and wait for user selection
2447      * @param messageBox the MessageBox we want to display
2448      */
2449     public static void displayAndWait(MessageBox messageBox) {
2450         ScilabMessageBoxBridge.displayAndWait(messageBox);
2451     }
2452
2453     /**
2454      * Get the index of the button clicked
2455      * @param messageBox the MessageBox we want to get the answer of
2456      * @return the index of the button clicked
2457      */
2458     public static int getSelectedButton(MessageBox messageBox) {
2459         return ScilabMessageBoxBridge.getSelectedButton(messageBox);
2460     }
2461
2462     /**
2463      * Set the indices of the default selected buttons (x_choices)
2464      * @param messageBox the MessageBox we want to set the defaults of
2465      * @param indices the indices of the default selected buttons
2466      */
2467     public static void setDefaultSelectedButtons(MessageBox messageBox, int[] indices) {
2468         ScilabMessageBoxBridge.setDefaultSelectedButtons(messageBox, indices);
2469     }
2470
2471     /**
2472      * Get the indices of the user selected buttons (x_choices)
2473      * @param messageBox the MessageBox we want to set the defaults of
2474      * @return the indices of the default selected buttons
2475      */
2476     public static int[] getUserSelectedButtons(MessageBox messageBox) {
2477         return ScilabMessageBoxBridge.getUserSelectedButtons(messageBox);
2478     }
2479
2480     /**
2481      * Set the labels of the buttons in the MessageBox
2482      * @param messageBox the MessageBox we want to set the buttons labels of
2483      * @param labels the labels of the buttons
2484      */
2485     public static void setButtonsLabels(MessageBox messageBox, String[] labels) {
2486         ScilabMessageBoxBridge.setButtonsLabels(messageBox, labels);
2487     }
2488
2489     /**
2490      * Set the initial values of the editable zone in the MessageBox
2491      * @param messageBox the MessageBox we want to set the initial value of
2492      * @param value the initial values
2493      */
2494     public static void setInitialValue(MessageBox messageBox, String[] value) {
2495         ScilabMessageBoxBridge.setInitialValue(messageBox, value);
2496     }
2497
2498     /**
2499      * Get the value of the editable zone in the MessageBox
2500      * @param messageBox the MessageBox we want to get the value of
2501      * @return the value
2502      */
2503     public static String[] getValue(MessageBox messageBox) {
2504         return ScilabMessageBoxBridge.getValue(messageBox);
2505     }
2506
2507     /**
2508      * Get the size of the value of the editable zone in the MessageBox
2509      * @param messageBox the MessageBox we want to get the value size of
2510      * @return the value size
2511      */
2512     public static int getValueSize(MessageBox messageBox) {
2513         return ScilabMessageBoxBridge.getValueSize(messageBox);
2514     }
2515
2516     /**
2517      * Set the items of the listbox in the MessageBox
2518      * @param messageBox the MessageBox we want to set the items of
2519      * @param items the items to set
2520      */
2521     public static void setListBoxItems(MessageBox messageBox, String[] items) {
2522         ScilabMessageBoxBridge.setListBoxItems(messageBox, items);
2523     }
2524
2525     /**
2526      * Get the index of the selected item in the listbox in the MessageBox
2527      * @param messageBox the MessageBox we want to get the selected item of
2528      * @return the index
2529      */
2530     public static int getSelectedItem(MessageBox messageBox) {
2531         return ScilabMessageBoxBridge.getSelectedItem(messageBox);
2532     }
2533
2534     /**
2535      * Set the name of the lines labels in the editable zone in the MessageBox
2536      * @param messageBox the MessageBox we want to set the labels
2537      * @param labels the labels
2538      */
2539     public static void setLineLabels(MessageBox messageBox, String[] labels) {
2540         ScilabMessageBoxBridge.setLineLabels(messageBox, labels);
2541     }
2542
2543     /**
2544      * Set the name of the columns labels in the editable zone in the MessageBox
2545      * @param messageBox the MessageBox we want to set the labels
2546      * @param labels the labels
2547      */
2548     public static void setColumnLabels(MessageBox messageBox, String[] labels) {
2549         ScilabMessageBoxBridge.setColumnLabels(messageBox, labels);
2550     }
2551
2552     /**
2553      * Set the default values of a multi-value editable zone in the MessageBox
2554      * @param messageBox the MessageBox we want to set the default values
2555      * @param values the values
2556      */
2557     public static void setDefaultInput(MessageBox messageBox, String[] values) {
2558         ScilabMessageBoxBridge.setDefaultInput(messageBox, values);
2559     }
2560
2561     /**
2562      * Set a MessageBox modal or not
2563      * @param messageBox the MessageBox we want to set the modality of
2564      * @param status true to set the MessageBox modal and false else
2565      */
2566     public static void setModal(MessageBox messageBox, boolean status) {
2567         ScilabMessageBoxBridge.setModal(messageBox, status);
2568     }
2569
2570     /**
2571      * Set the MessageBox icon
2572      * @param messageBox the MessageBox we want to set the icon of
2573      * @param name the name of the icon
2574      */
2575     public static void setIcon(MessageBox messageBox, String name) {
2576         ScilabMessageBoxBridge.setIcon(messageBox, name);
2577     }
2578
2579     /**
2580      * Set the component used to set the location of the MessageBox (default is Scilab Console)
2581      * @param messageBox the MessageBox we want to set the parent of
2582      * @param parent the tab to be set as parent
2583      */
2584     public static void setParentForLocation(MessageBox messageBox, SimpleTab parent) {
2585         ScilabMessageBoxBridge.setParentForLocation(messageBox, parent);
2586     }
2587
2588     /***********************/
2589     /* Help Browser Bridge */
2590     /***********************/
2591
2592     /**
2593      * Create a new Help Browser
2594      * @param helps help chapters and directories
2595      * @param language Scilab current language
2596      * @return the created Help Browser
2597      */
2598     public static SimpleHelpBrowser createHelpBrowser(String[] helps, String language) {
2599         return ScilabHelpBrowserBridge.createHelpBrowser(helps, language);
2600     }
2601
2602     /**
2603      * Display the Help Browser
2604      * @param browser the Help Browser
2605      */
2606     public static void display(HelpBrowser browser) {
2607         ScilabHelpBrowserBridge.display(browser);
2608     }
2609
2610     /**
2611      * Display the matching items for a specified keyword
2612      * @param browser the Help Browser
2613      * @param keyword the keyword
2614      */
2615     public static void searchKeywork(HelpBrowser browser, String keyword) {
2616         ScilabHelpBrowserBridge.searchKeywork(browser, keyword);
2617     }
2618
2619     /**
2620      * Display the result of a full-text search for a specified word
2621      * @param browser the Help Browser
2622      * @param keyword the keyword
2623      */
2624     public static void fullTextSearch(HelpBrowser browser, String keyword) {
2625         ScilabHelpBrowserBridge.fullTextSearch(browser, keyword);
2626     }
2627
2628     /**
2629      * Close the HelpBrowser
2630      * @param browser the Help Browser
2631      */
2632     public static void close(HelpBrowser browser) {
2633         ScilabHelpBrowserBridge.close(browser);
2634     }
2635
2636     /***********************/
2637     /* FontChooser Bridge */
2638     /***********************/
2639
2640     /**
2641      * Create a new FontChooser
2642      * @param font the default font
2643      * @return the created FontChooser
2644      */
2645     public static SimpleFontChooser createFontChooser(Font font) {
2646         return ScilabFontChooserBridge.createFontChooser(font);
2647     }
2648
2649     /**
2650      * Retrieve the selected font, or null
2651      * @param fontChooser the FontChooser
2652      * @return the selected font
2653      */
2654     public static Font getSelectedFont(FontChooser fontChooser) {
2655         return ScilabFontChooserBridge.getSelectedFont(fontChooser);
2656     }
2657
2658     /**
2659      * Set the default font name
2660      * @param fontChooser the FontChooser
2661      * @param fontName the default font name
2662      */
2663     public static void setDefaultFontName(FontChooser fontChooser, String fontName) {
2664         ScilabFontChooserBridge.setDefaultFontName(fontChooser, fontName);
2665     }
2666
2667     /**
2668      * Set the default font size
2669      * @param fontChooser the FontChooser
2670      * @param fontSize the default font size
2671      */
2672     public static void setDefaultFontSize(FontChooser fontChooser, int fontSize) {
2673         ScilabFontChooserBridge.setDefaultFontSize(fontChooser, fontSize);
2674     }
2675
2676     /**
2677      * Set the default font bold attribute
2678      * @param fontChooser the FontChooser
2679      * @param bold the default font bold attribute
2680      */
2681     public static void setDefaultBold(FontChooser fontChooser, boolean bold) {
2682         ScilabFontChooserBridge.setDefaultBold(fontChooser, bold);
2683     }
2684
2685     /**
2686      * Set the default font italic attribute
2687      * @param fontChooser the FontChooser
2688      * @param italic the default font italic attribute
2689      */
2690     public static void setDefaultItalic(FontChooser fontChooser, boolean italic) {
2691         ScilabFontChooserBridge.setDefaultItalic(fontChooser, italic);
2692     }
2693
2694     /**
2695      * Display the font chooser and wait for a user input
2696      * @param fontChooser the FontChooser
2697      */
2698     public static void displayAndWait(FontChooser fontChooser) {
2699         ScilabFontChooserBridge.displayAndWait(fontChooser);
2700     }
2701
2702     /***********************/
2703     /* ColorChooser Bridge */
2704     /***********************/
2705
2706     /**
2707      * Create a new ColorChooser
2708      * @param color the default color
2709      * @return the created ColorChooser
2710      */
2711     public static SimpleColorChooser createColorChooser(Color color) {
2712         return ScilabColorChooserBridge.createColorChooser(color);
2713     }
2714
2715     /**
2716      * Set the title of the ColorChooser
2717      * @param colorChooser the ColorChooser
2718      * @param title the title to set
2719      */
2720     public static void setTitle(ColorChooser colorChooser, String title) {
2721         ScilabColorChooserBridge.setTitle(colorChooser, title);
2722     }
2723
2724     /**
2725      * Retrieve the selected color, or null
2726      * @param colorChooser the ColorChooser
2727      * @return the selected color
2728      */
2729     public static Color getSelectedColor(ColorChooser colorChooser) {
2730         return ScilabColorChooserBridge.getSelectedColor(colorChooser);
2731     }
2732
2733     /**
2734      * Set the default color
2735      * @param colorChooser the ColorChooser
2736      * @param color the default color
2737      */
2738     public static void setDefaultColor(ColorChooser colorChooser, Color color) {
2739         ScilabColorChooserBridge.setDefaultColor(colorChooser, color);
2740     }
2741
2742     /**
2743      * Display the font chooser and wait for a user input
2744      * @param colorChooser the ColorChooser
2745      */
2746     public static void displayAndWait(ColorChooser colorChooser) {
2747         ScilabColorChooserBridge.displayAndWait(colorChooser);
2748     }
2749
2750
2751     /******************/
2752     /* Tree Bridge    */
2753     /******************/
2754
2755     /**
2756      * Display a given tree
2757      * @param tree a tree structure
2758      */
2759     public static void  showTree(Tree tree) {
2760         ScilabTreeBridge.showTree(tree);
2761     }
2762
2763     /**
2764      * Create a Scilab Tree
2765      * @param scilabTree a tree structure
2766      * @return a graphical tree
2767      */
2768     public static SimpleTree createTree(Tree scilabTree) {
2769         return ScilabTreeBridge.createTree(scilabTree);
2770     }
2771
2772     /**
2773      * Function help on the keyword
2774      * @param console scilab console
2775      */
2776     public static void helpOnTheKeyword(ScilabConsole console) {
2777         ScilabConsoleBridge.helpOnTheKeyword(console);
2778
2779     }
2780
2781     /**
2782      * Evaluate the selection with echo
2783      * @param console the console
2784      */
2785     public static void evaluateSelectionWithEcho(ScilabConsole console) {
2786         ScilabConsoleBridge.evaluateSelectionWithEcho(console);
2787     }
2788
2789     /**
2790      * Evaluate the selection with no echo
2791      * @param console the console
2792      */
2793     public static void evaluateSelectionWithNoEcho(ScilabConsole console) {
2794         ScilabConsoleBridge.evaluateSelectionWithNoEcho(console);
2795     }
2796
2797     /**********************/
2798     /* UiDisplayTree Bridge */
2799     /**********************/
2800
2801     /**
2802      * Creates a new UiDisplayTree
2803      * @return the created UiDisplayTree
2804      */
2805     public static SimpleUiDisplayTree createUiDisplayTree() {
2806         return ScilabUiDisplayTreeBridge.createUiDisplayTree();
2807     }
2808
2809     /**
2810      * Sets the Text of a UiDisplayTree
2811      * @param uiTree the UiDisplayTree we want to set the Text of
2812      * @param newText the Text to set for the UiDisplayTree
2813      */
2814     public static void setText(UiDisplayTree uiTree, String newText) {
2815         ScilabUiDisplayTreeBridge.setText(uiTree, newText);
2816     }
2817
2818     /**
2819      * Gets the text of an UiDisplayTree
2820      * @param uiTree the UiDisplayTree we want to get the text of
2821      * @return the text of the UiDisplayTree
2822      */
2823     public static String getText(UiDisplayTree uiTree) {
2824         return ScilabUiDisplayTreeBridge.getText(uiTree);
2825     }
2826
2827     /**
2828      * Draws a Scilab UiDisplayTree
2829      * @param uiTree the UiDisplayTree to draw
2830      * @see org.scilab.modules.ihm.UIElement#draw()
2831      */
2832     public static void draw(UiDisplayTree uiTree) {
2833         ScilabUiDisplayTreeBridge.draw(uiTree);
2834     }
2835
2836     /**
2837      * Gets the dimensions (width and height) of a Scilab UiDisplayTree
2838      * @param uiTree the UiDisplayTree we want to get the dimensions of
2839      * @return the size of the uiTree
2840      * @see org.scilab.modules.ihm.UIElement#getDims()
2841      */
2842     public static Size getDims(UiDisplayTree uiTree) {
2843         return ScilabUiDisplayTreeBridge.getDims(uiTree);
2844     }
2845
2846     /**
2847      * Gets the position (X-coordinate and Y-coordinate) of a Scilab uiTree
2848      * @param uiTree the uiTree we want to get the position of
2849      * @return the position of the uiTree
2850      * @see org.scilab.modules.ihm.UIElement#getPosition()
2851      */
2852     public static Position getPosition(UiDisplayTree uiTree) {
2853         return ScilabUiDisplayTreeBridge.getPosition(uiTree);
2854     }
2855
2856     /**
2857      * Gets the visibility status of a Scilab UiDisplayTree
2858      * @param uiTree the uiTree we want to get the visiblity status of
2859      * @return the visibility status of the uiTree (true if the uiTree is visible, false if not)
2860      * @see org.scilab.modules.ihm.UIElement#isVisible()
2861      */
2862     public static boolean isVisible(UiDisplayTree uiTree) {
2863         return ScilabUiDisplayTreeBridge.isVisible(uiTree);
2864     }
2865
2866     /**
2867      * Sets the dimensions (width and height) of a Scilab UiDisplayTree
2868      * @param uiTree the uiTree we want to set the dimensions of
2869      * @param newSize the size we want to set to the uiTree
2870      * @see org.scilab.modules.ihm.UIElement#setDims(org.scilab.modules.ihm.utils.Size)
2871      */
2872     public static void setDims(UiDisplayTree uiTree, Size newSize) {
2873         ScilabUiDisplayTreeBridge.setDims(uiTree, newSize);
2874     }
2875
2876     /**
2877      * Sets the position (X-coordinate and Y-coordinate) of a Scilab uiTree
2878      * @param uiTree the uiTree we want to set the position of
2879      * @param newPosition the position we want to set to the uiTree
2880      * @see org.scilab.modules.ihm.UIElement#setPosition(org.scilab.modules.ihm.utils.Position)
2881      */
2882     public static void setPosition(UiDisplayTree uiTree, Position newPosition) {
2883         ScilabUiDisplayTreeBridge.setPosition(uiTree, newPosition);
2884     }
2885
2886     /**
2887      * Sets the visibility status of a Scilab UiDisplayTree
2888      * @param uiTree the uiTree we want to set the visiblity status of
2889      * @param newVisibleState the visibility status we want to set to the uiTree (true to set the uiTree visible, false else)
2890      * @see org.scilab.modules.ihm.UIElement#setVisible(boolean)
2891      */
2892     public static void setVisible(UiDisplayTree uiTree, boolean newVisibleState) {
2893         ScilabUiDisplayTreeBridge.setVisible(uiTree, newVisibleState);
2894     }
2895
2896     /**
2897      * Set the Background color of the UiDisplayTree
2898      * @param uiTree the UiDisplayTree we want to set the background of
2899      * @param color the Color
2900      */
2901     public static void setBackground(UiDisplayTree uiTree, Color color) {
2902         ScilabUiDisplayTreeBridge.setBackground(uiTree, color);
2903     }
2904
2905     /**
2906      * Get the Background color of the UiDisplayTree
2907      * @param uiTree the UiDisplayTree we want to get the background of
2908      * @return the Color
2909      */
2910     public static Color getBackground(UiDisplayTree uiTree) {
2911         return ScilabUiDisplayTreeBridge.getBackground(uiTree);
2912     }
2913
2914     /**
2915      * Set the Foreground color of the UiDisplayTree
2916      * @param uiTree the UiDisplayTree we want to set the foreground of
2917      * @param color the Color
2918      */
2919     public static void setForeground(UiDisplayTree uiTree, Color color) {
2920         ScilabUiDisplayTreeBridge.setForeground(uiTree, color);
2921     }
2922
2923     /**
2924      * Get the Foreground color of the UiDisplayTree
2925      * @param uiTree the UiDisplayTree we want to get the foreground of
2926      * @return the Color
2927      */
2928     public static Color getForeground(UiDisplayTree uiTree) {
2929         return ScilabUiDisplayTreeBridge.getForeground(uiTree);
2930     }
2931
2932     /**
2933      * Set the font of the UiDisplayTree.
2934      * @param uiTree the UiDisplayTree we want to set the font of
2935      * @param font the font
2936      */
2937     public static void setFont(UiDisplayTree uiTree, Font font) {
2938         ScilabUiDisplayTreeBridge.setFont(uiTree, font);
2939     }
2940
2941     /**
2942      * Get the font of the UiDisplayTree.
2943      * @param uiTree the UiDisplayTree we want to get the font of
2944      * @return the font
2945      */
2946     public static Font getFont(UiDisplayTree uiTree) {
2947         return ScilabUiDisplayTreeBridge.getFont(uiTree);
2948     }
2949
2950     /**
2951      * Set if the UiDisplayTree is enabled or not
2952      * @param uiTree the UiDisplayTree we want to set the status of
2953      * @param status true if the UiDisplayTree is enabled
2954      */
2955     public static void setEnabled(UiDisplayTree uiTree, boolean status) {
2956         ScilabUiDisplayTreeBridge.setEnabled(uiTree, status);
2957     }
2958
2959     /**
2960      * Gets the enable status of a UiDisplayTree
2961      * @param uiTree the UiDisplayTree we want to get the status of
2962      * @return the enable status of the UiDisplayTree (true if the UiDisplayTree is enabled, false if not)
2963      */
2964     public static boolean isEnabled(UiDisplayTree uiTree) {
2965         return ScilabUiDisplayTreeBridge.isEnabled(uiTree);
2966     }
2967
2968     /**
2969      * Add a callback to the UiDisplayTree
2970      * @param uiTree the UiDisplayTree we want to set the callback of
2971      * @param callback the Callback to set.
2972      */
2973     public static void setCallback(UiDisplayTree uiTree, CommonCallBack callback) {
2974         ScilabUiDisplayTreeBridge.setCallback(uiTree, callback);
2975     }
2976
2977     /**
2978      * Set the horizontal alignment for the UiDisplayTree text
2979      * @param uiTree the UiDisplayTree we want to set the alignment of
2980      * @param alignment the value for the alignment (See ScilabAlignment.java)
2981      */
2982     public static void setHorizontalAlignment(UiDisplayTree uiTree, String alignment) {
2983         ScilabUiDisplayTreeBridge.setHorizontalAlignment(uiTree, alignment);
2984     }
2985
2986     /**
2987      * Set the vertical alignment for the UiDisplayTree text
2988      * @param uiTree the UiDisplayTree we want to set the alignment of
2989      * @param alignment the value for the alignment (See ScilabAlignment.java)
2990      */
2991     public static void setVerticalAlignment(UiDisplayTree uiTree, String alignment) {
2992         ScilabUiDisplayTreeBridge.setVerticalAlignment(uiTree, alignment);
2993     }
2994
2995     /**
2996      * Set the Relief of the UiDisplayTree
2997      * @param uiTree the UiDisplayTree which we want to set the Relief of
2998      * @param reliefType the type of the relief to set (See ScilabRelief.java)
2999      */
3000     public static void setRelief(UiDisplayTree uiTree, String reliefType) {
3001         ScilabUiDisplayTreeBridge.setRelief(uiTree, reliefType);
3002     }
3003
3004     /**
3005      * Delete the UiDisplayTree
3006      * @param uiTree the UiDisplayTree to be destroyed
3007      */
3008     public static void destroy(UiDisplayTree uiTree) {
3009         ScilabUiDisplayTreeBridge.destroy(uiTree);
3010     }
3011
3012     /**
3013      * Give the focus to the UiDisplayTree
3014      * @param uiTree the UiDisplayTree
3015      */
3016     public static void requestFocus(UiDisplayTree uiTree) {
3017         ScilabUiDisplayTreeBridge.requestFocus(uiTree);
3018     }
3019
3020     /**
3021      * Sets the tree data to be added to viewport
3022      * @param text the array of strings containing tree data
3023      */
3024     public static void setData(UiDisplayTree uiTree, String[] text) {
3025         ScilabUiDisplayTreeBridge.setData(uiTree, text);
3026     }
3027 }