Add a closeEditvar() function
[scilab.git] / scilab / modules / ui_data / src / java / org / scilab / modules / ui_data / EditVar.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Allan SIMON
4  * Copyright (C) 2010 - Calixte DENIZET
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13 package org.scilab.modules.ui_data;
14
15 import org.scilab.modules.ui_data.variableeditor.ScilabVariableEditor;
16 import org.scilab.modules.ui_data.variableeditor.VariableEditor;
17
18 /**
19  * Static class to open/close Scilab Variable Editor
20  * @author Allan SIMON
21  * @author Calixte DENIZET
22  */
23 public final class EditVar {
24
25     /**
26      * Integer type
27      */
28     public static final String INTEGER = "Integer";
29
30     /**
31      * Double type
32      */
33     public static final String DOUBLE = "Double";
34
35     /**
36      * Boolean sparse type
37      */
38     public static final String BOOLEANSPARSE = "Boolean Sparse";
39
40     /**
41      * Sparse type
42      */
43     public static final String SPARSE = "Sparse";
44
45     /**
46      * Complex sparse type
47      */
48     public static final String COMPLEXSPARSE = "Complex Sparse";
49
50     /**
51      * Complex type
52      */
53     public static final String COMPLEX = "Complex";
54
55     /**
56      * String type
57      */
58     public static final String STRING = "String";
59
60     /**
61      * Boolean type
62      */
63     public static final String BOOLEAN = "Boolean";
64
65     /**
66      * Default private constructor for utility class
67      */
68     private EditVar() { }
69
70     /**
71      * Open Variable editor
72      */
73     public static void openVariableEditor() { }
74
75     /**
76      * Open variable Editor with information given by Scilab
77      * @param data : scilab double matrix
78      * @param variableName : name of the variable being edited.
79      */
80     public static void openVariableEditorDouble(double[][] data, String variableName) {
81         int c = data.length == 0 ? 0 : data[0].length;
82         Double[][] dataDouble = new Double[data.length][c];
83         for (int i = 0; i < data.length; i++) {
84             for (int j = 0; j < c; j++) {
85                 dataDouble[i][j] = data[i][j];
86             }
87         }
88         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(DOUBLE, dataDouble, variableName);
89     }
90
91     /**
92      * Open variable Editor with information given by Scilab
93      * @param data : scilab double matrix
94      * @param variableName : name of the variable being edited.
95      */
96     public static void openVariableEditorBooleanSparse(int[][] data, String variableName) {
97         int c = data.length == 0 ? 0 : data[0].length;
98         Boolean[][] dataBool = new Boolean[data.length][c];
99         for (int i = 0; i < data.length; i++) {
100             for (int j = 0; j < c; j++) {
101                 dataBool[i][j] = data[i][j] == 1;
102             }
103         }
104         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(BOOLEANSPARSE, dataBool, variableName);
105     }
106
107     /**
108      * Open variable Editor with information given by Scilab
109      * @param data : scilab double matrix
110      * @param variableName : name of the variable being edited.
111      */
112     public static void openVariableEditorSparse(double[][] data, String variableName) {
113         int c = data.length == 0 ? 0 : data[0].length;
114         Double[][] dataDouble = new Double[data.length][c];
115         for (int i = 0; i < data.length; i++) {
116             for (int j = 0; j < c; j++) {
117                 dataDouble[i][j] = data[i][j];
118             }
119         }
120         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(SPARSE, dataDouble, variableName);
121     }
122
123     /**
124      * Open variable Editor with information given by Scilab
125      * @param data : scilab double matrix
126      * @param variableName : name of the variable being edited.
127      */
128     public static void openVariableEditorComplexSparse(double[][] realData, double[][] complexData, String variableName) {
129         int c = realData.length == 0 ? 0 : realData[0].length;
130         Double[][][] dataDoubleComplex = new Double[realData.length][c][2];
131         for (int i = 0; i < realData.length; i++) {
132             for (int j = 0; j < c; j++) {
133                 dataDoubleComplex[i][j][0] = realData[i][j];
134                 dataDoubleComplex[i][j][1] = complexData[i][j];
135             }
136         }
137         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(COMPLEXSPARSE, dataDoubleComplex, variableName);
138     }
139
140     /**
141      * Open variable Editor with information given by Scilab
142      * @param data : scilab double matrix
143      * @param variableName : name of the variable being edited.
144      */
145     public static void openVariableEditorInteger8(byte[][] data, String variableName) {
146         int c = data.length == 0 ? 0 : data[0].length;
147         Byte[][] dataInteger = new Byte[data.length][c];
148         for (int i = 0; i < data.length; i++) {
149             for (int j = 0; j < c; j++) {
150                 dataInteger[i][j] = data[i][j];
151             }
152         }
153         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(INTEGER, dataInteger, variableName);
154     }
155
156     /**
157      * Open variable Editor with information given by Scilab
158      * @param data : scilab double matrix
159      * @param variableName : name of the variable being edited.
160      */
161     public static void openVariableEditorUInteger8(short[][] data, String variableName) {
162         int c = data.length == 0 ? 0 : data[0].length;
163         Short[][] dataInteger = new Short[data.length][c];
164         for (int i = 0; i < data.length; i++) {
165             for (int j = 0; j < c; j++) {
166                 dataInteger[i][j] = data[i][j];
167             }
168         }
169         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(INTEGER, dataInteger, variableName);
170     }
171
172     /**
173      * Open variable Editor with information given by Scilab
174      * @param data : scilab double matrix
175      * @param variableName : name of the variable being edited.
176      */
177     public static void openVariableEditorInteger16(short[][] data, String variableName) {
178         int c = data.length == 0 ? 0 : data[0].length;
179         Short[][] dataInteger = new Short[data.length][c];
180         for (int i = 0; i < data.length; i++) {
181             for (int j = 0; j < c; j++) {
182                 dataInteger[i][j] = data[i][j];
183             }
184         }
185         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(INTEGER, dataInteger, variableName);
186     }
187
188     /**
189      * Open variable Editor with information given by Scilab
190      * @param data : scilab double matrix
191      * @param variableName : name of the variable being edited.
192      */
193     public static void openVariableEditorUInteger16(int[][] data, String variableName) {
194         int c = data.length == 0 ? 0 : data[0].length;
195         Integer[][] dataInteger = new Integer[data.length][c];
196         for (int i = 0; i < data.length; i++) {
197             for (int j = 0; j < c; j++) {
198                 dataInteger[i][j] = data[i][j];
199             }
200         }
201         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(INTEGER, dataInteger, variableName);
202     }
203
204     /**
205      * Open variable Editor with information given by Scilab
206      * @param data : scilab double matrix
207      * @param variableName : name of the variable being edited.
208      */
209     public static void openVariableEditorInteger32(int[][] data, String variableName) {
210         int c = data.length == 0 ? 0 : data[0].length;
211         Integer[][] dataInteger = new Integer[data.length][c];
212         for (int i = 0; i < data.length; i++) {
213             for (int j = 0; j < c; j++) {
214                 dataInteger[i][j] = data[i][j];
215             }
216         }
217         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(INTEGER, dataInteger, variableName);
218     }
219
220     /**
221      * Open variable Editor with information given by Scilab
222      * @param data : scilab double matrix
223      * @param variableName : name of the variable being edited.
224      */
225     public static void openVariableEditorUInteger32(long[][] data, String variableName) {
226         int c = data.length == 0 ? 0 : data[0].length;
227         Long[][] dataInteger = new Long[data.length][c];
228         for (int i = 0; i < data.length; i++) {
229             for (int j = 0; j < c; j++) {
230                 dataInteger[i][j] = data[i][j];
231             }
232         }
233         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(INTEGER, dataInteger, variableName);
234     }
235
236     /**
237      * Open variable Editor with information given by Scilab
238      * @param data : scilab double matrix
239      * @param variableName : name of the variable being edited.
240      */
241     public static void openVariableEditorString(String[][] data, String variableName) {
242         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(STRING, data, variableName);
243     }
244
245     /**
246      * Open variable Editor with information given by Scilab
247      * @param realData : real part of scilab double matrix
248      * @param complexData : complex part of scilab double matrix
249      * @param variableName : name of the variable being edited.
250      */
251     public static void openVariableEditorComplex(double[][] realData, double[][] complexData, String variableName) {
252         int c = realData.length == 0 ? 0 : realData[0].length;
253         Double[][][] dataDoubleComplex = new Double[realData.length][c][2];
254         for (int i = 0; i < realData.length; i++) {
255             for (int j = 0; j < c; j++) {
256                 dataDoubleComplex[i][j][0] = realData[i][j];
257                 dataDoubleComplex[i][j][1] = complexData[i][j];
258             }
259         }
260         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(COMPLEX, dataDoubleComplex, variableName);
261     }
262
263     /**
264      * Open variable Editor with information given by Scilab
265      * @param data : scilab double matrix
266      * @param variableName : name of the variable being edited.
267      */
268     public static void openVariableEditorBoolean(int[][] data, String variableName) {
269         int c = data.length == 0 ? 0 : data[0].length;
270         Boolean[][] dataBool = new Boolean[data.length][c];
271         for (int i = 0; i < data.length; i++) {
272             for (int j = 0; j < c; j++) {
273                 dataBool[i][j] = data[i][j] == 1;
274             }
275         }
276         VariableEditor editvar = ScilabVariableEditor.getVariableEditor(BOOLEAN, dataBool, variableName);
277     }
278
279     /**
280      * Open variable Editor with information given by Scilab
281      * @param data : scilab double matrix
282      * @param variableName : name of the variable being edited.
283      */
284     public static void refreshVariableEditorDouble(double[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
285         int c = data.length == 0 ? 0 : data[0].length;
286         Double[][] dataDouble = new Double[data.length][c];
287         for (int i = 0; i < data.length; i++) {
288             for (int j = 0; j < c; j++) {
289                 dataDouble[i][j] = data[i][j];
290             }
291         }
292         ScilabVariableEditor.refreshVariableEditor(DOUBLE, dataDouble, rowsIndex, colsIndex, variableName);
293     }
294
295     /**
296      * Open variable Editor with information given by Scilab
297      * @param data : scilab double matrix
298      * @param variableName : name of the variable being edited.
299      */
300     public static void refreshVariableEditorBooleanSparse(int[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
301         int c = data.length == 0 ? 0 : data[0].length;
302         Boolean[][] dataBool = new Boolean[data.length][c];
303         for (int i = 0; i < data.length; i++) {
304             for (int j = 0; j < c; j++) {
305                 dataBool[i][j] = data[i][j] == 1;
306             }
307         }
308         ScilabVariableEditor.refreshVariableEditor(BOOLEANSPARSE, dataBool, rowsIndex, colsIndex, variableName);
309     }
310
311     /**
312      * Open variable Editor with information given by Scilab
313      * @param data : scilab double matrix
314      * @param variableName : name of the variable being edited.
315      */
316     public static void refreshVariableEditorSparse(double[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
317         int c = data.length == 0 ? 0 : data[0].length;
318         Double[][] dataDouble = new Double[data.length][c];
319         for (int i = 0; i < data.length; i++) {
320             for (int j = 0; j < c; j++) {
321                 dataDouble[i][j] = data[i][j];
322             }
323         }
324         ScilabVariableEditor.refreshVariableEditor(SPARSE, dataDouble, rowsIndex, colsIndex, variableName);
325     }
326
327     /**
328      * Open variable Editor with information given by Scilab
329      * @param realData : real part of scilab double matrix
330      * @param complexData : complex part of scilab double matrix
331      * @param variableName : name of the variable being edited.
332      */
333     public static void refreshVariableEditorComplexSparse(double[][] realData, double[][] complexData, double[] rowsIndex, double[] colsIndex, String variableName) {
334         int c = realData.length == 0 ? 0 : realData[0].length;
335         Double[][][] dataDoubleComplex = new Double[realData.length][c][2];
336         for (int i = 0; i < realData.length; i++) {
337             for (int j = 0; j < c; j++) {
338                 dataDoubleComplex[i][j][0] = realData[i][j];
339                 dataDoubleComplex[i][j][1] = complexData[i][j];
340             }
341         }
342         ScilabVariableEditor.refreshVariableEditor(COMPLEXSPARSE, dataDoubleComplex, rowsIndex, colsIndex, variableName);
343     }
344
345     /**
346      * Open variable Editor with information given by Scilab
347      * @param data : scilab double matrix
348      * @param variableName : name of the variable being edited.
349      */
350     public static void refreshVariableEditorInteger8(byte[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
351         int c = data.length == 0 ? 0 : data[0].length;
352         Byte[][] dataInteger = new Byte[data.length][c];
353         for (int i = 0; i < data.length; i++) {
354             for (int j = 0; j < c; j++) {
355                 dataInteger[i][j] = data[i][j];
356             }
357         }
358         ScilabVariableEditor.refreshVariableEditor(INTEGER, dataInteger, rowsIndex, colsIndex, variableName);
359     }
360
361     /**
362      * Open variable Editor with information given by Scilab
363      * @param data : scilab double matrix
364      * @param variableName : name of the variable being edited.
365      */
366     public static void refreshVariableEditorUInteger8(short[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
367         int c = data.length == 0 ? 0 : data[0].length;
368         Short[][] dataInteger = new Short[data.length][c];
369         for (int i = 0; i < data.length; i++) {
370             for (int j = 0; j < c; j++) {
371                 dataInteger[i][j] = data[i][j];
372             }
373         }
374         ScilabVariableEditor.refreshVariableEditor(INTEGER, dataInteger, rowsIndex, colsIndex, variableName);
375     }
376
377     /**
378      * Open variable Editor with information given by Scilab
379      * @param data : scilab double matrix
380      * @param variableName : name of the variable being edited.
381      */
382     public static void refreshVariableEditorInteger16(short[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
383         int c = data.length == 0 ? 0 : data[0].length;
384         Short[][] dataInteger = new Short[data.length][c];
385         for (int i = 0; i < data.length; i++) {
386             for (int j = 0; j < c; j++) {
387                 dataInteger[i][j] = data[i][j];
388             }
389         }
390         ScilabVariableEditor.refreshVariableEditor(INTEGER, dataInteger, rowsIndex, colsIndex, variableName);
391     }
392
393     /**
394      * Open variable Editor with information given by Scilab
395      * @param data : scilab double matrix
396      * @param variableName : name of the variable being edited.
397      */
398     public static void refreshVariableEditorUInteger16(int[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
399         int c = data.length == 0 ? 0 : data[0].length;
400         Integer[][] dataInteger = new Integer[data.length][c];
401         for (int i = 0; i < data.length; i++) {
402             for (int j = 0; j < c; j++) {
403                 dataInteger[i][j] = data[i][j];
404             }
405         }
406         ScilabVariableEditor.refreshVariableEditor(INTEGER, dataInteger, rowsIndex, colsIndex, variableName);
407     }
408
409     /**
410      * Open variable Editor with information given by Scilab
411      * @param data : scilab double matrix
412      * @param variableName : name of the variable being edited.
413      */
414     public static void refreshVariableEditorInteger32(int[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
415         int c = data.length == 0 ? 0 : data[0].length;
416         Integer[][] dataInteger = new Integer[data.length][c];
417         for (int i = 0; i < data.length; i++) {
418             for (int j = 0; j < c; j++) {
419                 dataInteger[i][j] = data[i][j];
420             }
421         }
422         ScilabVariableEditor.refreshVariableEditor(INTEGER, dataInteger, rowsIndex, colsIndex, variableName);
423     }
424
425     /**
426      * Open variable Editor with information given by Scilab
427      * @param data : scilab double matrix
428      * @param variableName : name of the variable being edited.
429      */
430     public static void refreshVariableEditorUInteger32(long[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
431         int c = data.length == 0 ? 0 : data[0].length;
432         Long[][] dataInteger = new Long[data.length][c];
433         for (int i = 0; i < data.length; i++) {
434             for (int j = 0; j < c; j++) {
435                 dataInteger[i][j] = data[i][j];
436             }
437         }
438         ScilabVariableEditor.refreshVariableEditor(INTEGER, dataInteger, rowsIndex, colsIndex, variableName);
439     }
440
441     /**
442      * Open variable Editor with information given by Scilab
443      * @param data : scilab double matrix
444      * @param variableName : name of the variable being edited.
445      */
446     public static void refreshVariableEditorString(String[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
447         ScilabVariableEditor.refreshVariableEditor(STRING, data, rowsIndex, colsIndex, variableName);
448     }
449
450     /**
451      * Open variable Editor with information given by Scilab
452      * @param realData : real part of scilab double matrix
453      * @param complexData : complex part of scilab double matrix
454      * @param variableName : name of the variable being edited.
455      */
456     public static void refreshVariableEditorComplex(double[][] realData, double[][] complexData, double[] rowsIndex, double[] colsIndex, String variableName) {
457         int c = realData.length == 0 ? 0 : realData[0].length;
458         Double[][][] dataDoubleComplex = new Double[realData.length][c][2];
459         for (int i = 0; i < realData.length; i++) {
460             for (int j = 0; j < c; j++) {
461                 dataDoubleComplex[i][j][0] = realData[i][j];
462                 dataDoubleComplex[i][j][1] = complexData[i][j];
463             }
464         }
465         ScilabVariableEditor.refreshVariableEditor(COMPLEX, dataDoubleComplex, rowsIndex, colsIndex, variableName);
466     }
467
468     /**
469      * Open variable Editor with information given by Scilab
470      * @param data : scilab double matrix
471      * @param variableName : name of the variable being edited.
472      */
473     public static void refreshVariableEditorBoolean(int[][] data, double[] rowsIndex, double[] colsIndex, String variableName) {
474         int c = data.length == 0 ? 0 : data[0].length;
475         Boolean[][] dataBool = new Boolean[data.length][c];
476         for (int i = 0; i < data.length; i++) {
477             for (int j = 0; j < c; j++) {
478                 dataBool[i][j] = data[i][j] == 1;
479             }
480         }
481         ScilabVariableEditor.refreshVariableEditor(BOOLEAN, dataBool, rowsIndex, colsIndex, variableName);
482     }
483
484     /**
485      * Close Variable Editor
486      */
487     public static void closeVariableEditor() {
488         ScilabVariableEditor.closeEditVar();
489     }
490 }