Module org.controlsfx.controls
Package org.controlsfx.control.spreadsheet

Class GridBase

  • All Implemented Interfaces:
    EventTarget, Grid
    public class GridBase
extends Object
implements Grid, EventTarget
    A base implementation of the Grid interface.

    How to span

    First of all, the Grid must have all its rows filled with the same number of SpreadsheetCell. A span is materialized by the same cell (same instance of SpreadsheetCell) repeated all over the covered part. In order to materialize span, you have two ways :

    - First way is to manually add the same cell where you want to span. For example, we will make the first cell span on two columns : 

     //I create a sample grid
 int rowCount = 15;
     int columnCount = 10;
     GridBase grid = new GridBase(rowCount, columnCount);

     ObservableList<ObservableList<SpreadsheetCell>> rows = FXCollections.observableArrayList();
     for (int row = 0; row < grid.getRowCount(); ++row) {
         final ObservableList<SpreadsheetCell> list = FXCollections.observableArrayList();
         for (int column = 0; column < grid.getColumnCount(); ++column) {
             list.add(SpreadsheetCellType.STRING.createCell(row, column, 1, 1,"value"));
         }
         rows.add(list);
     }
      //I create my SpreadsheetCell spanning on two columns.
      SpreadsheetCell cell = SpreadsheetCellType.STRING.createCell(0, 0, 1, 2,"value");
      //I add them in the area covered by the span.
      rows.get(0).set(0, cell);
      rows.get(0).set(1, cell);
      grid.setRows(rows);

     SpreadsheetView spv = new SpreadsheetView(grid);
    - The second way is to build the SpreadsheetView, but to use the spanRow(int, int, int) or spanColumn(int, int, int) methods. These methods will take the SpreadsheetCell at the specified position, and enlarge the span by modifying the rowSpan or columnSpan of the cell. And also put the SpreadsheetCell in the area covered by the span. 
     //I create a sample grid
 int rowCount = 15;
     int columnCount = 10;
     GridBase grid = new GridBase(rowCount, columnCount);

     ObservableList<ObservableList<SpreadsheetCell>> rows = FXCollections.observableArrayList();
     for (int row = 0; row < grid.getRowCount(); ++row) {
         final ObservableList<SpreadsheetCell> list = FXCollections.observableArrayList();
         for (int column = 0; column < grid.getColumnCount(); ++column) {
             list.add(SpreadsheetCellType.STRING.createCell(row, column, 1, 1,"value"));
         }
         rows.add(list);
     }
      //I First set the rows in the grid.
      grid.setRows(rows);
      //Then I simply tell the grid to span the first cell
      grid.spanColumn(2,0,0);

     SpreadsheetView spv = new SpreadsheetView(grid);

    Row Height

    You can specify some row height for some of your rows at the beginning. You have to use the method setRowHeightCallback(javafx.util.Callback) in order to specify a Callback that will give you the index of the row, and you will give back the height of the row.
    If you just have a Map available, you can use the GridBase.MapBasedRowHeightFactory that will construct the Callback for you. The default height is 24.0.

    Cell values

    If you want to change the value of a cell, you have to go through the API with setCellValue(int, int, Object). This method will verify that the value is corresponding to the SpreadsheetCellType of the cell and try to convert it if possible. It will also fire a GridChange event in order to notify all listeners that a value has changed.

    If you want to listen to those changes, you can use the addEventHandler(EventType, EventHandler) and removeEventHandler(EventType, EventHandler) methods.
    A basic listener for implementing a undo/redo in the SpreadsheetView could be like that: 

     Grid grid = ...;
 Stack<GridChange> undoStack = ...;
 grid.addEventHandler(GridChange.GRID_CHANGE_EVENT, new EventHandler<GridChange>() {
         
         public void handle(GridChange change) {
                 undoStack.push(change);
             }
         });

    Display selection

    By default, the SpreadsheetView will display a black rectangle around your selection if it's contiguous. Some may want to disable that effect. Therefore a simple call to setDisplaySelection(boolean) with a false value will make that rectangle disappear.

    Headers

    The SpreadsheetView is displaying row numbers and column letters by default. Just like any other spreadsheet would do. However, some may want to customize theose headers. You can use the getColumnHeaders() and getRowHeaders() in order to customize what will appear in these headers.
    If you put some long text in the row headers, it will not fit. Thus you may consider using SpreadsheetView.setRowHeaderWidth(double) in order to enlarge the row header so that your text can fit properly.
    See Also:
    Grid, GridChange

    • Constructor Detail

      • GridBase

        public GridBase​(int rowCount,
                int columnCount)
        Creates a GridBase with a fixed number of rows and columns.
        Parameters:
        rowCount - the number of rows
        columnCount - the numbers of columns

    • Method Detail

      • setCellValue

        public void setCellValue​(int modelRow,
                         int column,
                         Object value)
        Changes the value situated at the intersection if possible. Verification and conversion of the value should be done before with SpreadsheetCellType.match(Object) and SpreadsheetCellType.convertValue(Object).
        Specified by:
        setCellValue in interface Grid
        Parameters:
        modelRow - the row index issued from the SpreadsheetCell
        column - the column index issued from the SpreadsheetCell
        value - the value to set to the SpreadsheetCell

      • getRowCount

        public int getRowCount()
        Returns how many rows are inside the Grid.
        Specified by:
        getRowCount in interface Grid
        Returns:
        the number of rows in the Grid.

      • getColumnCount

        public int getColumnCount()
        Returns how many columns are inside the Grid.
        Specified by:
        getColumnCount in interface Grid
        Returns:
        the number of columns in the Grid.

      • getRowHeight

        public double getRowHeight​(int row)
        Returns the height of a row. Grid.AUTOFIT can be returned in order to let the system compute the best row height.
        Specified by:
        getRowHeight in interface Grid
        Parameters:
        row - the row index
        Returns:
        the height in pixels of the given row.

      • setRowHeightCallback

        public void setRowHeightCallback​(Callback<Integer,​Double> rowHeight)
        Sets a new Callback for this grid in order to specify height of each row.
        Parameters:
        rowHeight - the Callback to use for rown height computation

      • getRowHeaders

        public ObservableList<String> getRowHeaders()
        Returns an ObservableList of String to display in the row headers.
        Specified by:
        getRowHeaders in interface Grid
        Returns:
        an ObservableList of String to display in the row headers

      • getColumnHeaders

        public ObservableList<String> getColumnHeaders()
        Returns an ObservableList of String to display in the column headers.
        Specified by:
        getColumnHeaders in interface Grid
        Returns:
        an ObservableList of String to display in the column headers

      • isLocked

        public boolean isLocked()
        Returns whether this GridBase id locked or not.
        Returns:
        true if this GridBase is locked

      • setLocked

        public void setLocked​(Boolean lock)
        Locks or unlocks this GridBase.
        Parameters:
        lock - true to lock this GridBase

      • spanRow

        public void spanRow​(int count,
                    int rowIndex,
                    int colIndex)
        Spans in row the cell situated at rowIndex and colIndex by the number count.
        Specified by:
        spanRow in interface Grid
        Parameters:
        count - the span range
        rowIndex - the row index
        colIndex - the column index

      • spanColumn

        public void spanColumn​(int count,
                       int rowIndex,
                       int colIndex)
        Spans in column the cell situated at rowIndex and colIndex by the number count.
        Specified by:
        spanColumn in interface Grid
        Parameters:
        count - the span range
        rowIndex - the row index
        colIndex - the column index

      • setResizableRows

        public void setResizableRows​(BitSet resizableRow)
        Sets the resizable state of all rows. If a bit is set to true in the BitSet, it means the row is resizable. The BitSet.length() must be equal to the getRowCount()
        Parameters:
        resizableRow - a BitSet where the bits set to true represent the resizable rows

      • isRowResizable

        public boolean isRowResizable​(int row)
        Returns true if the specified row is resizable.
        Specified by:
        isRowResizable in interface Grid
        Parameters:
        row - the row index
        Returns:
        true if the specified row is resizable

      • isDisplaySelection

        public boolean isDisplaySelection()
        Return true if the selection (black rectangle) is displayed on the Grid. Cells may override this property with Grid.setCellDisplaySelection(int, int, boolean).
        Specified by:
        isDisplaySelection in interface Grid
        Returns:
        true if the selection (black rectangle) is displayed on the Grid

      • setDisplaySelection

        public void setDisplaySelection​(boolean value)
        If set to true, the selection (black rectangle) will be displayed on the Grid. Cells may override this property with Grid.setCellDisplaySelection(int, int, boolean).
        Specified by:
        setDisplaySelection in interface Grid
        Parameters:
        value - true if the selection should be displayed

      • setCellDisplaySelection

        public void setCellDisplaySelection​(int row,
                                    int column,
                                    boolean displaySelection)
        Overrides the value defined by Grid.isDisplaySelection() so that no matter what is defined on the grid, the given cell will always have its selection set to the displaySelection parameter.
        Specified by:
        setCellDisplaySelection in interface Grid
        Parameters:
        row - the row index
        column - the column index
        displaySelection - true is the selection should always be displayed on this cell

      • isCellDisplaySelection

        public boolean isCellDisplaySelection​(int row,
                                      int column)
        Returns true if the given cell will display a selection rectangle when selected. If nothing is defined for this cell, Grid.isDisplaySelection() is returned.
        Specified by:
        isCellDisplaySelection in interface Grid
        Parameters:
        row - the row index
        column - the column index
        Returns:
        true if the given cell will display a selection rectangle

      • addEventHandler

        public <E extends GridChange> void addEventHandler​(EventType<E> eventType,
                                                   EventHandler<E> eventHandler)
        Registers an event handler to this Grid. The Grid class allows registration of listeners which will be notified as a SpreadsheetCell's value will change.
        Specified by:
        addEventHandler in interface Grid
        Parameters:
        eventType - the type of the events to receive by the handler
        eventHandler - the handler to register

      • removeEventHandler

        public <E extends GridChange> void removeEventHandler​(EventType<E> eventType,
                                                      EventHandler<E> eventHandler)
        Unregisters a previously registered event handler from this Grid. One handler might have been registered for different event types, so the caller needs to specify the particular event type from which to unregister the handler.
        Specified by:
        removeEventHandler in interface Grid
        Parameters:
        eventType - the event type from which to unregister
        eventHandler - the handler to unregister