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