3dc32c4c7fb63da2726d9d97b18c059bb8351845
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / bridge / CallScilabBridge.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007-2008 - INRIA - Vincent COUVERT
4  * Copyright (C) 2008 - DIGITEO - Sylvestre KOUMAR
5  * Copyright (C) 2010 - DIGITEO - Manuel JULIACHS
6  * Copyright (C) 2010-2011 - DIGITEO - Vincent COUVERT
7  *
8  * Copyright (C) 2012 - 2016 - Scilab Enterprises
9  *
10  * This file is hereby licensed under the terms of the GNU GPL v2.0,
11  * pursuant to article 5.3.4 of the CeCILL v.2.1.
12  * This file was originally licensed under the terms of the CeCILL v2.1,
13  * and continues to be available under such terms.
14  * For more information, see the COPYING file which you should have received
15  * along with this program.
16  *
17  */
18
19
20 package org.scilab.modules.gui.bridge;
21
22 import java.awt.Color;
23 import java.awt.Font;
24 import java.awt.Image;
25 import java.awt.Toolkit;
26 import java.awt.datatransfer.Clipboard;
27 import java.awt.datatransfer.DataFlavor;
28 import java.awt.datatransfer.StringSelection;
29 import java.awt.datatransfer.Transferable;
30 import java.awt.datatransfer.UnsupportedFlavorException;
31 import java.awt.image.BufferedImage;
32 import java.awt.print.PrinterJob;
33 import java.io.File;
34 import java.io.FileInputStream;
35 import java.io.FileNotFoundException;
36 import java.io.IOException;
37 import java.lang.reflect.InvocationTargetException;
38
39 import javax.imageio.ImageIO;
40 import javax.print.Doc;
41 import javax.print.DocFlavor;
42 import javax.print.DocPrintJob;
43 import javax.print.PrintException;
44 import javax.print.PrintService;
45 import javax.print.SimpleDoc;
46 import javax.print.attribute.HashPrintRequestAttributeSet;
47 import javax.print.attribute.PrintRequestAttribute;
48 import javax.print.attribute.PrintRequestAttributeSet;
49 import javax.print.attribute.standard.OrientationRequested;
50 import javax.swing.JEditorPane;
51 import javax.swing.JTextPane;
52 import javax.swing.SwingUtilities;
53 import javax.swing.text.BadLocationException;
54 import javax.swing.text.Document;
55
56 import org.scilab.modules.commons.ScilabCommons;
57 import org.scilab.modules.console.SciConsole;
58 import org.scilab.modules.graphic_export.FileExporter;
59 import org.scilab.modules.graphic_objects.ScilabNativeView;
60 import org.scilab.modules.graphic_objects.figure.Figure;
61 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
62 import org.scilab.modules.gui.SwingView;
63 import org.scilab.modules.gui.SwingViewObject;
64 import org.scilab.modules.gui.bridge.canvas.SwingScilabCanvas;
65 import org.scilab.modules.gui.bridge.canvas.SwingScilabCanvasImpl;
66 import org.scilab.modules.gui.bridge.console.SwingScilabConsole;
67 import org.scilab.modules.gui.bridge.contextmenu.SwingScilabContextMenu;
68 import org.scilab.modules.gui.bridge.frame.SwingScilabFrame;
69 import org.scilab.modules.gui.bridge.frame.SwingScilabScrollableFrame;
70 import org.scilab.modules.gui.bridge.tab.SwingScilabDockablePanel;
71 import org.scilab.modules.gui.bridge.tab.SwingScilabPanel;
72 import org.scilab.modules.gui.colorchooser.ColorChooser;
73 import org.scilab.modules.gui.colorchooser.ScilabColorChooser;
74 import org.scilab.modules.gui.console.ScilabConsole;
75 import org.scilab.modules.gui.filechooser.FileChooser;
76 import org.scilab.modules.gui.filechooser.ScilabFileChooser;
77 import org.scilab.modules.gui.fontchooser.FontChooser;
78 import org.scilab.modules.gui.fontchooser.ScilabFontChooser;
79 import org.scilab.modules.gui.helpbrowser.HelpBrowser;
80 import org.scilab.modules.gui.helpbrowser.ScilabHelpBrowser;
81 import org.scilab.modules.gui.messagebox.MessageBox;
82 import org.scilab.modules.gui.messagebox.ScilabMessageBox;
83 import org.scilab.modules.gui.utils.ClosingOperationsManager;
84 import org.scilab.modules.gui.utils.ConfigManager;
85 import org.scilab.modules.gui.utils.ImageExporter;
86 import org.scilab.modules.gui.utils.PrinterHelper;
87 import org.scilab.modules.gui.utils.ScilabAboutBox;
88 import org.scilab.modules.gui.utils.ScilabPrint;
89 import org.scilab.modules.gui.utils.UIElementMapper;
90 import org.scilab.modules.gui.utils.WebBrowser;
91 import org.scilab.modules.gui.widget.Widget;
92 import org.scilab.modules.localization.Messages;
93
94 /**
95  * This class is used to call Scilab GUIs objects from Scilab
96  * @author Vincent COUVERT
97  */
98 public class CallScilabBridge {
99
100     private static final int NB_COLORS = 3;
101
102     private static PrintRequestAttributeSet scilabPageFormat = new HashPrintRequestAttributeSet();
103
104     private static final String CONSOLE = "Console";
105
106     /**
107      * Constructor
108      */
109     protected CallScilabBridge() {
110         throw new UnsupportedOperationException(); /* Prevents calls from subclass */
111     }
112
113     /******************/
114     /*                */
115     /* CONSOLE BRIDGE */
116     /*                */
117     /******************/
118
119     /**
120      * Read a line from the Console
121      * @return the line read
122      */
123     public static String readLine() {
124         return ScilabConsole.getConsole().readLine();
125     }
126
127     /**
128      * Display a line in the Console
129      * @param dataToDisplay the line to display
130      */
131     public static void display(String dataToDisplay) {
132         ScilabConsole.getConsole().display(dataToDisplay);
133     }
134
135     /**
136      * Get the status of the Console
137      * @return true if the console is at the prompt
138      */
139     public static boolean isWaitingForInput() {
140         return ScilabConsole.getConsole().isWaitingForInput();
141     }
142
143     /**
144      * Update the number of lines and columns that Scilab use to format data to display
145      */
146     public static void scilabLinesUpdate() {
147         ScilabConsole.getConsole().scilabLinesUpdate();
148     }
149
150     /**
151      * Clear the Console
152      */
153     public static void clear() {
154         ScilabConsole.getConsole().clear();
155     }
156
157     /**
158      * Clear some lines in the Console
159      * @param nbLines the number of lines to clear
160      */
161     public static void clear(int nbLines) {
162         ScilabConsole.getConsole().clear(nbLines);
163     }
164
165     /**
166      * Get a char to know if the user wants more data to be displayed
167      * @return the user answer
168      */
169     public static int getCharWithoutOutput() {
170         return ScilabConsole.getConsole().getAsSimpleConsole().getCharWithoutOutput();
171     }
172
173     /**
174      * Put the prompt on the top left corner
175      */
176     public static void toHome() {
177         ScilabConsole.getConsole().toHome();
178     }
179
180     /**
181      * Set the contents of the prompt
182      * @param prompt the content to set (default is -->)
183      */
184     public static void setPrompt(String prompt) {
185         ScilabConsole.getConsole().setPrompt(prompt);
186     }
187
188     /**
189      * Clear the commands history
190      */
191     public static void clearHistory() {
192         ScilabConsole.getConsole().clearHistory();
193     }
194
195     /**************************/
196     /*                        */
197     /* OBJECT CREATION BRIDGE */
198     /*                        */
199     /**************************/
200
201     /**
202      * Create a new Color Chooser in Scilab GUIs
203      * @return the ID of the Color Chooser in the UIElementMapper
204      */
205     public static int newColorChooser() {
206         ColorChooser colorChooser = ScilabColorChooser.createColorChooser();
207         return UIElementMapper.add(colorChooser);
208     }
209
210     /**
211      * Create a new Font Chooser in Scilab GUIs
212      * @return the ID of the Font Chooser in the UIElementMapper
213      */
214     public static int newFontChooser() {
215         FontChooser fontChooser = ScilabFontChooser.createFontChooser();
216         return UIElementMapper.add(fontChooser);
217     }
218
219     /**
220      * Create a new MessageBox in Scilab GUIs
221      * @return the ID of the MessageBox in the UIElementMapper
222      */
223     public static int newMessageBox() {
224         MessageBox messageBox = ScilabMessageBox.createMessageBox();
225         return UIElementMapper.add(messageBox);
226     }
227
228     /**
229      * Create a new ContextMenu in Scilab GUIs
230      * and wait for a user answer
231      * @param uicontextmenuUID the id of the Context Menu
232      * @return the item of the menu selected
233      */
234     public static String displayAndWaitContextMenu(int uicontextmenuUID) {
235         SwingViewObject uicontextmenu = SwingView.getFromId(uicontextmenuUID);
236         return ((SwingScilabContextMenu) uicontextmenu).displayAndWait();
237     }
238
239     /************************/
240     /*                      */
241     /* ENABLE/DISABLE MENUS */
242     /*                      */
243     /************************/
244
245     /**
246      * Enable/Disable a menu of a Scilab figure or console giving its name
247      * @param parentUID the UID of the figure or console
248      * @param menuName the name of the menu
249      * @param status true to set the menu enabled
250      */
251     public static void setMenuEnabled(int parentUID, String menuName, boolean status) {
252         SwingScilabDockablePanel parentTab = (SwingScilabDockablePanel) SwingView.getFromId(parentUID);
253         if (parentTab != null) { /** Parent must exist */
254             parentTab.getMenuBar().getAsSimpleMenuBar().setMenuEnabled(menuName, status);
255         }
256     }
257
258     /**
259      * Disable a MenuItem of a Scilab figure or console giving its parent name and position
260      * @param parentUID the UID of the figure or console
261      * @param parentMenuName the name of the parent menu
262      * @param menuItemPosition the name of the parent menu
263      * @param status true to set the menu enabled
264      */
265     public static void setSubMenuEnabled(int parentUID, String parentMenuName, int menuItemPosition, boolean status) {
266         SwingScilabDockablePanel parentTab = (SwingScilabDockablePanel) SwingView.getFromId(parentUID);
267         if (parentTab != null) { /** Parent must exist */
268             parentTab.getMenuBar().getAsSimpleMenuBar().setSubMenuEnabled(parentMenuName, menuItemPosition, status);
269         }
270     }
271
272     /****************/
273     /*              */
274     /* REMOVE MENUS */
275     /*              */
276     /****************/
277
278     /**
279      * Delete a menu of a Scilab figure or console giving its name
280      * @param parentUID the UID of the figure or console
281      * @param menuName the name of the menu
282      */
283     public static void removeMenu(int parentUID, String menuName) {
284         SwingScilabPanel parentTab = (SwingScilabPanel) SwingView.getFromId(parentUID);
285         if (parentTab != null) { /** Parent must exist */
286             parentTab.getMenuBar().getAsSimpleMenuBar().removeMenu(menuName);
287         }
288     }
289
290     /***********************/
291     /*                     */
292     /* FILE CHOOSER BRIDGE */
293     /*                     */
294     /***********************/
295
296
297
298     /**
299      * Create a new Graphic Export File Chooser in Scilab GUIs
300      * @param figureId id of the figure to export
301      * @return the ID of the File Chooser in the UIElementMapper
302      */
303     public static int newExportFileChooser(int figureId) {
304         FileChooser fileChooser = ScilabFileChooser.createExportFileChooser(figureId);
305         return 0;
306     }
307
308     /**
309      * Create a new Graphic Export File Chooser in Scilab GUIs
310      * @param figureId id of the figure to export
311      * @return the ID of the File Chooser in the UIElementMapper
312      */
313     public static int exportUI(int figureId) {
314         FileChooser fileChooser = ScilabFileChooser.createExportFileChooser(ScilabNativeView.ScilabNativeView__getFigureFromIndex(figureId));
315         return 0;
316     }
317
318     /**********************/
319     /*                    */
320     /* MESSAGE BOX BRIDGE */
321     /*                    */
322     /**********************/
323
324     /**
325      * Set the MessageBox title
326      * @param id the id of the messageBox
327      * @param title the title of the messageBox
328      */
329     public static void setMessageBoxTitle(int id, String title) {
330         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setTitle(title);
331     }
332
333     /**
334      * Set the MessageBox message
335      * @param id the id of the messageBox
336      * @param message the message of the messageBox
337      */
338     public static void setMessageBoxMessage(int id, String message) {
339         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setMessage(message);
340     }
341
342     /**
343      * Set the MessageBox message (multi-line)
344      * @param id the id of the messageBox
345      * @param message the message of the messageBox
346      */
347     public static void setMessageBoxMessage(int id, String[] message) {
348         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setMessage(message);
349     }
350
351     /**
352      * Display this chooser and wait for user selection
353      * @param id the id of the messageBox
354      */
355     public static void messageBoxDisplayAndWait(int id) {
356         final int finalId = id;
357         try {
358             SwingUtilities.invokeAndWait(new Runnable() {
359
360                 @Override
361                 public void run() {
362                     ((MessageBox) UIElementMapper.getCorrespondingUIElement(finalId)).displayAndWait();
363                 }
364             });
365         } catch (InterruptedException e) {
366             // TODO Auto-generated catch block
367             e.printStackTrace();
368         } catch (InvocationTargetException e) {
369             // TODO Auto-generated catch block
370             e.printStackTrace();
371         }
372     }
373
374     /**
375      * Get the index of the selected button
376      * @param id the id of the messageBox
377      * @return the index of the selected button
378      */
379     public static int getMessageBoxSelectedButton(int id) {
380         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectedButton();
381     }
382
383     /**
384      * Set the indices of the default selected buttons (x_choices)
385      * @param id the id of the MessageBox
386      * @param indices the indices of the default selected buttons
387      */
388     public static void setMessageBoxDefaultSelectedButtons(int id, int[] indices) {
389         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setDefaultSelectedButtons(indices);
390     }
391
392     /**
393      * Get the indices of the user selected buttons (x_choices)
394      * @param id the id of the MessageBox
395      * @return the indices of the user selected buttons
396      */
397     public static int[] getMessageBoxUserSelectedButtons(int id) {
398         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getUserSelectedButtons();
399     }
400
401     /**
402      * Set the labels of the buttons in the MessageBox
403      * @param id the id of the MessageBox
404      * @param labels the labels of the buttons
405      */
406     public static void setMessageBoxButtonsLabels(int id, String[] labels) {
407         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setButtonsLabels(labels);
408     }
409
410     /**
411      * Set the initial value for the editable part of the MessageBox
412      * @param id the id of the MessageBox
413      * @param value the initial value
414      */
415     public static void setMessageBoxInitialValue(int id, String[] value) {
416         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setInitialValue(value);
417     }
418
419     /**
420      * Get the value of the editable zone in the MessageBox
421      * @param id the id of the MessageBox
422      * @return the value
423      */
424     public static String[] getMessageBoxValue(int id) {
425         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getValue();
426     }
427
428     /**
429      * Get the size of the value of the editable zone in the MessageBox
430      * @param id the id of the MessageBox
431      * @return the value size
432      */
433     public static int getMessageBoxValueSize(int id) {
434         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getValueSize();
435     }
436
437     /**
438      * Set the items of the listbox in the MessageBox
439      * @param id the id of the MessageBox
440      * @param items the items to set
441      */
442     public static void setMessageBoxListBoxItems(int id, String[] items) {
443         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setListBoxItems(items);
444     }
445
446     /**
447      * Get the index of the selected item in the listbox in the MessageBox
448      * @param id the id of the MessageBox
449      * @return the index
450      */
451     public static int getMessageBoxSelectedItem(int id) {
452         return ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).getSelectedItem();
453     }
454
455     /**
456      * Set the name of the lines labels in the editable zone in the MessageBox
457      * @param id the id of the MessageBox
458      * @param labels the labels
459      */
460     public static void setMessageBoxLineLabels(int id, String[] labels) {
461         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setLineLabels(labels);
462     }
463
464     /**
465      * Set the name of the columns labels in the editable zone in the MessageBox
466      * @param id the id of the MessageBox
467      * @param labels the labels
468      */
469     public static void setMessageBoxColumnLabels(int id, String[] labels) {
470         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setColumnLabels(labels);
471     }
472
473     /**
474      * Set the default values of a multi-value editable zone in the MessageBox
475      * @param id the id of the MessageBox
476      * @param values the values
477      */
478     public static void setMessageBoxDefaultInput(int id, String[] values) {
479         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setDefaultInput(values);
480     }
481
482     /**
483      * Set a MessageBox modal or not
484      * @param id the id of the MessageBox
485      * @param status true to set the MessageBox modal and false else
486      */
487     public static void setMessageBoxModal(int id, boolean status) {
488         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setModal(status);
489     }
490
491     /**
492      * Set the MessageBox icon
493      * @param id the id of the MessageBox
494      * @param name the name of the icon
495      */
496     public static void setMessageBoxIcon(int id, String name) {
497         ((MessageBox) UIElementMapper.getCorrespondingUIElement(id)).setIcon(name);
498     }
499
500     /**********************/
501     /*                    */
502     /* HELPBROWSER BRIDGE */
503     /*                    */
504     /**********************/
505
506     /**
507      * Launch Scilab help browser if not already created
508      * @param helps help chapters and directories
509      * @param language Scilab current language
510      */
511     public static void launchHelpBrowser(final String[] helps, final String language) {
512         SwingUtilities.invokeLater(new Runnable() {
513             public void run() {
514                 try {
515                     ScilabHelpBrowser.createHelpBrowser(helps, language);
516                     ScilabHelpBrowser.startHomePage();
517                 } catch (Exception e) {
518                     System.err.println(e);
519                 }
520             }
521         });
522     }
523
524     /**
525      * Search a keyword in Scilab Help Browser
526      * @param keyword the keyword to search
527      * @param helps help chapters and directories
528      * @param language Scilab current language
529      * @param fullText true for a full-text search
530      */
531     public static void searchKeyword(final String[] helps, final String keyword, final String language, final boolean fullText) {
532         SwingUtilities.invokeLater(new Runnable() {
533             public void run() {
534                 try {
535                     if (fullText) {
536                         HelpBrowser helpBrowser = ScilabHelpBrowser.createHelpBrowser(helps, language);
537                         if (helpBrowser != null) {
538                             helpBrowser.fullTextSearch(keyword);
539                         }
540                     } else {
541                         HelpBrowser helpBrowser = ScilabHelpBrowser.createHelpBrowser(helps, language);
542                         if (helpBrowser != null) {
543                             helpBrowser.searchKeywork(keyword);
544                         }
545                     }
546                 } catch (Exception e) {
547                     System.err.println(e);
548                 }
549             }
550         });
551     }
552
553     /**
554      * Open HelpBrowser on the page with the given xmlID
555      * @param xmlID the xml id
556      */
557     public static void openHelp(final String xmlID) {
558         SwingUtilities.invokeLater(new Runnable() {
559             public void run() {
560                 try {
561                     HelpBrowser helpBrowser = ScilabHelpBrowser.createHelpBrowser(null, ScilabCommons.getlanguage());
562                     if (helpBrowser != null) {
563                         helpBrowser.searchKeywork(xmlID);
564                     }
565                 } catch (Exception e) {
566                     System.err.println(e);
567                 }
568             }
569         });
570     }
571
572     /**
573      * Close Scilab Help Browser
574      */
575     public static void closeHelpBrowser() {
576         SwingUtilities.invokeLater(new Runnable() {
577             public void run() {
578                 try {
579                     ScilabHelpBrowser.getHelpBrowser().close();
580                 } catch (Exception e) {
581                     System.err.println(e);
582                 }
583             }
584         });
585     }
586
587     /**
588      * Show search field in Scilab Help Browser
589      */
590     public static void showSearchFieldInHelp() {
591         ScilabHelpBrowser.getHelpBrowser().showSearchField();
592     }
593
594     /**
595      * Increase the font in the help viewer
596      */
597     public static void increaseFontInHelpViewer() {
598         SwingUtilities.invokeLater(new Runnable() {
599             public void run() {
600                 ScilabHelpBrowser.getHelpBrowser().increaseFont();
601             }
602         });
603     }
604
605     /**
606      * Decrease the font in the help viewer
607      */
608     public static void decreaseFontInHelpViewer() {
609         SwingUtilities.invokeLater(new Runnable() {
610             public void run() {
611                 ScilabHelpBrowser.getHelpBrowser().decreaseFont();
612             }
613         });
614     }
615
616     /************/
617     /*          */
618     /* WEBLINKS */
619     /*          */
620     /************/
621
622     /**
623      * Open a Browser on Scilab Web Site
624      */
625     public static void openScilabWebSite() {
626         WebBrowser.openUrl("http://www.scilab.org/");
627     }
628
629     /**
630      * Open a Browser on Wiki Web Site
631      */
632     public static void openWiki() {
633         WebBrowser.openUrl("http://wiki.scilab.org/");
634     }
635
636     /**
637      * Open a Browser on ATOMS Web Site
638      */
639     public static void openAtomsScilab() {
640         WebBrowser.openUrl("http://atoms.scilab.org/");
641     }
642
643     /**
644      * Open a Browser on File Exchange Web Site
645      */
646     public static void openFileExchange() {
647         WebBrowser.openUrl("http://fileexchange.scilab.org/");
648     }
649
650     /**
651      * Open a Browser on Bugzilla Web Site
652      */
653     public static void openBugzilla() {
654         WebBrowser.openUrl("http://bugzilla.scilab.org/");
655     }
656
657     /**
658      * Open a Browser on Forge Web Site
659      */
660     public static void openForge() {
661         WebBrowser.openUrl("http://forge.scilab.org/");
662     }
663
664     /**
665      * Open a Browser on Scilab Online Help
666      */
667     public static void openOnlineHelp() {
668         WebBrowser.openUrl("http://help.scilab.org/");
669     }
670
671     /**
672      * Open a Browser on Mailing List info
673      */
674     public static void openMailingList() {
675         WebBrowser.openUrl("http://www.scilab.org/communities/developer_zone/tools/mailing_list");
676     }
677
678     /**
679      * Open a Browser on Mailing List Archives
680      */
681     public static void openMailingListArchives() {
682         WebBrowser.openUrl("http://mailinglists.scilab.org/");
683     }
684
685     /**
686      * Open a Browser on S/E
687      */
688     public static void openSE() {
689         WebBrowser.openUrl("http://www.scilab.io");
690     }
691
692     /***************************/
693     /*                         */
694     /* JAVA CALLBACKS FOR GUIS */
695     /*                         */
696     /***************************/
697
698     /**
699      * Select all the console contents
700      */
701     public static void selectAllConsoleContents() {
702         ScilabConsole.getConsole().selectAll();
703     }
704
705     /**
706      * Select all the console contents
707      */
708     public static void helpOnTheKeyword() {
709         ScilabConsole.getConsole().helpOnTheKeyword();
710     }
711
712     /**
713      * Put the console selected text in the clipboard
714      */
715     public static void copyConsoleSelection() {
716         ScilabConsole.getConsole().copyToClipboard();
717     }
718
719     /**
720      * Cut the console selected text in the clipboard
721      */
722     public static void cutConsoleSelection() {
723         ScilabConsole.getConsole().cutSelection();
724     }
725
726     /**
727      * Paste clipboard contents in Console input line
728      */
729     public static void pasteClipboardIntoConsole() {
730         ScilabConsole.getConsole().pasteClipboard();
731     }
732
733     /**
734      * Make the clipboard contents empty
735      */
736     public static void emptyClipboard() {
737         Transferable contents = new StringSelection("");
738         Toolkit.getDefaultToolkit().getSystemClipboard().setContents(contents, null);
739     }
740
741     /**
742      * Evaluate the selection with echo
743      */
744     public static void evaluateSelectionWithEcho() {
745         ScilabConsole.getConsole().evaluateSelectionWithEcho();
746     }
747
748     /**
749      * Evaluate the selection with no echo
750      */
751     public static void evaluateSelectionWithNoEcho() {
752         ScilabConsole.getConsole().evaluateSelectionWithNoEcho();
753     }
754
755     /**
756      * Opens a dialog to selected a new font for the console
757      */
758     public static void changeConsoleFont() {
759         FontChooser fontChooser = ScilabFontChooser.createFontChooser(ScilabConsole.getConsole().getFont());
760         fontChooser.displayAndWait();
761
762         Font selectedFont = fontChooser.getSelectedFont();
763
764         if (selectedFont != null) {
765             /* Change console font */
766             ScilabConsole.getConsole().setFont(selectedFont);
767
768             /* Save new settings */
769             ConfigManager.saveFont(selectedFont);
770         }
771     }
772
773     /**
774      * Unblock the console if it is in "Continue display..." mode
775      */
776     public static void unblockConsole() {
777         SwingScilabConsole sciConsole = ((SwingScilabConsole) ScilabConsole.getConsole().getAsSimpleConsole());
778         sciConsole.unblock();
779     }
780
781     /**
782      * Opens a dialog to selected a new Foreground Color for the console
783      */
784     public static void changeConsoleForeground() {
785         ColorChooser colorChooser = ScilabColorChooser.createColorChooser(ScilabConsole.getConsole().getForeground());
786         colorChooser.setTitle(Messages.gettext("Console Font..."));
787         colorChooser.displayAndWait();
788
789         Color selectedColor = colorChooser.getSelectedColor();
790
791         if (selectedColor != null) {
792             /* Change console foreground */
793             ScilabConsole.getConsole().setForeground(selectedColor);
794
795             /* Save new settings */
796             ConfigManager.saveConsoleForeground(selectedColor);
797         }
798     }
799
800     /**
801      * Opens a dialog to selected a new Background Color for the console
802      */
803     public static void changeConsoleBackground() {
804         ColorChooser colorChooser = ScilabColorChooser.createColorChooser(ScilabConsole.getConsole().getBackground());
805         colorChooser.setTitle(Messages.gettext("Console Background..."));
806         colorChooser.displayAndWait();
807
808         Color selectedColor = colorChooser.getSelectedColor();
809
810         if (selectedColor != null) {
811             /* Change console background */
812             ScilabConsole.getConsole().setBackground(selectedColor);
813
814             /* Save new settings */
815             ConfigManager.saveConsoleBackground(selectedColor);
816         }
817     }
818
819     /**
820      * Display a dialog to print the console text contents
821      */
822     public static void printConsoleContents() {
823
824         SciConsole scilabConsole = ((SciConsole) ScilabConsole.getConsole().getAsSimpleConsole());
825         Document doc = ((JEditorPane) scilabConsole.getConfiguration().getOutputView()).getDocument();
826         String textToPrint = null;
827
828         /* Text selected in the input */
829         String strInputSelected = ((JTextPane) scilabConsole.getConfiguration().getInputCommandView()).getSelectedText();
830         /* Text selected in the output */
831         String strOutputSelected = ((JEditorPane) scilabConsole.getConfiguration().getOutputView()).getSelectedText();
832
833         try {
834             textToPrint = doc.getText(0, doc.getLength());
835         } catch (BadLocationException e) {
836             e.printStackTrace();
837         }
838         if (strInputSelected != null) {
839             printString(strInputSelected, new String(CONSOLE));
840         } else if (strOutputSelected != null) {
841             printString(strOutputSelected, new String(CONSOLE));
842         } else {
843             printString(textToPrint, new String(CONSOLE));
844         }
845     }
846
847     /**
848      * Print a character string
849      * @param theString the string to print
850      * @param pageHeader header for printed pages
851      * @return execution status
852      */
853     public static boolean printString(String theString, String pageHeader) {
854         return PrinterHelper.printString(theString, pageHeader);
855     }
856
857     /**
858      * Display a dialog to print a file
859      * @param fileName the name of the file
860      * @return execution status
861      */
862     public static boolean printFile(String fileName) {
863         return PrinterHelper.printFile(fileName);
864     }
865
866     /**
867      * Display a dialog to print a figure (Called from graphics figures menus)
868      * @param figID the ID of the figure to print
869      * @return execution status
870      */
871     public static boolean print_figure(int figureId) {
872         return printFigure(ScilabNativeView.ScilabNativeView__getFigureFromIndex(figureId), true, true);
873     }
874
875     /**
876      * Display a dialog to print a figure
877      * @param figID the ID of the figure to print
878      * @param postScript true to print in postscript mode
879      * @param displayDialog true to display a print setup dialog
880      * @return execution status
881      */
882     public static boolean printFigure(int figID, boolean postScript, boolean displayDialog) {
883         // Get the PrinterJob object
884         PrinterJob printerJob = PrinterJob.getPrinterJob();
885
886         boolean userOK = true;
887         if (displayDialog) {
888             userOK = printerJob.printDialog(scilabPageFormat);
889         }
890
891         if (userOK) {
892             //If the OS is Windows
893             if (isWindowsPlateform()) {
894                 Figure figure = (Figure) GraphicController.getController().getObjectFromId(figID);
895                 int figureID = figure.getId();
896                 BufferedImage bimage = null;
897                 if (figure.getVisible()) {
898                     bimage = ((SwingScilabDockablePanel) SwingView.getFromId(figID)).getContentCanvas().dumpAsBufferedImage();
899                 } else {
900                     try {
901                         File tmpPrinterFile = File.createTempFile("scilabfigure", ".png");
902                         tmpPrinterFile.delete();
903                         FileExporter.fileExport(figID, tmpPrinterFile.getAbsolutePath(), "PNG", 1, 0);
904                         bimage = ImageIO.read(tmpPrinterFile);
905                     } catch (IOException e) {
906                         e.printStackTrace();
907                         return false;
908                     }
909                 }
910
911                 if (bimage != null) {
912                     ScilabPrint scilabPrint = new ScilabPrint(bimage, printerJob, scilabPageFormat);
913                     if (scilabPrint != null) {
914                         return true;
915                     } else {
916                         return false;
917                     }
918                 } else {
919                     return false;
920                 }
921
922                 //If the OS is Linux
923             } else {
924                 DocFlavor printDocFlavor = DocFlavor.INPUT_STREAM.POSTSCRIPT;
925                 String fileExtension = ".ps";
926
927                 try {
928                     String tmpPrinterFile = File.createTempFile("scilabfigure", "").getAbsolutePath();
929                     // Export image to PostScript
930                     if (((PrintRequestAttribute) scilabPageFormat.get(OrientationRequested.class)) == OrientationRequested.PORTRAIT) {
931                         FileExporter.fileExport(figID,
932                                                 tmpPrinterFile + fileExtension,
933                                                 "PS", 1, 0); // 1 is the quality. Useless in this context
934                     } else {
935                         FileExporter.fileExport(figID,
936                                                 tmpPrinterFile + fileExtension,
937                                                 "PS", 1, 1); // 1 is the quality. Useless in this context
938                     }
939
940                     // Read file
941                     FileInputStream psStream = null;
942
943                     try {
944                         psStream = new FileInputStream(tmpPrinterFile + fileExtension);
945                     } catch (FileNotFoundException ffne) {
946                         ffne.printStackTrace();
947                         return false;
948                     }
949
950                     Doc myDoc = new SimpleDoc(psStream, printDocFlavor, null);
951                     PrintService printService = printerJob.getPrintService();
952
953                     if (printService == null) {
954                         // Could not find the print service
955                         MessageBox messageBox = ScilabMessageBox.createMessageBox();
956                         messageBox.setMessage(Messages.gettext("No print service found."));
957                         messageBox.setModal(true);
958                         messageBox.setIcon("error");
959                         messageBox.displayAndWait();
960                         return false;
961                     }
962                     DocPrintJob job = printService.createPrintJob();
963
964                     // Remove Orientation option from page setup because already managed in FileExporter
965                     PrintRequestAttributeSet aset = new HashPrintRequestAttributeSet(scilabPageFormat);
966                     aset.add(OrientationRequested.PORTRAIT);
967                     job.print(myDoc, aset);
968                     return true;
969                 } catch (IOException e) {
970                     System.err.println("Could not create temporary file " + e.getLocalizedMessage());
971                     return false;
972                 } catch (PrintException e) {
973                     e.printStackTrace();
974                     return false;
975                 }
976             }
977         }
978         return false;
979     }
980
981     /**
982      * Display a page setup dialog for printing
983      * @return true if the user clicked the OK button
984      */
985     public static boolean pageSetup() {
986         // Get the PrinterJob object
987         PrinterJob job = PrinterJob.getPrinterJob();
988
989         // Get the default page format, then allow the user to modify it
990         return (job.pageDialog(scilabPageFormat) != null);
991     }
992
993     /***********************/
994     /*                     */
995     /* FONT CHOOSER BRIDGE */
996     /*                     */
997     /***********************/
998
999     /**
1000      * Set the default font name for a FileChooser
1001      * @param id the id of the FileChooser
1002      * @param fontName the name of the font
1003      */
1004     public static void setFontChooserFontName(int id, String fontName) {
1005         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultFontName(fontName);
1006     }
1007
1008     /**
1009      * Set the default font size for a FileChooser
1010      * @param id the id of the FileChooser
1011      * @param fontSize the size of the font
1012      */
1013     public static void setFontChooserFontSize(int id, int fontSize) {
1014         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultFontSize(fontSize);
1015     }
1016
1017     /**
1018      * Set the default bold attribute for a FileChooser
1019      * @param id the id of the FileChooser
1020      * @param bold the bold attribute of the font
1021      */
1022     public static void setFontChooserBold(int id, boolean bold) {
1023         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultBold(bold);
1024     }
1025
1026     /**
1027      * Set the default italic attribute for a FileChooser
1028      * @param id the id of the FileChooser
1029      * @param italic the italic attribute of the font
1030      */
1031     public static void setFontChooserItalic(int id, boolean italic) {
1032         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultItalic(italic);
1033     }
1034
1035     /**
1036      * Get the selected font name for a FileChooser
1037      * @param id the id of the FileChooser
1038      * @return the name of the font
1039      */
1040     public static String getFontChooserFontName(int id) {
1041         Font selectedFont = ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedFont();
1042         if (selectedFont != null) {
1043             return selectedFont.getFamily();
1044         } else {
1045             return "";
1046         }
1047     }
1048
1049     /**
1050      * Get the selected font size for a FileChooser
1051      * @param id the id of the FileChooser
1052      * @return the size of the font
1053      */
1054     public static int getFontChooserFontSize(int id) {
1055         return ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedFont().getSize();
1056     }
1057
1058     /**
1059      * Get the selected bold attribute for a FileChooser
1060      * @param id the id of the FileChooser
1061      * @return the bold attribute of the font
1062      */
1063     public static boolean getFontChooserBold(int id) {
1064         return ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedFont().isBold();
1065     }
1066
1067     /**
1068      * Get the selected italic attribute for a FileChooser
1069      * @param id the id of the FileChooser
1070      * @return the italic attribute of the font
1071      */
1072     public static boolean getFontChooserItalic(int id) {
1073         return ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedFont().isItalic();
1074     }
1075
1076     /**
1077      * Display this chooser and wait for user selection
1078      * @param id the id of the FontChooser
1079      */
1080     public static void fontChooserDisplayAndWait(int id) {
1081         ((FontChooser) UIElementMapper.getCorrespondingUIElement(id)).displayAndWait();
1082     }
1083
1084     /************************/
1085     /*                      */
1086     /* COLOR CHOOSER BRIDGE */
1087     /*                      */
1088     /************************/
1089
1090     /**
1091      * Set the title of a ColorChooser
1092      * @param id the id of the ColorChooser
1093      * @param title the title
1094      */
1095     public static void setColorChooserTitle(int id, String title) {
1096         ((ColorChooser) UIElementMapper.getCorrespondingUIElement(id)).setTitle(title);
1097     }
1098
1099     /**
1100      * Set the default Color for a ColorChooser
1101      * @param id the id of the ColorChooser
1102      * @param rgb the default color
1103      */
1104     public static void setColorChooserDefaultColor(int id, int[] rgb) {
1105         ((ColorChooser) UIElementMapper.getCorrespondingUIElement(id)).setDefaultColor(new Color(rgb[0], rgb[1], rgb[2]));
1106     }
1107
1108     /**
1109      * Get the selected Color for a ColorChooser
1110      * @param id the id of the ColorChooser
1111      * @return the selected color
1112      */
1113     public static int[] getColorChooserSelectedColor(int id) {
1114         Color selectedColor = ((ColorChooser) UIElementMapper.getCorrespondingUIElement(id)).getSelectedColor();
1115         int[] returnedValues = new int[NB_COLORS];
1116         if (selectedColor != null) {
1117             returnedValues[0] = selectedColor.getRed();
1118             returnedValues[1] = selectedColor.getGreen();
1119             returnedValues[2] = selectedColor.getBlue();
1120         } else {
1121             returnedValues[0] = -1;
1122             returnedValues[1] = -1;
1123             returnedValues[2] = -1;
1124         }
1125         return returnedValues;
1126
1127     }
1128
1129     /**
1130      * Display this chooser and wait for user selection
1131      * @param id the id of the ColorChooser
1132      */
1133     public static void colorChooserDisplayAndWait(int id) {
1134         ((ColorChooser) UIElementMapper.getCorrespondingUIElement(id)).displayAndWait();
1135     }
1136
1137     /************************/
1138     /*                      */
1139     /* CLIPBOARD MANAGEMENT */
1140     /*                      */
1141     /************************/
1142
1143     /**
1144      * Get the contents of the clipboard
1145      * @return the string contained in the clipboard or null
1146      */
1147     public static String getClipboardContents() {
1148         // Gets the contents of the clipboard
1149         Toolkit toolkit = Toolkit.getDefaultToolkit();
1150         Clipboard systemClipboard = toolkit.getSystemClipboard();
1151         String clipboardContents = "";
1152
1153         // Verify that clibpboard data is of text type
1154         boolean dataAvailable;
1155         try {
1156             dataAvailable = systemClipboard.isDataFlavorAvailable(DataFlavor.stringFlavor);
1157         } catch (IllegalStateException exception) {
1158             return clipboardContents;
1159         }
1160
1161         // Exit if text data not available
1162         if (!dataAvailable) {
1163             return clipboardContents;
1164         }
1165
1166         // Read data
1167         try {
1168             clipboardContents = (String) systemClipboard.getData(DataFlavor.stringFlavor);
1169         } catch (UnsupportedFlavorException e1) {
1170             // Should never be here
1171             e1.printStackTrace();
1172         } catch (IOException e1) {
1173             // Should never be here
1174             e1.printStackTrace();
1175         }
1176
1177         return clipboardContents;
1178     }
1179
1180     /**
1181      * Set the contents of the clipboard
1182      * @param text the string to put in the clipboard
1183      */
1184     public static void setClipboardContents(String text) {
1185         Transferable contents = new StringSelection(text);
1186         Toolkit.getDefaultToolkit().getSystemClipboard().setContents(contents, null);
1187     }
1188
1189     /**
1190      * Copy figure to clipboard
1191      * @param figID the ID of the figure
1192      */
1193     public static void clipboard_figure(int figureId) {
1194         copyFigureToClipBoard(ScilabNativeView.ScilabNativeView__getFigureFromIndex(figureId));
1195     }
1196
1197     /**
1198      * Copy figure to clipboard
1199      * @param figID the ID of the figure
1200      */
1201     public static void copyFigureToClipBoard(int figID) {
1202         Image figureImage = ImageExporter.imageExport(figID);
1203         if (figureImage != null) {
1204             Transferable clipboardImage = new ClipboardImage(figureImage);
1205             Toolkit.getDefaultToolkit().getSystemClipboard().setContents(clipboardImage, null);
1206         }
1207     }
1208
1209     /**
1210      * Class used to store Images in the clipboard
1211      */
1212     public static class ClipboardImage implements Transferable {
1213         private final DataFlavor[] flavors = new DataFlavor[] {DataFlavor.imageFlavor};
1214         private final Image image;
1215
1216         /**
1217          * Default constructor
1218          * @param image the image
1219          */
1220         public ClipboardImage(Image image) {
1221             this.image = image;
1222         }
1223
1224         /**
1225          * DataFlavors of this transferable
1226          * @return the DataFlavors accepeted
1227          */
1228         @Override
1229         public DataFlavor[] getTransferDataFlavors() {
1230             return flavors;
1231         }
1232
1233         /**
1234          * Test supported DataFlavors
1235          * @param flavor the flavor to test
1236          * @return true if the flavor is supported
1237          */
1238         @Override
1239         public boolean isDataFlavorSupported(DataFlavor flavor) {
1240             return flavors[0].equals(flavor);
1241         }
1242
1243         /**
1244          * Get the contents of this transferable
1245          * @param flavor the flavor to test
1246          * @return the contents
1247          * @throws UnsupportedFlavorException if the flavor is not supported by this transferable
1248          */
1249         @Override
1250         public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException {
1251             if (!flavors[0].equals(flavor)) {
1252                 throw new UnsupportedFlavorException(flavor);
1253             }
1254
1255             return image;
1256         }
1257     }
1258
1259     /********/
1260     /*      */
1261     /* MISC */
1262     /*      */
1263     /********/
1264
1265     /**
1266      * Get the screen resolution
1267      * @return the number of dot per inch
1268      */
1269     public static int getScreenResolution() {
1270         return Toolkit.getDefaultToolkit().getScreenResolution();
1271     }
1272
1273     /**
1274      * Get the screen Width in pixels
1275      * @return the screen Width
1276      */
1277     public static double getScreenWidth() {
1278         return Toolkit.getDefaultToolkit().getScreenSize().getWidth();
1279     }
1280
1281     /**
1282      * Get the screen Height in pixels
1283      * @return the screen Height
1284      */
1285     public static double getScreenHeight() {
1286         return Toolkit.getDefaultToolkit().getScreenSize().getHeight();
1287     }
1288
1289     /**
1290      * Get the screen Depth
1291      * @return the screen Depth
1292      */
1293     public static int getScreenDepth() {
1294         return Toolkit.getDefaultToolkit().getColorModel().getPixelSize();
1295     }
1296
1297     /**
1298      * Give the focus to a uicontrol
1299      * @param uicontrolUID the uicontrolUID of the Widget
1300      */
1301     public static void requestFocus(int uicontrolUID) {
1302         SwingViewObject uicontrol = SwingView.getFromId(uicontrolUID);
1303         if (uicontrol instanceof SwingScilabScrollableFrame) {
1304             ((SwingScilabScrollableFrame) uicontrol).requestFocus();
1305         } else if (uicontrol instanceof SwingScilabFrame) {
1306             ((SwingScilabFrame) uicontrol).requestFocus();
1307         } else {
1308             ((Widget) uicontrol).requestFocus();
1309         }
1310
1311     }
1312
1313     /**
1314      * Raise the window specified by the user
1315      * @param id the id of the figure
1316      */
1317     public static void raiseWindow(int id) {
1318         /*((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(id).getRendererProperties()).getParentTab().getParentWindow().raise();
1319           ((ScilabRendererProperties) FigureMapper.getCorrespondingFigure(id).getRendererProperties()).getParentTab().setCurrent();*/
1320     }
1321
1322     /**
1323      * @return true if the os is windows, false otherwise
1324      */
1325     public static boolean isWindowsPlateform() {
1326         // get os name
1327         return System.getProperty("os.name").toLowerCase().contains("windows");
1328     }
1329
1330     /**
1331      * Change object used for graphic figure (GLCanvas or GLJPanel)
1332      * @param onOrOff true to set GLCanvas display
1333      */
1334     public static void useCanvasForDisplay(boolean onOrOff) {
1335         SwingScilabCanvasImpl.switchToGLCanvas(onOrOff);
1336     }
1337
1338     /**
1339      * Get object used for graphic figure (GLCanvas or GLJPanel)
1340      * @return true if GLCanvas display is set
1341      */
1342     public static boolean useCanvasForDisplay() {
1343         return SwingScilabCanvasImpl.isGLCanvasEnabled();
1344     }
1345
1346     /**
1347      * Display Scilab about box
1348      */
1349     public static void scilabAboutBox() {
1350         ScilabAboutBox.displayAndWait();
1351     }
1352
1353     /******************/
1354     /*                */
1355     /* UITABLE BRIDGE */
1356     /*                */
1357     /******************/
1358
1359     public static void fireClosingFinished(int figUID) {
1360         SwingScilabDockablePanel parentTab = (SwingScilabDockablePanel) SwingView.getFromId(figUID);
1361         ClosingOperationsManager.removeFromDunnoList(parentTab);
1362     }
1363 }