Compilation: enable full parallel build
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / bridge / messagebox / SwingScilabMessageBox.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2008 - INRIA - Vincent Couvert
4  * Copyright (C) 2010 - DIGITEO - Vincent Couvert
5  * Copyright (C) 2013 - Scilab Enterprises - Clement DAVID
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13  */
14
15 package org.scilab.modules.gui.bridge.messagebox;
16
17 import java.awt.BorderLayout;
18 import java.awt.Component;
19 import java.awt.Font;
20 import java.awt.GridBagConstraints;
21 import java.awt.GridBagLayout;
22 import java.awt.Image;
23 import java.awt.event.ActionEvent;
24 import java.awt.event.ActionListener;
25 import java.awt.event.MouseEvent;
26 import java.awt.event.MouseListener;
27 import java.util.ArrayList;
28 import java.util.Enumeration;
29 import java.util.List;
30
31 import javax.swing.AbstractButton;
32 import javax.swing.Action;
33 import javax.swing.BorderFactory;
34 import javax.swing.ButtonGroup;
35 import javax.swing.DefaultListModel;
36 import javax.swing.GroupLayout;
37 import javax.swing.GroupLayout.Alignment;
38 import javax.swing.GroupLayout.ParallelGroup;
39 import javax.swing.GroupLayout.SequentialGroup;
40 import javax.swing.Icon;
41 import javax.swing.ImageIcon;
42 import javax.swing.JButton;
43 import javax.swing.JCheckBox;
44 import javax.swing.JDialog;
45 import javax.swing.JLabel;
46 import javax.swing.JList;
47 import javax.swing.JOptionPane;
48 import javax.swing.JPanel;
49 import javax.swing.JScrollPane;
50 import javax.swing.JTextArea;
51 import javax.swing.JTextField;
52 import javax.swing.JTextPane;
53 import javax.swing.JToggleButton;
54 import javax.swing.LayoutStyle.ComponentPlacement;
55 import javax.swing.ListSelectionModel;
56 import javax.swing.UIManager;
57 import javax.swing.event.HyperlinkEvent;
58 import javax.swing.event.HyperlinkListener;
59 import javax.swing.text.html.HTMLEditorKit;
60 import javax.swing.text.html.StyleSheet;
61
62 import org.scilab.modules.commons.gui.FindIconHelper;
63 import org.scilab.modules.gui.console.ScilabConsole;
64 import org.scilab.modules.gui.messagebox.SimpleMessageBox;
65 import org.scilab.modules.gui.tab.SimpleTab;
66 import org.scilab.modules.gui.tab.Tab;
67 import org.scilab.modules.gui.utils.ScilabSwingUtilities;
68 import org.scilab.modules.gui.utils.WebBrowser;
69 import org.scilab.modules.localization.Messages;
70
71 /**
72  * Swing implementation of a Scilab MessageBox
73  * @author Vincent COUVERT
74  */
75 public class SwingScilabMessageBox extends JDialog implements SimpleMessageBox, ActionListener {
76
77     private static final long serialVersionUID = 7939976395338222763L;
78
79     private static final int X_MESSAGE_TYPE = 0;
80     private static final int X_DIALOG_TYPE = 1;
81     private static final int X_CHOOSE_TYPE = 2;
82     private static final int X_MDIALOG_TYPE = 3;
83     private static final int X_CHOICES_TYPE = 4;
84
85     /**
86      * New line character for mutli-line text components
87      */
88     private static final String NEW_LINE = "\n";
89
90     /**
91      * Separator used for x_choices
92      */
93     private static final String SEPARATOR = "[--sep--]";
94
95     /**
96      * The minimal fixed width of any mdialog inputs
97      */
98     private static final int X_MDIALOG_TEXTFIELD_SIZE = 10;
99
100     /**
101      * Icons
102      */
103     private final Icon scilabIcon = new ImageIcon(FindIconHelper.findIcon("scilab", "48x48"));
104     private final Icon passwdIcon = new ImageIcon(FindIconHelper.findIcon("emblem-readonly", "48x48"));
105     private final Icon hourglassIcon = new ImageIcon(FindIconHelper.findIcon("process-working"));
106
107     private int elementId;
108
109     private Icon messageIcon;
110
111     private int scilabDialogType = X_MESSAGE_TYPE;
112
113     private Component parentWindow;
114
115     private final JButton btnOK = new JButton(Messages.gettext("OK"));
116     private final JButton btnCancel = new JButton(Messages.gettext("Cancel"));
117
118     /**
119      * Used for x_dialog
120      */
121     private JTextArea textArea;
122     private String initialValue;
123     private int initialValueSize;
124     private String userValue;
125
126     /**
127      * Used for x_choose
128      */
129     private JList listBox;
130     private String[] listboxItems;
131     private int selectedItem;
132
133     /**
134      * Used for x_mdialog
135      */
136     private String[] lineLabels;
137     private String[] columnLabels;
138     private String[] defaultInput;
139     private Component[] textFields;
140     private String[] userValues;
141
142     /**
143      * Used for x_choose & x_message
144      */
145     private String[] buttonsLabels;
146     private int selectedButton;
147
148     /**
149      * Used for x_choices
150      */
151     private int[] defaultSelectedButtons;
152     private ButtonGroup[] buttonGroups;
153     private int[] userSelectedButtons;
154
155     /**
156      * Used for all Message Boxes
157      */
158     private String message;
159     private String title;
160     private final Image imageForIcon = ((ImageIcon) scilabIcon).getImage();
161     private int messageType = -1;
162     private Component[] objs;
163     private Object[] buttons;
164     private boolean modal = true;
165     private JCheckBox checkbox;
166
167     /**
168      * Default constructor
169      */
170     public SwingScilabMessageBox() {
171         super();
172         setIconImage(imageForIcon);
173     }
174
175     /**
176      * Set the element id for this MessageBox
177      * @param id the id of the corresponding MessageBox object
178      */
179     @Override
180     public void setElementId(int id) {
181         this.elementId = id;
182     }
183
184     /**
185      * Get the element id for MessageBox
186      * @return id the id of the corresponding MessageBox object
187      */
188     @Override
189     public int getElementId() {
190         return this.elementId;
191     }
192
193     /**
194      * Set the title of the MessageBox
195      * @param title the title to set
196      */
197     @Override
198     public void setTitle(String title) {
199         this.title = title;
200     }
201
202     /**
203      * Set the message of the MessageBox
204      * @param message the message to set
205      */
206     @Override
207     public void setMessage(String message) {
208         this.message = message;
209     }
210
211     /**
212      * Set the message of the MessageBox (multi-line)
213      * @param mess the message to set
214      */
215     @Override
216     public void setMessage(String[] mess) {
217         int line = 0;
218         message = "<HTML>";
219         for (line = 0; line < mess.length - 1; line++) {
220             message += "<div>" + mess[line] + "</div>";
221         }
222         message += mess[line] + "</HTML>";
223     }
224
225     /**
226      * Set a checkbox in the messagebox
227      * @param message text of the checkbox
228      * @param action the associated action
229      * @param checked if true the checkbox is checked
230      */
231     public void setCheckbox(String message, Action action) {
232         checkbox = new JCheckBox(action);
233         checkbox.setText(message);
234     }
235
236     /**
237      * DefaultValues
238      * Display this MessageBox and wait for user selection
239      */
240     @Override
241     public void displayAndWait() {
242         JButton defaultButton = null;
243
244         // Set the title & icon
245         //setIconImage(imageForIcon); // Not Java 1.5 compatible
246         super.setTitle(title);
247
248         // Create the message to display
249         JTextPane messageLabel = new JTextPane();
250         messageLabel.setContentType("text/html");
251         messageLabel.setOpaque(false);
252         messageLabel.setBorder(null);
253         messageLabel.setEditable(false);
254
255         // Update the stylesheet so that the font matches JLabel font
256         Font labelFont = UIManager.getFont("Label.font");
257         HTMLEditorKit editorKit = (HTMLEditorKit) messageLabel.getEditorKit();
258         StyleSheet styles = editorKit.getStyleSheet();
259         String css = "body {font-family:\"" + labelFont.getName()
260                      + "\"; font-size:\"" + labelFont.getSize() + "pt\"}";
261         styles.addRule(css);
262         editorKit.setStyleSheet(styles);
263         messageLabel.setEditorKit(editorKit);
264
265         messageLabel.setText(message);
266
267         /* Add a link to make HTML links active */
268         messageLabel.addHyperlinkListener(new HyperlinkListener() {
269             @Override
270             public void hyperlinkUpdate(HyperlinkEvent e) {
271                 if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
272                     WebBrowser.openUrl(e.getURL(), e.getDescription());
273                 }
274             }
275         });
276
277         JScrollPane messageScrollPane = new JScrollPane(messageLabel);
278         // Make the scroll Pane transparent
279         messageScrollPane.setOpaque(false);
280         messageScrollPane.getViewport().setOpaque(false);
281         /* Make the Border of the ScrollPane invisible */
282         messageScrollPane.setBorder(BorderFactory.createEmptyBorder());
283         messageScrollPane.setViewportBorder(BorderFactory.createEmptyBorder());
284
285         if (scilabDialogType == X_CHOICES_TYPE) {
286             // Create a MessageBox for Scilab x_choices
287
288             // All objects in the MessageBox:
289             //  - Message
290             //  - Editable zone
291             objs = new Component[2];
292
293             objs[0] = messageScrollPane;
294
295             // Search the max number of objects in a line
296             int curNumber = 0;
297             int numberOfLines = 0;
298             int numberOfColumns = 0;
299             List<Integer> buttonsPerLines = new ArrayList<Integer>();
300             for (int itemIndex = 0; itemIndex < lineLabels.length; itemIndex++) {
301                 if (!lineLabels[itemIndex].equals(SEPARATOR)) {
302                     curNumber++;
303                 } else {
304                     if (curNumber > numberOfColumns) {
305                         numberOfColumns = curNumber;
306                     }
307                     // Store information of current line
308                     buttonsPerLines.add(curNumber);
309                     curNumber = 0;
310                     numberOfLines++;
311                 }
312             }
313             // Store information of last line
314             // Because no separator after last line items
315             buttonsPerLines.add(curNumber);
316             numberOfLines++;
317
318             // Create the panel with button groups
319             JPanel panel = new JPanel(new GridBagLayout());
320             GridBagConstraints gbc = new GridBagConstraints();
321             gbc.gridx = 0;
322             gbc.gridy = 0;
323             gbc.fill = GridBagConstraints.HORIZONTAL;
324             buttonGroups = new ButtonGroup[numberOfLines];
325
326             // Initialize return value
327             userSelectedButtons = new int[numberOfLines];
328
329             int curItemIndex = 0;
330             int lineNumber = 0;
331             int buttonNumber = 0;
332             for (curItemIndex = 0; curItemIndex < lineLabels.length; curItemIndex++) {
333                 // Add the label of the line
334                 gbc.weightx = 1; // Labels will use remaining space when resizing
335                 panel.add(new JLabel(lineLabels[curItemIndex]), gbc);
336                 gbc.gridx++; // Increment the column index
337
338                 buttonNumber = 0;
339                 curItemIndex++;
340
341                 // Add the button group
342                 ButtonGroup group = new ButtonGroup();
343                 while (curItemIndex < lineLabels.length &&  !lineLabels[curItemIndex].equals(SEPARATOR)) {
344                     // Add a toggle button
345                     JToggleButton button = new JToggleButton(lineLabels[curItemIndex]);
346                     buttonNumber++;
347
348                     // Select this button if default
349                     if (buttonNumber == defaultSelectedButtons[lineNumber]) {
350                         button.setSelected(true);
351                     }
352                     // Select this button if default selection is a non existing button
353                     // And this button is the last of the line
354                     if (buttonNumber == (buttonsPerLines.get(lineNumber) - 1)
355                             && defaultSelectedButtons[lineNumber] > (buttonsPerLines.get(lineNumber) - 1)) {
356                         button.setSelected(true);
357                     }
358                     // Add the button to the group (for toggle)
359                     // And to the panel (for display)
360                     group.add(button);
361                     gbc.weightx = 0; // Button size will not change when resizing
362                     panel.add(button, gbc);
363                     gbc.gridx++; // Increment the column index
364
365                     // Increment item index
366                     curItemIndex++;
367
368                 }
369                 // Add empty labels if number of buttons in the line is lesser than maximum number of buttons found in a line
370                 for (int emptyLabelsIndex = buttonsPerLines.get(lineNumber); emptyLabelsIndex < numberOfColumns; emptyLabelsIndex++) {
371                     panel.add(new JLabel(), gbc);
372                     gbc.gridx++; // Increment the column index
373                 }
374
375                 // Store the group to get the user selection when returning
376                 buttonGroups[lineNumber] = group;
377
378                 // Increment current line number
379                 lineNumber++;
380                 gbc.gridx = 0; // New line --> Back to first column
381                 gbc.gridy++; // Increment the row index
382             }
383
384             // Display the panel
385             panel.doLayout();
386
387             // Editable text zone
388             JScrollPane scrollPane = new JScrollPane(panel);
389
390             objs[1] = scrollPane;
391
392             // And now the buttons
393             buttons = new Object[2];
394             btnOK.addActionListener(this);
395             btnCancel.addActionListener(this);
396             /* Test added for bug 4347 fix */
397             if (isWindows()) {
398                 buttons[0] = btnOK;
399                 buttons[1] = btnCancel;
400
401             } else {
402                 buttons[0] = btnCancel;
403                 buttons[1] = btnOK;
404             }
405             defaultButton = btnOK;
406         } else if (scilabDialogType == X_MDIALOG_TYPE) {
407             // Create a MessageBox for Scilab x_mdialog
408
409             // All objects in the MessageBox:
410             //  - Message
411             //  - Editable zone
412             objs = new Component[2];
413
414             objs[0] = messageScrollPane;
415
416             int numberOfColumns = 0;
417             if (columnLabels == null) {
418                 numberOfColumns = 2;
419             } else {
420                 numberOfColumns = columnLabels.length + 1;
421             }
422
423             // Allocate the Java Components
424             final JLabel[] colLabels;
425             final JLabel[] rowLabels;
426             if (columnLabels != null) {
427                 // Optional first line
428                 colLabels = new JLabel[columnLabels.length + 1];
429
430                 // the first column label is on top of the row label
431                 colLabels[0] = new JLabel("");
432
433                 // create the components on each column
434                 for (int col = 0; col < columnLabels.length; col++) {
435                     colLabels[col + 1] = new JLabel(columnLabels[col]);
436                 }
437             } else {
438                 // there is no first line
439                 colLabels = null;
440             }
441             rowLabels = new JLabel[lineLabels.length];
442             for (int row = 0; row < lineLabels.length; row++) {
443                 // add a gap (a space) between the column's labels and data
444                 rowLabels[row] = new JLabel(lineLabels[row] + " ");
445             }
446
447             // Prepare return value
448             if (columnLabels == null) {
449                 userValues = new String[lineLabels.length];
450                 textFields = new Component[lineLabels.length];
451             } else {
452                 userValues = new String[lineLabels.length * columnLabels.length];
453                 textFields = new Component[lineLabels.length * columnLabels.length];
454             }
455
456             // set the initial values
457             for (int line = 0; line < lineLabels.length; line++) {
458                 for (int col = 0; col < numberOfColumns - 1; col++) {
459                     final String initial = defaultInput[col * lineLabels.length + line];
460
461                     final Component c;
462                     if ("T".equalsIgnoreCase(initial)) {
463                         c = new JCheckBox();
464                         ((JCheckBox) c).setSelected(true);
465                     } else if ("F".equalsIgnoreCase(initial)) {
466                         c = new JCheckBox();
467                         ((JCheckBox) c).setSelected(false);
468                     } else {
469                         c = new JTextField(initial);
470
471                         // force an initial width when the initial text is too small
472                         if (initial.length() < X_MDIALOG_TEXTFIELD_SIZE) {
473                             ((JTextField) c).setColumns(X_MDIALOG_TEXTFIELD_SIZE);
474                         }
475                     }
476
477                     textFields[col * lineLabels.length + line] = c;
478                     rowLabels[line].setLabelFor(c);
479                 }
480             }
481
482             // Prepare the layout
483             JPanel panel = new JPanel();
484             GroupLayout layout = new GroupLayout(panel);
485             panel.setLayout(layout);
486
487             final SequentialGroup horizontalGroup = layout.createSequentialGroup().addContainerGap();
488             final SequentialGroup verticalGroup = layout.createSequentialGroup().addContainerGap();
489
490             // Horizontal layout
491             {
492                 final ParallelGroup localGroup = layout.createParallelGroup(Alignment.LEADING);
493
494                 if (colLabels != null) {
495                     localGroup.addComponent(colLabels[0]);
496                 }
497                 // special case for the row label
498                 for (int row = 0; row < lineLabels.length; row++) {
499                     localGroup.addComponent(rowLabels[row]);
500                 }
501                 horizontalGroup.addGroup(localGroup);
502                 horizontalGroup.addGap(18, 18, 18);
503             }
504             for (int col = 0 ; col < numberOfColumns - 1; col++) {
505                 if (col > 0) {
506                     horizontalGroup.addPreferredGap(ComponentPlacement.RELATED);
507                 }
508
509                 final ParallelGroup localGroup = layout.createParallelGroup(Alignment.CENTER);
510
511                 if (colLabels != null) {
512                     // center the labels to be rendered like a spreadsheet
513                     localGroup.addComponent(colLabels[col + 1]);
514                 }
515
516                 // common case for the initial values
517                 for (int row = 0; row < lineLabels.length; row++) {
518                     localGroup.addComponent(textFields[col * lineLabels.length + row]);
519                 }
520
521                 horizontalGroup.addGroup(localGroup);
522             }
523             layout.setHorizontalGroup(
524                 layout.createParallelGroup(Alignment.LEADING)
525                 .addGroup(horizontalGroup.addContainerGap()));
526
527             // Vertical layout
528             if (colLabels != null) {
529                 final ParallelGroup localGroup = layout.createParallelGroup(Alignment.BASELINE);
530                 for (int col = 0 ; col < numberOfColumns; col++) {
531                     localGroup.addComponent(colLabels[col]);
532                 }
533                 verticalGroup.addGroup(localGroup);
534                 verticalGroup.addGap(18, 18, 18);
535             }
536             for (int row = 0; row < lineLabels.length; row++) {
537                 if (row > 0) {
538                     verticalGroup.addPreferredGap(ComponentPlacement.RELATED);
539                 }
540
541                 final ParallelGroup localGroup = layout.createParallelGroup(Alignment.BASELINE);
542                 localGroup.addComponent(rowLabels[row]);
543                 for (int col = 0 ; col < numberOfColumns - 1; col++) {
544                     localGroup.addComponent(textFields[col * lineLabels.length + row]);
545                 }
546                 verticalGroup.addGroup(localGroup);
547             }
548             layout.setVerticalGroup(
549                 layout.createParallelGroup(Alignment.LEADING)
550                 .addGroup(verticalGroup.addContainerGap()));
551
552             // Editable text zone
553             JScrollPane scrollPane = new JScrollPane(panel);
554
555             objs[1] = scrollPane;
556
557             // And now the buttons
558             buttons = new Object[2];
559             btnOK.addActionListener(this);
560             btnCancel.addActionListener(this);
561             /* Test added for bug 4347 fix */
562             if (isWindows()) {
563                 buttons[0] = btnOK;
564                 buttons[1] = btnCancel;
565
566             } else {
567                 buttons[0] = btnCancel;
568                 buttons[1] = btnOK;
569             }
570             defaultButton = btnOK;
571         } else if (scilabDialogType == X_CHOOSE_TYPE) {
572             // Create a MessageBox for Scilab x_choose
573
574             // All objects in the MessageBox:
575             //  - Message
576             //  - Listbox
577             objs = new Component[2];
578
579             // Add the message
580             objs[0] = messageScrollPane;
581
582             // Add the listBox
583             objs[1] = createXchooseListBox();
584
585             // And now the buttons
586             buttons = new Object[1];
587             if (buttonsLabels != null) {
588                 btnCancel.setText(buttonsLabels[0]);
589             }
590             btnCancel.addActionListener(this);
591             buttons[0] = btnCancel;
592         } else if (scilabDialogType == X_DIALOG_TYPE) {
593             // Create a MessageBox for Scilab x_dialog
594
595             // All objects in the MessageBox:
596             //  - Message
597             //  - Editable zone
598             objs = new Component[2];
599
600             objs[0] = messageScrollPane;
601
602             // Editable text zone
603             textArea = new JTextArea(initialValue);
604             textArea.setRows(initialValueSize);
605             JScrollPane scrollPane = new JScrollPane(textArea);
606
607             objs[1] = scrollPane;
608
609             // And now the buttons
610             buttons = new Object[2];
611             btnOK.addActionListener(this);
612             btnCancel.addActionListener(this);
613             /* Test added for bug 4347 fix */
614             if (isWindows()) {
615                 buttons[0] = btnOK;
616                 buttons[1] = btnCancel;
617
618             } else {
619                 buttons[0] = btnCancel;
620                 buttons[1] = btnOK;
621             }
622             defaultButton = btnOK;
623         } else {
624             // Create a MessageBox for Scilab x_message
625
626             // All objects in the MessageBox:
627             //  - Message
628             int nb = checkbox == null ? 1 : 2;
629             objs = new Component[nb];
630
631             // Add the message
632             objs[0] = messageScrollPane;
633             if (nb == 2) {
634                 objs[1] = checkbox;
635             }
636
637             // And now the buttons
638             if (buttonsLabels == null) {
639                 buttons = new Object[1];
640                 btnOK.addActionListener(this);
641                 buttons[0] = btnOK;
642                 defaultButton = btnOK;
643                 //messageType = JOptionPane.INFORMATION_MESSAGE;
644             } else {
645                 buttons = new Object[buttonsLabels.length];
646                 for (int buttonNb = 0; buttonNb < buttonsLabels.length; buttonNb++) {
647                     JButton currentButton = new JButton(buttonsLabels[buttonNb]);
648                     currentButton.addActionListener(this);
649                     if (buttonNb == 0) {
650                         defaultButton = currentButton;
651                     }
652                     /* Test added for bug 4347 fix */
653                     if (isWindows()) {
654                         buttons[buttonNb] = currentButton;
655                     } else {
656                         buttons[buttonsLabels.length - buttonNb - 1] = currentButton;
657                     }
658                 }
659             }
660         }
661         // Display
662         ((JScrollPane) objs[0]).setBorder(BorderFactory.createEmptyBorder());
663         final JPanel message = new JPanel(new BorderLayout());
664
665         /*
666          * If there is only one object to display then center it
667          * If 2 objects then add a header and a centered component
668          * If more then add a header and append all other objects to a centered container
669          */
670         if (objs.length > 1) {
671             message.add(objs[0], BorderLayout.NORTH);
672         } else {
673             message.add(objs[0], BorderLayout.CENTER);
674         }
675
676         if (objs.length == 2) {
677             message.add(objs[1], BorderLayout.CENTER);
678         }
679
680         if (objs.length > 2) {
681             // seems that this case is never called as x_message is no more available into Scilab.
682             final JPanel content = new JPanel();
683             for (int i = 1; i < objs.length; i++) {
684                 content.add(objs[i]);
685             }
686             message.add(content, BorderLayout.CENTER);
687         }
688
689         if (messageType != -1) {
690             setContentPane(new JOptionPane(message, messageType, JOptionPane.CANCEL_OPTION, null, buttons));
691         } else {
692             if (messageIcon == null) {
693                 messageIcon = scilabIcon;
694             }
695             setContentPane(new JOptionPane(message, messageType, JOptionPane.CANCEL_OPTION, messageIcon, buttons));
696         }
697         pack();
698         super.setModal(modal); /* Must call the JDialog class setModal */
699
700         if (parentWindow == null) {
701             if (ScilabConsole.isExistingConsole()) {
702                 setLocationRelativeTo((Component) ScilabConsole.getConsole().getAsSimpleConsole());
703             }
704         } else {
705             setLocationRelativeTo(parentWindow);
706         }
707
708         ScilabSwingUtilities.closeOnEscape(this);
709
710         if (defaultButton != null) {
711             getRootPane().setDefaultButton(defaultButton);
712             defaultButton.requestFocusInWindow();
713         }
714
715         setVisible(true);
716         doLayout();
717
718         // If the dialog is not modal and Scilab waits for an answer, have to wait...
719         if (!modal && scilabDialogType != X_MESSAGE_TYPE) {
720             synchronized (btnOK) {
721                 try {
722                     btnOK.wait();
723                 } catch (InterruptedException e) {
724                     e.printStackTrace();
725                 }
726             }
727         }
728     }
729
730     /**
731      * Action management
732      * @param ae the action event
733      * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
734      */
735
736     @Override
737     public void actionPerformed(ActionEvent ae) {
738         if (ae.getSource() == btnOK) {
739             // For a x_dialog, get the user answer
740             if (scilabDialogType == X_DIALOG_TYPE) {
741                 userValue = textArea.getText();
742             } else if (scilabDialogType == X_MDIALOG_TYPE) {
743                 for (int textFieldIndex = 0; textFieldIndex < textFields.length; textFieldIndex++) {
744                     final Component c = textFields[textFieldIndex];
745                     if (c instanceof JTextField) {
746                         userValues[textFieldIndex] = ((JTextField) c).getText();
747                     } else if (c instanceof JCheckBox) {
748                         if (((JCheckBox) c).isSelected()) {
749                             userValues[textFieldIndex] = "%t";
750                         } else {
751                             userValues[textFieldIndex] = "%f";
752                         }
753                     }
754                 }
755                 userValue = ""; /* To make getValueSize return a non zero value */
756             } else if (scilabDialogType == X_CHOICES_TYPE) {
757
758                 // Get the selected button index of each button group
759                 for (int groupNum = 0; groupNum < buttonGroups.length; groupNum++) {
760                     Enumeration<AbstractButton> theButtons = buttonGroups[groupNum].getElements();
761                     for (int btnNum = 0; btnNum < buttonGroups[groupNum].getButtonCount(); btnNum++) {
762                         JToggleButton b = (JToggleButton) theButtons.nextElement();
763                         if (b.getModel() == buttonGroups[groupNum].getSelection()) {
764                             userSelectedButtons[groupNum] = btnNum + 1;
765                         }
766                     }
767                 }
768                 userValue = ""; /* To make getValueSize return a non zero value */
769             }
770             selectedButton = 1;
771         } else if (ae.getSource() == btnCancel) {
772             selectedButton = 2;
773         } else if (buttonsLabels != null) { // User defined buttons
774             for (int index = 0; index < buttonsLabels.length; index++) {
775                 if (((JButton) ae.getSource()).getText().equals(buttonsLabels[index])) {
776                     selectedButton = index + 1;
777                     break;
778                 }
779             }
780         }
781         // Notify btnOK for not modal Dialogs
782         synchronized (btnOK) {
783             btnOK.notify();
784         }
785         // Destroy the Dialog
786         dispose();
787     }
788     /**
789      * Get the index of the button clicked
790      * @return the index of the button clicked
791      */
792     @Override
793     public int getSelectedButton() {
794         return selectedButton;
795     }
796
797     /**
798      * Set the indices of the default selected buttons (x_choices)
799      * @param indices the indices of the default selected buttons
800      */
801     @Override
802     public void setDefaultSelectedButtons(int[] indices) {
803         defaultSelectedButtons = indices;
804         scilabDialogType = X_CHOICES_TYPE;
805     }
806
807     /**
808      * Get the indices of the selected buttons (x_choices)
809      * @return the indices of the selected buttons
810      */
811     @Override
812     public int[] getUserSelectedButtons() {
813         return userSelectedButtons;
814     }
815
816     /**
817      * Set the labels of the buttons in the MessageBox
818      * @param labels the labels of the buttons
819      */
820     @Override
821     public void setButtonsLabels(String[] labels) {
822         buttonsLabels = labels;
823     }
824
825     /**
826      * Set the initial values of the editable zone in the MessageBox
827      * @param value the initial values
828      */
829     @Override
830     public void setInitialValue(String[] value) {
831         int line = 0;
832         initialValue = "";
833         for (line = 0; line < value.length - 1; line++) {
834             initialValue += value[line] + NEW_LINE;
835         }
836         initialValue += value[line];
837         initialValueSize = value.length;
838
839         scilabDialogType = X_DIALOG_TYPE;
840     }
841
842     /**
843      * Get the value of the editable zone in the MessageBox
844      * @return the value
845      */
846     @Override
847     public String[] getValue() {
848         if (scilabDialogType == X_MDIALOG_TYPE) {
849             return userValues;
850         } else {
851             return userValue.split(NEW_LINE);
852         }
853     }
854
855     /**
856      * Get the size of the value of the editable zone in the MessageBox
857      * @return the value size
858      */
859     @Override
860     public int getValueSize() {
861         if (userValue == null) {
862             return 0;
863         } else {
864             return userValue.split(NEW_LINE).length;
865         }
866     }
867
868     /**
869      * Set the items of the listbox in the MessageBox
870      * @param items the items to set
871      */
872     @Override
873     public void setListBoxItems(String[] items) {
874         listboxItems = items;
875
876         scilabDialogType = X_CHOOSE_TYPE;
877     }
878
879     /**
880      * Get the index of the selected item in the listbox in the MessageBox
881      * @return the index
882      */
883     @Override
884     public int getSelectedItem() {
885         return selectedItem;
886     }
887
888     /**
889      * Create the listbox to be displayed in a x_choose dialog
890      * @return the scrollpane containing the listbox
891      */
892     private JScrollPane createXchooseListBox() {
893         // Add the ListBox
894         listBox = new JList();
895         listBox.setLayoutOrientation(JList.VERTICAL);
896         listBox.setModel(new DefaultListModel());
897         listBox.addMouseListener(new MouseListener() {
898
899             @Override
900             public void mouseClicked(MouseEvent arg0) {
901                 if (arg0.getClickCount() == 2) {
902                     selectedItem = listBox.getSelectedIndex() + 1;
903                     // Notify btnOK for not modal Dialogs
904                     synchronized (btnOK) {
905                         btnOK.notify();
906                     }
907                     dispose();
908                 }
909             }
910
911             @Override
912             public void mouseEntered(MouseEvent arg0) {
913             }
914
915             @Override
916             public void mouseExited(MouseEvent arg0) {
917             }
918
919             @Override
920             public void mousePressed(MouseEvent arg0) {
921             }
922
923             @Override
924             public void mouseReleased(MouseEvent arg0) {
925             }
926
927         });
928         ((DefaultListModel) listBox.getModel()).clear();
929         for (int i = 0; i < listboxItems.length; i++) {
930             ((DefaultListModel) listBox.getModel()).addElement(listboxItems[i]);
931         }
932         listBox.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
933         JScrollPane scrollPane = new JScrollPane(listBox);
934         return  scrollPane;
935     }
936
937     /**
938      * Set the name of the lines labels in the editable zone in the MessageBox
939      * @param labels the labels
940      */
941     @Override
942     public void setLineLabels(String[] labels) {
943         scilabDialogType = X_MDIALOG_TYPE;
944         lineLabels = labels;
945     }
946
947     /**
948      * Set the name of the columns labels in the editable zone in the MessageBox
949      * @param labels the labels
950      */
951     @Override
952     public void setColumnLabels(String[] labels) {
953         columnLabels = labels;
954     }
955
956     /**
957      * Set the default values of a multi-value editable zone in the MessageBox
958      * @param values the values
959      */
960     @Override
961     public void setDefaultInput(String[] values) {
962         defaultInput = values;
963     }
964
965     /**
966      * Set a MessageBox modal or not
967      * @param status true to set the MessageBox modal and false else
968      */
969     @Override
970     public void setModal(boolean status) {
971         modal = status;
972     }
973
974
975     /**
976      * Set the MessageBox icon
977      * @param name the name of the icon
978      */
979     @Override
980     public void setIcon(String name) {
981         if (name.equals("error")) {
982             messageType = JOptionPane.ERROR_MESSAGE;
983         } else if (name.equals("hourglass")) {
984             messageIcon = hourglassIcon;
985         } else if (name.equals("info")) {
986             messageType = JOptionPane.INFORMATION_MESSAGE;
987         } else if (name.equals("passwd")) {
988             messageIcon = passwdIcon;
989         } else if (name.equals("question")) {
990             messageType = JOptionPane.QUESTION_MESSAGE;
991         } else if (name.equals("warning")) {
992             messageType = JOptionPane.WARNING_MESSAGE;
993         } else {
994             messageIcon = scilabIcon;
995         }
996     }
997
998     private boolean isWindows() {
999         return System.getProperty("os.name").toLowerCase().contains("windows");
1000     }
1001
1002     /**
1003      * Set the component used to set the location of the MessageBox (default is Scilab Console)
1004      * @param parent the parent
1005      */
1006     public void setParentForLocation(SimpleTab parent) {
1007         if (parent != null) {
1008             parentWindow = (Component) parent;
1009         } else {
1010             parentWindow = null;
1011         }
1012     }
1013
1014     /**
1015      * Set the component used to set the location of the MessageBox (default is Scilab Console)
1016      * @param parent
1017      */
1018     public void setParentForLocation(Component parent) {
1019         parentWindow = parent;
1020     }
1021
1022     /**
1023      * Set the component used to set the location of the MessageBox (default is Scilab Console)
1024      * @param parent
1025      */
1026     public void setParentForLocation(Tab parent) {
1027         setParentForLocation((Component) parent.getAsSimpleTab());
1028     }
1029 }