+ This method is not virtual and is only provided as a convenience for
+ the derived classes which can't call GetNumberRows() without a
+ @c const_cast from their const methods.
+ */
+ int GetRowsCount() const;
+
+ /**
+ Return the number of columns in the table.
+
+ This method is not virtual and is only provided as a convenience for
+ the derived classes which can't call GetNumberCols() without a
+ @c const_cast from their const methods.
+ */
+ int GetColsCount() const;
+
+
+ /**
+ @name Table Cell Accessors
+ */
+ //@{
+
+ /**
+ May be overridden to implement testing for empty cells.
+
+ This method is used by the grid to test if the given cell is not used
+ and so whether a neighbouring cell may overflow into it. By default it
+ only returns true if the value of the given cell, as returned by
+ GetValue(), is empty.
+ */
+ virtual bool IsEmptyCell(int row, int col);
+
+ /**
+ Same as IsEmptyCell() but taking wxGridCellCoords.
+
+ Notice that this method is not virtual, only IsEmptyCell() should be
+ overridden.
+ */
+ bool IsEmpty(const wxGridCellCoords& coords);
+
+ /**
+ Must be overridden to implement accessing the table values as text.
+ */
+ virtual wxString GetValue(int row, int col) = 0;
+
+ /**
+ Must be overridden to implement setting the table values as text.
+ */
+ virtual void SetValue(int row, int col, const wxString& value) = 0;
+
+ /**
+ Returns the type of the value in the given cell.
+
+ By default all cells are strings and this method returns
+ @c wxGRID_VALUE_STRING.
+ */
+ virtual wxString GetTypeName(int row, int col);
+
+ /**
+ Returns true if the value of the given cell can be accessed as if it
+ were of the specified type.
+
+ By default the cells can only be accessed as strings. Note that a cell
+ could be accessible in different ways, e.g. a numeric cell may return
+ @true for @c wxGRID_VALUE_NUMBER but also for @c wxGRID_VALUE_STRING
+ indicating that the value can be coerced to a string form.
+ */
+ virtual bool CanGetValueAs(int row, int col, const wxString& typeName);
+
+ /**
+ Returns true if the value of the given cell can be set as if it were of
+ the specified type.
+
+ @see CanGetValueAs()
+ */
+ virtual bool CanSetValueAs(int row, int col, const wxString& typeName);
+
+ /**
+ Returns the value of the given cell as a long.
+
+ This should only be called if CanGetValueAs() returns @true when called
+ with @c wxGRID_VALUE_NUMBER argument. Default implementation always
+ return 0.
+ */
+ virtual long GetValueAsLong(int row, int col);
+
+ /**
+ Returns the value of the given cell as a double.
+
+ This should only be called if CanGetValueAs() returns @true when called
+ with @c wxGRID_VALUE_FLOAT argument. Default implementation always
+ return 0.0.
+ */
+ virtual double GetValueAsDouble(int row, int col);
+
+ /**
+ Returns the value of the given cell as a boolean.
+
+ This should only be called if CanGetValueAs() returns @true when called
+ with @c wxGRID_VALUE_BOOL argument. Default implementation always
+ return false.
+ */
+ virtual bool GetValueAsBool(int row, int col);
+
+ /**
+ Returns the value of the given cell as a user-defined type.
+
+ This should only be called if CanGetValueAs() returns @true when called
+ with @a typeName. Default implementation always return @NULL.
+ */
+ virtual void *GetValueAsCustom(int row, int col, const wxString& typeName);
+
+ /**
+ Sets the value of the given cell as a long.
+
+ This should only be called if CanSetValueAs() returns @true when called
+ with @c wxGRID_VALUE_NUMBER argument. Default implementation doesn't do
+ anything.
+ */
+ virtual void SetValueAsLong(int row, int col, long value);
+
+ /**
+ Sets the value of the given cell as a double.
+
+ This should only be called if CanSetValueAs() returns @true when called
+ with @c wxGRID_VALUE_FLOAT argument. Default implementation doesn't do
+ anything.
+ */
+ virtual void SetValueAsDouble(int row, int col, double value);
+
+ /**
+ Sets the value of the given cell as a boolean.
+
+ This should only be called if CanSetValueAs() returns @true when called
+ with @c wxGRID_VALUE_BOOL argument. Default implementation doesn't do
+ anything.
+ */
+ virtual void SetValueAsBool( int row, int col, bool value );
+
+ /**
+ Sets the value of the given cell as a user-defined type.
+
+ This should only be called if CanSetValueAs() returns @true when called
+ with @a typeName. Default implementation doesn't do anything.
+ */
+ virtual void SetValueAsCustom(int row, int col, const wxString& typeName,
+ void *value);
+
+ //@}
+
+
+ /**
+ Called by the grid when the table is associated with it.
+
+ The default implementation stores the pointer and returns it from its
+ GetView() and so only makes sense if the table cannot be associated
+ with more than one grid at a time.
+ */
+ virtual void SetView(wxGrid *grid);
+
+ /**
+ Returns the last grid passed to SetView().
+ */
+ virtual wxGrid *GetView() const;
+
+
+ /**
+ @name Table Structure Modifiers
+
+ Notice that none of these functions are pure virtual as they don't have
+ to be implemented if the table structure is never modified after
+ creation, i.e. neither rows nor columns are never added or deleted but
+ that you do need to implement them if they are called, i.e. if your
+ code either calls them directly or uses the matching wxGrid methods, as
+ by default they simply do nothing which is definitely inappropriate.
+ */
+ //@{
+
+ /**
+ Clear the table contents.
+
+ This method is used by wxGrid::ClearGrid().
+ */
+ virtual void Clear();
+
+ /**
+ Insert additional rows into the table.
+
+ @param pos
+ The position of the first new row.
+ @param numRows
+ The number of rows to insert.
+ */
+ virtual bool InsertRows(size_t pos = 0, size_t numRows = 1);
+
+ /**
+ Append additional rows at the end of the table.
+
+ This method is provided in addition to InsertRows() as some data models
+ may only support appending rows to them but not inserting them at
+ arbitrary locations. In such case you may implement this method only
+ and leave InsertRows() unimplemented.
+
+ @param numRows
+ The number of rows to add.
+ */
+ virtual bool AppendRows(size_t numRows = 1);
+
+ /**
+ Delete rows from the table.
+
+ Notice that currently deleting a row intersecting a multi-cell (see
+ SetCellSize()) is not supported and will result in a crash.
+
+ @param pos
+ The first row to delete.
+ @param numRows
+ The number of rows to delete.
+ */
+ virtual bool DeleteRows(size_t pos = 0, size_t numRows = 1);
+
+ /**
+ Exactly the same as InsertRows() but for columns.
+ */
+ virtual bool InsertCols(size_t pos = 0, size_t numCols = 1);
+
+ /**
+ Exactly the same as AppendRows() but for columns.
+ */
+ virtual bool AppendCols(size_t numCols = 1);
+
+ /**
+ Exactly the same as DeleteRows() but for columns.
+ */
+ virtual bool DeleteCols(size_t pos = 0, size_t numCols = 1);
+
+ //@}
+
+ /**
+ @name Table Row and Column Labels
+
+ By default the numbers are used for labeling rows and Latin letters for
+ labeling columns. If the table has more than 26 columns, the pairs of
+ letters are used starting from the 27-th one and so on, i.e. the
+ sequence of labels is A, B, ..., Z, AA, AB, ..., AZ, BA, ..., ..., ZZ,
+ AAA, ...
+ */
+ //@{
+
+ /**
+ Return the label of the specified row.
+ */
+ virtual wxString GetRowLabelValue(int row);
+
+ /**
+ Return the label of the specified column.
+ */
+ virtual wxString GetColLabelValue(int col);
+
+ /**
+ Set the given label for the specified row.
+
+ The default version does nothing, i.e. the label is not stored. You
+ must override this method in your derived class if you wish
+ wxGrid::SetRowLabelValue() to work.
+ */
+ virtual void SetRowLabelValue(int row, const wxString& label);
+
+ /**
+ Exactly the same as SetRowLabelValue() but for columns.
+ */
+ virtual void SetColLabelValue(int col, const wxString& label);
+
+ //@}
+
+
+ /**
+ @name Attributes Management
+
+ By default the attributes management is delegated to
+ wxGridCellAttrProvider class. You may override the methods in this
+ section to handle the attributes directly if, for example, they can be
+ computed from the cell values.
+ */
+ //@{
+
+ /**
+ Associate this attributes provider with the table.
+
+ The table takes ownership of @a attrProvider pointer and will delete it
+ when it doesn't need it any more. The pointer can be @NULL, however
+ this won't disable attributes management in the table but will just
+ result in a default attributes being recreated the next time any of the
+ other functions in this section is called. To completely disable the
+ attributes support, should this be needed, you need to override
+ CanHaveAttributes() to return @false.
+ */
+ void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
+
+ /**
+ Returns the attribute provider currently being used.
+
+ This function may return @NULL if the attribute provider hasn't been
+ neither associated with this table by SetAttrProvider() nor created on
+ demand by any other methods.
+ */
+ wxGridCellAttrProvider *GetAttrProvider() const;
+
+ /**
+ Return the attribute for the given cell.
+
+ By default this function is simply forwarded to
+ wxGridCellAttrProvider::GetAttr() but it may be overridden to handle
+ attributes directly in the table.
+ */
+ virtual wxGridCellAttr *GetAttr(int row, int col,
+ wxGridCellAttr::wxAttrKind kind);
+
+ /**
+ Set attribute of the specified cell.
+
+ By default this function is simply forwarded to
+ wxGridCellAttrProvider::SetAttr().
+
+ The table takes ownership of @a attr, i.e. will call DecRef() on it.
+ */
+ virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
+
+ /**
+ Set attribute of the specified row.
+
+ By default this function is simply forwarded to
+ wxGridCellAttrProvider::SetRowAttr().
+
+ The table takes ownership of @a attr, i.e. will call DecRef() on it.
+ */
+ virtual void SetRowAttr(wxGridCellAttr *attr, int row);
+
+ /**
+ Set attribute of the specified column.
+
+ By default this function is simply forwarded to
+ wxGridCellAttrProvider::SetColAttr().
+
+ The table takes ownership of @a attr, i.e. will call DecRef() on it.
+ */
+ virtual void SetColAttr(wxGridCellAttr *attr, int col);
+
+ //@}
+
+ /**
+ Returns true if this table supports attributes or false otherwise.
+
+ By default, the table automatically creates a wxGridCellAttrProvider
+ when this function is called if it had no attribute provider before and
+ returns @true.
+ */
+ virtual bool CanHaveAttributes();
+};
+
+
+
+enum wxGridTableRequest
+{
+ wxGRIDTABLE_REQUEST_VIEW_GET_VALUES = 2000,
+ wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES,
+ wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
+ wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
+ wxGRIDTABLE_NOTIFY_ROWS_DELETED,
+ wxGRIDTABLE_NOTIFY_COLS_INSERTED,
+ wxGRIDTABLE_NOTIFY_COLS_APPENDED,
+ wxGRIDTABLE_NOTIFY_COLS_DELETED
+};
+
+
+/**
+ @class wxGridTableMessage
+
+ A simple class used to pass messages from the table to the grid.
+
+ @library{wxadv}
+ @category{grid}
+*/
+class wxGridTableMessage
+{
+public:
+ wxGridTableMessage();
+ wxGridTableMessage( wxGridTableBase *table, int id,
+ int comInt1 = -1,
+ int comInt2 = -1 );
+
+ void SetTableObject( wxGridTableBase *table );
+ wxGridTableBase * GetTableObject() const;
+ void SetId( int id );
+ int GetId();
+ void SetCommandInt( int comInt1 );
+ int GetCommandInt();
+ void SetCommandInt2( int comInt2 );
+ int GetCommandInt2();
+};
+
+
+
+/**
+ @class wxGridStringTable
+
+ Simplest type of data table for a grid for small tables of strings
+ that are stored in memory
+*/
+class wxGridStringTable : public wxGridTableBase
+{
+public:
+ wxGridStringTable();
+ wxGridStringTable( int numRows, int numCols );
+
+ // these are pure virtual in wxGridTableBase
+ virtual int GetNumberRows();
+ virtual int GetNumberCols();
+ virtual wxString GetValue( int row, int col );
+ virtual void SetValue( int row, int col, const wxString& value );
+
+ // overridden functions from wxGridTableBase
+ void Clear();
+ bool InsertRows( size_t pos = 0, size_t numRows = 1 );
+ bool AppendRows( size_t numRows = 1 );
+ bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
+ bool InsertCols( size_t pos = 0, size_t numCols = 1 );
+ bool AppendCols( size_t numCols = 1 );
+ bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
+
+ void SetRowLabelValue( int row, const wxString& );
+ void SetColLabelValue( int col, const wxString& );
+ wxString GetRowLabelValue( int row );
+ wxString GetColLabelValue( int col );
+};
+
+
+
+
+
+
+/**
+ @class wxGridSizesInfo
+
+ wxGridSizesInfo stores information about sizes of all wxGrid rows or
+ columns.
+
+ It assumes that most of the rows or columns (which are both called elements
+ here as the difference between them doesn't matter at this class level)
+ have the default size and so stores it separately. And it uses a wxHashMap
+ to store the sizes of all elements which have the non-default size.
+
+ This structure is particularly useful for serializing the sizes of all
+ wxGrid elements at once.
+
+ @library{wxadv}
+ @category{grid}
+ */
+struct wxGridSizesInfo
+{
+ /**
+ Default constructor.
+
+ m_sizeDefault and m_customSizes must be initialized later.
+ */
+ wxGridSizesInfo();
+
+ /**
+ Constructor.
+
+ This constructor is used by wxGrid::GetRowSizes() and GetColSizes()
+ methods. User code will usually use the default constructor instead.
+
+ @param defSize
+ The default element size.
+ @param allSizes
+ Array containing the sizes of @em all elements, including those
+ which have the default size.
+ */
+ wxGridSizesInfo(int defSize, const wxArrayInt& allSizes);
+
+ /**
+ Get the element size.
+
+ @param pos
+ The index of the element.
+ @return
+ The size for this element, using m_customSizes if @a pos is in it
+ or m_sizeDefault otherwise.
+ */
+ int GetSize(unsigned pos) const;
+
+
+ /// Default size
+ int m_sizeDefault;
+
+ /**
+ Map with element indices as keys and their sizes as values.
+
+ This map only contains the elements with non-default size.
+ */
+ wxUnsignedToIntHashMap m_customSizes;
+};
+
+
+
+/**
+ Rendering styles supported by wxGrid::Render() method.
+
+ @since 2.9.4
+ */
+enum wxGridRenderStyle
+{
+ /// Draw grid row header labels.
+ wxGRID_DRAW_ROWS_HEADER = 0x001,
+
+ /// Draw grid column header labels.
+ wxGRID_DRAW_COLS_HEADER = 0x002,
+
+ /// Draw grid cell border lines.
+ wxGRID_DRAW_CELL_LINES = 0x004,
+
+ /**
+ Draw a bounding rectangle around the rendered cell area.
+
+ Useful where row or column headers are not drawn or where there is
+ multi row or column cell clipping and therefore no cell border at
+ the rendered outer boundary.
+ */
+ wxGRID_DRAW_BOX_RECT = 0x008,
+
+ /**
+ Draw the grid cell selection highlight if a selection is present.
+
+ At present the highlight colour drawn depends on whether the grid
+ window loses focus before drawing begins.
+ */
+ wxGRID_DRAW_SELECTION = 0x010,
+
+ /**
+ The default render style.
+
+ Includes all except wxGRID_DRAW_SELECTION.
+ */
+ wxGRID_DRAW_DEFAULT = wxGRID_DRAW_ROWS_HEADER |
+ wxGRID_DRAW_COLS_HEADER |
+ wxGRID_DRAW_CELL_LINES |
+ wxGRID_DRAW_BOX_RECT
+};
+
+
+
+/**
+ @class wxGrid
+
+ wxGrid and its related classes are used for displaying and editing tabular
+ data. They provide a rich set of features for display, editing, and
+ interacting with a variety of data sources. For simple applications, and to
+ help you get started, wxGrid is the only class you need to refer to
+ directly. It will set up default instances of the other classes and manage
+ them for you. For more complex applications you can derive your own classes
+ for custom grid views, grid data tables, cell editors and renderers. The
+ @ref overview_grid has examples of simple and more complex applications,
+ explains the relationship between the various grid classes and has a
+ summary of the keyboard shortcuts and mouse functions provided by wxGrid.
+
+ A wxGridTableBase class holds the actual data to be displayed by a wxGrid
+ class. One or more wxGrid classes may act as a view for one table class.
+ The default table class is called wxGridStringTable and holds an array of
+ strings. An instance of such a class is created by CreateGrid().
+
+ wxGridCellRenderer is the abstract base class for rendering contents in a
+ cell. The following renderers are predefined:
+
+ - wxGridCellBoolRenderer
+ - wxGridCellFloatRenderer
+ - wxGridCellNumberRenderer
+ - wxGridCellStringRenderer
+
+ The look of a cell can be further defined using wxGridCellAttr. An object
+ of this type may be returned by wxGridTableBase::GetAttr().
+
+ wxGridCellEditor is the abstract base class for editing the value of a
+ cell. The following editors are predefined:
+
+ - wxGridCellBoolEditor
+ - wxGridCellChoiceEditor
+ - wxGridCellFloatEditor
+ - wxGridCellNumberEditor
+ - wxGridCellTextEditor
+
+ Please see wxGridEvent, wxGridSizeEvent, wxGridRangeSelectEvent, and
+ wxGridEditorCreatedEvent for the documentation of all event types you can
+ use with wxGrid.
+
+ @library{wxadv}
+ @category{grid}
+
+ @see @ref overview_grid, wxGridUpdateLocker
+*/
+class wxGrid : public wxScrolledWindow
+{
+public:
+
+ /**
+ Different selection modes supported by the grid.
+ */
+ enum wxGridSelectionModes
+ {
+ /**
+ The default selection mode allowing selection of the individual
+ cells as well as of the entire rows and columns.
+ */
+ wxGridSelectCells,
+
+ /**
+ The selection mode allowing the selection of the entire rows only.
+
+ The user won't be able to select any cells or columns in this mode.
+ */
+ wxGridSelectRows,
+
+ /**
+ The selection mode allowing the selection of the entire columns only.
+
+ The user won't be able to select any cells or rows in this mode.
+ */
+ wxGridSelectColumns,
+
+ /**
+ The selection mode allowing the user to select either the entire
+ columns or the entire rows but not individual cells nor blocks.
+
+ Notice that while this constant is defined as @code
+ wxGridSelectColumns | wxGridSelectRows @endcode this doesn't mean
+ that all the other combinations are valid -- at least currently
+ they are not.
+
+ @since 2.9.1
+ */
+ wxGridSelectRowsOrColumns
+ };
+
+ /**
+ Return values for GetCellSize().
+
+ @since 2.9.1
+ */
+ enum CellSpan
+ {
+ /// This cell is inside a span covered by another cell.
+ CellSpan_Inside = -1,
+
+ /// This is a normal, non-spanning cell.
+ CellSpan_None = 0,
+
+ /// This cell spans several physical wxGrid cells.
+ CellSpan_Main
+ };
+
+ /**
+ Constants defining different support built-in TAB handling behaviours.
+
+ The elements of this enum determine what happens when TAB is pressed
+ when the cursor is in the rightmost column (or Shift-TAB is pressed
+ when the cursor is in the leftmost one).
+
+ @see SetTabBehaviour(), @c wxEVT_GRID_TABBING
+
+ @since 2.9.5
+ */
+ enum TabBehaviour
+ {
+ /// Do nothing, this is default.
+ Tab_Stop,
+
+ /// Move to the beginning of the next (or the end of the previous) row.
+ Tab_Wrap,
+
+ /// Move to the next (or the previous) control after the grid.
+ Tab_Leave
+ };
+
+ /**
+ @name Constructors and Initialization
+ */
+ //@{
+
+ /**
+ Default constructor.
+
+ You must call Create() to really create the grid window and also call
+ CreateGrid() or SetTable() to initialize the grid contents.
+ */
+ wxGrid();
+ /**
+ Constructor creating the grid window.
+
+ You must call either CreateGrid() or SetTable() to initialize the grid
+ contents before using it.
+ */
+ wxGrid(wxWindow* parent, wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxWANTS_CHARS,
+ const wxString& name = wxGridNameStr);
+
+ /**
+ Destructor.
+
+ This will also destroy the associated grid table unless you passed a
+ table object to the grid and specified that the grid should not take
+ ownership of the table (see SetTable()).
+ */
+ virtual ~wxGrid();
+
+ /**
+ Creates the grid window for an object initialized using the default
+ constructor.
+
+ You must call either CreateGrid() or SetTable() to initialize the grid
+ contents before using it.
+ */
+ bool Create(wxWindow* parent, wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxWANTS_CHARS,
+ const wxString& name = wxGridNameStr);
+
+ /**
+ Creates a grid with the specified initial number of rows and columns.
+
+ Call this directly after the grid constructor. When you use this
+ function wxGrid will create and manage a simple table of string values
+ for you. All of the grid data will be stored in memory.
+
+ For applications with more complex data types or relationships, or for
+ dealing with very large datasets, you should derive your own grid table
+ class and pass a table object to the grid with SetTable().
+ */
+ bool CreateGrid(int numRows, int numCols,
+ wxGridSelectionModes selmode = wxGridSelectCells);
+
+ /**
+ Passes a pointer to a custom grid table to be used by the grid.
+
+ This should be called after the grid constructor and before using the
+ grid object. If @a takeOwnership is set to @true then the table will be
+ deleted by the wxGrid destructor.
+
+ Use this function instead of CreateGrid() when your application
+ involves complex or non-string data or data sets that are too large to
+ fit wholly in memory.
+ */
+ bool SetTable(wxGridTableBase* table, bool takeOwnership = false,
+ wxGridSelectionModes selmode = wxGridSelectCells);
+
+ /**
+ Receive and handle a message from the table.
+ */
+ bool ProcessTableMessage(wxGridTableMessage& msg);
+
+ //@}
+
+
+ /**
+ @name Grid Line Formatting
+ */
+ //@{
+
+ /**
+ Turns the drawing of grid lines on or off.
+ */
+ void EnableGridLines(bool enable = true);
+
+ /**
+ Returns the pen used for vertical grid lines.
+
+ This virtual function may be overridden in derived classes in order to
+ change the appearance of individual grid lines for the given column
+ @a col.
+
+ See GetRowGridLinePen() for an example.
+ */
+ virtual wxPen GetColGridLinePen(int col);
+
+ /**
+ Returns the pen used for grid lines.
+
+ This virtual function may be overridden in derived classes in order to
+ change the appearance of grid lines. Note that currently the pen width
+ must be 1.
+
+ @see GetColGridLinePen(), GetRowGridLinePen()
+ */
+ virtual wxPen GetDefaultGridLinePen();
+
+ /**
+ Returns the colour used for grid lines.
+
+ @see GetDefaultGridLinePen()
+ */
+ wxColour GetGridLineColour() const;
+
+ /**
+ Returns the pen used for horizontal grid lines.
+
+ This virtual function may be overridden in derived classes in order to
+ change the appearance of individual grid line for the given @a row.
+
+ Example:
+ @code
+ // in a grid displaying music notation, use a solid black pen between
+ // octaves (C0=row 127, C1=row 115 etc.)
+ wxPen MidiGrid::GetRowGridLinePen(int row)
+ {
+ if ( row % 12 == 7 )
+ return wxPen(*wxBLACK, 1, wxSOLID);
+ else
+ return GetDefaultGridLinePen();
+ }
+ @endcode
+ */
+ virtual wxPen GetRowGridLinePen(int row);
+
+ /**
+ Returns @true if drawing of grid lines is turned on, @false otherwise.
+ */
+ bool GridLinesEnabled() const;
+
+ /**
+ Sets the colour used to draw grid lines.
+ */
+ void SetGridLineColour(const wxColour& colour);
+
+ //@}
+
+
+ /**
+ @name Label Values and Formatting
+ */
+ //@{
+
+ /**
+ Sets the arguments to the current column label alignment values.
+
+ Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
+ or @c wxALIGN_RIGHT.
+
+ Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
+ @c wxALIGN_BOTTOM.
+ */
+ void GetColLabelAlignment(int* horiz, int* vert) const;
+
+ /**
+ Returns the orientation of the column labels (either @c wxHORIZONTAL or
+ @c wxVERTICAL).
+ */
+ int GetColLabelTextOrientation() const;
+
+ /**
+ Returns the specified column label.
+
+ The default grid table class provides column labels of the form
+ A,B...Z,AA,AB...ZZ,AAA... If you are using a custom grid table you can
+ override wxGridTableBase::GetColLabelValue() to provide your own
+ labels.
+ */
+ wxString GetColLabelValue(int col) const;
+
+ /**
+ Returns the colour used for the background of row and column labels.
+ */
+ wxColour GetLabelBackgroundColour() const;
+
+ /**
+ Returns the font used for row and column labels.
+ */
+ wxFont GetLabelFont() const;
+
+ /**
+ Returns the colour used for row and column label text.
+ */
+ wxColour GetLabelTextColour() const;
+
+ /**
+ Returns the alignment used for row labels.
+
+ Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
+ or @c wxALIGN_RIGHT.
+
+ Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
+ @c wxALIGN_BOTTOM.
+ */
+ void GetRowLabelAlignment(int* horiz, int* vert) const;
+
+ /**
+ Returns the specified row label.
+
+ The default grid table class provides numeric row labels. If you are
+ using a custom grid table you can override
+ wxGridTableBase::GetRowLabelValue() to provide your own labels.
+ */
+ wxString GetRowLabelValue(int row) const;
+
+ /**
+ Hides the column labels by calling SetColLabelSize() with a size of 0.
+ Show labels again by calling that method with a width greater than 0.
+ */
+ void HideColLabels();
+
+ /**
+ Hides the row labels by calling SetRowLabelSize() with a size of 0.
+
+ The labels can be shown again by calling SetRowLabelSize() with a width
+ greater than 0.
+ */
+ void HideRowLabels();
+
+ /**
+ Sets the horizontal and vertical alignment of column label text.
+
+ Horizontal alignment should be one of @c wxALIGN_LEFT,
+ @c wxALIGN_CENTRE or @c wxALIGN_RIGHT. Vertical alignment should be one
+ of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
+ */
+ void SetColLabelAlignment(int horiz, int vert);
+
+ /**
+ Sets the orientation of the column labels (either @c wxHORIZONTAL or
+ @c wxVERTICAL).
+ */
+ void SetColLabelTextOrientation(int textOrientation);
+
+ /**
+ Set the value for the given column label.
+
+ If you are using a custom grid table you must override
+ wxGridTableBase::SetColLabelValue() for this to have any effect.
+ */
+ void SetColLabelValue(int col, const wxString& value);
+
+ /**
+ Sets the background colour for row and column labels.
+ */
+ void SetLabelBackgroundColour(const wxColour& colour);
+
+ /**
+ Sets the font for row and column labels.
+ */
+ void SetLabelFont(const wxFont& font);
+
+ /**
+ Sets the colour for row and column label text.
+ */
+ void SetLabelTextColour(const wxColour& colour);
+
+ /**
+ Sets the horizontal and vertical alignment of row label text.
+
+ Horizontal alignment should be one of @c wxALIGN_LEFT,
+ @c wxALIGN_CENTRE or @c wxALIGN_RIGHT. Vertical alignment should be one
+ of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
+ */
+ void SetRowLabelAlignment(int horiz, int vert);
+
+ /**
+ Sets the value for the given row label.
+
+ If you are using a derived grid table you must override
+ wxGridTableBase::SetRowLabelValue() for this to have any effect.
+ */
+ void SetRowLabelValue(int row, const wxString& value);
+
+ /**
+ Call this in order to make the column labels use a native look by using
+ wxRendererNative::DrawHeaderButton() internally.
+
+ There is no equivalent method for drawing row columns as there is not
+ native look for that. This option is useful when using wxGrid for
+ displaying tables and not as a spread-sheet.
+
+ @see UseNativeColHeader()
+ */
+ void SetUseNativeColLabels(bool native = true);
+
+ /**
+ Enable the use of native header window for column labels.
+
+ If this function is called with @true argument, a wxHeaderCtrl is used
+ instead to display the column labels instead of drawing them in wxGrid
+ code itself. This has the advantage of making the grid look and feel
+ perfectly the same as native applications (using SetUseNativeColLabels()
+ the grid can be made to look more natively but it still doesn't feel
+ natively, notably the column resizing and dragging still works slightly
+ differently as it is implemented in wxWidgets itself) but results in
+ different behaviour for column and row headers, for which there is no
+ equivalent function, and, most importantly, is unsuitable for grids
+ with huge numbers of columns as wxHeaderCtrl doesn't support virtual
+ mode. Because of this, by default the grid does not use the native
+ header control but you should call this function to enable it if you
+ are using the grid to display tabular data and don't have thousands of
+ columns in it.
+
+ Another difference between the default behaviour and the native header
+ behaviour is that the latter provides the user with a context menu
+ (which appears on right clicking the header) allowing to rearrange the
+ grid columns if CanDragColMove() returns @true. If you want to prevent
+ this from happening for some reason, you need to define a handler for
+ @c wxEVT_GRID_LABEL_RIGHT_CLICK event which simply does nothing (in
+ particular doesn't skip the event) as this will prevent the default
+ right click handling from working.
+
+ Also note that currently @c wxEVT_GRID_LABEL_RIGHT_DCLICK event is not
+ generated for the column labels if the native columns header is used
+ (but this limitation could possibly be lifted in the future).
+ */
+ void UseNativeColHeader(bool native = true);
+
+ //@}
+
+
+ /**
+ @name Cell Formatting
+
+ Note that wxGridCellAttr can be used alternatively to most of these
+ methods. See the "Attributes Management" of wxGridTableBase.
+ */
+ //@{
+
+ /**
+ Sets the arguments to the horizontal and vertical text alignment values
+ for the grid cell at the specified location.
+
+ Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
+ or @c wxALIGN_RIGHT.
+
+ Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
+ @c wxALIGN_BOTTOM.
+ */
+ void GetCellAlignment(int row, int col, int* horiz, int* vert) const;
+
+ /**
+ Returns the background colour of the cell at the specified location.
+ */
+ wxColour GetCellBackgroundColour(int row, int col) const;
+
+ /**
+ Returns the font for text in the grid cell at the specified location.
+ */
+ wxFont GetCellFont(int row, int col) const;
+
+ /**
+ Returns the text colour for the grid cell at the specified location.
+ */
+ wxColour GetCellTextColour(int row, int col) const;
+
+ /**
+ Returns the default cell alignment.
+
+ Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
+ or @c wxALIGN_RIGHT.
+
+ Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
+ @c wxALIGN_BOTTOM.
+
+ @see SetDefaultCellAlignment()
+ */
+ void GetDefaultCellAlignment(int* horiz, int* vert) const;
+
+ /**
+ Returns the current default background colour for grid cells.
+ */
+ wxColour GetDefaultCellBackgroundColour() const;
+
+ /**
+ Returns the current default font for grid cell text.
+ */
+ wxFont GetDefaultCellFont() const;
+
+ /**
+ Returns the current default colour for grid cell text.
+ */
+ wxColour GetDefaultCellTextColour() const;
+
+ /**
+ Sets the horizontal and vertical alignment for grid cell text at the
+ specified location.
+
+ Horizontal alignment should be one of @c wxALIGN_LEFT,
+ @c wxALIGN_CENTRE or @c wxALIGN_RIGHT.
+
+ Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
+ or @c wxALIGN_BOTTOM.
+ */
+ void SetCellAlignment(int row, int col, int horiz, int vert);
+ /**
+ Sets the horizontal and vertical alignment for grid cell text at the
+ specified location.
+
+ Horizontal alignment should be one of @c wxALIGN_LEFT,
+ @c wxALIGN_CENTRE or @c wxALIGN_RIGHT.
+
+ Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
+ or @c wxALIGN_BOTTOM.
+ */
+ void SetCellAlignment(int align, int row, int col);
+
+ /**
+ Set the background colour for the given cell or all cells by default.
+ */
+ void SetCellBackgroundColour(int row, int col, const wxColour& colour);
+
+ /**
+ Sets the font for text in the grid cell at the specified location.
+ */
+ void SetCellFont(int row, int col, const wxFont& font);
+
+ /**
+ Sets the text colour for the given cell.
+ */
+ void SetCellTextColour(int row, int col, const wxColour& colour);
+ /**
+ Sets the text colour for the given cell.
+ */
+ void SetCellTextColour(const wxColour& val, int row, int col);
+ /**
+ Sets the text colour for all cells by default.
+ */
+ void SetCellTextColour(const wxColour& colour);
+
+ /**
+ Sets the default horizontal and vertical alignment for grid cell text.
+
+ Horizontal alignment should be one of @c wxALIGN_LEFT,
+ @c wxALIGN_CENTRE or @c wxALIGN_RIGHT. Vertical alignment should be one
+ of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
+ */
+ void SetDefaultCellAlignment(int horiz, int vert);
+
+ /**
+ Sets the default background colour for grid cells.
+ */
+ void SetDefaultCellBackgroundColour(const wxColour& colour);
+
+ /**
+ Sets the default font to be used for grid cell text.
+ */
+ void SetDefaultCellFont(const wxFont& font);
+
+ /**
+ Sets the current default colour for grid cell text.
+ */
+ void SetDefaultCellTextColour(const wxColour& colour);
+
+ //@}
+
+
+ /**
+ @name Cell Values, Editors, and Renderers
+
+ Note that wxGridCellAttr can be used alternatively to most of these
+ methods. See the "Attributes Management" of wxGridTableBase.
+ */
+ //@{
+
+ /**
+ Returns @true if the in-place edit control for the current grid cell
+ can be used and @false otherwise.
+
+ This function always returns @false for the read-only cells.
+ */
+ bool CanEnableCellControl() const;
+
+ /**
+ Disables in-place editing of grid cells.
+
+ Equivalent to calling EnableCellEditControl(@false).
+ */
+ void DisableCellEditControl();
+
+ /**
+ Enables or disables in-place editing of grid cell data.
+
+ The grid will issue either a @c wxEVT_GRID_EDITOR_SHOWN or
+ @c wxEVT_GRID_EDITOR_HIDDEN event.
+ */
+ void EnableCellEditControl(bool enable = true);
+
+ /**
+ Makes the grid globally editable or read-only.
+
+ If the edit argument is @false this function sets the whole grid as
+ read-only. If the argument is @true the grid is set to the default
+ state where cells may be editable. In the default state you can set
+ single grid cells and whole rows and columns to be editable or
+ read-only via wxGridCellAttr::SetReadOnly(). For single cells you
+ can also use the shortcut function SetReadOnly().
+
+ For more information about controlling grid cell attributes see the
+ wxGridCellAttr class and the @ref overview_grid.
+ */
+ void EnableEditing(bool edit);
+
+ /**
+ Returns a pointer to the editor for the cell at the specified location.
+
+ See wxGridCellEditor and the @ref overview_grid for more information
+ about cell editors and renderers.
+
+ The caller must call DecRef() on the returned pointer.
+ */
+ wxGridCellEditor* GetCellEditor(int row, int col) const;
+
+ /**
+ Returns a pointer to the renderer for the grid cell at the specified
+ location.
+
+ See wxGridCellRenderer and the @ref overview_grid for more information
+ about cell editors and renderers.
+
+ The caller must call DecRef() on the returned pointer.
+ */
+ wxGridCellRenderer* GetCellRenderer(int row, int col) const;
+
+ /**
+ Returns the string contained in 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
+ SetCellValue() 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::CanGetValueAs() and the @ref overview_grid for
+ more information.
+ */
+ wxString GetCellValue(int row, int col) const;
+ /**
+ Returns the string contained in 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
+ SetCellValue() 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::CanGetValueAs() and the @ref overview_grid for
+ more information.
+ */
+ wxString GetCellValue(const wxGridCellCoords& coords) const;
+
+ /**
+ Returns a pointer to the current default grid cell editor.
+
+ See wxGridCellEditor and the @ref overview_grid for more information
+ about cell editors and renderers.
+ */
+ wxGridCellEditor* GetDefaultEditor() const;
+
+ /**
+ Returns the default editor for the specified cell.
+
+ The base class version returns the editor appropriate for the current
+ cell type but this method may be overridden in the derived classes to
+ use custom editors for some cells by default.
+
+ Notice that the same may be achieved in a usually simpler way by
+ associating a custom editor with the given cell or cells.
+
+ The caller must call DecRef() on the returned pointer.
+ */
+ virtual wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
+ /**
+ Returns the default editor for the specified cell.
+
+ The base class version returns the editor appropriate for the current
+ cell type but this method may be overridden in the derived classes to
+ use custom editors for some cells by default.
+
+ Notice that the same may be achieved in a usually simpler way by
+ associating a custom editor with the given cell or cells.
+
+ The caller must call DecRef() on the returned pointer.
+ */
+ wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const;
+
+ /**
+ Returns the default editor for the cells containing values of the given
+ type.
+
+ The base class version returns the editor which was associated with the
+ specified @a typeName when it was registered RegisterDataType() but
+ this function may be overridden to return something different. This
+ allows to override an editor used for one of the standard types.
+
+ The caller must call DecRef() on the returned pointer.
+ */
+ virtual wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
+
+ /**
+ Returns a pointer to the current default grid cell renderer.
+
+ See wxGridCellRenderer and the @ref overview_grid for more information
+ about cell editors and renderers.
+
+ The caller must call DecRef() on the returned pointer.
+ */
+ wxGridCellRenderer* GetDefaultRenderer() const;
+
+ /**
+ Returns the default renderer for the given cell.
+
+ The base class version returns the renderer appropriate for the current
+ cell type but this method may be overridden in the derived classes to
+ use custom renderers for some cells by default.
+
+ The caller must call DecRef() on the returned pointer.
+ */
+ virtual wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
+
+ /**
+ Returns the default renderer for the cell containing values of the
+ given type.
+
+ @see GetDefaultEditorForType()
+ */
+ virtual wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
+
+ /**
+ Hides the in-place cell edit control.
+ */
+ void HideCellEditControl();
+
+ /**
+ Returns @true if the in-place edit control is currently enabled.
+ */
+ bool IsCellEditControlEnabled() const;
+
+ /**
+ Returns @true if the current cell is read-only.
+
+ @see SetReadOnly(), IsReadOnly()
+ */
+ bool IsCurrentCellReadOnly() const;
+
+ /**
+ Returns @false if the whole grid has been set as read-only or @true
+ otherwise.
+
+ See EnableEditing() for more information about controlling the editing
+ status of grid cells.
+ */
+ bool IsEditable() const;
+
+ /**
+ Returns @true if the cell at the specified location can't be edited.
+
+ @see SetReadOnly(), IsCurrentCellReadOnly()
+ */
+ bool IsReadOnly(int row, int col) const;
+
+ /**
+ Register a new data type.
+
+ The data types allow to naturally associate specific renderers and
+ editors to the cells containing values of the given type. For example,
+ the grid automatically registers a data type with the name
+ @c wxGRID_VALUE_STRING which uses wxGridCellStringRenderer and
+ wxGridCellTextEditor as its renderer and editor respectively -- this is
+ the data type used by all the cells of the default wxGridStringTable,
+ so this renderer and editor are used by default for all grid cells.
+
+ However if a custom table returns @c wxGRID_VALUE_BOOL from its
+ wxGridTableBase::GetTypeName() method, then wxGridCellBoolRenderer and
+ wxGridCellBoolEditor are used for it because the grid also registers a
+ boolean data type with this name.
+
+ And as this mechanism is completely generic, you may register your own
+ data types using your own custom renderers and editors. Just remember
+ that the table must identify a cell as being of the given type for them
+ to be used for this cell.
+
+ @param typeName
+ Name of the new type. May be any string, but if the type name is
+ the same as the name of an already registered type, including one
+ of the standard ones (which are @c wxGRID_VALUE_STRING, @c
+ wxGRID_VALUE_BOOL, @c wxGRID_VALUE_NUMBER, @c wxGRID_VALUE_FLOAT
+ and @c wxGRID_VALUE_CHOICE), then the new registration information
+ replaces the previously used renderer and editor.
+ @param renderer
+ The renderer to use for the cells of this type. Its ownership is
+ taken by the grid, i.e. it will call DecRef() on this pointer when
+ it doesn't need it any longer.
+ @param editor
+ The editor to use for the cells of this type. Its ownership is also
+ taken by the grid.
+ */
+ 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 @true if the cell value can overflow.
+
+ A cell can overflow if the next cell in the row is empty.
+ */
+ bool GetCellOverflow(int row, int col) const;
+
+ /**
+ 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 @true if the cells can overflow by default.
+ */
+ bool GetDefaultCellOverflow() 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 overflow permission of the cell.
+ */
+ void SetCellOverflow(int row, int col, bool allow);
+
+ /**
+ 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() to restore the previous column width.
+
+ If the column is already hidden, this method doesn't do anything.
+
+ @param col
+ The column index.
+ */
+ void HideCol(int col);
+
+ /**
+ Shows the previously hidden column by resizing it to non-0 size.
+
+ The column is shown again with the same width that it had before
+ HideCol() call.
+
+ If the column is currently shown, this method doesn't do anything.
+
+ @see HideCol(), SetColSize()
+ */
+ void ShowCol(int col);
+
+
+ /**
+ Sets the default overflow permission of the cells.
+ */
+ void SetDefaultCellOverflow( bool allow );
+
+ /**
+ 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);
projects / wxWidgets.git / blobdiff