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     /**
 338      * Sets the column names for uitable
 339      * @param names the String[] that contains column names
 340      */
 341     public void setColumnNames(String[] names) {
 342         //updates table with new column names
 343         nCol = names.length;
 344         colNames = names;
 345         uiTable = new JTable(data, names);
 346         getViewport().add(uiTable);
 347         uiTable.doLayout();
 348     }
 349
 350     /**
 351      * Sets the row names for uitable
 352      * @param names the String[] that contains row names
 353      */
 354     public void setRowNames(String[] names) {
 355         //updates table with new row names
 356         nRow = names.length;
 357         rowNames = names;
 358         rowHeader = new JList(names);
 359         rowHeader.setFixedCellWidth(50);
 360         rowHeader.setFixedCellHeight(uiTable.getRowHeight());
 361         rowHeader.setCellRenderer(new RowHeaderRenderer(uiTable));
 362         setRowHeaderView(rowHeader);
 363         uiTable.doLayout();
 364     }
 365
 366     /**
 367      * Sets the Data for uitable
 368      * @param text the String that contains row data delimited by a '|' and
 369      * column data delimited by " ". Example: 1.26 3.47 | a b | d e | a b
 370      */
 371     public void setData(String[] text) {
 372         //initializes data structure with number of rows and columns
 373         if (nRow == 0) {
 374             nRow = text.length / nCol;
 375         }
 376         data = new Object[nRow][nCol];
 377         int i = 0;
 378         int j = 0;
 379         int nbElements = 0;
 380
 381         while (nbElements < text.length && i < nRow && j < nCol) {
 382             data[i][j] = text[nbElements];
 383             i++;
 384             nbElements++;
 385             if (i == nRow) {
 386                 i = 0;
 387                 j++;
 388             }
 389         }
 390
 391         //if no row names were provided, it will set numeric ones according to number of rows. (1, 2, 3, 4, ...)
 392         if (nRow == 0) {
 393             nRow = j;
 394             rowNames = new Object[nRow];
 395             for (int k = 0; k < nRow; k++) {
 396                 rowNames[k] = k;
 397             }
 398             rowHeader = new JList(rowNames);
 399             rowHeader.setFixedCellWidth(50);
 400             rowHeader.setFixedCellHeight(uiTable.getRowHeight());
 401             rowHeader.setCellRenderer(new RowHeaderRenderer(uiTable));
 402             setRowHeaderView(rowHeader);
 403         }
 404
 405         //adds and updates table with new data
 406         uiTable = new JTable(data, colNames);
 407         getViewport().add(uiTable);
 408         uiTable.doLayout();
 409     }
 410
 411     /**
 412      * Set the UID
 413      * @param id the UID
 414      */
 415     public void setId(Integer id) {
 416         uid = id;
 417     }
 418
 419     /**
 420      * Get the UID
 421      * @return the UID
 422      */
 423     public Integer getId() {
 424         return uid;
 425     }
 426
 427     /**
 428      * Generic update method
 429      * @param property property name
 430      * @param value property value
 431      */
 432     public void update(int property, Object value) {
 433         GraphicController controller = GraphicController.getController();
 434
 435         switch (property) {
 436             case __GO_UI_STRING__: {
 437                 // Update column names
 438                 String[] stringValue = (String[]) value;
 439                 int colNb = ((Integer) controller.getProperty(uid, __GO_UI_STRING_COLNB__));
 440                 String[] colNames = new String[colNb - 1];
 441                 for (int k = 1; k < colNb; k++) {
 442                     colNames[k - 1] = stringValue[k * (stringValue.length / colNb)];
 443                 }
 444
 445                 setColumnNames(colNames);
 446
 447                 // Update row names
 448                 String[] rowNames = new String[stringValue.length / colNb - 1];
 449                 for (int k = 1; k < stringValue.length / colNb; k++) {
 450                     rowNames[k - 1] = stringValue[k];
 451                 }
 452
 453                 setRowNames(rowNames);
 454
 455                 // Update data
 456                 String[] tableData = new String[rowNames.length * colNames.length];
 457                 int kData = 0;
 458                 for (int kCol = 1; kCol <= colNames.length; kCol++) {
 459                     for (int kRow = 1; kRow <= rowNames.length; kRow++) {
 460                         tableData[kData++] = stringValue[kCol * (stringValue.length / colNb) + kRow];
 461                     }
 462                 }
 463
 464                 if (tableData.length != 0) {
 465                     setData(tableData);
 466                 }
 467                 break;
 468             }
 469             default: {
 470                 SwingViewWidget.update(this, property, value);
 471             }
 472         }
 473     }
 474
 475     public void resetBackground() {
 476         Color color = (Color) UIManager.getLookAndFeelDefaults().get("ScrollPane.background");
 477         if (color != null) {
 478             setBackground(color);
 479         }
 480     }
 481
 482     public void resetForeground() {
 483         Color color = (Color)UIManager.getLookAndFeelDefaults().get("ScrollPane.foreground");
 484         if (color != null) {
 485             setForeground(color);
 486         }
 487     }
 488 }