Fix table uicontrols.
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / bridge / uitable / SwingScilabUiTable.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - Han DONG
4  * Copyright (C) 2011 - DIGITEO - Vincent COUVERT
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.1-en.txt
11  *
12  */
13 package org.scilab.modules.gui.bridge.uitable;
14
15 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_STRING_COLNB__;
16 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_STRING__;
17
18 import java.awt.Color;
19 import java.awt.Font;
20
21 import javax.swing.JLabel;
22 import javax.swing.JList;
23 import javax.swing.JScrollPane;
24 import javax.swing.JTable;
25 import javax.swing.UIManager;
26 import javax.swing.border.Border;
27
28 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
29 import org.scilab.modules.gui.SwingViewObject;
30 import org.scilab.modules.gui.SwingViewWidget;
31 import org.scilab.modules.gui.events.callback.CommonCallBack;
32 import org.scilab.modules.gui.menubar.MenuBar;
33 import org.scilab.modules.gui.textbox.TextBox;
34 import org.scilab.modules.gui.toolbar.ToolBar;
35 import org.scilab.modules.gui.uitable.SimpleUiTable;
36 import org.scilab.modules.gui.utils.Position;
37 import org.scilab.modules.gui.utils.PositionConverter;
38 import org.scilab.modules.gui.utils.ScilabAlignment;
39 import org.scilab.modules.gui.utils.ScilabRelief;
40 import org.scilab.modules.gui.utils.ScilabSwingUtilities;
41 import org.scilab.modules.gui.utils.Size;
42
43 /**
44  * Swing implementation for Scilab UiTable in GUIs
45  * @author Han DONG
46  */
47 public class SwingScilabUiTable extends JScrollPane implements SwingViewObject, SimpleUiTable {
48
49     private static final long serialVersionUID = -5497171010652701217L;
50
51     private Integer uid;
52
53     private Border defaultBorder = null;
54
55     private JTable uiTable;
56     private JList rowHeader;
57
58     private Object[] colNames = {};
59     private Object[] rowNames = {};
60     private Object[][] data = {};
61
62     private int nCol;
63     private int nRow;
64
65     private JLabel label;
66
67     /**
68      * Constructor
69      */
70     public SwingScilabUiTable() {
71         super();
72         getViewport().add(getUiTable());
73         setRowHeaderView(getCustomRowHeader());
74     }
75
76     /**
77      * Apply a new font for the uiTable.
78      * @param font new font to use.
79      */
80     public void setFont(Font font) {
81         getLabel().setFont(font);
82     }
83
84     /**
85      * To get the Font of the element.
86      * @return font the Font
87      */
88     public Font getFont() {
89         return getLabel().getFont();
90     }
91
92     /**
93      * To get the Foreground color of the element.
94      * @return color the Color
95      */
96     public Color getForeground() {
97         return getLabel().getForeground();
98     }
99
100     /**
101      * To set the Foreground color of the element.
102      * @param color the Color
103      */
104     public void setForeground(Color color) {
105         getLabel().setForeground(color);
106     }
107
108     /**
109      * To set the Background color of the element.
110      * @param color the Color
111      */
112     public void setBackground(Color color) {
113         getLabel().setBackground(color);
114     }
115
116     /**
117      * To get the Background color of the element.
118      * @return color the Color
119      */
120     public Color getBackground() {
121         return getLabel().getBackground();
122     }
123
124     /**
125      * Draws a swing Scilab PushButton
126      * @see org.scilab.modules.gui.uielement.UIElement#draw()
127      */
128     public void draw() {
129         this.setVisible(true);
130         this.doLayout();
131     }
132
133     /**
134      * Sets the visibility status of an UIElement
135      * @param newVisibleState the visibility status we want to set for the
136      * UIElement (true if the UIElement is visible, false if not)
137      */
138     public void setVisible(boolean newVisibleState) {
139         super.setVisible(newVisibleState);
140         //getLabel().setVisible(newVisibleState);
141     }
142
143     /**
144      * Gets the dimensions (width and height) of a swing Scilab element
145      * @return the dimensions of the element
146      * @see org.scilab.modules.gui.uielement.UIElement#getDims()
147      */
148     public Size getDims() {
149         return new Size(getWidth(), getHeight());
150     }
151
152     /**
153      * Gets the position (X-coordinate and Y-coordinate) of a swing Scilab
154      * element
155      * @return the position of the element
156      * @see org.scilab.modules.gui.uielement.UIElement#getPosition()
157      */
158     public Position getPosition() {
159         return PositionConverter.javaToScilab(getLocation(), getSize(), getParent());
160     }
161
162     /**
163      * Sets the dimensions (width and height) of a swing Scilab element
164      * @param newSize the dimensions to set to the element
165      * @see org.scilab.modules.gui.uielement.UIElement#setDims(org.scilab.modules.gui.utils.Size)
166      */
167     public void setDims(Size newSize) {
168         setSize(newSize.getWidth(), newSize.getHeight());
169     }
170
171     /**
172      * Sets the position (X-coordinate and Y-coordinate) of a swing Scilab
173      * element
174      * @param newPosition the position to set to the element
175      * @see org.scilab.modules.gui.uielement.UIElement#setPosition(org.scilab.modules.gui.utils.Position)
176      */
177     public void setPosition(Position newPosition) {
178         Position javaPosition = PositionConverter.scilabToJava(newPosition, getDims(), getParent());
179         setLocation(javaPosition.getX(), javaPosition.getY());
180     }
181
182     /**
183      * Add a callback to the UiTable
184      * @param callback the callback to set.
185      */
186     public void setCallback(CommonCallBack callback) {
187         // Nothing to do...
188     }
189
190     /**
191      * Setter for MenuBar
192      * @param menuBarToAdd the MenuBar associated to the UiTable.
193      */
194     public void addMenuBar(MenuBar menuBarToAdd) {
195         /* Unimplemented for UiTables */
196         throw new UnsupportedOperationException();
197     }
198
199     /**
200      * Setter for ToolBar
201      * @param toolBarToAdd the ToolBar associated to the UiTable.
202      */
203     public void addToolBar(ToolBar toolBarToAdd) {
204         /* Unimplemented for UiTables */
205         throw new UnsupportedOperationException();
206     }
207
208     /**
209      * Getter for MenuBar
210      * @return MenuBar: the MenuBar associated to the UiTable.
211      */
212     public MenuBar getMenuBar() {
213         /* Unimplemented for UiTables */
214         throw new UnsupportedOperationException();
215     }
216
217     /**
218      * Getter for ToolBar
219      * @return ToolBar: the ToolBar associated to the UiTable.
220      */
221     public ToolBar getToolBar() {
222         /* Unimplemented for UiTables */
223         throw new UnsupportedOperationException();
224     }
225
226     /**
227      * Set the horizontal alignment for the UiTable text
228      * @param alignment the value for the alignment (See ScilabAlignment.java)
229      */
230     public void setHorizontalAlignment(String alignment) {
231         getLabel().setHorizontalAlignment(ScilabAlignment.toSwingAlignment(alignment));
232     }
233
234     /**
235      * Set the vertical alignment for the UiTable text
236      * @param alignment the value for the alignment (See ScilabAlignment.java)
237      */
238     public void setVerticalAlignment(String alignment) {
239         getLabel().setVerticalAlignment(ScilabAlignment.toSwingAlignment(alignment));
240     }
241
242     /**
243      * Set the Relief of the UiTable
244      * @param reliefType the type of the relief to set (See ScilabRelief.java)
245      */
246     public void setRelief(String reliefType) {
247         if (defaultBorder == null) {
248             defaultBorder = getBorder();
249         }
250         setBorder(ScilabRelief.getBorderFromRelief(reliefType, defaultBorder));
251     }
252
253     /**
254      * Destroy the UiTable
255      */
256     public void destroy() {
257         ScilabSwingUtilities.removeFromParent(this);
258     }
259
260     /**
261      * Setter for InfoBar
262      * @param infoBarToAdd the InfoBar associated to the UiTable.
263      */
264     public void addInfoBar(TextBox infoBarToAdd) {
265         /* Unimplemented for UiTables */
266         throw new UnsupportedOperationException();
267     }
268
269     /**
270      * Getter for InfoBar
271      * @return the InfoBar associated to the UiTable.
272      */
273     public TextBox getInfoBar() {
274         /* Unimplemented for UiTables */
275         throw new UnsupportedOperationException();
276     }
277
278     /**
279      * Create/Return the uiTable Java object
280      * @return the uiTable
281      */
282     private JTable getUiTable() {
283         if (uiTable == null) {
284             uiTable = new JTable(data, colNames);
285             uiTable.setFillsViewportHeight(true);
286             if (uiTable.getGridColor().equals(Color.WHITE)) {
287                 uiTable.setGridColor(new Color(128, 128, 128));
288             }
289             uiTable.setShowHorizontalLines(true);
290             uiTable.setShowVerticalLines(true);
291         }
292         return uiTable;
293     }
294
295     /**
296      * Create/Return the rowHeader Java Object
297      * @return the rowHeader
298      */
299     private JList getCustomRowHeader() {
300         if (rowHeader == null) {
301             rowHeader = new JList(rowNames);
302             rowHeader.setFixedCellWidth(50);
303             rowHeader.setFixedCellHeight(uiTable.getRowHeight());
304             rowHeader.setCellRenderer(new RowHeaderRenderer(uiTable));
305         }
306         return rowHeader;
307     }
308
309     /**
310      * Create/Return the uiTable Java object
311      * @return the uiTable
312      */
313     private JLabel getLabel() {
314         if (label == null) {
315             label = new JLabel();
316         }
317         return label;
318     }
319
320     /**
321      * gets directory of image in image render
322      * @return the directory string
323      * @see org.scilab.modules.gui.text.SimpleText#getText()
324      */
325     public String getText() {
326         return getLabel().getText();
327     }
328
329     /**
330      * Sets the directory for image to render
331      * @param newText the new directory to image
332      */
333     public void setText(String newText) {
334         getLabel().setText(newText);
335     }
336
337     public void setEmptyText() {
338         setColumnNames(new String[] {""});
339         setRowNames(new String[] {""});
340         setData(new String[] {""});
341     }
342
343     /**
344      * Sets the column names for uitable
345      * @param names the String[] that contains column names
346      */
347     public void setColumnNames(String[] names) {
348         //updates table with new column names
349         nCol = names.length;
350         colNames = names;
351         uiTable = new JTable(data, names);
352         getViewport().add(uiTable);
353         uiTable.doLayout();
354     }
355
356     /**
357      * Sets the row names for uitable
358      * @param names the String[] that contains row names
359      */
360     public void setRowNames(String[] names) {
361         //updates table with new row names
362         nRow = names.length;
363         rowNames = names;
364         rowHeader = new JList(names);
365         rowHeader.setFixedCellWidth(50);
366         rowHeader.setFixedCellHeight(uiTable.getRowHeight());
367         rowHeader.setCellRenderer(new RowHeaderRenderer(uiTable));
368         setRowHeaderView(rowHeader);
369         uiTable.doLayout();
370     }
371
372     /**
373      * Sets the Data for uitable
374      * @param text the String that contains row data delimited by a '|' and
375      * column data delimited by " ". Example: 1.26 3.47 | a b | d e | a b
376      */
377     public void setData(String[] text) {
378         //initializes data structure with number of rows and columns
379         if (nRow == 0) {
380             nRow = text.length / nCol;
381         }
382         data = new Object[nRow][nCol];
383         int i = 0;
384         int j = 0;
385         int nbElements = 0;
386
387         while (nbElements < text.length && i < nRow && j < nCol) {
388             data[i][j] = text[nbElements];
389             i++;
390             nbElements++;
391             if (i == nRow) {
392                 i = 0;
393                 j++;
394             }
395         }
396
397         //if no row names were provided, it will set numeric ones according to number of rows. (1, 2, 3, 4, ...)
398         if (nRow == 0) {
399             nRow = j;
400             rowNames = new Object[nRow];
401             for (int k = 0; k < nRow; k++) {
402                 rowNames[k] = k;
403             }
404             rowHeader = new JList(rowNames);
405             rowHeader.setFixedCellWidth(50);
406             rowHeader.setFixedCellHeight(uiTable.getRowHeight());
407             rowHeader.setCellRenderer(new RowHeaderRenderer(uiTable));
408             setRowHeaderView(rowHeader);
409         }
410
411         //adds and updates table with new data
412         uiTable = new JTable(data, colNames);
413         getViewport().add(uiTable);
414         uiTable.doLayout();
415     }
416
417     /**
418      * Set the UID
419      * @param id the UID
420      */
421     public void setId(Integer id) {
422         uid = id;
423     }
424
425     /**
426      * Get the UID
427      * @return the UID
428      */
429     public Integer getId() {
430         return uid;
431     }
432
433     /**
434      * Generic update method
435      * @param property property name
436      * @param value property value
437      */
438     public void update(int property, Object value) {
439         GraphicController controller = GraphicController.getController();
440
441         switch (property) {
442             case __GO_UI_STRING__: {
443                 // Update column names
444                 String[] stringValue = (String[]) value;
445                 if (stringValue.length == 0) {
446                     setColumnNames(new String[] {""});
447                     setRowNames(new String[] {""});
448                     setData(new String[] {""});
449                     return;
450                 }
451                 int colNb = ((Integer) controller.getProperty(uid, __GO_UI_STRING_COLNB__));
452                 String[] colNames = new String[colNb - 1];
453                 for (int k = 1; k < colNb; k++) {
454                     colNames[k - 1] = stringValue[k * (stringValue.length / colNb)];
455                 }
456
457                 setColumnNames(colNames);
458
459                 // Update row names
460                 String[] rowNames = new String[stringValue.length / colNb - 1];
461                 for (int k = 1; k < stringValue.length / colNb; k++) {
462                     rowNames[k - 1] = stringValue[k];
463                 }
464
465                 setRowNames(rowNames);
466
467                 // Update data
468                 String[] tableData = new String[rowNames.length * colNames.length];
469                 int kData = 0;
470                 for (int kCol = 1; kCol <= colNames.length; kCol++) {
471                     for (int kRow = 1; kRow <= rowNames.length; kRow++) {
472                         tableData[kData++] = stringValue[kCol * (stringValue.length / colNb) + kRow];
473                     }
474                 }
475
476                 if (tableData.length != 0) {
477                     setData(tableData);
478                 }
479                 break;
480             }
481             default: {
482                 SwingViewWidget.update(this, property, value);
483             }
484         }
485     }
486
487     public void resetBackground() {
488         Color color = (Color) UIManager.getLookAndFeelDefaults().get("ScrollPane.background");
489         if (color != null) {
490             setBackground(color);
491         }
492     }
493
494     public void resetForeground() {
495         Color color = (Color)UIManager.getLookAndFeelDefaults().get("ScrollPane.foreground");
496         if (color != null) {
497             setForeground(color);
498         }
499     }
500 }