EditVar: start editvar in EDT
[scilab.git] / scilab / modules / ui_data / src / java / org / scilab / modules / ui_data / variableeditor / ScilabVariableEditor.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Allan SIMON
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12 package org.scilab.modules.ui_data.variableeditor;
13
14 import java.awt.Component;
15 import java.util.HashMap;
16 import java.util.Map;
17
18 import javax.swing.JTable;
19 import javax.swing.SwingUtilities;
20 import javax.swing.event.ChangeListener;
21
22 import org.scilab.modules.action_binding.InterpreterManagement;
23 import org.scilab.modules.gui.bridge.window.SwingScilabWindow;
24 import org.scilab.modules.gui.textbox.ScilabTextBox;
25 import org.scilab.modules.gui.textbox.TextBox;
26 import org.scilab.modules.localization.Messages;
27
28 /**
29  * Class ScilabVariableEditor
30  * Implements a ScilabWindow containing Variable Editor (JTable)
31  */
32 @SuppressWarnings(value = { "serial" })
33 public final class ScilabVariableEditor extends SwingScilabWindow implements VariableEditor {
34
35     private static Map<String, Component> map = new HashMap();
36
37     private static ScilabVariableEditor instance;
38
39     private static SwingScilabVariableEditor editorTab;
40     private static ScilabTabbedPane tabPane;
41
42     /**
43      * Constructor
44      * @param type the variable type
45      * @param data the JTable data.
46      * @param variableName the name in Scilab of the variable being edited.
47      */
48     private ScilabVariableEditor(String type, Object[][] data, String variableName) {
49         super();
50         editorTab = new SwingScilabVariableEditor(variableName, type, data);
51         tabPane = editorTab.getTabPane();
52         TextBox infobar = ScilabTextBox.createTextBox();
53         editorTab.addInfoBar(infobar);
54         addTab(editorTab);
55         map.put(variableName, tabPane.getSelectedComponent());
56     }
57
58     /**
59      * Close Variable Editor
60      */
61     public void close() {
62         SwingScilabWindow editvarWindow = SwingScilabWindow.allScilabWindows.get(editorTab.getParentWindowId());
63         ChangeListener[] cl = tabPane.getChangeListeners();
64         for (int i = 0; i < cl.length; i++) {
65             tabPane.removeChangeListener(cl[i]);
66         }
67         instance = null;
68         map.clear();
69         super.close();
70     }
71
72     /**
73      * Close the edition of the variable
74      * @param name the variable
75      */
76     public static void close(String name) {
77         map.remove(name);
78     }
79
80     /**
81      * Set data displayed in JTable
82      * @param name the variable name
83      * @param type the variable type
84      * @param data : data to be displayed in JTable
85      */
86     public void updateData(String name, String type, Object[][] data) {
87         if (map.containsKey(name)) {
88             editorTab.updateData(map.get(name), name, type, data);
89         } else {
90             editorTab.setData(name, type, data);
91             map.put(name, tabPane.getSelectedComponent());
92         }
93     }
94
95     /**
96      * Set data displayed in JTable
97      * @param name the variable name
98      * @param type the variable type
99      * @param data : data to be displayed in JTable
100      */
101     public void updateData(String name, String type, Object[][] data, double[] rowsIndex, double[] colsIndex) {
102         if (map.containsKey(name)) {
103             editorTab.updateData(map.get(name), name, type, data, rowsIndex, colsIndex);
104         }
105     }
106
107     /**
108      * Get the variable editor singleton
109      * @return the Variable Editor
110      */
111     public static ScilabVariableEditor getVariableEditor() {
112         return instance;
113     }
114
115     /**
116      * Get the variable editor singleton with specified data.
117      * @param type the variable type
118      * @param data : the data to fill the editor with
119      * @param variableName : the scilab name of the variable being edited.
120      * @return the Variable Editor
121      */
122     public static ScilabVariableEditor getVariableEditor(final String type, final Object[][] data, final String variableName) {
123         if (instance == null) {
124             try {
125                 SwingUtilities.invokeAndWait(new Runnable() {
126                         public void run() {
127                             instance = new ScilabVariableEditor(type, data, variableName);
128                             instance.setVisible(true);
129                         }
130                     });
131             } catch (Exception e) {
132                 System.err.println(e);
133             }
134         } else {
135             SwingUtilities.invokeLater(new Runnable() {
136                     public void run() {
137                         SwingScilabWindow window = (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, editorTab);
138                         window.setVisible(true);
139                         window.toFront();
140                         final JTable table = editorTab.getCurrentTable();
141                         int r = -1;
142                         int c = -1;
143
144                         if (table != null) {
145                             r = table.getSelectedRow();
146                             c = table.getSelectedColumn();
147                         }
148                         boolean b = map.containsKey(variableName);
149                         instance.updateData(variableName, type, data);
150                         if (b && r != -1 && c != -1) {
151                             table.setRowSelectionInterval(r, r);
152                             table.setColumnSelectionInterval(c, c);
153                         }
154                     }
155                 });
156         }
157
158         editorTab.setName(Messages.gettext("Variable Editor") + " - " + variableName + "  (" + type + ")");
159         return instance;
160     }
161
162     public static void refreshVariableEditor(final String type, final Object[][] data, double[] rowsIndex, double[] colsIndex, final String variableName) {
163         if (instance != null) {
164             instance.updateData(variableName, type, data, rowsIndex, colsIndex);
165         }
166     }
167
168     /**
169      * {@inheritDoc}
170      */
171     public String getVariablename() {
172         String title = tabPane.getScilabTitleAt(tabPane.getSelectedIndex());
173         return title.substring(SwingScilabVariableEditor.PREFIX.length());
174     }
175
176     /**
177      * {@inheritDoc}
178      */
179     public void setVariableName(String variableName) {
180         tabPane.setTitleAt(tabPane.getSelectedIndex(), SwingScilabVariableEditor.PREFIX + variableName);
181     }
182
183     /**
184      * {@inheritDoc}
185      */
186     public void setVisible(boolean status) {
187         super.setVisible(status);
188         editorTab.setVisible(status);
189     }
190
191     /**
192      * This method is called by the OSXAdapter class when the specific Mac
193      * OS X "About" menu is called. It is the only case where this method
194      * should be used
195      */
196     public void macosxAbout() {
197         InterpreterManagement.requestScilabExec("about()");
198     }
199
200     /**
201      * This method is called by the OSXAdapter class when the specific Mac
202      * OS X "Quit Scilab" menu is called. It is the only case where this method
203      * should be used
204      */
205     public boolean macosxQuit() {
206         InterpreterManagement.requestScilabExec("exit()");
207         return false;
208     }
209
210     /**
211      * This method is called by the OSXAdapter class when the specific Mac
212      * OS X "Preferences" menu is called. It is the only case where this method
213      * should be used
214      */
215     public void macosxPreferences() {
216         InterpreterManagement.requestScilabExec("preferences();");
217     }
218
219
220 }