module Fox
#
# Represents a cell position in an FXTable.
#
class FXTablePos
# Cell row (zero-based) [Integer]
attr_accessor :row
# Cell column (zero-based) [Integer]
attr_accessor :col
#
# Returns an initialized FXTablePos instance.
#
def initialize; end
end
#
# Represents a range of cells in an FXTable.
#
class FXTableRange
# Starting position for this range of cells {FXTablePos}
attr_accessor :fm
# Ending position for this range of cells {FXTablePos}
attr_accessor :to
#
# Returns an initialized FXTableRange instance.
#
def initialize; end
end
#
# Represents a particular cell in an FXTable.
#
class FXTableItem < FXObject
# Text associated with this cell [String]
attr_accessor :text
# Icon associated with this cell {FXIcon}
attr_accessor :icon
# User data associated with this cell [Object]
attr_accessor :data
# Indicates whether this item has the focus [Boolean]
attr_writer :focus
# Indicates whether this item is selected [Boolean]
attr_writer :selected
# Indicates whether this item is enabled [Boolean]
attr_writer :enabled
# Indicates whether this item is draggable [Boolean]
attr_writer :draggable
#
# Indicates how the text in the cell will be justified.
# This value is some combination of the horizontal justification
# flags +LEFT+, +CENTER_X+ and +RIGHT+, and the vertical
# justification flags +TOP+, +CENTER_Y+ and +BOTTOM+.
#
attr_accessor :justify
# The icon's position in the cell, relative to the text (one
# of +BEFORE+, +AFTER+, +ABOVE+ or +BELOW+) [Integer]
attr_accessor :iconPosition
# Which borders will be drawn for this cell (some combination of
# +LBORDER+, +RBORDER+, +TBORDER+ and +BBORDER+) [Integer]
attr_accessor :borders
# The background stipple pattern for this cell [Integer]
attr_accessor :stipple
#
# Return an initialized FXTableItem instance.
#
# ==== Parameters:
#
# +text+:: the text for this table item [String]
# +icon+:: the icon, if any, for this table item {FXIcon}
# +data+:: the user data for this table item [Object]
#
def initialize(text, icon=nil, data=nil); end
# Return the width of this item (in pixels)
def getWidth(table); end
# Return the height of this item (in pixels)
def getHeight(table); end
# Return true if this item has the focus
def hasFocus?; end
# Return true if this item is selected
def selected?; end
# Return true if this item is enabled
def enabled?; end
# Return true if this item is draggable
def draggable?; end
# Return the text for this table item
def to_s
text
end
# Change item icon, deleting the previous item icon if it was owned
# by this table item.
def setIcon(icn, owned=false); end
# Draw this table item
def draw(table, dc, x, y, w, h); end
# Draw borders
def drawBorders(table, dc, x, y, w, h); end
# Draw content
def drawContent(table, dc, x, y, w, h); end
# Draw hatch pattern
def drawPattern(table, dc, x, y, w, h); end
# Draw background behind the cell
def drawBackground(table, dc, x, y, w, h)
hg = table.horizontalGridShown? ? 1 : 0
vg = table.verticalGridShown? ? 1 : 0
dc.fillRectangle(x + vg, y + hg, w - vg, h - hg)
end
#
# Create input control for editing this item.
# Should return a new instance of some subclass of FXWindow.
#
def getControlFor(table); end
#
# Set item value from input _control_ (an instance of some subclass
# of FXWindow).
#
def setFromControl(control); end
# Create the server-side resources associated with this table item
def create; end
# Detach the server-side resources associated with this table item
def detach; end
# Destroy the server-side resources associated with this table item
def destroy; end
end
#
# The FXTable widget displays a table of items, each with some text and optional
# icon. A column Header control provide captions for each column, and a row
# Header control provides captions for each row. Columns are resizable by
# means of the column Header control if the TABLE_COL_SIZABLE option is passed.
# Likewise, rows in the table are resizable if the TABLE_ROW_SIZABLE option is
# specified. An entire row (column) can be selected by clicking on the a button
# in the row (column) Header control. Passing TABLE_NO_COLSELECT disables column
# selection, and passing TABLE_NO_ROWSELECT disables column selection.
# When TABLE_COL_RENUMBER is specified, columns are automatically renumbered when
# columns are added or removed. Similarly, TABLE_ROW_RENUMBER will cause row numbers
# to be recalculated automatically when rows are added or removed.
# To disable editing of cells in the table, the TABLE_READONLY can be specified.
# Cells in the table may or may not have items in them. When populating a cell
# for the first time, an item will be automatically created if necessary. Thus,
# a cell in the table takes no space unless it has actual contents.
# Moreover, a contiguous, rectangular region of cells in the table may refer to
# one single item; in that case, the item will be stretched to cover all the
# cells in the region, and no grid lines will be drawn interior to the spanning
# item.
#
# The Table widget issues SEL_SELECTED or SEL_DESELECTED when cells are selected
# or deselected, respectively. The table position affected is passed along as the
# 3rd parameter of these messages.
# Whenever the current (focus) item is changed, a SEL_CHANGED message is sent with
# the new table position as a parameter.
# When items are added to the table, a SEL_INSERTED message is sent, with the table
# range of the newly added cells as the parameter in the message.
# When items are removed from the table, a SEL_DELETED message is sent prior to the
# removal of the items, and the table range of the removed cells is passed as a parameter.
# A SEL_REPLACED message is sent when the contents of a cell are changed, either through
# editing or by other means; the parameter is the range of affected cells. This message
# is sent prior to the change.
# SEL_CLICKED, SEL_DOUBLECLICKED, and SEL_TRIPLECLICKED messages are sent when a cell
# is clicked, double-clicked, or triple-clicked, respectively.
# A SEL_COMMAND is sent when an enabled item is clicked inside the table.
#
# === Events
#
# The following messages are sent by FXTable to its target:
#
# +SEL_COMMAND+:: sent when a new item is clicked; the message data is an FXTablePos instance indicating the current cell.
# +SEL_KEYPRESS+:: sent when a key goes down; the message data is an FXEvent instance.
# +SEL_KEYRELEASE+:: sent when a key goes up; the message data is an FXEvent instance.
# +SEL_LEFTBUTTONPRESS+:: sent when the left mouse button goes down; the message data is an FXEvent instance.
# +SEL_LEFTBUTTONRELEASE+:: sent when the left mouse button goes up; the message data is an FXEvent instance.
# +SEL_RIGHTBUTTONPRESS+:: sent when the left mouse button goes down; the message data is an FXEvent instance.
# +SEL_RIGHTBUTTONRELEASE+:: sent when the left mouse button goes up; the message data is an FXEvent instance.
# +SEL_SELECTED+:: sent when a cell is selected; the message data is an FXTablePos instance indicating the position of the selected cell.
# +SEL_DESELECTED+:: sent when a cell is deselected; the message data is an FXTablePos instance indicating the position of the deselected cell.
# +SEL_CHANGED+:: sent when the current cell changes; the message data is an FXTablePos instance indicating the current cell.
# +SEL_CLICKED+:: sent when a cell is single-clicked; the message data is an FXTablePos instance indicating the current cell.
# +SEL_DOUBLECLICKED+:: sent when a cell is double-clicked; the message data is an FXTablePos instance indicating the current cell.
# +SEL_TRIPLECLICKED+:: sent when a cell is triple-clicked; the message data is an FXTablePos instance indicating the current cell.
# +SEL_DELETED+:: sent when a range of cells is about to be removed; the message data is an FXTableRange instance indicating the cells to be removed.
# +SEL_INSERTED+:: sent when a range of cells has been inserted; the message data is an FXTableRange instance indicating the cells inserted.
# +SEL_REPLACED+:: sent when a range of cells has been replaced; the message data is an FXTableRange instance indicating the cells replaced.
#
# === Table options
#
# +TABLE_COL_SIZABLE+:: Columns are resizable
# +TABLE_ROW_SIZABLE+:: Rows are resizable
# +TABLE_NO_COLSELECT+:: Disallow column selections
# +TABLE_NO_ROWSELECT+:: Disallow row selections
# +TABLE_READONLY+:: Table is not editable
# +TABLE_COL_RENUMBER+:: Renumber columns
# +TABLE_ROW_RENUMBER+:: Renumber rows
#
# === Message identifiers
#
# +ID_HORZ_GRID+:: x
# +ID_VERT_GRID+:: x
# +ID_TOGGLE_EDITABLE+:: x
# +ID_DELETE_COLUMN+:: x
# +ID_DELETE_ROW+:: x
# +ID_INSERT_COLUMN+:: x
# +ID_INSERT_ROW+:: x
# +ID_SELECT_COLUMN_INDEX+:: x
# +ID_SELECT_ROW_INDEX+:: x
# +ID_SELECT_COLUMN+:: x
# +ID_SELECT_ROW+:: x
# +ID_SELECT_CELL+:: x
# +ID_SELECT_ALL+:: x
# +ID_DESELECT_ALL+:: x
# +ID_MOVE_LEFT+:: x
# +ID_MOVE_RIGHT+:: x
# +ID_MOVE_UP+:: x
# +ID_MOVE_DOWN+:: x
# +ID_MOVE_HOME+:: x
# +ID_MOVE_END+:: x
# +ID_MOVE_TOP+:: x
# +ID_MOVE_BOTTOM+:: x
# +ID_MOVE_PAGEDOWN+:: x
# +ID_MOVE_PAGEUP+:: x
# +ID_START_INPUT+:: x
# +ID_CANCEL_INPUT+:: x
# +ID_ACCEPT_INPUT+:: x
# +ID_MARK+:: x
# +ID_EXTEND+:: x
# +ID_CUT_SEL+:: x
# +ID_COPY_SEL+:: x
# +ID_PASTE_SEL+:: x
# +ID_DELETE_SEL+:: x
class FXTable < FXScrollArea
# Button in the upper left corner {FXButton}
attr_reader :cornerButton
# Column header control {FXHeader}
attr_reader :columnHeader
# Row header control {FXHeader}
attr_reader :rowHeader
# Number of visible rows [Integer]
attr_accessor :visibleRows
# Number of visible columns [Integer]
attr_accessor :visibleColumns
# Number of rows [Integer]
attr_reader :numRows
# Number of columns [Integer]
attr_reader :numColumns
# Top cell margin, in pixels [Integer]
attr_accessor :marginTop
# Bottom cell margin, in pixels [Integer]
attr_accessor :marginBottom
# Left cell margin, in pixels [Integer]
attr_accessor :marginLeft
# Right cell margin, in pixels [Integer]
attr_accessor :marginRight
# Table style [Integer]
attr_accessor :tableStyle
# The column header height mode is either fixed (LAYOUT_FIX_HEIGHT) or variable.
# In variable height mode, the column header will size to fit the contents in it.
# In fixed height mode, the size is explicitly set via the _columnHeaderHeight_
# attribute.
attr_accessor :columnHeaderMode
# The row header width mode is either fixed (LAYOUT_FIX_WIDTH) or variable.
# In variable width mode, the row header will size to fit the contents in it.
# In fixed width mode, the size is explicitly set via the _rowHeaderWidth_
# attribute.
attr_accessor :rowHeaderMode
# Row header font {FXFont}
attr_accessor :rowHeaderFont
# Column header font {FXFont}
attr_accessor :columnHeaderFont
# The fixed column header height, if _columnHeaderMode_ is +LAYOUT_FIX_HEIGHT+.
attr_accessor :columnHeaderHeight
# The fixed row header width, if _rowHeaderMode_ is +LAYOUT_FIX_WIDTH+.
attr_accessor :rowHeaderWidth
# Default column width, in pixels [Integer]
attr_accessor :defColumnWidth
# Default row height, in pixels [Integer]
attr_accessor :defRowHeight
# Row number for current cell [Integer]
attr_reader :currentRow
# Column number for current cell [Integer]
attr_reader :currentColumn
# Row number for anchor cell [Integer]
attr_reader :anchorRow
# Column number for anchor cell [Integer]
attr_reader :anchorColumn
# Starting row number for selection, or -1 if there is no selection [Integer]
attr_reader :selStartRow
# Starting column number for selection, or -1 if there is no selection [Integer]
attr_reader :selStartColumn
# Ending row number for selection, or -1 if there is no selection [Integer]
attr_reader :selEndRow
# Ending column number for selection, or -1 if there is no selection [Integer]
attr_reader :selEndColumn
# Text font {FXFont}
attr_accessor :font
# Text color {FXColor}
attr_accessor :textColor
# Base GUI color {FXColor}
attr_accessor :baseColor
# Highlight color {FXColor}
attr_accessor :hiliteColor
# Shadow color {FXColor}
attr_accessor :shadowColor
# Border color {FXColor}
attr_accessor :borderColor
# Background color for selected cell(s) {FXColor}
attr_accessor :selBackColor
# Text color for selected cell(s) {FXColor}
attr_accessor :selTextColor
# Grid color {FXColor}
attr_accessor :gridColor
# Stipple color {FXColor}
attr_accessor :stippleColor
# Cell border color {FXColor}
attr_accessor :cellBorderColor
# Cell border width, in pixels [Integer]
attr_accessor :cellBorderWidth
# Status line help text [String]
attr_accessor :helpText
# Returns the drag type for CSV data
def FXTable.csvType; end
# Returns the drag type name for CSV data
def FXTable.csvTypeName; end
#
# Construct a new FXTable instance.
# The table is initially empty, and reports a default size based on
# the scroll areas's scrollbar placement policy.
#
# ==== Parameters:
#
# +p+:: the parent window for this table {FXComposite}
# +target+:: the message target (if any) for this table {FXObject}
# +selector+:: the message identifier for this table [Integer]
# +opts+:: table options [Integer]
# +x+:: initial x-position [Integer]
# +y+:: initial y-position [Integer]
# +width+:: initial width [Integer]
# +height+:: initial height [Integer]
# +padLeft+:: internal padding on the left side, in pixels [Integer]
# +padRight+:: internal padding on the right side, in pixels [Integer]
# +padTop+:: internal padding on the top side, in pixels [Integer]
# +padBottom+:: internal padding on the bottom side, in pixels [Integer]
#
def initialize(p, target=nil, selector=0, opts=0, x=0, y=0, width=0, height=0, padLeft=DEFAULT_MARGIN, padRight=DEFAULT_MARGIN, padTop=DEFAULT_MARGIN, padBottom=DEFAULT_MARGIN) # :yields: theTable
end
# Set visibility of horizontal grid to +true+ or +false+.
def horizontalGridShown=(vis); end
# Return +true+ if horizontal grid is shown.
def horizontalGridShown? ; end
# Set visibility of vertical grid to +true+ or +false+.
def verticalGridShown=(vis); end
# Is vertical grid shown?
def verticalGridShown? ; end
#
# Show or hide horizontal grid.
# Note that this is equivalent to the {#horizontalGridShown=} method.
#
def showHorzGrid(on=true) ; end
#
# Show or hide vertical grid.
# Note that this is equivalent to the {#verticalGridShown=} method.
#
def showVertGrid(on=true) ; end
# Set editability of this table to +true+ or +false+.
def editable=(edit); end
# Return +true+ if this table is editable.
def editable? ; end
#
# Start input mode for the cell at the given position.
# An input control is created which is used to edit the cell;
# it is filled by the original item's contents if the cell contained
# an item. You can enter input mode also by sending the table an
# <tt>ID_START_INPUT</tt> message.
#
def startInput(row, col); end
#
# Cancel input mode. The input control is immediately deleted
# and the cell will retain its old value. You can also cancel
# input mode by sending the table an <tt>ID_CANCEL_INPUT</tt> message.
#
def cancelInput(); end
#
# End input mode and accept the new value from the control.
# The item in the cell will be set to the value from the control,
# and the control will be deleted. If +true+ is passed, a +SEL_REPLACED+
# callback will be generated to signify to the target that this call
# has a new value. You can also accept the input by sending the table
# an <tt>ID_ACCEPT_INPUT</tt> message.
#
def acceptInput(notify=false); end
#
# Determine row containing _y_.
# Returns -1 if _y_ is above the first row, and _numRows_ if _y_ is below the last row.
# Otherwise, returns the row in the table containing _y_.
#
def rowAtY(y) ; end
#
# Determine column containing _x_.
# Returns -1 if _x_ is to the left of the first column, and _numColumns_ if _x_ is
# to the right of the last column. Otherwise, returns the column in the table
# containing _x_.
#
def colAtX(x) ; end
# Return the item (a reference to an FXTableItem) at the given _row_ and _column_.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def getItem(row, column) ; end
# Replace the item at the given _row_ and _column_ with a (possibly subclassed) _item_.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def setItem(row, column, item) ; end
#
# Resize the table content to _numRows_ rows and _numCols_ columns.
# Note that all existing items in the table will be destroyed and new
# items will be constructed.
# If _notify_ is +true+, then
# * a +SEL_DELETED+ message will be sent to the table's message target
# indicating which cells (if any) are about to be destroyed as a result of the resize;
# * a +SEL_INSERTED+ message will be sent to the table's message target
# indicating which cells (if any) were added as a result of the resize; and,
# * a +SEL_CHANGED+ message will be sent to the table's message target
# indicating the new current cell.
#
# Raises ArgError if either _numRows_ or _numCols_ is less than zero.
#
def setTableSize(numRows, numCols, notify=false) ; end
#
# Insert _numRows_ rows beginning at the specified _row_ number.
# If _row_ is equal to the number of rows in the table, the new
# rows are added to the bottom of the table.
# If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the table's
# message target for each cell that is inserted.
# Raises IndexError if _row_ is out of bounds.
#
def insertRows(row, numRows=1, notify=false) ; end
#
# Insert _numColumns_ columns beginning at the specified _column_ number.
# If _column_ is equal to the number of columns in the table, the
# new columns are added to the right of the table.
# If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the table's
# message target for each cell that is inserted.
# Raises IndexError if _column_ is out of bounds.
#
def insertColumns(column, numColumns=1, notify=false) ; end
#
# Remove the _nr_ rows starting at the specified _row_.
# If _notify_ is +true+, a +SEL_DELETED+ message is sent to the table's
# message target for each cell that is removed.
# Raises IndexError if _row_ is less than zero, or if _row_ + _nr_
# is greater than the current number of table rows.
#
def removeRows(row, nr=1, notify=false) ; end
#
# Remove the _nc_ columns starting at the specified _column_.
# If _notify_ is +true+, a +SEL_DELETED+ message is sent to the table's
# message target for each cell that is removed.
# Raises IndexError if _column_ is less than zero, or if
# _column_ + _nc_ is greater than the current number of table columns.
#
def removeColumns(column, nc=1, notify=false) ; end
#
# Extract item from table and return a reference to it.
# If _notify_ is +true+, a +SEL_REPLACED+ message is sent to the table's
# message target before this cell is removed.
# Raises IndexError if either _row_ or _col_ is out of bounds.
#
def extractItem(r, c, notify=false); end
#
# Remove item at (_row_, _col_), replacing it with +nil+.
# If _notify_ is +true+, a +SEL_REPLACED+ message is sent to the table's
# message target before this cell is removed.
# Raises IndexError if either _row_ or _col_ is out of bounds.
#
def removeItem(row, col, notify=false) ; end
#
# Remove all cells in the specified range of rows and columns.
# If _notify_ is +true+, a +SEL_REPLACED+ message is sent to the table's
# message target before each cell is removed.
# Raises IndexError if _startrow_, _endrow_, _startcol_ or
# _endcol_ is out of bounds.
#
def removeRange(startrow, endrow, startcol, endcol, notify=false); end
#
# Remove all items from table.
# If _notify_ is +true+, a +SEL_DELETED+ message is sent to the table's
# message target before the cells are removed.
#
def clearItems(notify=false); end
# Scroll to make cell at (_row_, _column_) fully visible.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def makePositionVisible(row, column) ; end
# Returns +true+ if the cell at position (_row_, _column_) is visible.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def itemVisible?(row, column) ; end
# Set column width.
# Raises IndexError if _column_ is out of bounds.
def setColumnWidth(column, columnWidth) ; end
# Get column width.
# Raises IndexError if _column_ is out of bounds.
def getColumnWidth(column) ; end
# Set row height.
# Raises IndexError if _row_ is out of bounds.
def setRowHeight(row, rowHeight) ; end
# Get row height.
# Raises IndexError if _row_ is out of bounds.
def getRowHeight(row) ; end
# Get x-coordinate of column.
# Raises IndexError if _column_ is out of bounds.
def getColumnX(column) ; end
# Get y-coordinate of row.
# Raises IndexError if _row_ is out of bounds.
def getRowY(row) ; end
# Return minimum row height for row _r_.
# Raises IndexError if _r_ is out of bounds.
def minRowHeight(r); end
# Return minimum column width for column _c_.
# Raises IndexError if _c_ is out of bounds.
def minColumnWidth(c); end
#
# Fit row heights to contents, for the _nr_ rows beginning with row index
# _row_.
#
def fitRowsToContents(row, nr=1); end
#
# Fit column widths to contents, for the _nc_ columns beginning with
# column index _col_.
#
def fitColumnsToContents(col, nc=1); end
# Set column header at _index_ to _text_.
# Raises IndexError if _index_ is out of bounds.
def setColumnText(index, text); end
# Return text of column header at _index_.
# Raises IndexError if _index_ is out of bounds.
def getColumnText(index); end
# Set row header at _index_ to _text_.
# Raises IndexError if _index_ is out of bounds.
def setRowText(index, text); end
# Return text of row header at _index_.
# Raises IndexError if _index_ is out of bounds.
def getRowText(index); end
# Change column header icon.
# Raises IndexError if _index_ is out of bounds.
def setColumnIcon(index, icon); end
# Return icon of column header at _index_.
# Raises IndexError if _index_ is out of bounds.
def getColumnIcon(index); end
# Change row header icon.
# Raises IndexError if _index_ is out of bounds.
def setRowIcon(index, icon); end
# Return icon of row header at _index_.
# Raises IndexError if _index_ is out of bounds.
def getRowIcon(index); end
# Change column header icon position, e.g. FXHeaderItem::BEFORE, etc.
# Raises IndexError if _index_ is out of bounds.
def setColumnIconPosition(index, mode); end
# Return icon position of column header at _index_.
# Raises IndexError if _index_ is out of bounds.
def getColumnIconPosition(index); end
# Change row header icon position, e.g. FXHeaderItem::BEFORE, etc.
# Raises IndexError if _index_ is out of bounds.
def setRowIconPosition(index, mode); end
# Return icon position of row header at _index_.
# Raises IndexError if _index_ is out of bounds.
def getRowIconPosition(index); end
# Change column header justify, e.g. FXHeaderItem::RIGHT, etc.
# Raises IndexError if _index_ is out of bounds.
def setColumnJustify(index, justify); end
# Return justify of column header at _index_.
# Raises IndexError if _index_ is out of bounds.
def getColumnJustify(index); end
# Change row header justify, e.g. FXHeaderItem::RIGHT, etc.
# Raises IndexError if _index_ is out of bounds.
def setRowJustify(index, justify); end
# Return justify of row header at _index_.
# Raises IndexError if _index_ is out of bounds.
def getRowJustify(index); end
#
# Modify cell text for item at specified _row_ and _col_.
# If _notify_ is +true+, a +SEL_REPLACED+ message is sent to the table's
# message target before the item's text is changed..
# Raises IndexError if either _row_ or _col_ is out of bounds.
#
def setItemText(row, col, text, notify=false) ; end
# Return cell text for item at specified _row_ and _column_.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def getItemText(row, column) ; end
#
# Modify cell icon, deleting the old icon if it was owned.
# If _notify_ is +true+, a +SEL_REPLACED+ message is sent to the table's
# message target before the item's icon is changed..
# Raises IndexError if either _row_ or _col_ is out of bounds.
#
def setItemIcon(row, col, icon, notify=false) ; end
# Return item icon.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def getItemIcon(row, column) ; end
# Modify cell user data.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def setItemData(row, column, data) ; end
# Return cell user data.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def getItemData(row, column) ; end
#
# Extract the text from all the cells in the specified range and
# return the result as a string.
# Within the result string, each column's text is delimited by
# the string specified by _cs_, and each row is delimited by
# the string specified by _rs_.
# To reverse this operation (i.e. set the table cells' text
# from a string), see {#overlayText}.
# Raises IndexError if any of _startrow_, _endrow_, _startcol_
# or _endcol_ is out of bounds.
#
# ==== Parameters:
#
# +startrow+:: the starting row for the range [Integer]
# +endrow+:: the ending row for the range [Integer]
# +startcol+:: the starting column for the range [Integer]
# +endcol+:: the ending column for the range [Integer]
# +cs+:: the string to insert at each column break [String]
# +rs+:: the string to insert at each row break [String]
#
def extractText(startrow, endrow, startcol, endcol, cs="\t", rs="\n"); end
#
# Overlay the text for the cells in the specified range with
# the fields specified in _text_.
# Within the _text_ string, each column's text should delimited by
# the character specified by _cs_, and each row should be delimited by
# the character specified by _rs_.
# To reverse this operation (i.e. extract the table cells' text
# into a string), see {#extractText}.
# Raises IndexError if any of _startrow_, _endrow_, _startcol_
# or _endcol_ is out of bounds.
#
# ==== Parameters:
#
# +startrow+:: the starting row for the range [Integer]
# +endrow+:: the ending row for the range [Integer]
# +startcol+:: the starting column for the range [Integer]
# +endcol+:: the ending column for the range [Integer]
# +text+:: the text containing the new cell text [String]
# +cs+:: the character to insert at each column break [String]
# +rs+:: the character to insert at each row break [String]
#
def overlayText(startrow, endrow, startcol, endcol, text, cs="\t", rs="\n", notify=false); end
#
# Determine the number of rows and columns in a block of text
# where columns are separated by characters from the set _cs_, and rows
# are separated by characters from the set _rs_.
# Return a two-element array containing the number of rows and
# columns, respectively.
#
def countText(text, cs="\t,", rs="\n"); end
# Return +true+ if the cell at position (_r_, _c_) is a spanning cell.
# Raises IndexError if either _r_ or _c_ is out of bounds.
def itemSpanning?(r, c); end
#
# Repaint cells between grid lines (_startRow_, _endRow_) and grid lines
# (_startCol_, _endCol_).
# Raises IndexError if any of the starting or ending grid lines is out of bounds.
#
def updateRange(startRow, endRow, startCol, endCol) ; end
# Repaint cell.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def updateItem(row, column) ; end
# Enable cell.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def enableItem(row, column) ; end
# Disable cell.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def disableItem(row, column) ; end
# Returns +true+ if the cell at position (_row_, _column_) is enabled.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def itemEnabled?(row, column) ; end
#
# Change item justification for the cell at (_r_, _c_).
# Horizontal justification is controlled by passing
# FXTableItem::RIGHT, FXTableItem::LEFT, or FXTableItem::CENTER_X.
# Vertical justification is controlled by FXTableItem::TOP, FXTableItem::BOTTOM,
# or FXTableItem::CENTER_Y.
# The default is a combination of FXTableItem::RIGHT and FXTableItem::CENTER_Y.
#
# Raises IndexError if either _r_ or _c_ is out of bounds.
#
def setItemJustify(r, c, justify); end
# Return item justification for the cell at (_r_, _c_).
# Raises IndexError if either _r_ or _c_ is out of bounds.
def getItemJustify(r, c); end
#
# Change relative position of icon and text of item at (_r_, _c_).
# Passing FXTableItem::BEFORE or FXTableItem::AFTER places the icon
# before or after the text, and passing FXTableItem::ABOVE or
# FXTableItem::BELOW places it above or below the text, respectively.
# The default is 0 which places the text on top of the icon.
#
# Raises IndexError if either _r_ or _c_ is out of bounds.
#
def setItemIconPosition(r, c, mode); end
# Return the relative position of the icon and text for the cell at (_r_, _c_).
# Raises IndexError if either _r_ or _c_ is out of bounds.
def getItemIconPosition(r, c); end
#
# Change item borders style for the item at (_r_, _c_).
# Borders on each side of the item can be turned
# controlled individually using FXTableItem::LBORDER, FXTableItem::RBORDER,
# FXTableItem::TBORDER and FXTableItem::BBORDER.
#
# Raises IndexError if either _r_ or _c_ is out of bounds.
#
def setItemBorders(r, c, borders); end
# Return the border style for the cell at (_r_, _c_).
# Raises IndexError if either _r_ or _c_ is out of bounds.
def getItemBorders(r, c); end
# Set the background stipple style for the cell at (_r_, _c_).
# Raises IndexError if either _r_ or _c_ is out of bounds.
def setItemStipple(r, c, pat); end
# Return the background stipple style for the cell at (_r_, _c_).
# Raises IndexError if either _r_ or _c_ is out of bounds.
def getItemStipple(r, c); end
# Change current cell.
# If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the table's
# message target after the current item changes.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def setCurrentItem(row, column, notify=false) ; end
# Returns +true+ if the cell at position (_row_, _column_) is the current cell.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def itemCurrent?(row, column) ; end
# Change anchored cell.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def setAnchorItem(row, column) ; end
# Returns +true+ if the cell at position (_row_, _column_) is selected.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def itemSelected?(row, column) ; end
# Return +true+ if the specified row of cells is selected.
# Raises IndexError if _r_ is out of bounds.
def rowSelected?(r); end
# Return +true+ if the specified column of cells is selected.
# Raises IndexError if _c_ is out of bounds.
def columnSelected?(c); end
# Return +true+ if any cells are selected.
def anythingSelected?; end
# Select a row of cells.
# If _notify_ is +true+, a +SEL_DESELECTED+ message is sent to the table's message
# target for each previously selected cell that becomes deselected as a result of
# this operation. Likewise, a +SEL_SELECTED+ message is sent to the table's
# message target for each newly-selected cell.
# Raises IndexError if _row_ is out of bounds.
def selectRow(row, notify=false); end
# Select a column of cells.
# If _notify_ is +true+, a +SEL_DESELECTED+ message is sent to the table's message
# target for each previously selected cell that becomes deselected as a result of
# this operation. Likewise, a +SEL_SELECTED+ message is sent to the table's
# message target for each newly-selected cell.
# Raises IndexError if _col_ is out of bounds.
def selectColumn(col, notify=false); end
# Select range.
# If _notify_ is +true+, a +SEL_DESELECTED+ message is sent to the table's message
# target for each previously selected cell that becomes deselected as a result of
# this operation. Likewise, a +SEL_SELECTED+ message is sent to the table's
# message target for each newly-selected cell.
# Raises IndexError if _startRow_, _endRow_, _startColumn_ or _endColumn_ is out of bounds.
def selectRange(startRow, endRow, startColumn, endColumn, notify=false) ; end
# Extend selection.
# If _notify_ is +true+, a series of +SEL_SELECTED+ and +SEL_DESELECTED+ messages are sent to the table's message target
# after each affected item is selected or deselected.
# Raises IndexError if either _row_ or _column_ is out of bounds.
def extendSelection(row, column, notify=false) ; end
# Kill selection.
# If _notify_ is +true+, a +SEL_DESELECTED+ message is sent to the table's
# message target for each cell that was previously selected.
def killSelection(notify=false) ; end
#
# Change cell background color.
# The values for _row_ and _column_ are either zero or one.
# If the value is zero, this background color is used for even-numbered
# rows (columns). If the value is one, this background color is used
# for odd-numbered rows (columns).
# See also {#getCellColor}.
#
def setCellColor(row, column, color) ; end
#
# Obtain cell background color.
# The values for _row_ and _column_ are either zero or one.
# If the value is zero, returns the background color used for even-numbered
# rows (columns). If the value is one, returns the background color used
# for odd-numbered rows (columns).
# See also {#setCellColor}.
#
def getCellColor(row, column) ; end
# Create a new table item
def createItem(text, icon, data) ; end
# Draw a table cell
def drawCell(dc, xlo, xhi, ylo, yhi, xoff, yoff, startRow, endRow, startCol, endCol) ; end
# Draw a range of cells
def drawRange(dc, xlo, xhi, ylo, yhi, xoff, yoff, rlo, rhi, clo, chi) ; end
# Set column renumbering to +true+ or +false+.
def columnRenumbering=(renumber); end
# Get column renumbering
def columnRenumbering? ; end
# Set row renumbering to +true+ or +false+.
def rowRenumbering=(renumber); end
# Get row renumbering
def rowRenumbering? ; end
end
end