+ void RegisterDataType(const wxString& typeName,
+ wxGridCellRenderer* renderer,
+ wxGridCellEditor* editor);
+
+ /**
+ Sets the value of the current grid cell to the current in-place edit
+ control value.
+
+ This is called automatically when the grid cursor moves from the
+ current cell to a new cell. It is also a good idea to call this
+ function when closing a grid since any edits to the final cell location
+ will not be saved otherwise.
+ */
+ void SaveEditControlValue();
+
+ /**
+ Sets the editor for the grid cell at the specified location.
+
+ The grid will take ownership of the pointer.
+
+ See wxGridCellEditor and the @ref overview_grid for more information
+ about cell editors and renderers.
+ */
+ void SetCellEditor(int row, int col, wxGridCellEditor* editor);
+
+ /**
+ Sets the renderer for the grid cell at the specified location.
+
+ The grid will take ownership of the pointer.
+
+ See wxGridCellRenderer and the @ref overview_grid for more information
+ about cell editors and renderers.
+ */
+ void SetCellRenderer(int row, int col, wxGridCellRenderer* renderer);
+
+ /**
+ Sets the string value for the cell at the specified location.
+
+ For simple applications where a grid object automatically uses a
+ default grid table of string values you use this function together with
+ GetCellValue() to access cell values. For more complex applications
+ where you have derived your own grid table class that contains various
+ data types (e.g. numeric, boolean or user-defined custom types) then
+ you only use this function for those cells that contain string values.
+
+ See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
+ more information.
+ */
+ void SetCellValue(int row, int col, const wxString& s);
+ /**
+ Sets the string value for the cell at the specified location.
+
+ For simple applications where a grid object automatically uses a
+ default grid table of string values you use this function together with
+ GetCellValue() to access cell values. For more complex applications
+ where you have derived your own grid table class that contains various
+ data types (e.g. numeric, boolean or user-defined custom types) then
+ you only use this function for those cells that contain string values.
+
+ See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
+ more information.
+ */
+ void SetCellValue(const wxGridCellCoords& coords, const wxString& s);
+ /**
+ @deprecated Please use SetCellValue(int,int,const wxString&) or
+ SetCellValue(const wxGridCellCoords&,const wxString&)
+ instead.
+
+ Sets the string value for the cell at the specified location.
+
+ For simple applications where a grid object automatically uses a
+ default grid table of string values you use this function together with
+ GetCellValue() to access cell values. For more complex applications
+ where you have derived your own grid table class that contains various
+ data types (e.g. numeric, boolean or user-defined custom types) then
+ you only use this function for those cells that contain string values.
+
+ See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
+ more information.
+ */
+ void SetCellValue(const wxString& val, int row, int col);
+
+ /**
+ Sets the specified column to display boolean values.
+
+ @see SetColFormatCustom()
+ */
+ void SetColFormatBool(int col);
+
+ /**
+ Sets the specified column to display data in a custom format.
+
+ This method provides an alternative to defining a custom grid table
+ which would return @a typeName from its GetTypeName() method for the
+ cells in this column: while it doesn't really change the type of the
+ cells in this column, it does associate the renderer and editor used
+ for the cells of the specified type with them.
+
+ See the @ref overview_grid for more information on working with custom
+ data types.
+ */
+ void SetColFormatCustom(int col, const wxString& typeName);
+
+ /**
+ Sets the specified column to display floating point values with the
+ given width and precision.
+
+ @see SetColFormatCustom()
+ */
+ void SetColFormatFloat(int col, int width = -1, int precision = -1);
+
+ /**
+ Sets the specified column to display integer values.
+
+ @see SetColFormatCustom()
+ */
+ void SetColFormatNumber(int col);
+
+ /**
+ Sets the default editor for grid cells.
+
+ The grid will take ownership of the pointer.
+
+ See wxGridCellEditor and the @ref overview_grid for more information
+ about cell editors and renderers.
+ */
+ void SetDefaultEditor(wxGridCellEditor* editor);
+
+ /**
+ Sets the default renderer for grid cells.
+
+ The grid will take ownership of the pointer.
+
+ See wxGridCellRenderer and the @ref overview_grid for more information
+ about cell editors and renderers.
+ */
+ void SetDefaultRenderer(wxGridCellRenderer* renderer);
+
+ /**
+ Makes the cell at the specified location read-only or editable.
+
+ @see IsReadOnly()
+ */
+ void SetReadOnly(int row, int col, bool isReadOnly = true);
+
+ /**
+ Displays the in-place cell edit control for the current cell.
+ */
+ void ShowCellEditControl();
+
+ //@}
+
+
+ /**
+ @name Column and Row Sizes
+
+ @see @ref overview_grid_resizing
+ */
+ //@{
+
+ /**
+ Automatically sets the height and width of all rows and columns to fit
+ their contents.
+ */
+ void AutoSize();
+
+ /**
+ Automatically adjusts width of the column to fit its label.
+ */
+ void AutoSizeColLabelSize(int col);
+
+ /**
+ Automatically sizes the column to fit its contents. If @a setAsMin is
+ @true the calculated width will also be set as the minimal width for
+ the column.
+ */
+ void AutoSizeColumn(int col, bool setAsMin = true);
+
+ /**
+ Automatically sizes all columns to fit their contents. If @a setAsMin
+ is @true the calculated widths will also be set as the minimal widths
+ for the columns.
+ */
+ void AutoSizeColumns(bool setAsMin = true);
+
+ /**
+ Automatically sizes the row to fit its contents. If @a setAsMin is
+ @true the calculated height will also be set as the minimal height for
+ the row.
+ */
+ void AutoSizeRow(int row, bool setAsMin = true);
+
+ /**
+ Automatically adjusts height of the row to fit its label.
+ */
+ void AutoSizeRowLabelSize(int col);
+
+ /**
+ Automatically sizes all rows to fit their contents. If @a setAsMin is
+ @true the calculated heights will also be set as the minimal heights
+ for the rows.
+ */
+ void AutoSizeRows(bool setAsMin = true);
+
+ /**
+ Returns the current height of the column labels.
+ */
+ int GetColLabelSize() const;
+
+ /**
+ Returns the minimal width to which a column may be resized.
+
+ Use SetColMinimalAcceptableWidth() to change this value globally or
+ SetColMinimalWidth() to do it for individual columns.
+
+ @see GetRowMinimalAcceptableHeight()
+ */
+ int GetColMinimalAcceptableWidth() const;
+
+ /**
+ Returns the width of the specified column.
+ */
+ int GetColSize(int col) const;
+
+ /**
+ Returns @true if the specified column is not currently hidden.
+ */
+ bool IsColShown(int col) const;
+
+ /**
+ Returns the default height for column labels.
+ */
+ int GetDefaultColLabelSize() const;
+
+ /**
+ Returns the current default width for grid columns.
+ */
+ int GetDefaultColSize() const;
+
+ /**
+ Returns the default width for the row labels.
+ */
+ int GetDefaultRowLabelSize() const;
+
+ /**
+ Returns the current default height for grid rows.
+ */
+ int GetDefaultRowSize() const;
+
+ /**
+ Returns the minimal size to which rows can be resized.
+
+ Use SetRowMinimalAcceptableHeight() to change this value globally or
+ SetRowMinimalHeight() to do it for individual cells.
+
+ @see GetColMinimalAcceptableWidth()
+ */
+ int GetRowMinimalAcceptableHeight() const;
+
+ /**
+ Returns the current width of the row labels.
+ */
+ int GetRowLabelSize() const;
+
+ /**
+ Returns the height of the specified row.
+ */
+ int GetRowSize(int row) const;
+
+ /**
+ Returns @true if the specified row is not currently hidden.
+ */
+ bool IsRowShown(int row) const;
+
+ /**
+ Sets the height of the column labels.
+
+ If @a height equals to @c wxGRID_AUTOSIZE then height is calculated
+ automatically so that no label is truncated. Note that this could be
+ slow for a large table.
+ */
+ void SetColLabelSize(int height);
+
+ /**
+ Sets the minimal @a width to which the user can resize columns.
+
+ @see GetColMinimalAcceptableWidth()
+ */
+ void SetColMinimalAcceptableWidth(int width);
+
+ /**
+ Sets the minimal @a width for the specified column @a col.
+
+ It is usually best to call this method during grid creation as calling
+ it later will not resize the column to the given minimal width even if
+ it is currently narrower than it.
+
+ @a width must be greater than the minimal acceptable column width as
+ returned by GetColMinimalAcceptableWidth().
+ */
+ void SetColMinimalWidth(int col, int width);
+
+ /**
+ Sets the width of the specified column.
+
+ @param col
+ The column index.
+ @param width
+ The new column width in pixels, 0 to hide the column or -1 to fit
+ the column width to its label width.
+ */
+ void SetColSize(int col, int width);
+
+ /**
+ Hides the specified column.
+
+ To show the column later you need to call SetColSize() with non-0
+ width or ShowCol().
+
+ @param col
+ The column index.
+ */
+ void HideCol(int col);
+
+ /**
+ Shows the previously hidden column by resizing it to non-0 size.
+
+ @see HideCol(), SetColSize()
+ */
+ void ShowCol(int col);
+
+
+ /**
+ Sets the default width for columns in the grid.
+
+ This will only affect columns subsequently added to the grid unless
+ @a resizeExistingCols is @true.
+
+ If @a width is less than GetColMinimalAcceptableWidth(), then the
+ minimal acceptable width is used instead of it.
+ */
+ void SetDefaultColSize(int width, bool resizeExistingCols = false);
+
+ /**
+ Sets the default height for rows in the grid.
+
+ This will only affect rows subsequently added to the grid unless
+ @a resizeExistingRows is @true.
+
+ If @a height is less than GetRowMinimalAcceptableHeight(), then the
+ minimal acceptable height is used instead of it.
+ */
+ void SetDefaultRowSize(int height, bool resizeExistingRows = false);
+
+ /**
+ Sets the width of the row labels.
+
+ If @a width equals @c wxGRID_AUTOSIZE then width is calculated
+ automatically so that no label is truncated. Note that this could be
+ slow for a large table.
+ */
+ void SetRowLabelSize(int width);
+
+ /**
+ Sets the minimal row @a height used by default.
+
+ See SetColMinimalAcceptableWidth() for more information.
+ */
+ void SetRowMinimalAcceptableHeight(int height);
+
+ /**
+ Sets the minimal @a height for the specified @a row.
+
+ See SetColMinimalWidth() for more information.
+ */
+ void SetRowMinimalHeight(int row, int height);
+
+ /**
+ Sets the height of the specified row.
+
+ See SetColSize() for more information.
+ */
+ void SetRowSize(int row, int height);
+
+ /**
+ Hides the specified row.
+
+ To show the row later you need to call SetRowSize() with non-0
+ width or ShowRow().
+
+ @param col
+ The row index.
+ */
+ void HideRow(int col);
+
+ /**
+ Shows the previously hidden row by resizing it to non-0 size.
+
+ @see HideRow(), SetRowSize()
+ */
+ void ShowRow(int col);
+
+ /**
+ Get size information for all columns at once.
+
+ This method is useful when the information about all column widths
+ needs to be saved. The widths can be later restored using
+ SetColSizes().
+
+ @sa wxGridSizesInfo, GetRowSizes()
+ */
+ wxGridSizesInfo GetColSizes() const;
+
+ /**
+ Get size information for all row at once.
+
+ @sa wxGridSizesInfo, GetColSizes()
+ */
+ wxGridSizesInfo GetRowSizes() const;
+
+ /**
+ Restore all columns sizes.
+
+ This is usually called with wxGridSizesInfo object previously returned
+ by GetColSizes().
+
+ @sa SetRowSizes()
+ */
+ void SetColSizes(const wxGridSizesInfo& sizeInfo);
+
+ /**
+ Restore all rows sizes.
+
+ @sa SetColSizes()
+ */
+ void SetRowSizes(const wxGridSizesInfo& sizeInfo);
+
+ /**
+ Set the size of the cell.
+
+ Specifying a value of more than 1 in @a num_rows or @a num_cols will
+ make the cell at (@a row, @a col) span the block of the specified size,
+ covering the other cells which would be normally shown in it. Passing 1
+ for both arguments resets the cell to normal appearance.
+
+ @see GetCellSize()
+
+ @param row
+ The row of the cell.
+ @param col
+ The column of the cell.
+ @param num_rows
+ Number of rows to be occupied by this cell, must be >= 1.
+ @param num_cols
+ Number of columns to be occupied by this cell, must be >= 1.
+ */
+ void SetCellSize(int row, int col, int num_rows, int num_cols);
+
+ /**
+ Get the size of the cell in number of cells covered by it.
+
+ For normal cells, the function fills both @a num_rows and @a num_cols
+ with 1 and returns CellSpan_None. For cells which span multiple cells, i.e.
+ for which SetCellSize() had been called, the returned values are the
+ same ones as were passed to SetCellSize() call and the function return
+ value is CellSpan_Main.
+
+ More unexpectedly, perhaps, the returned values may be @em negative for
+ the cells which are inside a span covered by a cell occupying multiple
+ rows or columns. They correspond to the offset of the main cell of the
+ span from the cell passed to this functions and the function returns
+ CellSpan_Inside value to indicate this.
+
+ As an example, consider a 3*3 grid with the cell (1, 1) (the one in the
+ middle) having a span of 2 rows and 2 columns, i.e. the grid looks like
+ @code
+ +----+----+----+
+ | | | |
+ +----+----+----+
+ | | |
+ +----+ |
+ | | |
+ +----+----+----+
+ @endcode
+ Then the function returns 2 and 2 in @a num_rows and @a num_cols for
+ the cell (1, 1) itself and -1 and -1 for the cell (2, 2) as well as -1
+ and 0 for the cell (2, 1).
+
+ @param row
+ The row of the cell.
+ @param col
+ The column of the cell.
+ @param num_rows
+ Pointer to variable receiving the number of rows, must not be @NULL.
+ @param num_cols
+ Pointer to variable receiving the number of columns, must not be
+ @NULL.
+ @return
+ The kind of this cell span (the return value is new in wxWidgets
+ 2.9.1, this function was void in previous wxWidgets versions).
+ */
+ CellSpan GetCellSize( int row, int col, int *num_rows, int *num_cols ) const;
+
+ /**
+ Get the number of rows and columns allocated for this cell.
+
+ This overload doesn't return a CellSpan value but the values returned
+ may still be negative, see GetCellSize(int, int, int *, int *) for
+ details.
+ */
+ wxSize GetCellSize(const wxGridCellCoords& coords);
+
+ //@}
+
+
+ /**
+ @name User-Resizing and Dragging
+
+ Functions controlling various interactive mouse operations.
+
+ By default, columns and rows can be resized by dragging the edges of
+ their labels (this can be disabled using DisableDragColSize() and
+ DisableDragRowSize() methods). And if grid line dragging is enabled with
+ EnableDragGridSize() they can also be resized by dragging the right or
+ bottom edge of the grid cells.
+
+ Columns can also be moved to interactively change their order but this
+ needs to be explicitly enabled with EnableDragColMove().
+ */
+ //@{
+
+ /**
+ Return @true if the dragging of cells is enabled or @false otherwise.
+ */
+ bool CanDragCell() const;
+
+ /**
+ Returns @true if columns can be moved by dragging with the mouse.
+
+ Columns can be moved by dragging on their labels.
+ */
+ bool CanDragColMove() const;
+
+ /**
+ Returns @true if the given column can be resized by dragging with the
+ mouse.
+
+ This function returns @true if resizing the columns interactively is
+ globally enabled, i.e. if DisableDragColSize() hadn't been called, and
+ if this column wasn't explicitly marked as non-resizable with
+ DisableColResize().
+ */
+ bool CanDragColSize(int col) const;
+
+ /**
+ Return @true if the dragging of grid lines to resize rows and columns
+ is enabled or @false otherwise.
+ */
+ bool CanDragGridSize() const;
+
+ /**
+ Returns @true if the given row can be resized by dragging with the
+ mouse.
+
+ This is the same as CanDragColSize() but for rows.
+ */
+ bool CanDragRowSize(int row) const;
+
+ /**
+ Disable interactive resizing of the specified column.
+
+ This method allows to disable resizing of an individual column in a
+ grid where the columns are otherwise resizable (which is the case by
+ default).
+
+ Notice that currently there is no way to make some columns resizable in
+ a grid where columns can't be resized by default as there doesn't seem
+ to be any need for this in practice. There is also no way to make the
+ column marked as fixed using this method resizable again because it is
+ supposed that fixed columns are used for static parts of the grid and
+ so should remain fixed during the entire grid lifetime.
+
+ Also notice that disabling interactive column resizing will not prevent
+ the program from changing the column size.
+
+ @see EnableDragColSize()
+ */
+ void DisableColResize(int col);
+
+ /**
+ Disable interactive resizing of the specified row.
+
+ This is the same as DisableColResize() but for rows.
+
+ @see EnableDragRowSize()
+ */
+ void DisableRowResize(int row);
+
+ /**
+ Disables column moving by dragging with the mouse.
+
+ Equivalent to passing @false to EnableDragColMove().
+ */
+ void DisableDragColMove();
+
+ /**
+ Disables column sizing by dragging with the mouse.
+
+ Equivalent to passing @false to EnableDragColSize().
+ */
+ void DisableDragColSize();
+
+ /**
+ Disable mouse dragging of grid lines to resize rows and columns.
+
+ Equivalent to passing @false to EnableDragGridSize()
+ */
+ void DisableDragGridSize();
+
+ /**
+ Disables row sizing by dragging with the mouse.
+
+ Equivalent to passing @false to EnableDragRowSize().
+ */
+ void DisableDragRowSize();
+
+ /**
+ Enables or disables cell dragging with the mouse.
+ */
+ void EnableDragCell(bool enable = true);
+
+ /**
+ Enables or disables column moving by dragging with the mouse.
+ */
+ void EnableDragColMove(bool enable = true);
+
+ /**
+ Enables or disables column sizing by dragging with the mouse.
+
+ @see DisableColResize()
+ */
+ void EnableDragColSize(bool enable = true);
+
+ /**
+ Enables or disables row and column resizing by dragging gridlines with
+ the mouse.
+ */
+ void EnableDragGridSize(bool enable = true);
+
+ /**
+ Enables or disables row sizing by dragging with the mouse.
+
+ @see DisableRowResize()
+ */
+ void EnableDragRowSize(bool enable = true);
+
+ /**
+ Returns the column ID of the specified column position.
+ */
+ int GetColAt(int colPos) const;
+
+ /**
+ Returns the position of the specified column.
+ */
+ int GetColPos(int colID) const;
+
+ /**
+ Sets the position of the specified column.
+ */
+ void SetColPos(int colID, int newPos);
+
+ /**
+ Sets the positions of all columns at once.
+
+ This method takes an array containing the indices of the columns in
+ their display order, i.e. uses the same convention as
+ wxHeaderCtrl::SetColumnsOrder().
+ */
+ void SetColumnsOrder(const wxArrayInt& order);
+
+ /**
+ Resets the position of the columns to the default.
+ */
+ void ResetColPos();
+
+ //@}
+
+
+ /**
+ @name Cursor Movement
+ */
+ //@{
+
+ /**
+ Returns the current grid cell column position.
+ */
+ int GetGridCursorCol() const;
+
+ /**
+ Returns the current grid cell row position.
+ */
+ int GetGridCursorRow() const;
+
+ /**
+ Make the given cell current and ensure it is visible.
+
+ This method is equivalent to calling MakeCellVisible() and
+ SetGridCursor() and so, as with the latter, a @c wxEVT_GRID_SELECT_CELL
+ event is generated by it and the selected cell doesn't change if the
+ event is vetoed.
+ */
+ void GoToCell(int row, int col);
+ /**
+ Make the given cell current and ensure it is visible.
+
+ This method is equivalent to calling MakeCellVisible() and
+ SetGridCursor() and so, as with the latter, a @c wxEVT_GRID_SELECT_CELL
+ event is generated by it and the selected cell doesn't change if the
+ event is vetoed.
+ */
+ void GoToCell(const wxGridCellCoords& coords);
+
+ /**
+ Moves the grid cursor down by one row.
+
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
+ */
+ bool MoveCursorDown(bool expandSelection);
+
+ /**
+ Moves the grid cursor down in the current column such that it skips to
+ the beginning or end of a block of non-empty cells.
+
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
+ */
+ bool MoveCursorDownBlock(bool expandSelection);
+
+ /**
+ Moves the grid cursor left by one column.
+
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
+ */
+ bool MoveCursorLeft(bool expandSelection);
+
+ /**
+ Moves the grid cursor left in the current row such that it skips to the
+ beginning or end of a block of non-empty cells.
+
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
+ */
+ bool MoveCursorLeftBlock(bool expandSelection);
+
+ /**
+ Moves the grid cursor right by one column.
+
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
+ */
+ bool MoveCursorRight(bool expandSelection);
+
+ /**
+ Moves the grid cursor right in the current row such that it skips to
+ the beginning or end of a block of non-empty cells.
+
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
+ */
+ bool MoveCursorRightBlock(bool expandSelection);
+
+ /**
+ Moves the grid cursor up by one row.
+
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
+ */
+ bool MoveCursorUp(bool expandSelection);
+
+ /**
+ Moves the grid cursor up in the current column such that it skips to
+ the beginning or end of a block of non-empty cells.
+
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
+ */
+ bool MoveCursorUpBlock(bool expandSelection);
+
+ /**
+ Moves the grid cursor down by some number of rows so that the previous
+ bottom visible row becomes the top visible row.
+ */
+ bool MovePageDown();
+
+ /**
+ Moves the grid cursor up by some number of rows so that the previous
+ top visible row becomes the bottom visible row.
+ */
+ bool MovePageUp();
+
+ /**
+ Set the grid cursor to the specified cell.
+
+ The grid cursor indicates the current cell and can be moved by the user
+ using the arrow keys or the mouse.
+
+ Calling this function generates a @c wxEVT_GRID_SELECT_CELL event and
+ if the event handler vetoes this event, the cursor is not moved.
+
+ This function doesn't make the target call visible, use GoToCell() to
+ do this.
+ */
+ void SetGridCursor(int row, int col);
+ /**
+ Set the grid cursor to the specified cell.
+
+ The grid cursor indicates the current cell and can be moved by the user
+ using the arrow keys or the mouse.
+
+ Calling this function generates a @c wxEVT_GRID_SELECT_CELL event and
+ if the event handler vetoes this event, the cursor is not moved.
+
+ This function doesn't make the target call visible, use GoToCell() to
+ do this.
+ */
+ void SetGridCursor(const wxGridCellCoords& coords);
+
+ //@}
+
+
+ /**
+ @name User Selection
+ */
+ //@{
+
+ /**
+ Deselects all cells that are currently selected.
+ */
+ void ClearSelection();
+
+ /**
+ Returns an array of individually selected cells.
+
+ Notice that this array does @em not contain all the selected cells in
+ general as it doesn't include the cells selected as part of column, row
+ or block selection. You must use this method, GetSelectedCols(),
+ GetSelectedRows() and GetSelectionBlockTopLeft() and
+ GetSelectionBlockBottomRight() methods to obtain the entire selection
+ in general.
+
+ Please notice this behaviour is by design and is needed in order to
+ support grids of arbitrary size (when an entire column is selected in
+ a grid with a million of columns, we don't want to create an array with
+ a million of entries in this function, instead it returns an empty
+ array and GetSelectedCols() returns an array containing one element).
+ */
+ wxGridCellCoordsArray GetSelectedCells() const;
+
+ /**
+ Returns an array of selected columns.
+
+ Please notice that this method alone is not sufficient to find all the
+ selected columns as it contains only the columns which were
+ individually selected but not those being part of the block selection
+ or being selected in virtue of all of their cells being selected
+ individually, please see GetSelectedCells() for more details.
+ */
+ wxArrayInt GetSelectedCols() const;
+
+ /**
+ Returns an array of selected rows.
+
+ Please notice that this method alone is not sufficient to find all the
+ selected rows as it contains only the rows which were individually
+ selected but not those being part of the block selection or being
+ selected in virtue of all of their cells being selected individually,
+ please see GetSelectedCells() for more details.
+ */
+ wxArrayInt GetSelectedRows() const;
+
+ /**
+ Returns the colour used for drawing the selection background.
+ */
+ wxColour GetSelectionBackground() const;
+
+ /**
+ Returns an array of the bottom right corners of blocks of selected
+ cells.
+
+ Please see GetSelectedCells() for more information about the selection
+ representation in wxGrid.
+
+ @see GetSelectionBlockTopLeft()
+ */
+ wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
+
+ /**
+ Returns an array of the top left corners of blocks of selected cells.
+
+ Please see GetSelectedCells() for more information about the selection
+ representation in wxGrid.
+
+ @see GetSelectionBlockBottomRight()
+ */
+ wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
+
+ /**
+ Returns the colour used for drawing the selection foreground.
+ */
+ wxColour GetSelectionForeground() const;
+
+ /**
+ Returns the current selection mode.
+
+ @see SetSelectionMode().
+ */
+ wxGridSelectionModes GetSelectionMode() const;
+
+ /**
+ Returns @true if the given cell is selected.
+ */
+ bool IsInSelection(int row, int col) const;
+ /**
+ Returns @true if the given cell is selected.
+ */
+ bool IsInSelection(const wxGridCellCoords& coords) const;
+
+ /**
+ Returns @true if there are currently any selected cells, rows, columns
+ or blocks.
+ */
+ bool IsSelection() const;
+
+ /**
+ Selects all cells in the grid.
+ */
+ void SelectAll();
+
+ /**
+ Selects a rectangular block of cells.
+
+ If @a addToSelected is @false then any existing selection will be
+ deselected; if @true the column will be added to the existing
+ selection.
+ */
+ void SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
+ bool addToSelected = false);
+ /**
+ Selects a rectangular block of cells.
+
+ If @a addToSelected is @false then any existing selection will be
+ deselected; if @true the column will be added to the existing
+ selection.
+ */
+ void SelectBlock(const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight,
+ bool addToSelected = false);
+
+ /**
+ Selects the specified column.
+
+ If @a addToSelected is @false then any existing selection will be
+ deselected; if @true the column will be added to the existing
+ selection.
+
+ This method won't select anything if the current selection mode is
+ wxGridSelectRows.
+ */
+ void SelectCol(int col, bool addToSelected = false);
+
+ /**
+ Selects the specified row.
+
+ If @a addToSelected is @false then any existing selection will be
+ deselected; if @true the row will be added to the existing selection.
+
+ This method won't select anything if the current selection mode is
+ wxGridSelectColumns.
+ */
+ void SelectRow(int row, bool addToSelected = false);
+
+ /**
+ Set the colour to be used for drawing the selection background.
+ */
+ void SetSelectionBackground(const wxColour& c);
+
+ /**
+ Set the colour to be used for drawing the selection foreground.
+ */
+ void SetSelectionForeground(const wxColour& c);
+
+ /**
+ Set the selection behaviour of the grid.
+
+ The existing selection is converted to conform to the new mode if
+ possible and discarded otherwise (e.g. any individual selected cells
+ are deselected if the new mode allows only the selection of the entire
+ rows or columns).
+ */
+ void SetSelectionMode(wxGridSelectionModes selmode);
+
+ //@}
+
+
+ /**
+ @name Scrolling
+ */
+ //@{
+
+ /**
+ Returns the number of pixels per horizontal scroll increment.
+
+ The default is 15.
+
+ @see GetScrollLineY(), SetScrollLineX(), SetScrollLineY()
+ */
+ int GetScrollLineX() const;
+
+ /**
+ Returns the number of pixels per vertical scroll increment.
+
+ The default is 15.
+
+ @see GetScrollLineX(), SetScrollLineX(), SetScrollLineY()
+ */
+ int GetScrollLineY() const;
+
+ /**
+ Returns @true if a cell is either entirely or at least partially
+ visible in the grid window.
+
+ By default, the cell must be entirely visible for this function to
+ return @true but if @a wholeCellVisible is @false, the function returns
+ @true even if the cell is only partially visible.
+ */
+ bool IsVisible(int row, int col, bool wholeCellVisible = true) const;
+ /**
+ Returns @true if a cell is either entirely or at least partially
+ visible in the grid window.
+
+ By default, the cell must be entirely visible for this function to
+ return @true but if @a wholeCellVisible is @false, the function returns
+ @true even if the cell is only partially visible.
+ */
+ bool IsVisible(const wxGridCellCoords& coords,
+ bool wholeCellVisible = true) const;
+
+ /**
+ Brings the specified cell into the visible grid cell area with minimal
+ scrolling.
+
+ Does nothing if the cell is already visible.
+ */
+ void MakeCellVisible(int row, int col);
+ /**
+ Brings the specified cell into the visible grid cell area with minimal
+ scrolling.
+
+ Does nothing if the cell is already visible.
+ */
+ void MakeCellVisible(const wxGridCellCoords& coords);
+
+ /**
+ Sets the number of pixels per horizontal scroll increment.
+
+ The default is 15.
+
+ @see GetScrollLineX(), GetScrollLineY(), SetScrollLineY()
+ */
+ void SetScrollLineX(int x);
+
+ /**
+ Sets the number of pixels per vertical scroll increment.
+
+ The default is 15.
+
+ @see GetScrollLineX(), GetScrollLineY(), SetScrollLineX()
+ */
+ void SetScrollLineY(int y);
+
+ //@}
+
+
+ /**
+ @name Cell and Device Coordinate Translation
+ */
+ //@{
+
+ /**
+ Convert grid cell coordinates to grid window pixel coordinates.
+
+ This function returns the rectangle that encloses the block of cells
+ limited by @a topLeft and @a bottomRight cell in device coords and
+ clipped to the client size of the grid window.
+
+ @see CellToRect()
+ */
+ wxRect BlockToDeviceRect(const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight) const;
+
+ /**
+ Return the rectangle corresponding to the grid cell's size and position
+ in logical coordinates.
+
+ @see BlockToDeviceRect()
+ */
+ wxRect CellToRect(int row, int col) const;
+ /**
+ Return the rectangle corresponding to the grid cell's size and position
+ in logical coordinates.
+
+ @see BlockToDeviceRect()
+ */
+ wxRect CellToRect(const wxGridCellCoords& coords) const;
+
+ /**
+ Returns the column at the given pixel position.
+
+ @param x
+ The x position to evaluate.
+ @param clipToMinMax
+ If @true, rather than returning @c wxNOT_FOUND, it returns either
+ the first or last column depending on whether @a x is too far to
+ the left or right respectively.
+ @return
+ The column index or @c wxNOT_FOUND.
+ */
+ int XToCol(int x, bool clipToMinMax = false) const;
+
+ /**
+ Returns the column whose right hand edge is close to the given logical
+ @a x position.
+
+ If no column edge is near to this position @c wxNOT_FOUND is returned.
+ */
+ int XToEdgeOfCol(int x) const;
+
+ /**
+ Translates logical pixel coordinates to the grid cell coordinates.
+
+ Notice that this function expects logical coordinates on input so if
+ you use this function in a mouse event handler you need to translate
+ the mouse position, which is expressed in device coordinates, to
+ logical ones.
+
+ @see XToCol(), YToRow()
+ */
+ wxGridCellCoords XYToCell(int x, int y) const;
+ /**
+ Translates logical pixel coordinates to the grid cell coordinates.
+
+ Notice that this function expects logical coordinates on input so if
+ you use this function in a mouse event handler you need to translate
+ the mouse position, which is expressed in device coordinates, to
+ logical ones.
+
+ @see XToCol(), YToRow()
+ */
+ wxGridCellCoords XYToCell(const wxPoint& pos) const;
+ // XYToCell(int, int, wxGridCellCoords&) overload is intentionally
+ // undocumented, using it is ugly and non-const reference parameters are
+ // not used in wxWidgets API
+
+ /**
+ Returns the row whose bottom edge is close to the given logical @a y
+ position.
+
+ If no row edge is near to this position @c wxNOT_FOUND is returned.
+ */
+ int YToEdgeOfRow(int y) const;
+
+ /**
+ Returns the grid row that corresponds to the logical @a y coordinate.
+
+ Returns @c wxNOT_FOUND if there is no row at the @a y position.
+ */
+ int YToRow(int y, bool clipToMinMax = false) const;
+
+ //@}
+
+
+ /**
+ @name Miscellaneous Functions
+ */
+ //@{
+
+ /**
+ Appends one or more new columns to the right of the grid.
+
+ The @a updateLabels argument is not used at present. If you are using a
+ derived grid table class you will need to override
+ wxGridTableBase::AppendCols(). See InsertCols() for further
+ information.
+
+ @return @true on success or @false if appending columns failed.
+ */
+ bool AppendCols(int numCols = 1, bool updateLabels = true);
+
+ /**
+ Appends one or more new rows to the bottom of the grid.
+
+ The @a updateLabels argument is not used at present. If you are using a
+ derived grid table class you will need to override
+ wxGridTableBase::AppendRows(). See InsertRows() for further
+ information.
+
+ @return @true on success or @false if appending rows failed.
+ */
+ bool AppendRows(int numRows = 1, bool updateLabels = true);
+
+ /**
+ Return @true if the horizontal grid lines stop at the last column
+ boundary or @false if they continue to the end of the window.
+
+ The default is to clip grid lines.
+
+ @see ClipHorzGridLines(), AreVertGridLinesClipped()
+ */
+ bool AreHorzGridLinesClipped() const;
+
+ /**
+ Return @true if the vertical grid lines stop at the last row
+ boundary or @false if they continue to the end of the window.
+
+ The default is to clip grid lines.
+
+ @see ClipVertGridLines(), AreHorzGridLinesClipped()
+ */
+ bool AreVertGridLinesClipped() const;
+
+ /**
+ Increments the grid's batch count.
+
+ When the count is greater than zero repainting of the grid is
+ suppressed. Each call to BeginBatch must be matched by a later call to
+ EndBatch(). Code that does a lot of grid modification can be enclosed
+ between BeginBatch() and EndBatch() calls to avoid screen flicker. The
+ final EndBatch() call will cause the grid to be repainted.
+
+ Notice that you should use wxGridUpdateLocker which ensures that there
+ is always a matching EndBatch() call for this BeginBatch() if possible
+ instead of calling this method directly.
+ */
+ void BeginBatch();
+
+ /**
+ Clears all data in the underlying grid table and repaints the grid.
+
+ The table is not deleted by this function. If you are using a derived
+ table class then you need to override wxGridTableBase::Clear() for this
+ function to have any effect.
+ */
+ void ClearGrid();
+
+ /**
+ Change whether the horizontal grid lines are clipped by the end of the
+ last column.
+
+ By default the grid lines are not drawn beyond the end of the last
+ column but after calling this function with @a clip set to @false they
+ will be drawn across the entire grid window.
+
+ @see AreHorzGridLinesClipped(), ClipVertGridLines()
+ */
+ void ClipHorzGridLines(bool clip);
+
+ /**
+ Change whether the vertical grid lines are clipped by the end of the
+ last row.
+
+ By default the grid lines are not drawn beyond the end of the last
+ row but after calling this function with @a clip set to @false they
+ will be drawn across the entire grid window.
+
+ @see AreVertGridLinesClipped(), ClipHorzGridLines()
+ */
+ void ClipVertGridLines(bool clip);
+
+ /**
+ Deletes one or more columns from a grid starting at the specified
+ position.
+
+ The @a updateLabels argument is not used at present. If you are using a
+ derived grid table class you will need to override
+ wxGridTableBase::DeleteCols(). See InsertCols() for further
+ information.
+
+ @return @true on success or @false if deleting columns failed.
+ */
+ bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true);
+
+ /**
+ Deletes one or more rows from a grid starting at the specified
+ position.
+
+ The @a updateLabels argument is not used at present. If you are using a
+ derived grid table class you will need to override
+ wxGridTableBase::DeleteRows(). See InsertRows() for further
+ information.
+
+ @return @true on success or @false if appending rows failed.
+ */
+ bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true);
+
+ /**
+ Decrements the grid's batch count.
+
+ When the count is greater than zero repainting of the grid is
+ suppressed. Each previous call to BeginBatch() must be matched by a
+ later call to EndBatch(). Code that does a lot of grid modification can
+ be enclosed between BeginBatch() and EndBatch() calls to avoid screen
+ flicker. The final EndBatch() will cause the grid to be repainted.
+
+ @see wxGridUpdateLocker
+ */
+ void EndBatch();
+
+ /**
+ Overridden wxWindow method.
+ */
+ virtual void Fit();
+
+ /**
+ Causes immediate repainting of the grid.
+
+ Use this instead of the usual wxWindow::Refresh().
+ */
+ void ForceRefresh();
+
+ /**
+ Returns the number of times that BeginBatch() has been called without
+ (yet) matching calls to EndBatch(). While the grid's batch count is
+ greater than zero the display will not be updated.
+ */
+ int GetBatchCount();
+
+ /**
+ Returns the total number of grid columns.
+
+ This is the same as the number of columns in the underlying grid table.
+ */
+ int GetNumberCols() const;
+
+ /**
+ Returns the total number of grid rows.
+
+ This is the same as the number of rows in the underlying grid table.
+ */
+ int GetNumberRows() const;
+
+ /**
+ Returns the attribute for the given cell creating one if necessary.
+
+ If the cell already has an attribute, it is returned. Otherwise a new
+ attribute is created, associated with the cell and returned. In any
+ case the caller must call DecRef() on the returned pointer.
+
+ This function may only be called if CanHaveAttributes() returns @true.
+ */
+ wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
+
+ /**
+ Returns a base pointer to the current table object.
+
+ The returned pointer is still owned by the grid.
+ */
+ wxGridTableBase *GetTable() const;
+
+ /**
+ Inserts one or more new columns into a grid with the first new column
+ at the specified position.
+
+ Notice that inserting the columns in the grid requires grid table
+ cooperation: when this method is called, grid object begins by
+ requesting the underlying grid table to insert new columns. If this is
+ successful the table notifies the grid and the grid updates the
+ display. For a default grid (one where you have called CreateGrid())
+ this process is automatic. If you are using a custom grid table
+ (specified with SetTable()) then you must override
+ wxGridTableBase::InsertCols() in your derived table class.
+
+ @param pos
+ The position which the first newly inserted column will have.
+ @param numCols
+ The number of columns to insert.
+ @param updateLabels
+ Currently not used.
+ @return
+ @true if the columns were successfully inserted, @false if an error
+ occurred (most likely the table couldn't be updated).
+ */
+ bool InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true);
+
+ /**
+ Inserts one or more new rows into a grid with the first new row at the
+ specified position.
+
+ Notice that you must implement wxGridTableBase::InsertRows() if you use
+ a grid with a custom table, please see InsertCols() for more
+ information.
+
+ @param pos
+ The position which the first newly inserted row will have.
+ @param numRows
+ The number of rows to insert.
+ @param updateLabels
+ Currently not used.
+ @return
+ @true if the rows were successfully inserted, @false if an error
+ occurred (most likely the table couldn't be updated).
+ */
+ bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true);
projects / wxWidgets.git / blobdiff