ttable scrollbars and mouse working
[fanfix.git] / src / jexer / TTableWidget.java
index 480e8289c2e8def0f1be139675bb963544857c60..2e10a3faedc702295335cd740d60a85ca4a331e6 100644 (file)
  */
 package jexer;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
+import jexer.bits.CellAttributes;
 import jexer.event.TKeypressEvent;
 import jexer.event.TMenuEvent;
+import jexer.event.TMouseEvent;
+import jexer.event.TResizeEvent;
 import jexer.menu.TMenu;
 import static jexer.TKeypress.*;
 
@@ -113,12 +117,22 @@ public class TTableWidget extends TWidget {
     /**
      * If true, highlight the entire row of the currently-selected cell.
      */
-    private boolean highlightRow = false;
+    private boolean highlightRow = true;
 
     /**
      * If true, highlight the entire column of the currently-selected cell.
      */
-    private boolean highlightColumn = false;
+    private boolean highlightColumn = true;
+
+    /**
+     * If true, show the row labels as the first column.
+     */
+    private boolean showRowLabels = true;
+
+    /**
+     * If true, show the column labels as the first row.
+     */
+    private boolean showColumnLabels = true;
 
     /**
      * Column represents a column of cells.
@@ -145,6 +159,24 @@ public class TTableWidget extends TWidget {
          */
         private Border border = Border.NONE;
 
+        /**
+         * Constructor sets label to lettered column.
+         *
+         * @param col column number to use for this column.  Column 0 will be
+         * "A", column 1 will be "B", column 26 will be "AA", and so on.
+         */
+        Column(int col) {
+            StringBuilder sb = new StringBuilder();
+            for (;;) {
+                sb.append((char) ('A' + (col % 26)));
+                if (col < 26) {
+                    break;
+                }
+                col /= 26;
+            }
+            label = sb.reverse().toString();
+        }
+
         /**
          * Add an entry to this column.
          *
@@ -190,6 +222,15 @@ public class TTableWidget extends TWidget {
          */
         private Border border = Border.NONE;
 
+        /**
+         * Constructor sets label to numbered row.
+         *
+         * @param row row number to use for this row
+         */
+        Row(final int row) {
+            label = Integer.toString(row);
+        }
+
         /**
          * Add an entry to this column.
          *
@@ -270,10 +311,8 @@ public class TTableWidget extends TWidget {
             this.column = column;
             this.row = row;
 
-            field = addField(0, 0, width - 1, false);
+            field = addField(0, 0, width, false);
             field.setEnabled(false);
-            field.setActiveColorKey("ttable.active");
-            field.setInactiveColorKey("ttable.inactive");
             field.setBackgroundChar(' ');
         }
 
@@ -281,6 +320,66 @@ public class TTableWidget extends TWidget {
         // Event handlers -----------------------------------------------------
         // --------------------------------------------------------------------
 
+        /**
+         * Handle mouse double-click events.
+         *
+         * @param mouse mouse double-click event
+         */
+        @Override
+        public void onMouseDoubleClick(final TMouseEvent mouse) {
+            // Use TWidget's code to pass the event to the children.
+            super.onMouseDown(mouse);
+
+            // Double-click means to start editing.
+            fieldText = field.getText();
+            isEditing = true;
+            field.setEnabled(true);
+            activate(field);
+
+            if (isActive()) {
+                // Let the table know that I was activated.
+                ((TTableWidget) getParent()).selectedRow = row;
+                ((TTableWidget) getParent()).selectedColumn = column;
+                ((TTableWidget) getParent()).alignGrid();
+            }
+        }
+
+        /**
+         * Handle mouse press events.
+         *
+         * @param mouse mouse button press event
+         */
+        @Override
+        public void onMouseDown(final TMouseEvent mouse) {
+            // Use TWidget's code to pass the event to the children.
+            super.onMouseDown(mouse);
+
+            if (isActive()) {
+                // Let the table know that I was activated.
+                ((TTableWidget) getParent()).selectedRow = row;
+                ((TTableWidget) getParent()).selectedColumn = column;
+                ((TTableWidget) getParent()).alignGrid();
+            }
+        }
+
+        /**
+         * Handle mouse release events.
+         *
+         * @param mouse mouse button release event
+         */
+        @Override
+        public void onMouseUp(final TMouseEvent mouse) {
+            // Use TWidget's code to pass the event to the children.
+            super.onMouseDown(mouse);
+
+            if (isActive()) {
+                // Let the table know that I was activated.
+                ((TTableWidget) getParent()).selectedRow = row;
+                ((TTableWidget) getParent()).selectedColumn = column;
+                ((TTableWidget) getParent()).alignGrid();
+            }
+        }
+
         /**
          * Handle keystrokes.
          *
@@ -330,27 +429,30 @@ public class TTableWidget extends TWidget {
         public void draw() {
             TTableWidget table = (TTableWidget) getParent();
 
-            field.setActiveColorKey("ttable.active");
-            field.setInactiveColorKey("ttable.inactive");
-
             if (isAbsoluteActive()) {
-                if (table.selectedColumn == column) {
-                    if ((table.selectedRow == row)
-                        || (table.highlightColumn == true)
-                    ) {
-                        field.setActiveColorKey("ttable.active");
-                        field.setInactiveColorKey("ttable.active");
-                    }
-                } else if (table.selectedRow == row) {
-                    if ((table.selectedColumn == column)
-                        || (table.highlightRow == true)
-                    ) {
-                        field.setActiveColorKey("ttable.active");
-                        field.setInactiveColorKey("ttable.active");
-                    }
+                if (isEditing) {
+                    field.setActiveColorKey("tfield.active");
+                    field.setInactiveColorKey("tfield.inactive");
+                } else {
+                    field.setActiveColorKey("ttable.selected");
+                    field.setInactiveColorKey("ttable.selected");
                 }
+            } else if (((table.selectedColumn == column)
+                    && ((table.selectedRow == row)
+                        || (table.highlightColumn == true)))
+                || ((table.selectedRow == row)
+                    && ((table.selectedColumn == column)
+                        || (table.highlightRow == true)))
+            ) {
+                field.setActiveColorKey("ttable.active");
+                field.setInactiveColorKey("ttable.active");
+            } else {
+                field.setActiveColorKey("ttable.active");
+                field.setInactiveColorKey("ttable.inactive");
             }
 
+            assert (isVisible() == true);
+
             super.draw();
         }
 
@@ -397,8 +499,8 @@ public class TTableWidget extends TWidget {
         super(parent, x, y, width, height);
 
         // Initialize the starting row and column.
-        rows.add(new Row());
-        columns.add(new Column());
+        rows.add(new Row(0));
+        columns.add(new Column(0));
 
         // Place a grid of cells that fit in this space.
         int row = 0;
@@ -412,22 +514,61 @@ public class TTableWidget extends TWidget {
                 rows.get(row).add(cell);
                 columns.get(column).add(cell);
                 if ((i == 0) && (j + columns.get(0).width < width)) {
-                    columns.add(new Column());
+                    columns.add(new Column(column + 1));
                 }
                 column++;
             }
             if (i + rows.get(0).height < height) {
-                rows.add(new Row());
+                rows.add(new Row(row + 1));
             }
             row++;
         }
         activate(columns.get(selectedColumn).get(selectedRow));
+
+        alignGrid();
+
+        // Set the menu to match the flags.
+        getApplication().getMenuItem(TMenu.MID_TABLE_VIEW_ROW_LABELS).
+                setChecked(showRowLabels);
+        getApplication().getMenuItem(TMenu.MID_TABLE_VIEW_COLUMN_LABELS).
+                setChecked(showColumnLabels);
+        getApplication().getMenuItem(TMenu.MID_TABLE_VIEW_HIGHLIGHT_ROW).
+                setChecked(highlightRow);
+        getApplication().getMenuItem(TMenu.MID_TABLE_VIEW_HIGHLIGHT_COLUMN).
+                setChecked(highlightColumn);
+
+
     }
 
     // ------------------------------------------------------------------------
     // Event handlers ---------------------------------------------------------
     // ------------------------------------------------------------------------
 
+    /**
+     * Handle mouse press events.
+     *
+     * @param mouse mouse button press event
+     */
+    @Override
+    public void onMouseDown(final TMouseEvent mouse) {
+        if (mouse.isMouseWheelUp() || mouse.isMouseWheelDown()) {
+            // Treat wheel up/down as 3 up/down
+            TKeypressEvent keyEvent;
+            if (mouse.isMouseWheelUp()) {
+                keyEvent = new TKeypressEvent(kbUp);
+            } else {
+                keyEvent = new TKeypressEvent(kbDown);
+            }
+            for (int i = 0; i < 3; i++) {
+                onKeypress(keyEvent);
+            }
+            return;
+        }
+
+        // Use TWidget's code to pass the event to the children.
+        super.onMouseDown(mouse);
+    }
+
     /**
      * Handle keystrokes.
      *
@@ -442,50 +583,93 @@ public class TTableWidget extends TWidget {
             // grid context.
             return;
         }
-        
+
+        // If editing, pass to that cell and do nothing else.
         if (getSelectedCell().isEditing) {
             super.onKeypress(keypress);
             return;
         }
 
         if (keypress.equals(kbLeft)) {
+            // Left
             if (selectedColumn > 0) {
                 selectedColumn--;
             }
             activate(columns.get(selectedColumn).get(selectedRow));
         } else if (keypress.equals(kbRight)) {
+            // Right
             if (selectedColumn < columns.size() - 1) {
                 selectedColumn++;
             }
             activate(columns.get(selectedColumn).get(selectedRow));
         } else if (keypress.equals(kbUp)) {
+            // Up
             if (selectedRow > 0) {
                 selectedRow--;
             }
             activate(columns.get(selectedColumn).get(selectedRow));
         } else if (keypress.equals(kbDown)) {
+            // Down
             if (selectedRow < rows.size() - 1) {
                 selectedRow++;
             }
             activate(columns.get(selectedColumn).get(selectedRow));
         } else if (keypress.equals(kbHome)) {
+            // Home - leftmost column
             selectedColumn = 0;
             activate(columns.get(selectedColumn).get(selectedRow));
         } else if (keypress.equals(kbEnd)) {
+            // End - rightmost column
             selectedColumn = columns.size() - 1;
             activate(columns.get(selectedColumn).get(selectedRow));
         } else if (keypress.equals(kbPgUp)) {
-            // TODO
+            // PgUp - Treat like multiple up
+            for (int i = 0; i < getHeight() - 2; i++) {
+                if (selectedRow > 0) {
+                    selectedRow--;
+                }
+            }
+            activate(columns.get(selectedColumn).get(selectedRow));
         } else if (keypress.equals(kbPgDn)) {
-            // TODO
+            // PgDn - Treat like multiple up
+            for (int i = 0; i < getHeight() - 2; i++) {
+                if (selectedRow < rows.size() - 1) {
+                    selectedRow++;
+                }
+            }
+            activate(columns.get(selectedColumn).get(selectedRow));
         } else if (keypress.equals(kbCtrlHome)) {
-            // TODO
+            // Ctrl-Home - go to top-left
+            selectedRow = 0;
+            selectedColumn = 0;
+            activate(columns.get(selectedColumn).get(selectedRow));
+            activate(columns.get(selectedColumn).get(selectedRow));
         } else if (keypress.equals(kbCtrlEnd)) {
-            // TODO
+            // Ctrl-End - go to bottom-right
+            selectedRow = rows.size() - 1;
+            selectedColumn = columns.size() - 1;
+            activate(columns.get(selectedColumn).get(selectedRow));
+            activate(columns.get(selectedColumn).get(selectedRow));
         } else {
             // Pass to the Cell.
             super.onKeypress(keypress);
         }
+
+        // We may have scrolled off screen.  Reset positions as needed to
+        // make the newly selected cell visible.
+        alignGrid();
+    }
+
+    /**
+     * Handle widget resize events.
+     *
+     * @param event resize event
+     */
+    @Override
+    public void onResize(final TResizeEvent event) {
+        super.onResize(event);
+
+        alignGrid();
     }
 
     /**
@@ -496,6 +680,18 @@ public class TTableWidget extends TWidget {
     @Override
     public void onMenu(final TMenuEvent menu) {
         switch (menu.getId()) {
+        case TMenu.MID_TABLE_VIEW_ROW_LABELS:
+            showRowLabels = getApplication().getMenuItem(menu.getId()).getChecked();
+            break;
+        case TMenu.MID_TABLE_VIEW_COLUMN_LABELS:
+            showColumnLabels = getApplication().getMenuItem(menu.getId()).getChecked();
+            break;
+        case TMenu.MID_TABLE_VIEW_HIGHLIGHT_ROW:
+            highlightRow = getApplication().getMenuItem(menu.getId()).getChecked();
+            break;
+        case TMenu.MID_TABLE_VIEW_HIGHLIGHT_COLUMN:
+            highlightColumn = getApplication().getMenuItem(menu.getId()).getChecked();
+            break;
         case TMenu.MID_TABLE_BORDER_NONE:
         case TMenu.MID_TABLE_BORDER_ALL:
         case TMenu.MID_TABLE_BORDER_RIGHT:
@@ -517,28 +713,84 @@ public class TTableWidget extends TWidget {
             columns.get(selectedColumn).width--;
             for (Cell cell: getSelectedColumn().cells) {
                 cell.setWidth(columns.get(selectedColumn).width);
-                cell.field.setWidth(columns.get(selectedColumn).width - 1);
+                cell.field.setWidth(columns.get(selectedColumn).width);
             }
+            for (int i = selectedColumn + 1; i < columns.size(); i++) {
+                for (Cell cell: columns.get(i).cells) {
+                    cell.setX(cell.getX() - 1);
+                }
+            }
+            alignGrid();
             break;
         case TMenu.MID_TABLE_COLUMN_WIDEN:
             columns.get(selectedColumn).width++;
             for (Cell cell: getSelectedColumn().cells) {
                 cell.setWidth(columns.get(selectedColumn).width);
-                cell.field.setWidth(columns.get(selectedColumn).width - 1);
+                cell.field.setWidth(columns.get(selectedColumn).width);
+            }
+            for (int i = selectedColumn + 1; i < columns.size(); i++) {
+                for (Cell cell: columns.get(i).cells) {
+                    cell.setX(cell.getX() + 1);
+                }
             }
+            alignGrid();
             break;
         case TMenu.MID_TABLE_FILE_SAVE_CSV:
+            // TODO
+            break;
         case TMenu.MID_TABLE_FILE_SAVE_TEXT:
+            // TODO
             break;
         default:
             super.onMenu(menu);
         }
+
+        alignGrid();
     }
 
     // ------------------------------------------------------------------------
     // TWidget ----------------------------------------------------------------
     // ------------------------------------------------------------------------
 
+    /**
+     * Draw the table row/column labels, and borders.
+     */
+    @Override
+    public void draw() {
+        CellAttributes labelColor = getTheme().getColor("ttable.label");
+        CellAttributes labelColorSelected = getTheme().getColor("ttable.label.selected");
+        CellAttributes borderColor = getTheme().getColor("ttable.border");
+
+        // Column labels.
+        if (showColumnLabels == true) {
+            for (int i = left; i < columns.size(); i++) {
+                if (columns.get(i).get(top).isVisible() == false) {
+                    break;
+                }
+                putStringXY(columns.get(i).get(top).getX(), 0,
+                    String.format(" %-" +
+                        (columns.get(i).get(top).getWidth() - 2)
+                        + "s ", columns.get(i).label),
+                    (i == selectedColumn ? labelColorSelected : labelColor));
+            }
+        }
+
+        // Row labels.
+        if (showRowLabels == true) {
+            for (int i = top; i < rows.size(); i++) {
+                if (rows.get(i).get(left).isVisible() == false) {
+                    break;
+                }
+                putStringXY(0, rows.get(i).get(left).getY(),
+                    String.format(" %-6s ", rows.get(i).label),
+                    (i == selectedRow ? labelColorSelected : labelColor));
+            }
+        }
+
+        // Now draw the window borders.
+        super.draw();
+    }
+
     // ------------------------------------------------------------------------
     // TTable -----------------------------------------------------------------
     // ------------------------------------------------------------------------
@@ -583,4 +835,307 @@ public class TTableWidget extends TWidget {
         return rows.get(selectedRow);
     }
 
+    /**
+     * Get the currently-selected column number.  0 is the left-most column.
+     *
+     * @return the selected column number
+     */
+    public int getSelectedColumnNumber() {
+        return selectedColumn;
+    }
+
+    /**
+     * Set the currently-selected column number.  0 is the left-most column.
+     *
+     * @param column the column number to select
+     */
+    public void setSelectedColumnNumber(final int column) {
+        if ((column < 0) || (column > columns.size() - 1)) {
+            throw new IndexOutOfBoundsException("Column count is " +
+                columns.size() + ", requested index " + column);
+        }
+        selectedColumn = column;
+        activate(columns.get(selectedColumn).get(selectedRow));
+        alignGrid();
+    }
+
+    /**
+     * Get the currently-selected row number.  0 is the top-most row.
+     *
+     * @return the selected row number
+     */
+    public int getSelectedRowNumber() {
+        return selectedRow;
+    }
+
+    /**
+     * Set the currently-selected row number.  0 is the left-most column.
+     *
+     * @param row the row number to select
+     */
+    public void setSelectedRowNumber(final int row) {
+        if ((row < 0) || (row > rows.size() - 1)) {
+            throw new IndexOutOfBoundsException("Row count is " +
+                rows.size() + ", requested index " + row);
+        }
+        selectedRow = row;
+        activate(columns.get(selectedColumn).get(selectedRow));
+        alignGrid();
+    }
+
+    /**
+     * Get the number of columns.
+     *
+     * @return the number of columns
+     */
+    public int getColumnCount() {
+        return columns.size();
+    }
+
+    /**
+     * Get the number of rows.
+     *
+     * @return the number of rows
+     */
+    public int getRowCount() {
+        return rows.size();
+    }
+
+    /**
+     * Get the full horizontal width of this table.
+     *
+     * @return the width required to render the entire table
+     */
+    private int getMaximumWidth() {
+        int totalWidth = 0;
+        if (showRowLabels == true) {
+            // For now, all row labels are 8 cells wide.  TODO: make this
+            // adjustable.
+            totalWidth += 8;
+        }
+        for (Cell cell: getSelectedRow().cells) {
+            totalWidth += cell.getWidth() + 1;
+        }
+        return totalWidth;
+    }
+
+    /**
+     * Get the full vertical height of this table.
+     *
+     * @return the height required to render the entire table
+     */
+    private int getMaximumHeight() {
+        int totalHeight = 0;
+        if (showColumnLabels == true) {
+            // For now, all column labels are 1 cell tall.  TODO: make this
+            // adjustable.
+            totalHeight += 1;
+        }
+        for (Cell cell: getSelectedColumn().cells) {
+            totalHeight += cell.getHeight();
+            // TODO: handle top/bottom borders.
+        }
+        return totalHeight;
+    }
+
+    /**
+     * Align the grid so that the selected cell is fully visible.
+     */
+    private void alignGrid() {
+
+        /*
+         * We start by assuming that all cells are visible, and then mark as
+         * invisible those that are outside the viewable area.
+         */
+        for (int x = 0; x < columns.size(); x++) {
+            for (int y = 0; y < rows.size(); y++) {
+                Cell cell =  rows.get(y).cells.get(x);
+                cell.setVisible(true);
+
+                // Special case: mouse double-clicks can lead to multiple
+                // cells in editing mode.  Only allow a cell to remain
+                // editing if it is fact the active widget.
+                if (cell.isEditing && !cell.isActive()) {
+                    cell.fieldText = cell.field.getText();
+                    cell.isEditing = false;
+                    cell.field.setEnabled(false);
+                }
+            }
+        }
+
+        // Adjust X locations to be visible -----------------------------------
+
+        // Determine if we need to shift left or right.
+        int leftCellX = 0;
+        if (showRowLabels == true) {
+            // For now, all row labels are 8 cells wide.  TODO: make this
+            // adjustable.
+            leftCellX += 8;
+        }
+        Row row = getSelectedRow();
+        Cell selectedColumnCell = null;
+        for (int i = 0; i < row.cells.size(); i++) {
+            if (i == selectedColumn) {
+                selectedColumnCell = row.cells.get(i);
+                break;
+            }
+            leftCellX += row.cells.get(i).getWidth() + 1;
+        }
+        // There should always be a selected column.
+        assert (selectedColumnCell != null);
+
+        int excessWidth = leftCellX + selectedColumnCell.getWidth() + 1 - getWidth();
+        if (excessWidth > 0) {
+            leftCellX -= excessWidth;
+        }
+        if (leftCellX < 0) {
+            if (showRowLabels == true) {
+                leftCellX = 8;
+            } else {
+                leftCellX = 0;
+            }
+        }
+
+        /*
+         * leftCellX now contains the basic left offset necessary to draw the
+         * cells such that the selected cell (column) is fully visible within
+         * this widget's given width.  Or, if the widget is too narrow to
+         * display the full cell, leftCellX is 0 or 8.
+         *
+         * Now reset all of the X positions of the other cells so that the
+         * selected cell X is leftCellX.
+         */
+        for (int y = 0; y < rows.size(); y++) {
+            // All cells to the left of selected cell.
+            int newCellX = leftCellX;
+            left = selectedColumn;
+            for (int x = selectedColumn - 1; x >= 0; x--) {
+                newCellX -= rows.get(y).cells.get(x).getWidth() + 1;
+                if (newCellX >= (showRowLabels ? 8 : 0)) {
+                    rows.get(y).cells.get(x).setVisible(true);
+                    rows.get(y).cells.get(x).setX(newCellX);
+                    left--;
+                } else {
+                    // This cell won't be visible.
+                    rows.get(y).cells.get(x).setVisible(false);
+                }
+            }
+
+            // Selected cell.
+            rows.get(y).cells.get(selectedColumn).setX(leftCellX);
+            assert (rows.get(y).cells.get(selectedColumn).isVisible());
+
+            // All cells to the right of selected cell.
+            newCellX = leftCellX + selectedColumnCell.getWidth() + 1;
+            for (int x = selectedColumn + 1; x < columns.size(); x++) {
+                if (newCellX <= getWidth()) {
+                    rows.get(y).cells.get(x).setVisible(true);
+                    rows.get(y).cells.get(x).setX(newCellX);
+                } else {
+                    // This cell won't be visible.
+                    rows.get(y).cells.get(x).setVisible(false);
+                }
+                newCellX += rows.get(y).cells.get(x).getWidth() + 1;
+            }
+        }
+
+        // Adjust Y locations to be visible -----------------------------------
+        // The same logic as above, but applied to the column Y.
+
+        // Determine if we need to shift up or down.
+        int topCellY = 0;
+        if (showColumnLabels == true) {
+            // For now, all column labels are 1 cell high.  TODO: make this
+            // adjustable.
+            topCellY += 1;
+        }
+        Column column = getSelectedColumn();
+        Cell selectedRowCell = null;
+        for (int i = 0; i < column.cells.size(); i++) {
+            if (i == selectedRow) {
+                selectedRowCell = column.cells.get(i);
+                break;
+            }
+            topCellY += column.cells.get(i).getHeight();
+            // TODO: if a border is selected, add 1 to topCellY.
+        }
+        // There should always be a selected row.
+        assert (selectedRowCell != null);
+
+        int excessHeight = topCellY + selectedRowCell.getHeight() - getHeight() - 1;
+        if (showColumnLabels == true) {
+            excessHeight += 1;
+        }
+        if (excessHeight > 0) {
+            topCellY -= excessHeight;
+        }
+        if (topCellY < 0) {
+            if (showColumnLabels == true) {
+                topCellY = 1;
+            } else {
+                topCellY = 0;
+            }
+        }
+
+        /*
+         * topCellY now contains the basic top offset necessary to draw the
+         * cells such that the selected cell (row) is fully visible within
+         * this widget's given height.  Or, if the widget is too short to
+         * display the full cell, topCellY is 0 or 1.
+         *
+         * Now reset all of the Y positions of the other cells so that the
+         * selected cell Y is topCellY.
+         */
+        for (int x = 0; x < columns.size(); x++) {
+
+            if (columns.get(x).get(0).isVisible() == false) {
+                // This column won't be visible as determined by the checks
+                // above, just continue to the next.
+                continue;
+            }
+
+            // All cells above the selected cell.
+            int newCellY = topCellY;
+            top = selectedRow;
+            for (int y = selectedRow - 1; y >= 0; y--) {
+                newCellY -= rows.get(y).cells.get(x).getHeight();
+                if (newCellY >= (showColumnLabels == true ? 1 : 0)) {
+                    rows.get(y).cells.get(x).setVisible(true);
+                    rows.get(y).cells.get(x).setY(newCellY);
+                    top--;
+                } else {
+                    // This cell won't be visible.
+                    rows.get(y).cells.get(x).setVisible(false);
+                }
+            }
+
+            // Selected cell.
+            columns.get(x).cells.get(selectedRow).setY(topCellY);
+
+            // All cells below the selected cell.
+            newCellY = topCellY + selectedRowCell.getHeight();
+            for (int y = selectedRow + 1; y < rows.size(); y++) {
+                if (newCellY <= getHeight()) {
+                    rows.get(y).cells.get(x).setVisible(true);
+                    rows.get(y).cells.get(x).setY(newCellY);
+                } else {
+                    // This cell won't be visible.
+                    rows.get(y).cells.get(x).setVisible(false);
+                }
+                newCellY += rows.get(y).cells.get(x).getHeight();
+            }
+        }
+
+    }
+
+    /**
+     * Save contents to file.
+     *
+     * @param filename file to save to
+     * @throws IOException if a java.io operation throws
+     */
+    public void saveToFilename(final String filename) throws IOException {
+        // TODO
+    }
+
 }