b735c83bf7619490832e887a5dbf2d8d58253053
[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             instance = new ScilabVariableEditor(type, data, variableName);
125             instance.setVisible(true);
126         } else {
127             SwingScilabWindow window = (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, editorTab);
128             window.setVisible(true);
129             window.toFront();
130             final JTable table = editorTab.getCurrentTable();
131             SwingUtilities.invokeLater(new Runnable() {
132                 public void run() {
133                     int r = -1;
134                     int c = -1;
135
136                     if (table != null) {
137                         r = table.getSelectedRow();
138                         c = table.getSelectedColumn();
139                     }
140                     boolean b = map.containsKey(variableName);
141                     instance.updateData(variableName, type, data);
142                     if (b && r != -1 && c != -1) {
143                         table.setRowSelectionInterval(r, r);
144                         table.setColumnSelectionInterval(c, c);
145                     }
146                 }
147             });
148         }
149
150         editorTab.setName(Messages.gettext("Variable Editor") + " - " + variableName + "  (" + type + ")");
151         return instance;
152     }
153
154     public static void refreshVariableEditor(final String type, final Object[][] data, double[] rowsIndex, double[] colsIndex, final String variableName) {
155         if (instance != null) {
156             instance.updateData(variableName, type, data, rowsIndex, colsIndex);
157         }
158     }
159
160     /**
161      * {@inheritDoc}
162      */
163     public String getVariablename() {
164         String title = tabPane.getScilabTitleAt(tabPane.getSelectedIndex());
165         return title.substring(SwingScilabVariableEditor.PREFIX.length());
166     }
167
168     /**
169      * {@inheritDoc}
170      */
171     public void setVariableName(String variableName) {
172         tabPane.setTitleAt(tabPane.getSelectedIndex(), SwingScilabVariableEditor.PREFIX + variableName);
173     }
174
175     /**
176      * {@inheritDoc}
177      */
178     public void setVisible(boolean status) {
179         super.setVisible(status);
180         editorTab.setVisible(status);
181     }
182
183     /**
184      * This method is called by the OSXAdapter class when the specific Mac
185      * OS X "About" menu is called. It is the only case where this method
186      * should be used
187      */
188     public void macosxAbout() {
189         InterpreterManagement.requestScilabExec("about()");
190     }
191
192     /**
193      * This method is called by the OSXAdapter class when the specific Mac
194      * OS X "Quit Scilab" menu is called. It is the only case where this method
195      * should be used
196      */
197     public boolean macosxQuit() {
198         InterpreterManagement.requestScilabExec("exit()");
199         return false;
200     }
201
202     /**
203      * This method is called by the OSXAdapter class when the specific Mac
204      * OS X "Preferences" menu is called. It is the only case where this method
205      * should be used
206      */
207     public void macosxPreferences() {
208         InterpreterManagement.requestScilabExec("preferences();");
209     }
210
211
212 }