*/
package jexer;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
+import jexer.bits.CellAttributes;
+import jexer.bits.StringUtils;
import jexer.event.TKeypressEvent;
-import jexer.event.TMenuEvent;
-import jexer.menu.TMenu;
+import jexer.event.TMouseEvent;
+import jexer.event.TResizeEvent;
import static jexer.TKeypress.*;
/**
DOUBLE,
/**
- * Thick bar: \u258C (vertical, left half block) and \u2580
- * (horizontal, upper block).
+ * Thick bar: \u2503 (vertical heavy) and \u2501 (horizontal heavy).
*/
THICK,
}
+ /**
+ * If true, put a grid of numbers in the cells.
+ */
+ private static final boolean DEBUG = false;
+
+ /**
+ * Row label width.
+ */
+ private static final int ROW_LABEL_WIDTH = 8;
+
+ /**
+ * Column label height.
+ */
+ private static final int COLUMN_LABEL_HEIGHT = 1;
+
+ /**
+ * Column default width.
+ */
+ private static final int COLUMN_DEFAULT_WIDTH = 8;
+
+ /**
+ * Extra rows to add.
+ */
+ private static final int EXTRA_ROWS = (DEBUG ? 10 : 0);
+
+ /**
+ * Extra columns to add.
+ */
+ private static final int EXTRA_COLUMNS = (DEBUG ? 3 : 0);
+
// ------------------------------------------------------------------------
// Variables --------------------------------------------------------------
// ------------------------------------------------------------------------
*/
private boolean highlightColumn = false;
+ /**
+ * 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;
+
+ /**
+ * The top border for the first row.
+ */
+ private Border topBorder = Border.NONE;
+
+ /**
+ * The left border for the first column.
+ */
+ private Border leftBorder = Border.NONE;
+
/**
* Column represents a column of cells.
*/
public class Column {
+ /**
+ * X position of this column.
+ */
+ private int x = 0;
+
/**
* Width of column.
*/
- private int width = 8;
+ private int width = COLUMN_DEFAULT_WIDTH;
/**
* The cells of this column.
private String label = "";
/**
- * The border for this column.
+ * The right border for this column.
+ */
+ private Border rightBorder = 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.
*/
- private Border border = Border.NONE;
+ Column(int col) {
+ label = makeColumnLabel(col);
+ }
/**
* Add an entry to this column.
public Cell get(final int row) {
return cells.get(row);
}
+
+ /**
+ * Get the X position of the cells in this column.
+ *
+ * @return the position
+ */
+ public int getX() {
+ return x;
+ }
+
+ /**
+ * Set the X position of the cells in this column.
+ *
+ * @param x the position
+ */
+ public void setX(final int x) {
+ for (Cell cell: cells) {
+ cell.setX(x);
+ }
+ this.x = x;
+ }
+
}
/**
*/
public class Row {
+ /**
+ * Y position of this row.
+ */
+ private int y = 0;
+
/**
* Height of row.
*/
private String label = "";
/**
- * The border for this row.
+ * The bottom border for this row.
+ */
+ private Border bottomBorder = Border.NONE;
+
+ /**
+ * Constructor sets label to numbered row.
+ *
+ * @param row row number to use for this row
*/
- private Border border = Border.NONE;
+ Row(final int row) {
+ label = Integer.toString(row);
+ }
/**
* Add an entry to this column.
public Cell get(final int column) {
return cells.get(column);
}
+ /**
+ * Get the Y position of the cells in this column.
+ *
+ * @return the position
+ */
+ public int getY() {
+ return y;
+ }
+
+ /**
+ * Set the Y position of the cells in this column.
+ *
+ * @param y the position
+ */
+ public void setY(final int y) {
+ for (Cell cell: cells) {
+ cell.setY(y);
+ }
+ this.y = y;
+ }
}
*/
private boolean isEditing = false;
+ /**
+ * If true, the cell is read-only (non-editable).
+ */
+ private boolean readOnly = false;
+
/**
* Text of field before editing.
*/
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(' ');
}
// 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.
*
public void onKeypress(final TKeypressEvent keypress) {
// System.err.println("Cell onKeypress: " + keypress);
+ if (readOnly) {
+ // Read only: do nothing.
+ return;
+ }
+
if (isEditing) {
if (keypress.equals(kbEsc)) {
// ESC cancels the edit.
- field.setText(fieldText);
- isEditing = false;
- field.setEnabled(false);
+ cancelEdit();
return;
}
if (keypress.equals(kbEnter)) {
// Enter ends editing.
+
+ // Pass down to field first so that it can execute
+ // enterAction if specified.
+ super.onKeypress(keypress);
+
fieldText = field.getText();
isEditing = false;
field.setEnabled(false);
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();
}
field.setText(text);
}
+ /**
+ * Cancel any pending edit.
+ */
+ public void cancelEdit() {
+ // Cancel any pending edit.
+ if (fieldText != null) {
+ field.setText(fieldText);
+ }
+ isEditing = false;
+ field.setEnabled(false);
+ }
+
+ /**
+ * Set an entire column of cells read-only (non-editable) or not.
+ *
+ * @param readOnly if true, the cells will be non-editable
+ */
+ public void setReadOnly(final boolean readOnly) {
+ cancelEdit();
+ this.readOnly = readOnly;
+ }
+
}
// ------------------------------------------------------------------------
* @param y row relative to parent
* @param width width of widget
* @param height height of widget
+ * @param gridColumns number of columns in grid
+ * @param gridRows number of rows in grid
*/
public TTableWidget(final TWidget parent, final int x, final int y,
- final int width, final int height) {
+ final int width, final int height, final int gridColumns,
+ final int gridRows) {
super(parent, x, y, width, height);
+ /*
+ System.err.println("gridColumns " + gridColumns +
+ " gridRows " + gridRows);
+ */
+
+ if (gridColumns < 1) {
+ throw new IllegalArgumentException("Column count cannot be less " +
+ "than 1");
+ }
+ if (gridRows < 1) {
+ throw new IllegalArgumentException("Row count cannot be less " +
+ "than 1");
+ }
+
// Initialize the starting row and column.
- rows.add(new Row());
- columns.add(new Column());
+ rows.add(new Row(0));
+ columns.add(new Column(0));
+ assert (rows.get(0).height == 1);
// Place a grid of cells that fit in this space.
- int row = 0;
- for (int i = 0; i < height; i += rows.get(0).height) {
- int column = 0;
- for (int j = 0; j < width; j += columns.get(0).width) {
- Cell cell = new Cell(this, j, i, columns.get(0).width,
- rows.get(0).height, column, row);
-
- cell.setText("" + row + " " + column);
+ for (int row = 0; row < gridRows; row++) {
+ for (int column = 0; column < gridColumns; column++) {
+ Cell cell = new Cell(this, 0, 0, COLUMN_DEFAULT_WIDTH, 1,
+ column, row);
+
+ if (DEBUG) {
+ // For debugging: set a grid of cell index labels.
+ cell.setText("" + row + " " + column);
+ }
rows.get(row).add(cell);
columns.get(column).add(cell);
- if ((i == 0) && (j + columns.get(0).width < width)) {
- columns.add(new Column());
+
+ if (columns.size() < gridColumns) {
+ columns.add(new Column(column + 1));
}
- column++;
}
- if (i + rows.get(0).height < height) {
- rows.add(new Row());
+ if (row < gridRows - 1) {
+ rows.add(new Row(row + 1));
}
- row++;
+ }
+ for (int i = 0; i < rows.size(); i++) {
+ rows.get(i).setY(i + (showColumnLabels ? COLUMN_LABEL_HEIGHT : 0));
+ }
+ for (int j = 0; j < columns.size(); j++) {
+ columns.get(j).setX((j * (COLUMN_DEFAULT_WIDTH + 1)) +
+ (showRowLabels ? ROW_LABEL_WIDTH : 0));
}
activate(columns.get(selectedColumn).get(selectedRow));
+
+ alignGrid();
+ }
+
+ /**
+ * Public constructor.
+ *
+ * @param parent parent widget
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param width width of widget
+ * @param height height of widget
+ */
+ public TTableWidget(final TWidget parent, final int x, final int y,
+ final int width, final int height) {
+
+ this(parent, x, y, width, height,
+ width / (COLUMN_DEFAULT_WIDTH + 1) + EXTRA_COLUMNS,
+ height + EXTRA_ROWS);
}
// ------------------------------------------------------------------------
// 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.
*
// 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 posted menu events.
+ * Handle widget resize events.
*
- * @param menu menu event
+ * @param event resize event
*/
@Override
- public void onMenu(final TMenuEvent menu) {
- switch (menu.getId()) {
- case TMenu.MID_TABLE_BORDER_NONE:
- case TMenu.MID_TABLE_BORDER_ALL:
- case TMenu.MID_TABLE_BORDER_RIGHT:
- case TMenu.MID_TABLE_BORDER_LEFT:
- case TMenu.MID_TABLE_BORDER_TOP:
- case TMenu.MID_TABLE_BORDER_BOTTOM:
- case TMenu.MID_TABLE_BORDER_DOUBLE_BOTTOM:
- case TMenu.MID_TABLE_BORDER_THICK_BOTTOM:
- case TMenu.MID_TABLE_DELETE_LEFT:
- case TMenu.MID_TABLE_DELETE_UP:
- case TMenu.MID_TABLE_DELETE_ROW:
- case TMenu.MID_TABLE_DELETE_COLUMN:
- case TMenu.MID_TABLE_INSERT_LEFT:
- case TMenu.MID_TABLE_INSERT_RIGHT:
- case TMenu.MID_TABLE_INSERT_ABOVE:
- case TMenu.MID_TABLE_INSERT_BELOW:
- break;
- case TMenu.MID_TABLE_COLUMN_NARROW:
- columns.get(selectedColumn).width--;
- for (Cell cell: getSelectedColumn().cells) {
- cell.setWidth(columns.get(selectedColumn).width);
- cell.field.setWidth(columns.get(selectedColumn).width - 1);
- }
- 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);
- }
- break;
- case TMenu.MID_TABLE_FILE_SAVE_CSV:
- case TMenu.MID_TABLE_FILE_SAVE_TEXT:
- break;
- default:
- super.onMenu(menu);
- }
+ public void onResize(final TResizeEvent event) {
+ super.onResize(event);
+
+ bottomRightCorner();
}
// ------------------------------------------------------------------------
// 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).width - 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));
+ }
+ }
+
+ // Draw vertical borders.
+ if (leftBorder == Border.SINGLE) {
+ vLineXY((showRowLabels ? ROW_LABEL_WIDTH : 0),
+ (topBorder == Border.NONE ? 0 : 1) +
+ (showColumnLabels ? COLUMN_LABEL_HEIGHT : 0),
+ getHeight(), '\u2502', borderColor);
+ }
+ for (int i = left; i < columns.size(); i++) {
+ if (columns.get(i).get(top).isVisible() == false) {
+ break;
+ }
+ if (columns.get(i).rightBorder == Border.SINGLE) {
+ vLineXY(columns.get(i).getX() + columns.get(i).width,
+ (topBorder == Border.NONE ? 0 : 1) +
+ (showColumnLabels ? COLUMN_LABEL_HEIGHT : 0),
+ getHeight(), '\u2502', borderColor);
+ }
+ }
+
+ // Draw horizontal borders.
+ if (topBorder == Border.SINGLE) {
+ hLineXY((showRowLabels ? ROW_LABEL_WIDTH : 0),
+ (showColumnLabels ? COLUMN_LABEL_HEIGHT : 0),
+ getWidth(), '\u2500', borderColor);
+ }
+ for (int i = top; i < rows.size(); i++) {
+ if (rows.get(i).get(left).isVisible() == false) {
+ break;
+ }
+ if (rows.get(i).bottomBorder == Border.SINGLE) {
+ hLineXY((leftBorder == Border.NONE ? 0 : 1) +
+ (showRowLabels ? ROW_LABEL_WIDTH : 0),
+ rows.get(i).getY() + rows.get(i).height - 1,
+ getWidth(), '\u2500', borderColor);
+ } else if (rows.get(i).bottomBorder == Border.DOUBLE) {
+ hLineXY((leftBorder == Border.NONE ? 0 : 1) +
+ (showRowLabels ? ROW_LABEL_WIDTH : 0),
+ rows.get(i).getY() + rows.get(i).height - 1,
+ getWidth(), '\u2550', borderColor);
+ } else if (rows.get(i).bottomBorder == Border.THICK) {
+ hLineXY((leftBorder == Border.NONE ? 0 : 1) +
+ (showRowLabels ? ROW_LABEL_WIDTH : 0),
+ rows.get(i).getY() + rows.get(i).height - 1,
+ getWidth(), '\u2501', borderColor);
+ }
+ }
+ // Top-left corner if needed
+ if ((topBorder == Border.SINGLE) && (leftBorder == Border.SINGLE)) {
+ putCharXY((showRowLabels ? ROW_LABEL_WIDTH : 0),
+ (showColumnLabels ? COLUMN_LABEL_HEIGHT : 0),
+ '\u250c', borderColor);
+ }
+
+ // Now draw the correct corners
+ for (int i = top; i < rows.size(); i++) {
+ if (rows.get(i).get(left).isVisible() == false) {
+ break;
+ }
+ for (int j = left; j < columns.size(); j++) {
+ if (columns.get(j).get(i).isVisible() == false) {
+ break;
+ }
+ if ((i == top) && (topBorder == Border.SINGLE)
+ && (columns.get(j).rightBorder == Border.SINGLE)
+ ) {
+ // Top tee
+ putCharXY(columns.get(j).getX() + columns.get(j).width,
+ (showColumnLabels ? COLUMN_LABEL_HEIGHT : 0),
+ '\u252c', borderColor);
+ }
+ if ((j == left) && (leftBorder == Border.SINGLE)
+ && (rows.get(i).bottomBorder == Border.SINGLE)
+ ) {
+ // Left tee
+ putCharXY((showRowLabels ? ROW_LABEL_WIDTH : 0),
+ rows.get(i).getY() + rows.get(i).height - 1,
+ '\u251c', borderColor);
+ }
+ if ((columns.get(j).rightBorder == Border.SINGLE)
+ && (rows.get(i).bottomBorder == Border.SINGLE)
+ ) {
+ // Intersection of single bars
+ putCharXY(columns.get(j).getX() + columns.get(j).width,
+ rows.get(i).getY() + rows.get(i).height - 1,
+ '\u253c', borderColor);
+ }
+ if ((j == left) && (leftBorder == Border.SINGLE)
+ && (rows.get(i).bottomBorder == Border.DOUBLE)
+ ) {
+ // Left tee: single bar vertical, double bar horizontal
+ putCharXY((showRowLabels ? ROW_LABEL_WIDTH : 0),
+ rows.get(i).getY() + rows.get(i).height - 1,
+ '\u255e', borderColor);
+ }
+ if ((j == left) && (leftBorder == Border.SINGLE)
+ && (rows.get(i).bottomBorder == Border.THICK)
+ ) {
+ // Left tee: single bar vertical, thick bar horizontal
+ putCharXY((showRowLabels ? ROW_LABEL_WIDTH : 0),
+ rows.get(i).getY() + rows.get(i).height - 1,
+ '\u251d', borderColor);
+ }
+ if ((columns.get(j).rightBorder == Border.SINGLE)
+ && (rows.get(i).bottomBorder == Border.DOUBLE)
+ ) {
+ // Intersection: single bar vertical, double bar
+ // horizontal
+ putCharXY(columns.get(j).getX() + columns.get(j).width,
+ rows.get(i).getY() + rows.get(i).height - 1,
+ '\u256a', borderColor);
+ }
+ if ((columns.get(j).rightBorder == Border.SINGLE)
+ && (rows.get(i).bottomBorder == Border.THICK)
+ ) {
+ // Intersection: single bar vertical, thick bar
+ // horizontal
+ putCharXY(columns.get(j).getX() + columns.get(j).width,
+ rows.get(i).getY() + rows.get(i).height - 1,
+ '\u253f', borderColor);
+ }
+ }
+ }
+
+ // Now draw the window borders.
+ super.draw();
+ }
+
// ------------------------------------------------------------------------
// TTable -----------------------------------------------------------------
// ------------------------------------------------------------------------
+ /**
+ * Generate the default letter name for a column number.
+ *
+ * @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.
+ */
+ private String makeColumnLabel(int col) {
+ StringBuilder sb = new StringBuilder();
+ for (;;) {
+ sb.append((char) ('A' + (col % 26)));
+ if (col < 26) {
+ break;
+ }
+ col /= 26;
+ }
+ return sb.reverse().toString();
+ }
+
/**
* Get the currently-selected cell.
*
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 highlight row flag.
+ *
+ * @return true if the selected row is highlighted
+ */
+ public boolean getHighlightRow() {
+ return highlightRow;
+ }
+
+ /**
+ * Set the highlight row flag.
+ *
+ * @param highlightRow if true, the selected row will be highlighted
+ */
+ public void setHighlightRow(final boolean highlightRow) {
+ this.highlightRow = highlightRow;
+ }
+
+ /**
+ * Get the highlight column flag.
+ *
+ * @return true if the selected column is highlighted
+ */
+ public boolean getHighlightColumn() {
+ return highlightColumn;
+ }
+
+ /**
+ * Set the highlight column flag.
+ *
+ * @param highlightColumn if true, the selected column will be highlighted
+ */
+ public void setHighlightColumn(final boolean highlightColumn) {
+ this.highlightColumn = highlightColumn;
+ }
+
+ /**
+ * Get the show row labels flag.
+ *
+ * @return true if row labels are shown
+ */
+ public boolean getShowRowLabels() {
+ return showRowLabels;
+ }
+
+ /**
+ * Set the show row labels flag.
+ *
+ * @param showRowLabels if true, the row labels will be shown
+ */
+ public void setShowRowLabels(final boolean showRowLabels) {
+ this.showRowLabels = showRowLabels;
+ }
+
+ /**
+ * Get the show column labels flag.
+ *
+ * @return true if column labels are shown
+ */
+ public boolean getShowColumnLabels() {
+ return showColumnLabels;
+ }
+
+ /**
+ * Set the show column labels flag.
+ *
+ * @param showColumnLabels if true, the column labels will be shown
+ */
+ public void setShowColumnLabels(final boolean showColumnLabels) {
+ this.showColumnLabels = showColumnLabels;
+ }
+
+ /**
+ * 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();
+ }
+
+
+ /**
+ * Push top and left to the bottom-most right corner of the available
+ * grid.
+ */
+ private void bottomRightCorner() {
+ int viewColumns = getWidth();
+ if (showRowLabels == true) {
+ viewColumns -= ROW_LABEL_WIDTH;
+ }
+
+ // Set left and top such that the table stays on screen if possible.
+ top = rows.size() - getHeight();
+ left = columns.size() - (getWidth() / (viewColumns / (COLUMN_DEFAULT_WIDTH + 1)));
+ // Now ensure the selection is visible.
+ alignGrid();
+ }
+
+ /**
+ * Align the grid so that the selected cell is fully visible.
+ */
+ private void alignGrid() {
+
+ /*
+ System.err.println("alignGrid() # columns " + columns.size() +
+ " # rows " + rows.size());
+ */
+
+ int viewColumns = getWidth();
+ if (showRowLabels == true) {
+ viewColumns -= ROW_LABEL_WIDTH;
+ }
+ if (leftBorder != Border.NONE) {
+ viewColumns--;
+ }
+ int viewRows = getHeight();
+ if (showColumnLabels == true) {
+ viewRows -= COLUMN_LABEL_HEIGHT;
+ }
+ if (topBorder != Border.NONE) {
+ viewRows--;
+ }
+
+ // If we pushed left or right, adjust the box to include the new
+ // selected cell.
+ if (selectedColumn < left) {
+ left = selectedColumn - 1;
+ }
+ if (left < 0) {
+ left = 0;
+ }
+ if (selectedRow < top) {
+ top = selectedRow - 1;
+ }
+ if (top < 0) {
+ top = 0;
+ }
+
+ /*
+ * viewColumns and viewRows now contain the available columns and
+ * rows available to view the selected cell. We adjust left and top
+ * to ensure the selected cell is within view, and then make all
+ * cells outside the box between (left, top) and (right, bottom)
+ * invisible.
+ *
+ * We need to calculate right and bottom now.
+ */
+ int right = left;
+
+ boolean done = false;
+ while (!done) {
+ int rightCellX = (showRowLabels ? ROW_LABEL_WIDTH : 0);
+ if (leftBorder != Border.NONE) {
+ rightCellX++;
+ }
+ int maxCellX = rightCellX + viewColumns;
+ right = left;
+ boolean selectedIsVisible = false;
+ int selectedX = 0;
+ for (int x = left; x < columns.size(); x++) {
+ if (x == selectedColumn) {
+ selectedX = rightCellX;
+ if (selectedX + columns.get(x).width + 1 <= maxCellX) {
+ selectedIsVisible = true;
+ }
+ }
+ rightCellX += columns.get(x).width + 1;
+ if (rightCellX >= maxCellX) {
+ break;
+ }
+ right++;
+ }
+ if (right < selectedColumn) {
+ // selectedColumn is outside the view range. Push left over,
+ // and calculate again.
+ left++;
+ } else if (left == selectedColumn) {
+ // selectedColumn doesn't fit inside the view range, but we
+ // can't go over any further either. Bail out.
+ done = true;
+ } else if (selectedIsVisible == false) {
+ // selectedColumn doesn't fit inside the view range, continue
+ // on.
+ left++;
+ } else {
+ // selectedColumn is fully visible, all done.
+ assert (selectedIsVisible == true);
+ done = true;
+ }
+
+ } // while (!done)
+
+ // We have the left/right range correct, set cell visibility and
+ // column X positions.
+ int leftCellX = showRowLabels ? ROW_LABEL_WIDTH : 0;
+ if (leftBorder != Border.NONE) {
+ leftCellX++;
+ }
+ for (int x = 0; x < columns.size(); x++) {
+ if ((x < left) || (x > right)) {
+ for (int i = 0; i < rows.size(); i++) {
+ columns.get(x).get(i).setVisible(false);
+ columns.get(x).setX(getWidth() + 1);
+ }
+ continue;
+ }
+ for (int i = 0; i < rows.size(); i++) {
+ columns.get(x).get(i).setVisible(true);
+ }
+ columns.get(x).setX(leftCellX);
+ leftCellX += columns.get(x).width + 1;
+ }
+
+ int bottom = top;
+
+ done = false;
+ while (!done) {
+ int bottomCellY = (showColumnLabels ? COLUMN_LABEL_HEIGHT : 0);
+ if (topBorder != Border.NONE) {
+ bottomCellY++;
+ }
+ int maxCellY = bottomCellY + viewRows;
+ bottom = top;
+ for (int y = top; y < rows.size(); y++) {
+ bottomCellY += rows.get(y).height;
+ if (bottomCellY >= maxCellY) {
+ break;
+ }
+ bottom++;
+ }
+ if (bottom < selectedRow) {
+ // selectedRow is outside the view range. Push top down, and
+ // calculate again.
+ top++;
+ } else {
+ // selectedRow is inside the view range, done.
+ done = true;
+ }
+ } // while (!done)
+
+ // We have the top/bottom range correct, set cell visibility and
+ // row Y positions.
+ int topCellY = showColumnLabels ? COLUMN_LABEL_HEIGHT : 0;
+ if (topBorder != Border.NONE) {
+ topCellY++;
+ }
+ for (int y = 0; y < rows.size(); y++) {
+ if ((y < top) || (y > bottom)) {
+ for (int i = 0; i < columns.size(); i++) {
+ rows.get(y).get(i).setVisible(false);
+ }
+ rows.get(y).setY(getHeight() + 1);
+ continue;
+ }
+ for (int i = 0; i < columns.size(); i++) {
+ rows.get(y).get(i).setVisible(true);
+ }
+ rows.get(y).setY(topCellY);
+ topCellY += rows.get(y).height;
+ }
+
+ // Last thing: cancel any edits that are not the selected cell.
+ for (int y = 0; y < rows.size(); y++) {
+ for (int x = 0; x < columns.size(); x++) {
+ if ((x == selectedColumn) && (y == selectedRow)) {
+ continue;
+ }
+ rows.get(y).get(x).cancelEdit();
+ }
+ }
+ }
+
+ /**
+ * Load contents from file in CSV format.
+ *
+ * @param csvFile a File referencing the CSV data
+ * @throws IOException if a java.io operation throws
+ */
+ public void loadCsvFile(final File csvFile) throws IOException {
+ BufferedReader reader = null;
+
+ try {
+ reader = new BufferedReader(new FileReader(csvFile));
+
+ String line = null;
+ boolean first = true;
+ for (line = reader.readLine(); line != null;
+ line = reader.readLine()) {
+
+ List<String> list = StringUtils.fromCsv(line);
+ if (list.size() == 0) {
+ continue;
+ }
+
+ if (list.size() > columns.size()) {
+ int n = list.size() - columns.size();
+ for (int i = 0; i < n; i++) {
+ selectedColumn = columns.size() - 1;
+ insertColumnRight(selectedColumn);
+ }
+ }
+ assert (list.size() == columns.size());
+
+ if (first) {
+ // First row: just replace what is here.
+ selectedRow = 0;
+ first = false;
+ } else {
+ // All other rows: append to the end.
+ selectedRow = rows.size() - 1;
+ insertRowBelow(selectedRow);
+ selectedRow = rows.size() - 1;
+ }
+ for (int i = 0; i < list.size(); i++) {
+ rows.get(selectedRow).get(i).setText(list.get(i));
+ }
+ }
+ } finally {
+ if (reader != null) {
+ reader.close();
+ }
+ }
+
+ left = 0;
+ top = 0;
+ selectedRow = 0;
+ selectedColumn = 0;
+ alignGrid();
+ activate(columns.get(selectedColumn).get(selectedRow));
+ }
+
+ /**
+ * Save contents to file in CSV format.
+ *
+ * @param filename file to save to
+ * @throws IOException if a java.io operation throws
+ */
+ public void saveToCsvFilename(final String filename) throws IOException {
+ BufferedWriter writer = null;
+
+ try {
+ writer = new BufferedWriter(new FileWriter(filename));
+ for (Row row: rows) {
+ List<String> list = new ArrayList<String>(row.cells.size());
+ for (Cell cell: row.cells) {
+ list.add(cell.getText());
+ }
+ writer.write(StringUtils.toCsv(list));
+ writer.write("\n");
+ }
+ } finally {
+ if (writer != null) {
+ writer.close();
+ }
+ }
+ }
+
+ /**
+ * Save contents to file in text format with lines.
+ *
+ * @param filename file to save to
+ * @throws IOException if a java.io operation throws
+ */
+ public void saveToTextFilename(final String filename) throws IOException {
+ BufferedWriter writer = null;
+
+ try {
+ writer = new BufferedWriter(new FileWriter(filename));
+
+ if ((topBorder == Border.SINGLE) && (leftBorder == Border.SINGLE)) {
+ // Emit top-left corner.
+ writer.write("\u250c");
+ }
+
+ if (topBorder == Border.SINGLE) {
+ int cellI = 0;
+ for (Cell cell: rows.get(0).cells) {
+ for (int i = 0; i < columns.get(cellI).width; i++) {
+ writer.write("\u2500");
+ }
+
+ if (columns.get(cellI).rightBorder == Border.SINGLE) {
+ if (cellI < columns.size() - 1) {
+ // Emit top tee.
+ writer.write("\u252c");
+ } else {
+ // Emit top-right corner.
+ writer.write("\u2510");
+ }
+ }
+ cellI++;
+ }
+ }
+ writer.write("\n");
+
+ int rowI = 0;
+ for (Row row: rows) {
+
+ if (leftBorder == Border.SINGLE) {
+ // Emit left border.
+ writer.write("\u2502");
+ }
+
+ int cellI = 0;
+ for (Cell cell: row.cells) {
+ writer.write(String.format("%" +
+ columns.get(cellI).width + "s", cell.getText()));
+
+ if (columns.get(cellI).rightBorder == Border.SINGLE) {
+ // Emit right border.
+ writer.write("\u2502");
+ }
+ cellI++;
+ }
+ writer.write("\n");
+
+ if (row.bottomBorder == Border.NONE) {
+ // All done, move on to the next row.
+ continue;
+ }
+
+ // Emit the bottom borders and intersections.
+ if ((leftBorder == Border.SINGLE)
+ && (row.bottomBorder != Border.NONE)
+ ) {
+ if (rowI < rows.size() - 1) {
+ if (row.bottomBorder == Border.SINGLE) {
+ // Emit left tee.
+ writer.write("\u251c");
+ } else if (row.bottomBorder == Border.DOUBLE) {
+ // Emit left tee (double).
+ writer.write("\u255e");
+ } else if (row.bottomBorder == Border.THICK) {
+ // Emit left tee (thick).
+ writer.write("\u251d");
+ }
+ }
+
+ if (rowI == rows.size() - 1) {
+ if (row.bottomBorder == Border.SINGLE) {
+ // Emit left bottom corner.
+ writer.write("\u2514");
+ } else if (row.bottomBorder == Border.DOUBLE) {
+ // Emit left bottom corner (double).
+ writer.write("\u2558");
+ } else if (row.bottomBorder == Border.THICK) {
+ // Emit left bottom corner (thick).
+ writer.write("\u2515");
+ }
+ }
+ }
+
+ cellI = 0;
+ for (Cell cell: row.cells) {
+
+ for (int i = 0; i < columns.get(cellI).width; i++) {
+ if (row.bottomBorder == Border.SINGLE) {
+ writer.write("\u2500");
+ }
+ if (row.bottomBorder == Border.DOUBLE) {
+ writer.write("\u2550");
+ }
+ if (row.bottomBorder == Border.THICK) {
+ writer.write("\u2501");
+ }
+ }
+
+ if ((rowI < rows.size() - 1)
+ && (cellI == columns.size() - 1)
+ && (row.bottomBorder == Border.SINGLE)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit right tee.
+ writer.write("\u2524");
+ }
+ if ((rowI < rows.size() - 1)
+ && (cellI == columns.size() - 1)
+ && (row.bottomBorder == Border.DOUBLE)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit right tee (double).
+ writer.write("\u2561");
+ }
+ if ((rowI < rows.size() - 1)
+ && (cellI == columns.size() - 1)
+ && (row.bottomBorder == Border.THICK)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit right tee (thick).
+ writer.write("\u2525");
+ }
+ if ((rowI == rows.size() - 1)
+ && (cellI == columns.size() - 1)
+ && (row.bottomBorder == Border.SINGLE)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit right bottom corner.
+ writer.write("\u2518");
+ }
+ if ((rowI == rows.size() - 1)
+ && (cellI == columns.size() - 1)
+ && (row.bottomBorder == Border.DOUBLE)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit right bottom corner (double).
+ writer.write("\u255b");
+ }
+ if ((rowI == rows.size() - 1)
+ && (cellI == columns.size() - 1)
+ && (row.bottomBorder == Border.THICK)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit right bottom corner (thick).
+ writer.write("\u2519");
+ }
+ if ((rowI < rows.size() - 1)
+ && (cellI < columns.size() - 1)
+ && (row.bottomBorder == Border.SINGLE)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit intersection.
+ writer.write("\u253c");
+ }
+ if ((rowI < rows.size() - 1)
+ && (cellI < columns.size() - 1)
+ && (row.bottomBorder == Border.DOUBLE)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit intersection (double).
+ writer.write("\u256a");
+ }
+ if ((rowI < rows.size() - 1)
+ && (cellI < columns.size() - 1)
+ && (row.bottomBorder == Border.THICK)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit intersection (thick).
+ writer.write("\u253f");
+ }
+ if ((rowI == rows.size() - 1)
+ && (cellI < columns.size() - 1)
+ && (row.bottomBorder == Border.SINGLE)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit bottom tee.
+ writer.write("\u2534");
+ }
+ if ((rowI == rows.size() - 1)
+ && (cellI < columns.size() - 1)
+ && (row.bottomBorder == Border.DOUBLE)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit bottom tee (double).
+ writer.write("\u2567");
+ }
+ if ((rowI == rows.size() - 1)
+ && (cellI < columns.size() - 1)
+ && (row.bottomBorder == Border.THICK)
+ && (columns.get(cellI).rightBorder == Border.SINGLE)
+ ) {
+ // Emit bottom tee (thick).
+ writer.write("\u2537");
+ }
+
+ cellI++;
+ }
+
+ writer.write("\n");
+ rowI++;
+ }
+ } finally {
+ if (writer != null) {
+ writer.close();
+ }
+ }
+ }
+
+ /**
+ * Set the selected cell location.
+ *
+ * @param column the selected cell location column
+ * @param row the selected cell location row
+ */
+ public void setSelectedCell(final int column, final int row) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ selectedColumn = column;
+ selectedRow = row;
+ alignGrid();
+ }
+
+ /**
+ * Get a particular cell.
+ *
+ * @param column the cell column
+ * @param row the cell row
+ * @return the cell
+ */
+ public Cell getCell(final int column, final int row) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ return rows.get(row).get(column);
+ }
+
+ /**
+ * Get the text of a particular cell.
+ *
+ * @param column the cell column
+ * @param row the cell row
+ * @return the text in the cell
+ */
+ public String getCellText(final int column, final int row) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ return rows.get(row).get(column).getText();
+ }
+
+ /**
+ * Set the text of a particular cell.
+ *
+ * @param column the cell column
+ * @param row the cell row
+ * @param text the text to put into the cell
+ */
+ public void setCellText(final int column, final int row,
+ final String text) {
+
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ rows.get(row).get(column).setText(text);
+ }
+
+ /**
+ * Set the action to perform when the user presses enter on a particular
+ * cell.
+ *
+ * @param column the cell column
+ * @param row the cell row
+ * @param action the action to perform when the user presses enter on the
+ * cell
+ */
+ public void setCellEnterAction(final int column, final int row,
+ final TAction action) {
+
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ rows.get(row).get(column).field.setEnterAction(action);
+ }
+
+ /**
+ * Set the action to perform when the user updates a particular cell.
+ *
+ * @param column the cell column
+ * @param row the cell row
+ * @param action the action to perform when the user updates the cell
+ */
+ public void setCellUpdateAction(final int column, final int row,
+ final TAction action) {
+
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ rows.get(row).get(column).field.setUpdateAction(action);
+ }
+
+ /**
+ * Get the width of a column.
+ *
+ * @param column the column number
+ * @return the width of the column
+ */
+ public int getColumnWidth(final int column) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ return columns.get(column).width;
+ }
+
+ /**
+ * Set the width of a column.
+ *
+ * @param column the column number
+ * @param width the new width of the column
+ */
+ public void setColumnWidth(final int column, final int width) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+
+ if (width < 4) {
+ // Columns may not be smaller than 4 cells wide.
+ return;
+ }
+
+ int delta = width - columns.get(column).width;
+ columns.get(column).width = width;
+ for (Cell cell: columns.get(column).cells) {
+ cell.setWidth(columns.get(column).width);
+ cell.field.setWidth(columns.get(column).width);
+ }
+ for (int i = column + 1; i < columns.size(); i++) {
+ columns.get(i).setX(columns.get(i).getX() + delta);
+ }
+ if (column == columns.size() - 1) {
+ bottomRightCorner();
+ } else {
+ alignGrid();
+ }
+ }
+
+ /**
+ * Get the label of a column.
+ *
+ * @param column the column number
+ * @return the label of the column
+ */
+ public String getColumnLabel(final int column) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ return columns.get(column).label;
+ }
+
+ /**
+ * Set the label of a column.
+ *
+ * @param column the column number
+ * @param label the new label of the column
+ */
+ public void setColumnLabel(final int column, final String label) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ columns.get(column).label = label;
+ }
+
+ /**
+ * Get the label of a row.
+ *
+ * @param row the row number
+ * @return the label of the row
+ */
+ public String getRowLabel(final int row) {
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ return rows.get(row).label;
+ }
+
+ /**
+ * Set the label of a row.
+ *
+ * @param row the row number
+ * @param label the new label of the row
+ */
+ public void setRowLabel(final int row, final String label) {
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ rows.get(row).label = label;
+ }
+
+ /**
+ * Insert one row at a particular index.
+ *
+ * @param idx the row number
+ */
+ private void insertRowAt(final int idx) {
+ Row newRow = new Row(idx);
+ for (int i = 0; i < columns.size(); i++) {
+ Cell cell = new Cell(this, columns.get(i).getX(),
+ rows.get(idx).getY(), COLUMN_DEFAULT_WIDTH, 1, i, idx);
+ newRow.add(cell);
+ columns.get(i).cells.add(idx, cell);
+ }
+ rows.add(idx, newRow);
+
+ for (int x = 0; x < columns.size(); x++) {
+ for (int y = idx; y < rows.size(); y++) {
+ columns.get(x).get(y).row = y;
+ columns.get(x).get(y).column = x;
+ }
+ }
+ for (int i = idx + 1; i < rows.size(); i++) {
+ String oldRowLabel = Integer.toString(i - 1);
+ if (rows.get(i).label.equals(oldRowLabel)) {
+ rows.get(i).label = Integer.toString(i);
+ }
+ }
+ alignGrid();
+ }
+
+ /**
+ * Insert one row above a particular row.
+ *
+ * @param row the row number
+ */
+ public void insertRowAbove(final int row) {
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ insertRowAt(row);
+ selectedRow++;
+ activate(columns.get(selectedColumn).get(selectedRow));
+ }
+
+ /**
+ * Insert one row below a particular row.
+ *
+ * @param row the row number
+ */
+ public void insertRowBelow(final int row) {
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ int idx = row + 1;
+ if (idx < rows.size()) {
+ insertRowAt(idx);
+ activate(columns.get(selectedColumn).get(selectedRow));
+ return;
+ }
+
+ // row is the last row, we need to perform an append.
+ Row newRow = new Row(idx);
+ for (int i = 0; i < columns.size(); i++) {
+ Cell cell = new Cell(this, columns.get(i).getX(),
+ rows.get(row).getY(), COLUMN_DEFAULT_WIDTH, 1, i, idx);
+ newRow.add(cell);
+ columns.get(i).cells.add(cell);
+ }
+ rows.add(newRow);
+ alignGrid();
+ activate(columns.get(selectedColumn).get(selectedRow));
+ }
+
+ /**
+ * Delete a particular row.
+ *
+ * @param row the row number
+ */
+ public void deleteRow(final int row) {
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ if (rows.size() == 1) {
+ // Don't delete the last row.
+ return;
+ }
+ for (int i = 0; i < columns.size(); i++) {
+ Cell cell = columns.get(i).cells.remove(row);
+ getChildren().remove(cell);
+ }
+ rows.remove(row);
+
+ for (int x = 0; x < columns.size(); x++) {
+ for (int y = row; y < rows.size(); y++) {
+ columns.get(x).get(y).row = y;
+ columns.get(x).get(y).column = x;
+ }
+ }
+ for (int i = row; i < rows.size(); i++) {
+ String oldRowLabel = Integer.toString(i + 1);
+ if (rows.get(i).label.equals(oldRowLabel)) {
+ rows.get(i).label = Integer.toString(i);
+ }
+ }
+ if (selectedRow == rows.size()) {
+ selectedRow--;
+ }
+ activate(columns.get(selectedColumn).get(selectedRow));
+ bottomRightCorner();
+ }
+
+ /**
+ * Insert one column at a particular index.
+ *
+ * @param idx the column number
+ */
+ private void insertColumnAt(final int idx) {
+ Column newColumn = new Column(idx);
+ for (int i = 0; i < rows.size(); i++) {
+ Cell cell = new Cell(this, columns.get(idx).getX(),
+ rows.get(i).getY(), COLUMN_DEFAULT_WIDTH, 1, idx, i);
+ newColumn.add(cell);
+ rows.get(i).cells.add(idx, cell);
+ }
+ columns.add(idx, newColumn);
+
+ for (int x = idx; x < columns.size(); x++) {
+ for (int y = 0; y < rows.size(); y++) {
+ columns.get(x).get(y).row = y;
+ columns.get(x).get(y).column = x;
+ }
+ }
+ for (int i = idx + 1; i < columns.size(); i++) {
+ String oldColumnLabel = makeColumnLabel(i - 1);
+ if (columns.get(i).label.equals(oldColumnLabel)) {
+ columns.get(i).label = makeColumnLabel(i);
+ }
+ }
+ alignGrid();
+ }
+
+ /**
+ * Insert one column to the left of a particular column.
+ *
+ * @param column the column number
+ */
+ public void insertColumnLeft(final int column) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ insertColumnAt(column);
+ selectedColumn++;
+ activate(columns.get(selectedColumn).get(selectedRow));
+ }
+
+ /**
+ * Insert one column to the right of a particular column.
+ *
+ * @param column the column number
+ */
+ public void insertColumnRight(final int column) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ int idx = column + 1;
+ if (idx < columns.size()) {
+ insertColumnAt(idx);
+ activate(columns.get(selectedColumn).get(selectedRow));
+ return;
+ }
+
+ // column is the last column, we need to perform an append.
+ Column newColumn = new Column(idx);
+ for (int i = 0; i < rows.size(); i++) {
+ Cell cell = new Cell(this, columns.get(column).getX(),
+ rows.get(i).getY(), COLUMN_DEFAULT_WIDTH, 1, idx, i);
+ newColumn.add(cell);
+ rows.get(i).cells.add(cell);
+ }
+ columns.add(newColumn);
+ alignGrid();
+ activate(columns.get(selectedColumn).get(selectedRow));
+ }
+
+ /**
+ * Delete a particular column.
+ *
+ * @param column the column number
+ */
+ public void deleteColumn(final int column) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ if (columns.size() == 1) {
+ // Don't delete the last column.
+ return;
+ }
+ for (int i = 0; i < rows.size(); i++) {
+ Cell cell = rows.get(i).cells.remove(column);
+ getChildren().remove(cell);
+ }
+ columns.remove(column);
+
+ for (int x = column; x < columns.size(); x++) {
+ for (int y = 0; y < rows.size(); y++) {
+ columns.get(x).get(y).row = y;
+ columns.get(x).get(y).column = x;
+ }
+ }
+ for (int i = column; i < columns.size(); i++) {
+ String oldColumnLabel = makeColumnLabel(i + 1);
+ if (columns.get(i).label.equals(oldColumnLabel)) {
+ columns.get(i).label = makeColumnLabel(i);
+ }
+ }
+ if (selectedColumn == columns.size()) {
+ selectedColumn--;
+ }
+ activate(columns.get(selectedColumn).get(selectedRow));
+ bottomRightCorner();
+ }
+
+ /**
+ * Delete the selected cell, shifting cells over to the left.
+ */
+ public void deleteCellShiftLeft() {
+ // All we do is copy the text from every cell in this row over.
+ for (int i = selectedColumn + 1; i < columns.size(); i++) {
+ setCellText(i - 1, selectedRow, getCellText(i, selectedRow));
+ }
+ setCellText(columns.size() - 1, selectedRow, "");
+ }
+
+ /**
+ * Delete the selected cell, shifting cells from below up.
+ */
+ public void deleteCellShiftUp() {
+ // All we do is copy the text from every cell in this column up.
+ for (int i = selectedRow + 1; i < rows.size(); i++) {
+ setCellText(selectedColumn, i - 1, getCellText(selectedColumn, i));
+ }
+ setCellText(selectedColumn, rows.size() - 1, "");
+ }
+
+ /**
+ * Set a particular cell read-only (non-editable) or not.
+ *
+ * @param column the cell column
+ * @param row the cell row
+ * @param readOnly if true, the cell will be non-editable
+ */
+ public void setCellReadOnly(final int column, final int row,
+ final boolean readOnly) {
+
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ rows.get(row).get(column).setReadOnly(readOnly);
+ }
+
+ /**
+ * Set an entire row of cells read-only (non-editable) or not.
+ *
+ * @param row the row number
+ * @param readOnly if true, the cells will be non-editable
+ */
+ public void setRowReadOnly(final int row, final boolean readOnly) {
+ if ((row < 0) || (row > rows.size() - 1)) {
+ throw new IndexOutOfBoundsException("Row count is " +
+ rows.size() + ", requested index " + row);
+ }
+ for (Cell cell: rows.get(row).cells) {
+ cell.setReadOnly(readOnly);
+ }
+ }
+
+ /**
+ * Set an entire column of cells read-only (non-editable) or not.
+ *
+ * @param column the column number
+ * @param readOnly if true, the cells will be non-editable
+ */
+ public void setColumnReadOnly(final int column, final boolean readOnly) {
+ if ((column < 0) || (column > columns.size() - 1)) {
+ throw new IndexOutOfBoundsException("Column count is " +
+ columns.size() + ", requested index " + column);
+ }
+ for (Cell cell: columns.get(column).cells) {
+ cell.setReadOnly(readOnly);
+ }
+ }
+
+ /**
+ * Set all borders across the entire table to Border.NONE.
+ */
+ public void setBorderAllNone() {
+ topBorder = Border.NONE;
+ leftBorder = Border.NONE;
+ for (int i = 0; i < columns.size(); i++) {
+ columns.get(i).rightBorder = Border.NONE;
+ }
+ for (int i = 0; i < rows.size(); i++) {
+ rows.get(i).bottomBorder = Border.NONE;
+ rows.get(i).height = 1;
+ }
+ bottomRightCorner();
+ }
+
+ /**
+ * Set all borders across the entire table to Border.SINGLE.
+ */
+ public void setBorderAllSingle() {
+ topBorder = Border.SINGLE;
+ leftBorder = Border.SINGLE;
+ for (int i = 0; i < columns.size(); i++) {
+ columns.get(i).rightBorder = Border.SINGLE;
+ }
+ for (int i = 0; i < rows.size(); i++) {
+ rows.get(i).bottomBorder = Border.SINGLE;
+ rows.get(i).height = 2;
+ }
+ alignGrid();
+ }
+
+ /**
+ * Set all borders around the selected cell to Border.NONE.
+ */
+ public void setBorderCellNone() {
+ if (selectedRow == 0) {
+ topBorder = Border.NONE;
+ }
+ if (selectedColumn == 0) {
+ leftBorder = Border.NONE;
+ }
+ if (selectedColumn > 0) {
+ columns.get(selectedColumn - 1).rightBorder = Border.NONE;
+ }
+ columns.get(selectedColumn).rightBorder = Border.NONE;
+ if (selectedRow > 0) {
+ rows.get(selectedRow - 1).bottomBorder = Border.NONE;
+ rows.get(selectedRow - 1).height = 1;
+ }
+ rows.get(selectedRow).bottomBorder = Border.NONE;
+ rows.get(selectedRow).height = 1;
+ bottomRightCorner();
+ }
+
+ /**
+ * Set all borders around the selected cell to Border.SINGLE.
+ */
+ public void setBorderCellSingle() {
+ if (selectedRow == 0) {
+ topBorder = Border.SINGLE;
+ }
+ if (selectedColumn == 0) {
+ leftBorder = Border.SINGLE;
+ }
+ if (selectedColumn > 0) {
+ columns.get(selectedColumn - 1).rightBorder = Border.SINGLE;
+ }
+ columns.get(selectedColumn).rightBorder = Border.SINGLE;
+ if (selectedRow > 0) {
+ rows.get(selectedRow - 1).bottomBorder = Border.SINGLE;
+ rows.get(selectedRow - 1).height = 2;
+ }
+ rows.get(selectedRow).bottomBorder = Border.SINGLE;
+ rows.get(selectedRow).height = 2;
+ alignGrid();
+ }
+
+ /**
+ * Set the column border to the right of the selected cell to
+ * Border.SINGLE.
+ */
+ public void setBorderColumnRightSingle() {
+ columns.get(selectedColumn).rightBorder = Border.SINGLE;
+ alignGrid();
+ }
+
+ /**
+ * Set the column border to the right of the selected cell to
+ * Border.SINGLE.
+ */
+ public void setBorderColumnLeftSingle() {
+ if (selectedColumn == 0) {
+ leftBorder = Border.SINGLE;
+ } else {
+ columns.get(selectedColumn - 1).rightBorder = Border.SINGLE;
+ }
+ alignGrid();
+ }
+
+ /**
+ * Set the row border above the selected cell to Border.SINGLE.
+ */
+ public void setBorderRowAboveSingle() {
+ if (selectedRow == 0) {
+ topBorder = Border.SINGLE;
+ } else {
+ rows.get(selectedRow - 1).bottomBorder = Border.SINGLE;
+ rows.get(selectedRow - 1).height = 2;
+ }
+ alignGrid();
+ }
+
+ /**
+ * Set the row border below the selected cell to Border.SINGLE.
+ */
+ public void setBorderRowBelowSingle() {
+ rows.get(selectedRow).bottomBorder = Border.SINGLE;
+ rows.get(selectedRow).height = 2;
+ alignGrid();
+ }
+
+ /**
+ * Set the row border below the selected cell to Border.DOUBLE.
+ */
+ public void setBorderRowBelowDouble() {
+ rows.get(selectedRow).bottomBorder = Border.DOUBLE;
+ rows.get(selectedRow).height = 2;
+ alignGrid();
+ }
+
+ /**
+ * Set the row border below the selected cell to Border.THICK.
+ */
+ public void setBorderRowBelowThick() {
+ rows.get(selectedRow).bottomBorder = Border.THICK;
+ rows.get(selectedRow).height = 2;
+ alignGrid();
+ }
+
}