/////////////////////////////////////////////////////////////////////////////
// Name: grid.h
-// Purpose: interface of wxGridCellFloatRenderer
+// Purpose: interface of wxGrid and related classes
// Author: wxWidgets team
-// RCS-ID: $Id$
-// Licence: wxWindows license
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
- @class wxGridCellFloatRenderer
+ @class wxGridCellRenderer
- This class may be used to format floating point data in a cell.
+ This class is responsible for actually drawing the cell in the grid. You
+ may pass it to the wxGridCellAttr (below) to change the format of one given
+ cell or to wxGrid::SetDefaultRenderer() to change the view of all cells.
+ This is an abstract class, and you will normally use one of the predefined
+ derived classes or derive your own class from it.
@library{wxadv}
@category{grid}
- @see wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellStringRenderer,
- wxGridCellBoolRenderer
+ @see wxGridCellAutoWrapStringRenderer, wxGridCellBoolRenderer,
+ wxGridCellDateTimeRenderer, wxGridCellEnumRenderer,
+ wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+ wxGridCellStringRenderer
*/
-class wxGridCellFloatRenderer : public wxGridCellStringRenderer
+class wxGridCellRenderer : public wxClientDataContainer, public wxRefCounter
{
public:
- /**
- @param width
- Minimum number of characters to be shown.
- @param precision
- Number of digits after the decimal dot.
- */
- wxGridCellFloatRenderer(int width = -1, int precision = -1);
+ wxGridCellRenderer();
/**
- Returns the precision.
+ This function must be implemented in derived classes to return a copy
+ of itself.
*/
- int GetPrecision() const;
+ virtual wxGridCellRenderer* Clone() const = 0;
/**
- Returns the width.
- */
- int GetWidth() const;
+ Draw the given cell on the provided DC inside the given rectangle using
+ the style specified by the attribute and the default or selected state
+ corresponding to the isSelected value.
- /**
- Parameters string format is "width[,precision]".
+ This pure virtual function has a default implementation which will
+ prepare the DC using the given attribute: it will draw the rectangle
+ with the background colour from attr and set the text colour and font.
*/
- void SetParameters(const wxString& params);
+ virtual void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
+ const wxRect& rect, int row, int col,
+ bool isSelected) = 0;
/**
- Sets the precision.
+ Get the preferred size of the cell for its contents.
*/
- void SetPrecision(int precision);
+ virtual wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
+ int row, int col) = 0;
+protected:
/**
- Sets the width.
+ The destructor is private because only DecRef() can delete us.
*/
- void SetWidth(int width);
+ virtual ~wxGridCellRenderer();
};
-
-
/**
- @class wxGridTableBase
+ @class wxGridCellAutoWrapStringRenderer
- Grid table classes.
+ This class may be used to format string data in a cell. The too
+ long lines are wrapped to be shown entirely at word boundaries.
@library{wxadv}
@category{grid}
+
+ @see wxGridCellRenderer, wxGridCellBoolRenderer,
+ wxGridCellDateTimeRenderer, wxGridCellEnumRenderer,
+ wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+ wxGridCellStringRenderer
*/
-class wxGridTableBase : public wxObject
+
+class wxGridCellAutoWrapStringRenderer : public wxGridCellStringRenderer
{
public:
/**
-
- */
- wxGridTableBase();
-
- /**
-
- */
- ~wxGridTableBase();
-
- /**
-
- */
- bool AppendCols(size_t numCols = 1);
-
- /**
-
+ Default constructor.
*/
- bool AppendRows(size_t numRows = 1);
-
- /**
+ wxGridCellAutoWrapStringRenderer();
+};
- */
- bool CanGetValueAs(int row, int col, const wxString& typeName);
- /**
- Does this table allow attributes? Default implementation creates
- a wxGridCellAttrProvider if necessary.
- */
- bool CanHaveAttributes();
+/**
+ @class wxGridCellBoolRenderer
- /**
+ This class may be used to format boolean data in a cell.
- */
- bool CanSetValueAs(int row, int col, const wxString& typeName);
+ @library{wxadv}
+ @category{grid}
+ @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+ wxGridCellDateTimeRenderer, wxGridCellEnumRenderer,
+ wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+ wxGridCellStringRenderer
+*/
+class wxGridCellBoolRenderer : public wxGridCellRenderer
+{
+public:
/**
-
+ Default constructor.
*/
- void Clear();
-
- /**
+ wxGridCellBoolRenderer();
+};
- */
- bool DeleteCols(size_t pos = 0, size_t numCols = 1);
+/**
+ @class wxGridCellDateTimeRenderer
- /**
+ This class may be used to format a date/time data in a cell.
+ The class wxDateTime is used internally to display the local date/time
+ or to parse the string date entered in the cell thanks to the defined format.
- */
- bool DeleteRows(size_t pos = 0, size_t numRows = 1);
+ @library{wxadv}
+ @category{grid}
+ @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+ wxGridCellBoolRenderer, wxGridCellEnumRenderer,
+ wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+ wxGridCellStringRenderer
+*/
+class wxGridCellDateTimeRenderer : public wxGridCellStringRenderer
+{
+public:
/**
- by default forwarded to wxGridCellAttrProvider if any. May be
- overridden to handle attributes directly in the table.
- */
- wxGridCellAttr* GetAttr(int row, int col);
+ Date/time renderer constructor.
- /**
- get the currently used attr provider (may be @NULL)
+ @param outformat
+ strptime()-like format string used the parse the output date/time.
+ @param informat
+ strptime()-like format string used to parse the string entered in the cell.
*/
- wxGridCellAttrProvider* GetAttrProvider() const;
+ wxGridCellDateTimeRenderer(const wxString& outformat = wxDefaultDateTimeFormat,
+ const wxString& informat = wxDefaultDateTimeFormat);
- /**
-
- */
- wxString GetColLabelValue(int col);
/**
+ Sets the strptime()-like format string which will be used to parse
+ the date/time.
+ @param params
+ strptime()-like format string used to parse the date/time.
*/
- int GetNumberCols();
+ virtual void SetParameters(const wxString& params);
+};
- /**
- You must override these functions in a derived table class.
- */
- int GetNumberRows();
+/**
+ @class wxGridCellEnumRenderer
- /**
+ This class may be used to render in a cell a number as a textual
+ equivalent.
- */
- wxString GetRowLabelValue(int row);
+ The corresponding text strings are specified as comma-separated items in
+ the string passed to this renderer ctor or SetParameters() method. For
+ example, if this string is @c "John,Fred,Bob" the cell will be rendered as
+ "John", "Fred" or "Bob" if its contents is 0, 1 or 2 respectively.
- /**
- Data type determination and value access.
- */
- wxString GetTypeName(int row, int col);
+ @library{wxadv}
+ @category{grid}
+ @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+ wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
+ wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+ wxGridCellStringRenderer
+*/
+class wxGridCellEnumRenderer : public wxGridCellStringRenderer
+{
+public:
/**
+ Enum renderer ctor.
+ @param choices
+ Comma separated string parameters "item1[,item2[...,itemN]]".
*/
- wxString GetValue(int row, int col);
+ wxGridCellEnumRenderer( const wxString& choices = wxEmptyString );
/**
+ Sets the comma separated string content of the enum.
+ @param params
+ Comma separated string parameters "item1[,item2[...,itemN]]".
*/
- bool GetValueAsBool(int row, int col);
+ virtual void SetParameters(const wxString& params);
+};
- /**
- For user defined types
- */
- void* GetValueAsCustom(int row, int col,
- const wxString& typeName);
+/**
+ Specifier used to format the data to string for the numbers handled by
+ wxGridCellFloatRenderer and wxGridCellFloatEditor.
- /**
+ @since 2.9.3
+*/
+enum wxGridCellFloatFormat
+{
+ /// Decimal floating point (%f).
+ wxGRID_FLOAT_FORMAT_FIXED = 0x0010,
- */
- double GetValueAsDouble(int row, int col);
+ /// Scientific notation (mantise/exponent) using e character (%e).
+ wxGRID_FLOAT_FORMAT_SCIENTIFIC = 0x0020,
- /**
+ /// Use the shorter of %e or %f (%g).
+ wxGRID_FLOAT_FORMAT_COMPACT = 0x0040,
- */
- long GetValueAsLong(int row, int col);
+ /// To use in combination with one of the above formats for the upper
+ /// case version (%F/%E/%G)
+ wxGRID_FLOAT_FORMAT_UPPER = 0x0080,
- /**
+ /// The format used by default (wxGRID_FLOAT_FORMAT_FIXED).
+ wxGRID_FLOAT_FORMAT_DEFAULT = wxGRID_FLOAT_FORMAT_FIXED
+};
- */
- wxGrid* GetView() const;
+/**
+ @class wxGridCellFloatRenderer
- /**
+ This class may be used to format floating point data in a cell.
- */
- bool InsertCols(size_t pos = 0, size_t numCols = 1);
+ @library{wxadv}
+ @category{grid}
+ @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+ wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
+ wxGridCellEnumRenderer, wxGridCellNumberRenderer,
+ wxGridCellStringRenderer
+*/
+class wxGridCellFloatRenderer : public wxGridCellStringRenderer
+{
+public:
/**
+ Float cell renderer ctor.
+ @param width
+ Minimum number of characters to be shown.
+ @param precision
+ Number of digits after the decimal dot.
+ @param format
+ The format used to display the string, must be a combination of
+ ::wxGridCellFloatFormat enum elements. This parameter is only
+ available since wxWidgets 2.9.3.
*/
- bool InsertRows(size_t pos = 0, size_t numRows = 1);
+ wxGridCellFloatRenderer(int width = -1, int precision = -1,
+ int format = wxGRID_FLOAT_FORMAT_DEFAULT);
/**
+ Returns the specifier used to format the data to string.
- */
- bool IsEmptyCell(int row, int col);
+ The returned value is a combination of ::wxGridCellFloatFormat elements.
- /**
- these functions take ownership of the pointer
+ @since 2.9.3
*/
- void SetAttr(wxGridCellAttr* attr, int row, int col);
+ int GetFormat() const;
/**
- Attribute handling
- give us the attr provider to use - we take ownership of the pointer
+ Returns the precision.
*/
- void SetAttrProvider(wxGridCellAttrProvider* attrProvider);
+ int GetPrecision() const;
/**
-
+ Returns the width.
*/
- void SetColAttr(wxGridCellAttr* attr, int col);
+ int GetWidth() const;
/**
- , @e wxString)
- */
- void SetColLabelValue() const;
+ Set the format to use for display the number.
- /**
+ @param format
+ Must be a combination of ::wxGridCellFloatFormat enum elements.
+ @since 2.9.3
*/
- void SetRowAttr(wxGridCellAttr* attr, int row);
+ void SetFormat(int format);
/**
- , @e wxString)
+ The parameters string format is "width[,precision[,format]]" where
+ @c format should be chosen between f|e|g|E|G (f is used by default)
*/
- void SetRowLabelValue() const;
+ virtual void SetParameters(const wxString& params);
/**
-
+ Sets the precision.
*/
- void SetValue(int row, int col, const wxString& value);
+ void SetPrecision(int precision);
/**
-
+ Sets the width.
*/
- void SetValueAsBool(int row, int col, bool value);
-
- /**
+ void SetWidth(int width);
+};
- */
- void SetValueAsCustom(int row, int col, const wxString& typeName,
- void* value);
+/**
+ @class wxGridCellNumberRenderer
- /**
+ This class may be used to format integer data in a cell.
- */
- void SetValueAsDouble(int row, int col, double value);
+ @library{wxadv}
+ @category{grid}
+ @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+ wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
+ wxGridCellEnumRenderer, wxGridCellFloatRenderer,
+ wxGridCellStringRenderer
+*/
+class wxGridCellNumberRenderer : public wxGridCellStringRenderer
+{
+public:
/**
-
+ Default constructor.
*/
- void SetValueAsLong(int row, int col, long value);
+ wxGridCellNumberRenderer();
+};
- /**
- Overriding these is optional
- */
- void SetView(wxGrid* grid);
+/**
+ @class wxGridCellStringRenderer
- /**
+ This class may be used to format string data in a cell; it is the default
+ for string cells.
- */
- void UpdateAttrCols(size_t pos, int numCols);
+ @library{wxadv}
+ @category{grid}
+ @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+ wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
+ wxGridCellEnumRenderer, wxGridCellFloatRenderer,
+ wxGridCellNumberRenderer
+*/
+class wxGridCellStringRenderer : public wxGridCellRenderer
+{
+public:
/**
- change row/col number in attribute if needed
+ Default constructor.
*/
- void UpdateAttrRows(size_t pos, int numRows);
+ wxGridCellStringRenderer();
};
-
/**
@class wxGridCellEditor
- This class is responsible for providing and manipulating
- the in-place edit controls for the grid. Instances of wxGridCellEditor
- (actually, instances of derived classes since it is an abstract class) can be
- associated with the cell attributes for individual cells, rows, columns, or
- even for the entire grid.
+ This class is responsible for providing and manipulating the in-place edit
+ controls for the grid. Instances of wxGridCellEditor (actually, instances
+ of derived classes since it is an abstract class) can be associated with
+ the cell attributes for individual cells, rows, columns, or even for the
+ entire grid.
@library{wxadv}
@category{grid}
- @see wxGridCellTextEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
- wxGridCellNumberEditor, wxGridCellChoiceEditor
+ @see wxGridCellAutoWrapStringEditor, wxGridCellBoolEditor,
+ wxGridCellChoiceEditor, wxGridCellEnumEditor,
+ wxGridCellFloatEditor, wxGridCellNumberEditor,
+ wxGridCellTextEditor
*/
-class wxGridCellEditor
+class wxGridCellEditor : public wxClientDataContainer, public wxRefCounter
{
public:
/**
-
+ Default constructor.
*/
wxGridCellEditor();
/**
- The dtor is private because only DecRef() can delete us.
- */
- ~wxGridCellEditor();
+ Fetch the value from the table and prepare the edit control to begin
+ editing.
- /**
- Fetch the value from the table and prepare the edit control
- to begin editing. Set the focus to the edit control.
+ This function should save the original value of the grid cell at the
+ given @a row and @a col and show the control allowing the user to
+ change it.
+
+ @see EndEdit()
*/
- void BeginEdit(int row, int col, wxGrid* grid);
+ virtual void BeginEdit(int row, int col, wxGrid* grid) = 0;
/**
Create a new object which is the copy of this one.
*/
- wxGridCellEditor* Clone() const;
+ virtual wxGridCellEditor* Clone() const = 0;
/**
Creates the actual edit control.
*/
- void Create(wxWindow* parent, wxWindowID id,
- wxEvtHandler* evtHandler);
+ virtual void Create(wxWindow* parent, wxWindowID id,
+ wxEvtHandler* evtHandler) = 0;
/**
Final cleanup.
*/
- void Destroy();
+ virtual void Destroy();
/**
- Complete the editing of the current cell. Returns @true if the value has
- changed. If necessary, the control may be destroyed.
+ End editing the cell.
+
+ This function must check if the current value of the editing control is
+ valid and different from the original value (available as @a oldval in
+ its string form and possibly saved internally using its real type by
+ BeginEdit()). If it isn't, it just returns @false, otherwise it must do
+ the following:
+ - Save the new value internally so that ApplyEdit() could apply it.
+ - Fill @a newval (which is never @NULL) with the string
+ representation of the new value.
+ - Return @true
+
+ Notice that it must @em not modify the grid as the change could still
+ be vetoed.
+
+ If the user-defined wxEVT_GRID_CELL_CHANGING event handler doesn't veto
+ this change, ApplyEdit() will be called next.
*/
- bool EndEdit(int row, int col, wxGrid* grid);
+ virtual bool EndEdit(int row, int col, const wxGrid* grid,
+ const wxString& oldval, wxString* newval) = 0;
/**
- Some types of controls on some platforms may need some help
- with the Return key.
- */
- void HandleReturn(wxKeyEvent& event);
+ Effectively save the changes in the grid.
+
+ This function should save the value of the control in the grid. It is
+ called only after EndEdit() returns @true.
+ */
+ virtual void ApplyEdit(int row, int col, wxGrid* grid) = 0;
/**
+ Some types of controls on some platforms may need some help with the
+ Return key.
+ */
+ virtual void HandleReturn(wxKeyEvent& event);
+ /**
+ Returns @true if the edit control has been created.
*/
bool IsCreated();
Draws the part of the cell not occupied by the control: the base class
version just fills it with background colour from the attribute.
*/
- void PaintBackground(const wxRect& rectCell,
- wxGridCellAttr* attr);
+ virtual void PaintBackground(wxDC& dc, const wxRect& rectCell, wxGridCellAttr& attr);
/**
Reset the value in the control back to its starting value.
*/
- void Reset();
+ virtual void Reset() = 0;
/**
Size and position the edit control.
*/
- void SetSize(const wxRect& rect);
+ virtual void SetSize(const wxRect& rect);
/**
Show or hide the edit control, use the specified attributes to set
colours/fonts for it.
*/
- void Show(bool show, wxGridCellAttr* attr = NULL);
+ virtual void Show(bool show, wxGridCellAttr* attr = NULL);
/**
If the editor is enabled by clicking on the cell, this method will be
called.
*/
- void StartingClick();
+ virtual void StartingClick();
/**
- If the editor is enabled by pressing keys on the grid,
- this will be called to let the editor do something about
- that first key if desired.
+ If the editor is enabled by pressing keys on the grid, this will be
+ called to let the editor do something about that first key if desired.
*/
- void StartingKey(wxKeyEvent& event);
-};
+ virtual void StartingKey(wxKeyEvent& event);
+
+ /**
+ Returns the value currently in the editor control.
+ */
+ virtual wxString GetValue() const = 0;
+protected:
+ /**
+ The destructor is private because only DecRef() can delete us.
+ */
+ virtual ~wxGridCellEditor();
+};
/**
- @class wxGridCellTextEditor
+ @class wxGridCellAutoWrapStringEditor
- The editor for string/text data.
+ Grid cell editor for wrappable string/text data.
@library{wxadv}
@category{grid}
- @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
- wxGridCellNumberEditor, wxGridCellChoiceEditor
+ @see wxGridCellEditor, wxGridCellBoolEditor, wxGridCellChoiceEditor,
+ wxGridCellEnumEditor, wxGridCellFloatEditor,
+ wxGridCellNumberEditor, wxGridCellTextEditor
*/
-class wxGridCellTextEditor : public wxGridCellEditor
+class wxGridCellAutoWrapStringEditor : public wxGridCellTextEditor
{
public:
- /**
- Default constructor.
- */
- wxGridCellTextEditor();
-
- /**
- The parameters string format is "n" where n is a number representing the
- maximum width.
- */
- void SetParameters(const wxString& params);
+ wxGridCellAutoWrapStringEditor();
};
-
-
/**
- @class wxGridCellStringRenderer
+ @class wxGridCellBoolEditor
- This class may be used to format string data in a cell; it is the default
- for string cells.
+ Grid cell editor for boolean data.
@library{wxadv}
@category{grid}
- @see wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellFloatRenderer,
- wxGridCellBoolRenderer
+ @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+ wxGridCellChoiceEditor, wxGridCellEnumEditor,
+ wxGridCellFloatEditor, wxGridCellNumberEditor,
+ wxGridCellTextEditor
*/
-class wxGridCellStringRenderer : public wxGridCellRenderer
+class wxGridCellBoolEditor : public wxGridCellEditor
{
public:
/**
- Default constructor
+ Default constructor.
*/
- wxGridCellStringRenderer();
-};
+ wxGridCellBoolEditor();
+ /**
+ Returns @true if the given @a value is equal to the string
+ representation of the truth value we currently use (see
+ UseStringValues()).
+ */
+ static bool IsTrueValue(const wxString& value);
+ /**
+ This method allows you to customize the values returned by GetValue()
+ for the cell using this editor. By default, the default values of the
+ arguments are used, i.e. @c "1" is returned if the cell is checked and
+ an empty string otherwise.
+ */
+ static void UseStringValues(const wxString& valueTrue = "1",
+ const wxString& valueFalse = wxEmptyString);
+};
/**
@class wxGridCellChoiceEditor
- The editor for string data allowing to choose from a list of strings.
+ Grid cell editor for string data providing the user a choice from a list of
+ strings.
@library{wxadv}
@category{grid}
- @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
- wxGridCellTextEditor, wxGridCellNumberEditor
+ @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+ wxGridCellBoolEditor, wxGridCellEnumEditor,
+ wxGridCellFloatEditor, wxGridCellNumberEditor,
+ wxGridCellTextEditor
*/
class wxGridCellChoiceEditor : public wxGridCellEditor
{
public:
- //@{
/**
+ Choice cell renderer ctor.
+
@param count
Number of strings from which the user can choose.
@param choices
An array of strings from which the user can choose.
@param allowOthers
- If allowOthers is @true, the user can type a string not in choices array.
+ If allowOthers is @true, the user can type a string not in choices
+ array.
*/
wxGridCellChoiceEditor(size_t count = 0,
const wxString choices[] = NULL,
bool allowOthers = false);
+
+ /**
+ Choice cell renderer ctor.
+
+ @param choices
+ An array of strings from which the user can choose.
+ @param allowOthers
+ If allowOthers is @true, the user can type a string not in choices
+ array.
+ */
wxGridCellChoiceEditor(const wxArrayString& choices,
bool allowOthers = false);
- //@}
/**
Parameters string format is "item1[,item2[...,itemN]]"
*/
- void SetParameters(const wxString& params);
+ virtual void SetParameters(const wxString& params);
};
+/**
+ @class wxGridCellEnumEditor
+
+ Grid cell editor which displays an enum number as a textual equivalent
+ (eg. data in cell is 0,1,2 ... n the cell could be displayed as
+ "John","Fred"..."Bob" in the combo choice box).
+
+ @library{wxadv}
+ @category{grid}
+
+ @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+ wxGridCellBoolEditor, wxGridCellChoiceEditor,
+ wxGridCellTextEditor, wxGridCellFloatEditor,
+ wxGridCellNumberEditor
+*/
+class wxGridCellEnumEditor : public wxGridCellChoiceEditor
+{
+public:
+ /**
+ Enum cell editor ctor.
+ @param choices
+ Comma separated choice parameters "item1[,item2[...,itemN]]".
+ */
+ wxGridCellEnumEditor( const wxString& choices = wxEmptyString );
+};
/**
- @class wxGridEditorCreatedEvent
+ @class wxGridCellTextEditor
+ Grid cell editor for string/text data.
@library{wxadv}
@category{grid}
+
+ @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+ wxGridCellBoolEditor, wxGridCellChoiceEditor,
+ wxGridCellEnumEditor, wxGridCellFloatEditor,
+ wxGridCellNumberEditor
*/
-class wxGridEditorCreatedEvent : public wxCommandEvent
+class wxGridCellTextEditor : public wxGridCellEditor
{
public:
- //@{
/**
+ Text cell editor constructor.
+ @param maxChars
+ Maximum width of text (this parameter is supported starting since
+ wxWidgets 2.9.5).
*/
- wxGridEditorCreatedEvent();
- wxGridEditorCreatedEvent(int id, wxEventType type,
- wxObject* obj,
- int row,
- int col,
- wxControl* ctrl);
- //@}
+ explicit wxGridCellTextEditor(size_t maxChars = 0);
/**
- Returns the column at which the event occurred.
+ The parameters string format is "n" where n is a number representing
+ the maximum width.
*/
- int GetCol();
+ virtual void SetParameters(const wxString& params);
/**
- Returns the edit control.
- */
- wxControl* GetControl();
-
- /**
- Returns the row at which the event occurred.
- */
- int GetRow();
-
- /**
- Sets the column at which the event occurred.
- */
- void SetCol(int col);
-
- /**
- Sets the edit control.
- */
- void SetControl(wxControl* ctrl);
-
- /**
- Sets the row at which the event occurred.
- */
- void SetRow(int row);
-};
-
-
-
-/**
- @class wxGridRangeSelectEvent
-
-
- @library{wxadv}
- @category{grid}
-*/
-class wxGridRangeSelectEvent : public wxNotifyEvent
-{
-public:
- //@{
- /**
-
- */
- wxGridRangeSelectEvent();
- wxGridRangeSelectEvent(int id, wxEventType type,
- wxObject* obj,
- const wxGridCellCoords& topLeft,
- const wxGridCellCoords& bottomRight,
- bool sel = true,
- bool control = false,
- bool shift = false,
- bool alt = false,
- bool meta = false);
- //@}
-
- /**
- Returns @true if the Alt key was down at the time of the event.
- */
- bool AltDown();
-
- /**
- Returns @true if the Control key was down at the time of the event.
- */
- bool ControlDown();
-
- /**
- Top left corner of the rectangular area that was (de)selected.
- */
- wxGridCellCoords GetBottomRightCoords();
-
- /**
- Bottom row of the rectangular area that was (de)selected.
- */
- int GetBottomRow();
+ Set validator to validate user input.
- /**
- Left column of the rectangular area that was (de)selected.
- */
- int GetLeftCol();
-
- /**
- Right column of the rectangular area that was (de)selected.
- */
- int GetRightCol();
-
- /**
- Top left corner of the rectangular area that was (de)selected.
- */
- wxGridCellCoords GetTopLeftCoords();
-
- /**
- Top row of the rectangular area that was (de)selected.
- */
- int GetTopRow();
-
- /**
- Returns @true if the Meta key was down at the time of the event.
- */
- bool MetaDown();
-
- /**
- Returns @true if the area was selected, @false otherwise.
- */
- bool Selecting();
-
- /**
- Returns @true if the Shift key was down at the time of the event.
+ @since 2.9.5
*/
- bool ShiftDown();
+ virtual void SetValidator(const wxValidator& validator);
};
-
-
/**
- @class wxGridCellRenderer
+ @class wxGridCellFloatEditor
- This class is responsible for actually drawing the cell
- in the grid. You may pass it to the wxGridCellAttr (below) to change the
- format of one given cell or to wxGrid::SetDefaultRenderer() to change the
- view of all cells. This is an abstract class, and you will normally use one of
- the
- predefined derived classes or derive your own class from it.
+ The editor for floating point numbers data.
@library{wxadv}
@category{grid}
- @see wxGridCellStringRenderer, wxGridCellNumberRenderer,
- wxGridCellFloatRenderer, wxGridCellBoolRenderer
+ @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+ wxGridCellBoolEditor, wxGridCellChoiceEditor,
+ wxGridCellEnumEditor, wxGridCellNumberEditor,
+ wxGridCellTextEditor
*/
-class wxGridCellRenderer
+class wxGridCellFloatEditor : public wxGridCellTextEditor
{
public:
/**
+ Float cell editor ctor.
+ @param width
+ Minimum number of characters to be shown.
+ @param precision
+ Number of digits after the decimal dot.
+ @param format
+ The format to use for displaying the number, a combination of
+ ::wxGridCellFloatFormat enum elements. This parameter is only
+ available since wxWidgets 2.9.3.
*/
- wxGridCellRenderer* Clone() const;
-
- /**
- Draw the given cell on the provided DC inside the given rectangle
- using the style specified by the attribute and the default or selected
- state corresponding to the isSelected value.
- This pure virtual function has a default implementation which will
- prepare the DC using the given attribute: it will draw the rectangle
- with the background colour from attr and set the text colour and font.
- */
- void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
- const wxRect& rect, int row, int col,
- bool isSelected);
+ wxGridCellFloatEditor(int width = -1, int precision = -1,
+ int format = wxGRID_FLOAT_FORMAT_DEFAULT);
/**
- Get the preferred size of the cell for its contents.
+ The parameters string format is "width[,precision[,format]]" where
+ @c format should be chosen between f|e|g|E|G (f is used by default)
*/
- wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
- int row, int col);
+ virtual void SetParameters(const wxString& params);
};
-
-
/**
@class wxGridCellNumberEditor
- The editor for numeric integer data.
+ Grid cell editor for numeric integer data.
@library{wxadv}
@category{grid}
- @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
- wxGridCellTextEditor, wxGridCellChoiceEditor
+ @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+ wxGridCellBoolEditor, wxGridCellChoiceEditor,
+ wxGridCellEnumEditor, wxGridCellFloatEditor,
+ wxGridCellTextEditor
*/
class wxGridCellNumberEditor : public wxGridCellTextEditor
{
public:
/**
- Allows to specify the range for acceptable data;
- if min == max == -1, no range checking is done
+ Allows you to specify the range for acceptable data. Values equal to
+ -1 for both @a min and @a max indicate that no range checking should be
+ done.
*/
wxGridCellNumberEditor(int min = -1, int max = -1);
+
/**
- String representation of the value.
+ Parameters string format is "min,max".
*/
- wxString GetString() const;
+ virtual void SetParameters(const wxString& params);
+
+protected:
/**
- If the return value is @true, the editor uses a wxSpinCtrl to get user input,
- otherwise it uses a wxTextCtrl.
+ If the return value is @true, the editor uses a wxSpinCtrl to get user
+ input, otherwise it uses a wxTextCtrl.
*/
bool HasRange() const;
/**
- Parameters string format is "min,max".
+ String representation of the value.
*/
- void SetParameters(const wxString& params);
+ wxString GetString() const;
};
/**
- @class wxGridSizeEvent
+ @class wxGridCellAttr
- This event class contains information about a row/column resize event.
+ This class can be used to alter the cells' appearance in the grid by
+ changing their attributes from the defaults. An object of this class may be
+ returned by wxGridTableBase::GetAttr().
@library{wxadv}
@category{grid}
*/
-class wxGridSizeEvent : public wxNotifyEvent
+class wxGridCellAttr : public wxClientDataContainer, public wxRefCounter
{
public:
- //@{
/**
+ Kind of the attribute to retrieve.
- */
- wxGridSizeEvent();
- wxGridSizeEvent(int id, wxEventType type, wxObject* obj,
- int rowOrCol = -1,
- int x = -1,
- int y = -1,
- bool control = false,
- bool shift = false,
- bool alt = false,
- bool meta = false);
- //@}
+ @see wxGridCellAttrProvider::GetAttr(), wxGridTableBase::GetAttr()
+ */
+ enum wxAttrKind
+ {
+ /// Return the combined effective attribute for the cell.
+ Any,
- /**
- Returns @true if the Alt key was down at the time of the event.
- */
- bool AltDown();
+ /// Return the attribute explicitly set for this cell.
+ Cell,
- /**
- Returns @true if the Control key was down at the time of the event.
- */
- bool ControlDown();
+ /// Return the attribute set for this cells row.
+ Row,
- /**
- Position in pixels at which the event occurred.
- */
- wxPoint GetPosition();
+ /// Return the attribute set for this cells column.
+ Col
+ };
/**
- Row or column at that was resized.
+ Default constructor.
*/
- int GetRowOrCol();
-
+ wxGridCellAttr(wxGridCellAttr* attrDefault = NULL);
/**
- Returns @true if the Meta key was down at the time of the event.
+ Constructor specifying some of the often used attributes.
*/
- bool MetaDown();
+ wxGridCellAttr(const wxColour& colText, const wxColour& colBack,
+ const wxFont& font, int hAlign, int vAlign);
/**
- Returns @true if the Shift key was down at the time of the event.
+ Creates a new copy of this object.
*/
- bool ShiftDown();
-};
-
-
-
-/**
- @class wxGridCellNumberRenderer
-
- This class may be used to format integer data in a cell.
-
- @library{wxadv}
- @category{grid}
+ wxGridCellAttr* Clone() const;
- @see wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
- wxGridCellBoolRenderer
-*/
-class wxGridCellNumberRenderer : public wxGridCellStringRenderer
-{
-public:
/**
- Default constructor
+ This class is reference counted: it is created with ref count of 1, so
+ calling DecRef() once will delete it. Calling IncRef() allows to lock
+ it until the matching DecRef() is called.
*/
- wxGridCellNumberRenderer();
-};
-
-
+ void DecRef();
-/**
- @class wxGridCellAttr
+ /**
+ Get the alignment to use for the cell with the given attribute.
- This class can be used to alter the cells' appearance in
- the grid by changing their colour/font/... from default. An object of this
- class may be returned by wxGridTableBase::GetAttr.
+ If this attribute doesn't specify any alignment, the default attribute
+ alignment is used (which can be changed using
+ wxGrid::SetDefaultCellAlignment() but is left and top by default).
- @library{wxadv}
- @category{grid}
-*/
-class wxGridCellAttr
-{
-public:
- //@{
- /**
- Constructor specifying some of the often used attributes.
- */
- wxGridCellAttr();
- wxGridCellAttr(const wxColour& colText,
- const wxColour& colBack,
- const wxFont& font,
- int hAlign, int vAlign);
- //@}
+ Notice that @a hAlign and @a vAlign values are always overwritten by
+ this function, use GetNonDefaultAlignment() if this is not desirable.
- /**
- Creates a new copy of this object.
+ @param hAlign
+ Horizontal alignment is returned here if this argument is non-@NULL.
+ It is one of wxALIGN_LEFT, wxALIGN_CENTRE or wxALIGN_RIGHT.
+ @param vAlign
+ Vertical alignment is returned here if this argument is non-@NULL.
+ It is one of wxALIGN_TOP, wxALIGN_CENTRE or wxALIGN_BOTTOM.
*/
- wxGridCellAttr* Clone() const;
+ void GetAlignment(int* hAlign, int* vAlign) const;
/**
-
+ Returns the background colour.
*/
- void DecRef();
+ const wxColour& GetBackgroundColour() const;
/**
- See SetAlignment() for the returned values.
+ Returns the cell editor.
*/
- void GetAlignment(int* hAlign, int* vAlign) const;
+ wxGridCellEditor* GetEditor(const wxGrid* grid, int row, int col) const;
/**
-
+ Returns the font.
*/
- const wxColour GetBackgroundColour() const;
+ const wxFont& GetFont() const;
/**
+ Get the alignment defined by this attribute.
- */
- wxGridCellEditor* GetEditor(wxGrid* grid, int row, int col) const;
+ Unlike GetAlignment() this function only modifies @a hAlign and @a
+ vAlign if this attribute does define a non-default alignment. This
+ means that they must be initialized before calling this function and
+ that their values will be preserved unchanged if they are different
+ from wxALIGN_INVALID.
- /**
+ For example, the following fragment can be used to use the cell
+ alignment if one is defined but right-align its contents by default
+ (instead of left-aligning it by default) while still using the default
+ vertical alignment:
+ @code
+ int hAlign = wxALIGN_RIGHT,
+ vAlign = wxALIGN_INVALID;
+ attr.GetNonDefaultAlignment(&hAlign, &vAlign);
+ @endcode
- */
- const wxFont GetFont() const;
+ @since 2.9.1
+ */
+ void GetNonDefaultAlignment(int *hAlign, int *vAlign) const;
/**
-
+ Returns the cell renderer.
*/
- wxGridCellRenderer* GetRenderer(wxGrid* grid, int row, int col) const;
+ wxGridCellRenderer* GetRenderer(const wxGrid* grid, int row, int col) const;
/**
-
+ Returns the text colour.
*/
- const wxColour GetTextColour() const;
+ const wxColour& GetTextColour() const;
/**
-
+ Returns @true if this attribute has a valid alignment set.
*/
bool HasAlignment() const;
/**
-
+ Returns @true if this attribute has a valid background colour set.
*/
bool HasBackgroundColour() const;
/**
-
+ Returns @true if this attribute has a valid cell editor set.
*/
bool HasEditor() const;
/**
-
+ Returns @true if this attribute has a valid font set.
*/
bool HasFont() const;
/**
-
+ Returns @true if this attribute has a valid cell renderer set.
*/
bool HasRenderer() const;
/**
- accessors
+ Returns @true if this attribute has a valid text colour set.
*/
bool HasTextColour() const;
/**
- This class is ref counted: it is created with ref count of 1, so
+ This class is reference counted: it is created with ref count of 1, so
calling DecRef() once will delete it. Calling IncRef() allows to lock
- it until the matching DecRef() is called
+ it until the matching DecRef() is called.
*/
void IncRef();
/**
-
+ Returns @true if this cell is set as read-only.
*/
bool IsReadOnly() const;
/**
Sets the alignment. @a hAlign can be one of @c wxALIGN_LEFT,
- @c wxALIGN_CENTRE or @c wxALIGN_RIGHT and @a vAlign can be one
- of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
+ @c wxALIGN_CENTRE or @c wxALIGN_RIGHT and @a vAlign can be one of
+ @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
*/
void SetAlignment(int hAlign, int vAlign);
void SetBackgroundColour(const wxColour& colBack);
/**
-
+ @todo Needs documentation.
*/
void SetDefAttr(wxGridCellAttr* defAttr);
/**
-
+ Sets the editor to be used with the cells with this attribute.
*/
void SetEditor(wxGridCellEditor* editor);
void SetFont(const wxFont& font);
/**
-
+ Sets the cell as read-only.
*/
void SetReadOnly(bool isReadOnly = true);
/**
- takes ownership of the pointer
+ Sets the renderer to be used for cells with this attribute. Takes
+ ownership of the pointer.
*/
void SetRenderer(wxGridCellRenderer* renderer);
Sets the text colour.
*/
void SetTextColour(const wxColour& colText);
-};
+protected:
+ /**
+ The destructor is private because only DecRef() can delete us.
+ */
+ virtual ~wxGridCellAttr();
+};
/**
- @class wxGridCellBoolRenderer
+ Base class for corner window renderer.
- This class may be used to format boolean data in a cell.
- for string cells.
+ This is the simplest of all header renderers and only has a single
+ function.
- @library{wxadv}
- @category{grid}
+ @see wxGridCellAttrProvider::GetCornerRenderer()
- @see wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
- wxGridCellNumberRenderer
-*/
-class wxGridCellBoolRenderer : public wxGridCellRenderer
+ @since 2.9.1
+ */
+class wxGridCornerHeaderRenderer
{
public:
/**
- Default constructor
- */
- wxGridCellBoolRenderer();
+ Called by the grid to draw the corner window border.
+
+ This method is responsible for drawing the border inside the given @a
+ rect and adjusting the rectangle size to correspond to the area inside
+ the border, i.e. usually call wxRect::Deflate() to account for the
+ border width.
+
+ @param grid
+ The grid whose corner window is being drawn.
+ @param dc
+ The device context to use for drawing.
+ @param rect
+ Input/output parameter which contains the border rectangle on input
+ and should be updated to contain the area inside the border on
+ function return.
+ */
+ virtual void DrawBorder(const wxGrid& grid,
+ wxDC& dc,
+ wxRect& rect) const = 0;
};
-
-
/**
- @class wxGridEvent
+ Common base class for row and column headers renderers.
- This event class contains information about various grid events.
+ @see wxGridColumnHeaderRenderer, wxGridRowHeaderRenderer
- @library{wxadv}
- @category{grid}
-*/
-class wxGridEvent : public wxNotifyEvent
+ @since 2.9.1
+ */
+class wxGridHeaderLabelsRenderer : public wxGridCornerHeaderRenderer
{
public:
- //@{
/**
+ Called by the grid to draw the specified label.
- */
- wxGridEvent();
- wxGridEvent(int id, wxEventType type, wxObject* obj,
- int row = -1, int col = -1,
- int x = -1, int y = -1,
- bool sel = true,
- bool control = false,
- bool shift = false,
- bool alt = false,
- bool meta = false);
- //@}
+ Notice that the base class DrawBorder() method is called before this
+ one.
- /**
- Returns @true if the Alt key was down at the time of the event.
- */
- bool AltDown();
+ The default implementation uses wxGrid::GetLabelTextColour() and
+ wxGrid::GetLabelFont() to draw the label.
+ */
+ virtual void DrawLabel(const wxGrid& grid,
+ wxDC& dc,
+ const wxString& value,
+ const wxRect& rect,
+ int horizAlign,
+ int vertAlign,
+ int textOrientation) const;
+};
- /**
- Returns @true if the Control key was down at the time of the event.
- */
- bool ControlDown();
+/**
+ Base class for row headers renderer.
- /**
- Column at which the event occurred.
- */
- int GetCol();
+ This is the same as wxGridHeaderLabelsRenderer currently but we still use a
+ separate class for it to distinguish it from wxGridColumnHeaderRenderer.
- /**
- Position in pixels at which the event occurred.
- */
- wxPoint GetPosition();
+ @see wxGridRowHeaderRendererDefault
- /**
- Row at which the event occurred.
+ @see wxGridCellAttrProvider::GetRowHeaderRenderer()
+
+ @since 2.9.1
+ */
+class wxGridRowHeaderRenderer : public wxGridHeaderLabelsRenderer
+{
+};
+
+/**
+ Base class for column headers renderer.
+
+ This is the same as wxGridHeaderLabelsRenderer currently but we still use a
+ separate class for it to distinguish it from wxGridRowHeaderRenderer.
+
+ @see wxGridColumnHeaderRendererDefault
+
+ @see wxGridCellAttrProvider::GetColumnHeaderRenderer()
+
+ @since 2.9.1
+ */
+class wxGridColumnHeaderRenderer : public wxGridHeaderLabelsRenderer
+{
+};
+
+/**
+ Default row header renderer.
+
+ You may derive from this class if you need to only override one of its
+ methods (i.e. either DrawLabel() or DrawBorder()) but continue to use the
+ default implementation for the other one.
+
+ @see wxGridColumnHeaderRendererDefault
+
+ @since 2.9.1
+ */
+class wxGridRowHeaderRendererDefault : public wxGridRowHeaderRenderer
+{
+public:
+ /// Implement border drawing for the row labels.
+ virtual void DrawBorder(const wxGrid& grid,
+ wxDC& dc,
+ wxRect& rect) const;
+};
+
+/**
+ Default column header renderer.
+
+ @see wxGridRowHeaderRendererDefault
+
+ @since 2.9.1
+ */
+class wxGridColumnHeaderRendererDefault : public wxGridColumnHeaderRenderer
+{
+public:
+ /// Implement border drawing for the column labels.
+ virtual void DrawBorder(const wxGrid& grid,
+ wxDC& dc,
+ wxRect& rect) const;
+};
+
+/**
+ Default corner window renderer.
+
+ @see wxGridColumnHeaderRendererDefault, wxGridRowHeaderRendererDefault
+
+ @since 2.9.1
+ */
+class wxGridCornerHeaderRendererDefault : public wxGridCornerHeaderRenderer
+{
+public:
+ /// Implement border drawing for the corner window.
+ virtual void DrawBorder(const wxGrid& grid,
+ wxDC& dc,
+ wxRect& rect) const;
+};
+
+/**
+ Class providing attributes to be used for the grid cells.
+
+ This class both defines an interface which grid cell attributes providers
+ should implement -- and which can be implemented differently in derived
+ classes -- and a default implementation of this interface which is often
+ good enough to be used without modification, especially with not very large
+ grids for which the efficiency of attributes storage hardly matters (see
+ the discussion below).
+
+ An object of this class can be associated with a wxGrid using
+ wxGridTableBase::SetAttrProvider() but it's not necessary to call it if you
+ intend to use the default provider as it is used by wxGridTableBase by
+ default anyhow.
+
+ Notice that while attributes provided by this class can be set for
+ individual cells using SetAttr() or the entire rows or columns using
+ SetRowAttr() and SetColAttr() they are always retrieved using GetAttr()
+ function.
+
+
+ The default implementation of this class stores the attributes passed to
+ its SetAttr(), SetRowAttr() and SetColAttr() in a straightforward way. A
+ derived class may use its knowledge about how the attributes are used in
+ your program to implement it much more efficiently: for example, using a
+ special background colour for all even-numbered rows can be implemented by
+ simply returning the same attribute from GetAttr() if the row number is
+ even instead of having to store N/2 row attributes where N is the total
+ number of rows in the grid.
+
+ Notice that objects of this class can't be copied.
+ */
+class wxGridCellAttrProvider : public wxClientDataContainer
+{
+public:
+ /// Trivial default constructor.
+ wxGridCellAttrProvider();
+
+ /// Destructor releases any attributes held by this class.
+ virtual ~wxGridCellAttrProvider();
+
+ /**
+ Get the attribute to use for the specified cell.
+
+ If wxGridCellAttr::Any is used as @a kind value, this function combines
+ the attributes set for this cell using SetAttr() and those for its row
+ or column (set with SetRowAttr() or SetColAttr() respectively), with
+ the cell attribute having the highest precedence.
+
+ Notice that the caller must call DecRef() on the returned pointer if it
+ is non-@NULL.
+
+ @param row
+ The row of the cell.
+ @param col
+ The column of the cell.
+ @param kind
+ The kind of the attribute to return.
+ @return
+ The attribute to use which should be DecRef()'d by caller or @NULL
+ if no attributes are defined for this cell.
+ */
+ virtual wxGridCellAttr *GetAttr(int row, int col,
+ wxGridCellAttr::wxAttrKind kind) const;
+
+ /**
+ Setting attributes.
+
+ All these functions take ownership of the attribute passed to them,
+ i.e. will call DecRef() on it themselves later and so it should not be
+ destroyed by the caller. And the attribute can be @NULL to reset a
+ previously set value.
+ */
+ //@{
+
+ /// Set attribute for the specified cell.
+ virtual void SetAttr(wxGridCellAttr *attr, int row, int col);
+
+ /// Set attribute for the specified row.
+ virtual void SetRowAttr(wxGridCellAttr *attr, int row);
+
+ /// Set attribute for the specified column.
+ virtual void SetColAttr(wxGridCellAttr *attr, int col);
+
+ //@}
+
+ /**
+ Getting header renderers.
+
+ These functions return the renderers for the given row or column header
+ label and the corner window. Unlike cell attributes, these objects are
+ not reference counted and are never @NULL so they are returned by
+ reference and not pointer and DecRef() shouldn't (and can't) be called
+ for them.
+
+ All these functions were added in wxWidgets 2.9.1.
+ */
+ //@{
+
+ /**
+ Return the renderer used for drawing column headers.
+
+ By default wxGridColumnHeaderRendererDefault is returned.
+
+ @see wxGrid::SetUseNativeColLabels(), wxGrid::UseNativeColHeader()
+
+ @since 2.9.1
+ */
+ virtual const wxGridColumnHeaderRenderer& GetColumnHeaderRenderer(int col);
+
+ /**
+ Return the renderer used for drawing row headers.
+
+ By default wxGridRowHeaderRendererDefault is returned.
+
+ @since 2.9.1
+ */
+ virtual const wxGridRowHeaderRenderer& GetRowHeaderRenderer(int row);
+
+ /**
+ Return the renderer used for drawing the corner window.
+
+ By default wxGridCornerHeaderRendererDefault is returned.
+
+ @since 2.9.1
+ */
+ virtual const wxGridCornerHeaderRenderer& GetCornerRenderer();
+
+ //@}
+};
+
+/**
+ Represents coordinates of a grid cell.
+
+ An object of this class is simply a (row, column) pair.
+ */
+class wxGridCellCoords
+{
+public:
+ /**
+ Default constructor initializes the object to invalid state.
+
+ Initially the row and column are both invalid (-1) and so operator!()
+ for an uninitialized wxGridCellCoords returns false.
+ */
+ wxGridCellCoords();
+
+ /**
+ Constructor taking a row and a column.
+ */
+ wxGridCellCoords(int row, int col);
+
+ /**
+ Return the row of the coordinate.
+ */
+ int GetRow() const;
+
+ /**
+ Set the row of the coordinate.
+ */
+ void SetRow(int n);
+
+ /**
+ Return the column of the coordinate.
+ */
+ int GetCol() const;
+
+ /**
+ Set the column of the coordinate.
+ */
+ void SetCol(int n);
+
+ /**
+ Set the row and column of the coordinate.
+ */
+ void Set(int row, int col);
+
+ /**
+ Assignment operator for coordinate types.
+ */
+ wxGridCellCoords& operator=(const wxGridCellCoords& other);
+
+ /**
+ Equality operator.
+ */
+ bool operator==(const wxGridCellCoords& other) const;
+
+ /**
+ Inequality operator.
+ */
+ bool operator!=(const wxGridCellCoords& other) const;
+
+ /**
+ Checks whether the coordinates are invalid.
+
+ Returns false only if both row and column are -1. Notice that if either
+ row or column (but not both) are -1, this method returns true even if
+ the object is invalid. This is done because objects in such state
+ should actually never exist, i.e. either both coordinates should be -1
+ or none of them should be -1.
+ */
+ bool operator!() const;
+};
+
+/**
+ @class wxGridTableBase
+
+ The almost abstract base class for grid tables.
+
+ A grid table is responsible for storing the grid data and, indirectly, grid
+ cell attributes. The data can be stored in the way most convenient for the
+ application but has to be provided in string form to wxGrid. It is also
+ possible to provide cells values in other formats if appropriate, e.g. as
+ numbers.
+
+ This base class is not quite abstract as it implements a trivial strategy
+ for storing the attributes by forwarding it to wxGridCellAttrProvider and
+ also provides stubs for some other functions. However it does have a number
+ of pure virtual methods which must be implemented in the derived classes.
+
+ @see wxGridStringTable
+
+ @library{wxadv}
+ @category{grid}
+*/
+class wxGridTableBase : public wxObject
+{
+public:
+ /**
+ Default constructor.
+ */
+ wxGridTableBase();
+
+ /**
+ Destructor frees the attribute provider if it was created.
+ */
+ virtual ~wxGridTableBase();
+
+ /**
+ Must be overridden to return the number of rows in the table.
+
+ For backwards compatibility reasons, this method is not const.
+ Use GetRowsCount() instead of it in const methods of derived table
+ classes.
+ */
+ virtual int GetNumberRows() = 0;
+
+ /**
+ Must be overridden to return the number of columns in the table.
+
+ For backwards compatibility reasons, this method is not const.
+ Use GetColsCount() instead of it in const methods of derived table
+ classes,
+ */
+ virtual int GetNumberCols() = 0;
+
+ /**
+ Return the number of rows in the table.
+
+ 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.
*/
- int GetRow();
+ 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);
/**
- Returns @true if the Meta key was down at the time of the event.
+ @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.
*/
- bool MetaDown();
+ void SetCellValue(const wxString& val, int row, int col);
/**
- Returns @true if the user is selecting grid cells, @false -- if
- deselecting.
+ Sets the specified column to display boolean values.
+
+ @see SetColFormatCustom()
*/
- bool Selecting();
+ void SetColFormatBool(int col);
/**
- Returns @true if the Shift key was down at the time of the event.
+ 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.
*/
- bool ShiftDown();
-};
+ 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);
-/**
- @class wxGridCellFloatEditor
+ /**
+ Sets the specified column to display integer values.
- The editor for floating point numbers data.
+ @see SetColFormatCustom()
+ */
+ void SetColFormatNumber(int col);
- @library{wxadv}
- @category{grid}
+ /**
+ 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;
- @see wxGridCellEditor, wxGridCellNumberEditor, wxGridCellBoolEditor,
- wxGridCellTextEditor, wxGridCellChoiceEditor
-*/
-class wxGridCellFloatEditor : public wxGridCellTextEditor
-{
-public:
/**
+ 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
- Minimum number of characters to be shown.
- @param precision
- Number of digits after the decimal dot.
+ 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.
*/
- wxGridCellFloatEditor(int width = -1, int precision = -1);
+ void SetDefaultCellOverflow( bool allow );
/**
- Parameters string format is "width,precision"
+ 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 SetParameters(const wxString& params);
-};
+ 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() to restore its original height.
+
+ If the row is already hidden, this method doesn't do anything.
+
+ @param col
+ The row index.
+ */
+ void HideRow(int col);
+
+ /**
+ Shows the previously hidden row.
+
+ The row is shown again with the same height that it had before
+ HideRow() call.
+
+ If the row is currently shown, this method doesn't do anything.
+
+ @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().
-/**
- @class wxGrid
+ @sa SetRowSizes()
+ */
+ void SetColSizes(const wxGridSizesInfo& sizeInfo);
- 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_gridoverview 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.
+ /**
+ Restore all rows sizes.
- wxGrid has been greatly expanded and redesigned for wxWidgets 2.2 onwards.
- The new grid classes are reasonably backward-compatible but there are some
- exceptions. There are also easier ways of doing many things compared to the
- previous implementation.
+ @sa SetColSizes()
+ */
+ void SetRowSizes(const wxGridSizesInfo& sizeInfo);
- 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 wxGrid::CreateGrid.
+ /**
+ Set the size of the cell.
- wxGridCellRenderer is the abstract base class for rendereing contents in a
- cell. The following renderers are predefined:
- - wxGridCellStringRenderer,
- - wxGridCellBoolRenderer,
- - wxGridCellFloatRenderer,
- - wxGridCellNumberRenderer.
- The look of a cell can be further defined using wxGridCellAttr. An object
- of this type may be returned by wxGridTableBase::GetAttr.
+ 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.
- wxGridCellEditor is the abstract base class for editing the value of a
- cell. The following editors are predefined:
- - wxGridCellTextEditor
- - wxGridCellBoolEditor
- - wxGridCellChoiceEditor
- - wxGridCellNumberEditor.
+ @see GetCellSize()
- @library{wxadv}
- @category{grid}
+ @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;
- @see @ref overview_gridoverview "wxGrid overview"
-*/
-class wxGrid : public wxScrolledWindow
-{
-public:
/**
- Different selection modes supported by the grid.
+ 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.
*/
- enum wxGridSelectionModes
- {
- /**
- The default selection mode allowing selection of the individual
- cells as well as of the entire rows and columns.
- */
- wxGridSelectCells,
+ wxSize GetCellSize(const wxGridCellCoords& coords);
- /**
- 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.
+ /**
+ @name User-Resizing and Dragging
- The user won't be able to select any cells or rows in this mode.
- */
- wxGridSelectColumns
- };
+ Functions controlling various interactive mouse operations.
- /**
- Default constructor.
+ 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.
- You must call Create() to really create the grid window and also call
- CreateGrid() or SetTable() to initialize the grid contents.
+ Columns can also be moved to interactively change their order but this
+ needs to be explicitly enabled with EnableDragColMove().
*/
- wxGrid();
+ //@{
/**
- Constructor creating the grid window.
-
- You must call either CreateGrid() or SetTable() to initialize the grid
- contents before using it.
+ Return @true if the dragging of cells is enabled or @false otherwise.
*/
- wxGrid(wxWindow* parent,
- wxWindowID id,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = wxWANTS_CHARS,
- const wxString& name = wxGridNameStr);
+ bool CanDragCell() const;
/**
- Creates the grid window for an object initialized using the default
- constructor.
+ Returns @true if columns can be moved by dragging with the mouse.
- 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);
+ Columns can be moved by dragging on their labels.
+ */
+ bool CanDragColMove() const;
/**
- Destructor.
+ Returns @true if the given column can be resized by dragging with the
+ mouse.
- 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 wxGrid::SetTable).
+ 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().
*/
- virtual ~wxGrid();
+ bool CanDragColSize(int col) const;
/**
- Appends one or more new columns to the right of the grid.
+ Return @true if the dragging of grid lines to resize rows and columns
+ is enabled or @false otherwise.
+ */
+ bool CanDragGridSize() const;
- 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.
+ /**
+ Returns @true if the given row can be resized by dragging with the
+ mouse.
- @return @true on success or @false if appending columns failed.
+ This is the same as CanDragColSize() but for rows.
*/
- bool AppendCols(int numCols = 1, bool updateLabels = true);
+ bool CanDragRowSize(int row) const;
/**
- Appends one or more new rows to the bottom of the grid.
+ Disable interactive resizing of the specified column.
- 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.
+ 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).
- @return @true on success or @false if appending rows failed.
- */
- bool AppendRows(int numRows = 1, bool updateLabels = true);
+ 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);
/**
- Automatically sets the height and width of all rows and columns to fit their
- contents.
- */
- void AutoSize();
+ Disable interactive resizing of the specified row.
+
+ This is the same as DisableColResize() but for rows.
+
+ @see EnableDragRowSize()
+ */
+ void DisableRowResize(int row);
/**
- Automatically adjusts width of the column to fit its label.
+ Disables column moving by dragging with the mouse.
+
+ Equivalent to passing @false to EnableDragColMove().
*/
- void AutoSizeColLabelSize(int col);
+ void DisableDragColMove();
/**
- Automatically sizes the column to fit its contents. If setAsMin is @true the
- calculated width will
- also be set as the minimal width for the column.
+ Disables column sizing by dragging with the mouse.
+
+ Equivalent to passing @false to EnableDragColSize().
*/
- void AutoSizeColumn(int col, bool setAsMin = true);
+ void DisableDragColSize();
/**
- Automatically sizes all columns to fit their contents. If setAsMin is @true the
- calculated widths will
- also be set as the minimal widths for the columns.
+ Disable mouse dragging of grid lines to resize rows and columns.
+
+ Equivalent to passing @false to EnableDragGridSize()
*/
- void AutoSizeColumns(bool setAsMin = true);
+ void DisableDragGridSize();
/**
- Automatically sizes the row to fit its contents. If setAsMin is @true the
- calculated height will
- also be set as the minimal height for the row.
+ Disables row sizing by dragging with the mouse.
+
+ Equivalent to passing @false to EnableDragRowSize().
*/
- void AutoSizeRow(int row, bool setAsMin = true);
+ void DisableDragRowSize();
/**
- Automatically adjusts height of the row to fit its label.
+ Enables or disables cell dragging with the mouse.
*/
- void AutoSizeRowLabelSize(int col);
+ void EnableDragCell(bool enable = true);
/**
- Automatically sizes all rows to fit their contents. If setAsMin is @true the
- calculated heights will
- also be set as the minimal heights for the rows.
+ Enables or disables column moving by dragging with the mouse.
*/
- void AutoSizeRows(bool setAsMin = true);
+ void EnableDragColMove(bool enable = true);
/**
- 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 will cause the grid to be repainted.
+ Enables or disables column sizing by dragging with the mouse.
- 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.
+ @see DisableColResize()
*/
- void BeginBatch();
+ void EnableDragColSize(bool enable = true);
/**
- This function returns the rectangle that encloses the block of cells
- limited by TopLeft and BottomRight cell in device coords and clipped
- to the client size of the grid window.
+ Enables or disables row and column resizing by dragging gridlines with
+ the mouse.
*/
- wxRect BlockToDeviceRect(const wxGridCellCoords& topLeft,
- const wxGridCellCoords& bottomRight) const;
+ void EnableDragGridSize(bool enable = true);
/**
- Returns @true if columns can be moved by dragging with the mouse.
+ Enables or disables row sizing by dragging with the mouse.
- Columns can be moved by dragging on their labels.
+ @see DisableRowResize()
*/
- bool CanDragColMove() const;
+ void EnableDragRowSize(bool enable = true);
/**
- Returns @true if columns can be resized by dragging with the mouse.
- Columns can be resized by dragging the edges of their labels. If grid
- line dragging is enabled they can also be resized by dragging the right
- edge of the column in the grid cell area (see
- wxGrid::EnableDragGridSize).
+ Returns the column ID of the specified column position.
*/
- bool CanDragColSize() const;
+ int GetColAt(int colPos) const;
/**
- Return @true if the dragging of grid lines to resize rows and columns is enabled
- or @false otherwise.
+ Returns the position of the specified column.
*/
- bool CanDragGridSize() const;
+ int GetColPos(int colID) const;
/**
- Returns @true if rows can be resized by dragging with the mouse.
- Rows can be resized by dragging the edges of their labels. If grid line
- dragging is enabled they can also be resized by dragging the lower edge
- of the row in the grid cell area (see wxGrid::EnableDragGridSize).
+ Sets the position of the specified column.
*/
- bool CanDragRowSize() const;
+ void SetColPos(int colID, int newPos);
/**
- Returns @true if the in-place edit control for the current grid cell can be used
- and
- @false otherwise (e.g. if the current cell is read-only).
- */
- bool CanEnableCellControl() const;
+ Sets the positions of all columns at once.
- /**
- Do we have some place to store attributes in?
+ This method takes an array containing the indices of the columns in
+ their display order, i.e. uses the same convention as
+ wxHeaderCtrl::SetColumnsOrder().
*/
- bool CanHaveAttributes() const;
+ void SetColumnsOrder(const wxArrayInt& order);
- //@{
/**
- Return the rectangle corresponding to the grid cell's size and position in
- logical
- coordinates.
+ Resets the position of the columns to the default.
*/
- wxRect CellToRect(int row, int col) const;
- const wxRect CellToRect(const wxGridCellCoords& coords) const;
+ void ResetColPos();
+
//@}
- /**
- 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.
+ /**
+ @name Cursor Movement
*/
- void ClearGrid();
+ //@{
/**
- Deselects all cells that are currently selected.
+ Returns the current grid cell column position.
*/
- void ClearSelection();
+ int GetGridCursorCol() const;
/**
- 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().
+ Returns the current grid cell row position.
*/
- bool CreateGrid(int numRows, int numCols,
- wxGridSelectionModes selmode = wxGridSelectCells);
+ int GetGridCursorRow() const;
/**
- Deletes one or more columns from a grid starting at the specified
- position.
+ Make the given cell current and ensure it is visible.
- 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.
+ 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.
- @return @true on success or @false if deleting columns failed.
+ 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 DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true);
+ bool MoveCursorDown(bool expandSelection);
/**
- Deletes one or more rows from a grid starting at the specified position.
+ 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.
- 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.
+ 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);
- @return @true on success or @false if appending rows failed.
+ /**
+ 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 DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true);
+ bool MoveCursorLeft(bool expandSelection);
/**
- Disables in-place editing of grid cells.
- Equivalent to calling EnableCellEditControl(@false).
+ 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.
*/
- void DisableCellEditControl();
+ bool MoveCursorLeftBlock(bool expandSelection);
/**
- Disables column moving by dragging with the mouse.
+ Moves the grid cursor right by one column.
- Equivalent to passing @false to EnableDragColMove().
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
*/
- void DisableDragColMove();
+ bool MoveCursorRight(bool expandSelection);
/**
- Disables column sizing by dragging with the mouse.
+ 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.
- Equivalent to passing @false to EnableDragColSize().
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
*/
- void DisableDragColSize();
+ bool MoveCursorRightBlock(bool expandSelection);
/**
- Disable mouse dragging of grid lines to resize rows and columns.
+ Moves the grid cursor up by one row.
- Equivalent to passing @false to EnableDragGridSize()
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
*/
- void DisableDragGridSize();
+ bool MoveCursorUp(bool expandSelection);
/**
- Disables row sizing by dragging with the mouse.
+ 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.
- Equivalent to passing @false to EnableDragRowSize().
+ If a block of cells was previously selected it will expand if the
+ argument is @true or be cleared if the argument is @false.
*/
- void DisableDragRowSize();
+ bool MoveCursorUpBlock(bool expandSelection);
/**
- Enables or disables in-place editing of grid cell data.
+ Moves the grid cursor down by some number of rows so that the previous
+ bottom visible row becomes the top visible row.
+ */
+ bool MovePageDown();
- The grid will issue either a wxEVT_GRID_EDITOR_SHOWN or
- wxEVT_GRID_EDITOR_HIDDEN event.
+ /**
+ Moves the grid cursor up by some number of rows so that the previous
+ top visible row becomes the bottom visible row.
*/
- void EnableCellEditControl(bool enable = true);
+ bool MovePageUp();
/**
- Enables or disables column moving by dragging with the mouse.
+ 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 EnableDragColMove(bool enable = true);
+ 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);
/**
- Enables or disables column sizing by dragging with the mouse.
+ Set the grid's behaviour when the user presses the TAB key.
+
+ Pressing the TAB key moves the grid cursor right in the current row, if
+ there is a cell at the right and, similarly, Shift-TAB moves the cursor
+ to the left in the current row if it's not in the first column.
+
+ What happens if the cursor can't be moved because it it's already at
+ the beginning or end of the row can be configured using this function,
+ see wxGrid::TabBehaviour documentation for the detailed description.
+
+ IF none of the standard behaviours is appropriate, you can always
+ handle @c wxEVT_GRID_TABBING event directly to implement a custom
+ TAB-handling logic.
+
+ @since 2.9.5
*/
- void EnableDragColSize(bool enable = true);
+ void SetTabBehaviour(TabBehaviour behaviour);
+
+ //@}
+
/**
- Enables or disables row and column resizing by dragging gridlines with the
- mouse.
- */
- void EnableDragGridSize(bool enable = true);
+ @name User Selection
+ */
+ //@{
/**
- Enables or disables row sizing by dragging with the mouse.
+ Deselects all cells that are currently selected.
*/
- void EnableDragRowSize(bool enable = true);
+ void ClearSelection();
/**
- Makes the grid globally editable or read-only.
+ Returns an array of individually selected cells.
- 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 wxGridCellAttribute::SetReadOnly. For single cells you
- can also use the shortcut function SetReadOnly().
+ 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.
- For more information about controlling grid cell attributes see the
- wxGridCellAttr cell attribute class and the
- @ref overview_gridoverview.
+ 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).
*/
- void EnableEditing(bool edit);
+ wxGridCellCoordsArray GetSelectedCells() const;
/**
- Turns the drawing of grid lines on or off.
+ 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.
*/
- void EnableGridLines(bool enable = true);
+ wxArrayInt GetSelectedCols() const;
/**
- 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.
+ Returns an array of selected rows.
- @see wxGridUpdateLocker
+ 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.
*/
- void EndBatch();
+ wxArrayInt GetSelectedRows() const;
/**
- Overridden wxWindow method.
+ Returns the colour used for drawing the selection background.
*/
- void Fit();
+ wxColour GetSelectionBackground() const;
/**
- Causes immediate repainting of the grid.
+ Returns an array of the bottom right corners of blocks of selected
+ cells.
- Use this instead of the usual wxWindow::Refresh.
- */
- void ForceRefresh();
+ Please see GetSelectedCells() for more information about the selection
+ representation in wxGrid.
- /**
- 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.
+ @see GetSelectionBlockTopLeft()
*/
- int GetBatchCount() const;
+ wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
/**
- Sets the arguments to the horizontal and vertical text alignment values
- for the grid cell at the specified location.
+ Returns an array of the top left corners of blocks of selected cells.
- Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
- or @c wxALIGN_RIGHT.
+ Please see GetSelectedCells() for more information about the selection
+ representation in wxGrid.
- Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
- @c wxALIGN_BOTTOM.
+ @see GetSelectionBlockBottomRight()
*/
- void GetCellAlignment(int row, int col, int* horiz, int* vert) const;
+ wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
/**
- Returns the background colour of the cell at the specified location.
+ Returns the colour used for drawing the selection foreground.
*/
- wxColour GetCellBackgroundColour(int row, int col) const;
+ wxColour GetSelectionForeground() const;
/**
- Returns a pointer to the editor for the cell at the specified location.
- See wxGridCellEditor and
- the @ref overview_gridoverview "wxGrid overview" for more information about
- cell editors and renderers.
+ Returns the current selection mode.
+
+ @see SetSelectionMode().
*/
- wxGridCellEditor* GetCellEditor(int row, int col) const;
+ wxGridSelectionModes GetSelectionMode() const;
/**
- Returns the font for text in the grid cell at the specified location.
+ Returns @true if the given cell is selected.
*/
- wxFont GetCellFont(int row, int col) const;
-
+ bool IsInSelection(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_gridoverview "wxGrid overview" for more information about
- cell editors and renderers.
+ Returns @true if the given cell is selected.
*/
- wxGridCellRenderer* GetCellRenderer(int row, int col) const;
+ bool IsInSelection(const wxGridCellCoords& coords) const;
/**
- Returns the text colour for the grid cell at the specified location.
+ Returns @true if there are currently any selected cells, rows, columns
+ or blocks.
*/
- wxColour GetCellTextColour(int row, int col) const;
+ bool IsSelection() 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_gridoverview "wxGrid overview" for more information.
+ Selects all cells in the grid.
*/
- wxString GetCellValue(int row, int col) const;
- const wxString GetCellValue(const wxGridCellCoords& coords) const;
- //@}
+ void SelectAll();
/**
- Returns the column ID of the specified column position.
- */
- int GetColAt(int colPos) const;
+ 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);
/**
- 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 @e col.
- See GetRowGridLinePen() for an example.
+ 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.
*/
- wxPen GetColGridLinePen(int col);
+ void SelectBlock(const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight,
+ bool addToSelected = false);
/**
- Sets the arguments to the current column label alignment values.
+ Selects the specified column.
- Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
- or @c wxALIGN_RIGHT.
+ If @a addToSelected is @false then any existing selection will be
+ deselected; if @true the column will be added to the existing
+ selection.
- Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
- @c wxALIGN_BOTTOM.
+ This method won't select anything if the current selection mode is
+ wxGridSelectRows.
*/
- void GetColLabelAlignment(int* horiz, int* vert) const;
+ void SelectCol(int col, bool addToSelected = false);
/**
- Returns the current height of the column labels.
- */
- int GetColLabelSize() const;
+ Selects the specified row.
- /**
- Returns the specified column label.
+ If @a addToSelected is @false then any existing selection will be
+ deselected; if @true the row will be added to the existing selection.
- 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.
+ This method won't select anything if the current selection mode is
+ wxGridSelectColumns.
*/
- wxString GetColLabelValue(int col) const;
+ void SelectRow(int row, bool addToSelected = false);
/**
- Returns the coordinate of the left border specified column.
+ Set the colour to be used for drawing the selection background.
*/
- int GetColLeft(int col) const;
+ void SetSelectionBackground(const wxColour& c);
/**
- This returns the value of the lowest column width that can be handled
- correctly. See
- member SetColMinimalAcceptableWidth() for details.
+ Set the colour to be used for drawing the selection foreground.
*/
- int GetColMinimalAcceptableWidth() const;
+ void SetSelectionForeground(const wxColour& c);
/**
- Get the minimal width of the given column/row.
- */
- int GetColMinimalWidth(int col) const;
+ Set the selection behaviour of the grid.
- /**
- Returns the position of the specified column.
+ 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).
*/
- int GetColPos(int colID) const;
+ void SetSelectionMode(wxGridSelectionModes selmode);
+
+ //@}
+
/**
- Returns the coordinate of the right border specified column.
- */
- int GetColRight(int col) const;
+ @name Scrolling
+ */
+ //@{
/**
- Returns the width of the specified column.
+ Returns the number of pixels per horizontal scroll increment.
+
+ The default is 15.
+
+ @see GetScrollLineY(), SetScrollLineX(), SetScrollLineY()
*/
- int GetColSize(int col) const;
+ int GetScrollLineX() const;
/**
- Sets the arguments to the current default horizontal and vertical text alignment
- values.
- Horizontal alignment will be one of wxALIGN_LEFT, wxALIGN_CENTRE or
- wxALIGN_RIGHT.
+ Returns the number of pixels per vertical scroll increment.
+
+ The default is 15.
- Vertical alignment will be one of wxALIGN_TOP, wxALIGN_CENTRE or wxALIGN_BOTTOM.
+ @see GetScrollLineX(), SetScrollLineX(), SetScrollLineY()
*/
- void GetDefaultCellAlignment(int* horiz, int* vert) const;
+ int GetScrollLineY() const;
/**
- Returns the current default background colour for grid cells.
- */
- wxColour GetDefaultCellBackgroundColour() 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 the current default font for grid cell text.
+ 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.
*/
- wxFont GetDefaultCellFont() const;
+ bool IsVisible(const wxGridCellCoords& coords,
+ bool wholeCellVisible = true) const;
/**
- Returns the current default colour for grid cell text.
- */
- wxColour GetDefaultCellTextColour() 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);
/**
- Returns the default height for column labels.
+ Brings the specified cell into the visible grid cell area with minimal
+ scrolling.
+
+ Does nothing if the cell is already visible.
*/
- int GetDefaultColLabelSize() const;
+ void MakeCellVisible(const wxGridCellCoords& coords);
/**
- Returns the current default width for grid columns.
+ Sets the number of pixels per horizontal scroll increment.
+
+ The default is 15.
+
+ @see GetScrollLineX(), GetScrollLineY(), SetScrollLineY()
*/
- int GetDefaultColSize() const;
+ void SetScrollLineX(int x);
/**
- Returns a pointer to the current default grid cell editor.
- See wxGridCellEditor and
- the @ref overview_gridoverview "wxGrid overview" for more information about
- cell editors and renderers.
+ Sets the number of pixels per vertical scroll increment.
+
+ The default is 15.
+
+ @see GetScrollLineX(), GetScrollLineY(), SetScrollLineX()
*/
- wxGridCellEditor* GetDefaultEditor() const;
+ 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()
*/
- wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
- const wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const;
- //@}
+ 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()
*/
- wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
-
+ wxRect CellToRect(int row, int col) const;
/**
- 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.
+ Return the rectangle corresponding to the grid cell's size and position
+ in logical coordinates.
- @see GetColGridLinePen(), GetRowGridLinePen()
+ @see BlockToDeviceRect()
*/
- wxPen GetDefaultGridLinePen();
+ wxRect CellToRect(const wxGridCellCoords& coords) const;
/**
- Returns a pointer to the current default grid cell renderer.
- See wxGridCellRenderer and
- the @ref overview_gridoverview "wxGrid overview" for more information about
- cell editors and renderers.
+ 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.
*/
- wxGridCellRenderer* GetDefaultRenderer() const;
+ 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.
*/
- wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
+ int XToEdgeOfCol(int x) const;
/**
+ Translates logical pixel coordinates to the grid cell coordinates.
- */
- wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
+ 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;
/**
- Returns the default width for the row labels.
- */
- int GetDefaultRowLabelSize() 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 current default height for grid rows.
+ 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 GetDefaultRowSize() const;
+ int YToEdgeOfRow(int y) const;
/**
- Returns the current grid cell column position.
+ 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 GetGridCursorCol() const;
+ int YToRow(int y, bool clipToMinMax = false) const;
+
+ //@}
+
/**
- Returns the current grid cell row position.
- */
- int GetGridCursorRow() const;
+ @name Miscellaneous Functions
+ */
+ //@{
/**
- Returns the colour used for grid lines.
+ Appends one or more new columns to the right of the grid.
- @see GetDefaultGridLinePen()
+ 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.
*/
- wxColour GetGridLineColour() const;
+ bool AppendCols(int numCols = 1, bool updateLabels = true);
/**
- Returns the colour used for the background of row and column labels.
+ 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.
*/
- wxColour GetLabelBackgroundColour() const;
+ bool AppendRows(int numRows = 1, bool updateLabels = true);
/**
- Returns the font used for row and column labels.
+ 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.
*/
- wxFont GetLabelFont() const;
+ void BeginBatch();
/**
- Returns the colour used for row and column label text.
+ 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.
*/
- wxColour GetLabelTextColour() const;
+ void ClearGrid();
/**
- Returns the total number of grid columns (actually the number of columns in the
- underlying grid
- table).
- */
- int GetNumberCols() const;
+ Change whether the horizontal grid lines are clipped by the end of the
+ last column.
- /**
- Returns the total number of grid rows (actually the number of rows in the
- underlying grid table).
- */
- int GetNumberRows() const;
+ 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.
- */
- wxGridCellAttr* GetOrCreateCellAttr(int row, int col) const;
+ 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.
- /**
- 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 row @e row.
- Example:
- */
- wxPen GetRowGridLinePen(int row);
+ @see AreVertGridLinesClipped(), ClipHorzGridLines()
+ */
+ void ClipVertGridLines(bool clip);
/**
- Sets the arguments to the current row label alignment values.
- Horizontal alignment will be one of wxLEFT, wxCENTRE or wxRIGHT.
+ Deletes one or more columns from a grid starting at the specified
+ position.
- Vertical alignment will be one of wxTOP, wxCENTRE or wxBOTTOM.
- */
- void GetRowLabelAlignment(int* horiz, int* vert) const;
+ 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.
- /**
- Returns the current width of the row labels.
+ @return @true on success or @false if deleting columns failed.
*/
- int GetRowLabelSize() const;
+ bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true);
/**
- 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;
+ Deletes one or more rows from a grid starting at the specified
+ position.
- /**
- This returns the value of the lowest row width that can be handled correctly.
- See
- member SetRowMinimalAcceptableHeight() for details.
+ 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.
*/
- int GetRowMinimalAcceptableHeight() const;
+ bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true);
/**
+ Decrements the grid's batch count.
- */
- int GetRowMinimalHeight(int col) const;
+ 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.
- /**
- Returns the height of the specified row.
+ @see wxGridUpdateLocker
*/
- int GetRowSize(int row) const;
+ void EndBatch();
/**
- Returns the number of pixels per horizontal scroll increment. The default is 15.
-
- @see GetScrollLineY(), SetScrollLineX(), SetScrollLineY()
+ Overridden wxWindow method.
*/
- int GetScrollLineX() const;
+ virtual void Fit();
/**
- Returns the number of pixels per vertical scroll increment. The default is 15.
+ Causes immediate repainting of the grid.
- @see GetScrollLineX(), SetScrollLineX(), SetScrollLineY()
+ Use this instead of the usual wxWindow::Refresh().
*/
- int GetScrollLineY() const;
+ void ForceRefresh();
/**
- Returns an array of singly selected cells.
+ 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.
*/
- wxGridCellCoordsArray GetSelectedCells() const;
+ int GetBatchCount();
/**
- Returns an array of selected cols.
+ Returns the total number of grid columns.
- Please notice that this method alone is not sufficient to find all the
- selected columns, see the explanation in GetSelectedRows()
- documentation for more details.
+ This is the same as the number of columns in the underlying grid table.
*/
- wxArrayInt GetSelectedCols() const;
+ int GetNumberCols() const;
/**
- Returns an array of selected rows.
+ Returns the total number of grid rows.
- Note that this array contains only the rows which were individually
- selected (using the mouse with the row header or combinations involving
- @c Ctrl key for selecting individual rows). In particular if the user
- selects many rows at once (e.g. by pressing @c Shift key) this array is
- @b not updated because this could mean storing a very large number of
- elements in it. So in general to find the current selection you need to
- use both this method and GetSelectionBlockTopLeft() and
- GetSelectionBlockBottomRight() ones.
+ This is the same as the number of rows in the underlying grid table.
*/
- wxArrayInt GetSelectedRows() const;
+ int GetNumberRows() const;
/**
- Access or update the selection fore/back colours
- */
- wxColour GetSelectionBackground() const;
+ Returns the attribute for the given cell creating one if necessary.
- /**
- Returns an array of the bottom right corners of blocks of selected cells,
- see GetSelectionBlockTopLeft().
- */
- wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
+ 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.
- /**
- Returns an array of the top left corners of blocks of selected cells,
- see GetSelectionBlockBottomRight().
+ This function may only be called if CanHaveAttributes() returns @true.
*/
- wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
+ wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
/**
+ Returns a base pointer to the current table object.
- */
- wxColour GetSelectionForeground() const;
+ 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);
+
+ /**
+ Invalidates the cached attribute for the given cell.
+
+ For efficiency reasons, wxGrid may cache the recently used attributes
+ (currently it caches only the single most recently used one, in fact)
+ which can result in the cell appearance not being refreshed even when
+ the attribute returned by your custom wxGridCellAttrProvider-derived
+ class has changed. To force the grid to refresh the cell attribute,
+ this function may be used. Notice that calling it will not result in
+ actually redrawing the cell, you still need to call
+ wxWindow::RefreshRect() to invalidate the area occupied by the cell in
+ the window to do this. Also note that you don't need to call this
+ function if you store the attributes in wxGrid itself, i.e. use its
+ SetAttr() and similar methods, it is only useful when using a separate
+ custom attributes provider.
+
+ @param row
+ The row of the cell whose attribute needs to be queried again.
+ @param col
+ The column of the cell whose attribute needs to be queried again.
+
+ @since 2.9.2
+ */
+ void RefreshAttr(int row, int col);
+
+ /**
+ Draws part or all of a wxGrid on a wxDC for printing or display.
+
+ Pagination can be accomplished by using sequential Render() calls
+ with appropriate values in wxGridCellCoords topLeft and bottomRight.
+
+ @param dc
+ The wxDC to be drawn on.
+ @param pos
+ The position on the wxDC where rendering should begin. If not
+ specified drawing will begin at the wxDC MaxX() and MaxY().
+ @param size
+ The size of the area on the wxDC that the rendered wxGrid should
+ occupy. If not specified the drawing will be scaled to fit the
+ available dc width or height. The wxGrid's aspect ratio is
+ maintained whether or not size is specified.
+ @param topLeft
+ The top left cell of the block to be drawn. Defaults to ( 0, 0 ).
+ @param bottomRight
+ The bottom right cell of the block to be drawn. Defaults to row and
+ column counts.
+ @param style
+ A combination of values from wxGridRenderStyle.
+
+ @since 2.9.4
+ */
+ void Render( wxDC& dc,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ const wxGridCellCoords& topLeft = wxGridCellCoords( -1, -1 ),
+ const wxGridCellCoords& bottomRight = wxGridCellCoords( -1, -1 ),
+ int style = wxGRID_DRAW_DEFAULT );
/**
- Returns the current selection mode, see SetSelectionMode().
- */
- wxGridSelectionModes GetSelectionMode() const;
+ Sets the cell attributes for all cells in the specified column.
- /**
- Returns a base pointer to the current table object.
+ For more information about controlling grid cell attributes see the
+ wxGridCellAttr cell attribute class and the @ref overview_grid.
*/
- wxGridTableBase* GetTable() const;
+ void SetColAttr(int col, wxGridCellAttr* attr);
/**
- Returned number of whole cols visible.
+ Sets the extra margins used around the grid area.
+
+ A grid may occupy more space than needed for its data display and
+ this function allows to set how big this extra space is
*/
- int GetViewWidth() const;
+ void SetMargins(int extraWidth, int extraHeight);
/**
- EnableGridLines()
+ Sets the cell attributes for all cells in the specified row.
- GridLinesEnabled()
+ The grid takes ownership of the attribute pointer.
- SetGridLineColour()
+ See the wxGridCellAttr class for more information about controlling
+ cell attributes.
+ */
+ void SetRowAttr(int row, wxGridCellAttr* attr);
- GetGridLineColour()
+ //@}
- GetDefaultGridLinePen()
- GetRowGridLinePen()
+ /**
+ @name Sorting support.
- GetColGridLinePen()
- */
+ wxGrid doesn't provide any support for sorting the data but it does
+ generate events allowing the user code to sort it and supports
+ displaying the sort indicator in the column used for sorting.
+ To use wxGrid sorting support you need to handle wxEVT_GRID_COL_SORT
+ event (and not veto it) and resort the data displayed in the grid. The
+ grid will automatically update the sorting indicator on the column
+ which was clicked.
- /**
- Returns @true if drawing of grid lines is turned on, @false otherwise.
- */
- bool GridLinesEnabled() const;
+ You can also call the functions in this section directly to update the
+ sorting indicator. Once again, they don't do anything with the grid
+ data, it remains your responsibility to actually sort it appropriately.
+ */
+ //@{
/**
- Hides the in-place cell edit control.
- */
- void HideCellEditControl();
+ Return the column in which the sorting indicator is currently
+ displayed.
- /**
- 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();
+ Returns @c wxNOT_FOUND if sorting indicator is not currently displayed
+ at all.
- /**
- Hides the row labels by calling SetRowLabelSize()
- with a size of 0. Show labels again by calling that method with
- a width greater than 0.
- */
- void HideRowLabels();
+ @see SetSortingColumn()
+ */
+ int GetSortingColumn() const;
/**
- Init the m_colWidths/Rights arrays
- */
- void InitColWidths();
+ Return @true if this column is currently used for sorting.
- /**
- @note @e never access m_row/col arrays directly because they are created
- on demand, @e always use accessor functions instead!
- Init the m_rowHeights/Bottoms arrays with default values.
- */
- void InitRowHeights();
+ @see GetSortingColumn()
+ */
+ bool IsSortingBy(int col) const;
/**
- Inserts one or more new columns into a grid with the first new column at the
- specified position and returns @true if successful. The updateLabels argument is
- not
- used at present.
- The sequence of actions begins with the grid object 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
- wxGrid::CreateGrid) this process is automatic. If you are
- using a custom grid table (specified with wxGrid::SetTable)
- then you must override
- wxGridTableBase::InsertCols in your derived
- table class.
- */
- bool InsertCols(int pos = 0, int numCols = 1,
- bool updateLabels = true);
+ Return @true if the current sorting order is ascending or @false if it
+ is descending.
- /**
- Inserts one or more new rows into a grid with the first new row at the specified
- position and returns @true if successful. The updateLabels argument is not used
- at
- present.
- The sequence of actions begins with the grid object requesting the underlying
- grid
- table to insert new rows. If this is successful the table notifies the grid and
- the
- grid updates the display. For a default grid (one where you have called
- wxGrid::CreateGrid) this process is automatic. If you are
- using a custom grid table (specified with wxGrid::SetTable)
- then you must override
- wxGridTableBase::InsertRows in your derived
- table class.
- */
- bool InsertRows(int pos = 0, int numRows = 1,
- bool updateLabels = true);
+ It only makes sense to call this function if GetSortingColumn() returns
+ a valid column index and not @c wxNOT_FOUND.
- /**
- Returns @true if the in-place edit control is currently enabled.
- */
- bool IsCellEditControlEnabled() const;
+ @see SetSortingColumn()
+ */
+ bool IsSortOrderAscending() const;
/**
- Returns @true if the current cell has been set to read-only
- (see wxGrid::SetReadOnly).
- */
- bool IsCurrentCellReadOnly() const;
+ Set the column to display the sorting indicator in and its direction.
- /**
- 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;
+ @param col
+ The column to display the sorting indicator in or @c wxNOT_FOUND to
+ remove any currently displayed sorting indicator.
+ @param ascending
+ If @true, display the ascending sort indicator, otherwise display
+ the descending sort indicator.
+
+ @see GetSortingColumn(), IsSortOrderAscending()
+ */
+ void SetSortingColumn(int col, bool ascending = true);
- //@{
/**
- Is this cell currently selected.
- */
- bool IsInSelection(int row, int col) const;
- const bool IsInSelection(const wxGridCellCoords& coords) const;
+ Remove any currently shown sorting indicator.
+
+ This is equivalent to calling SetSortingColumn() with @c wxNOT_FOUND
+ first argument.
+ */
+ void UnsetSortingColumn();
//@}
- /**
- Returns @true if the cell at the specified location can't be edited.
- See also IsReadOnly().
- */
- bool IsReadOnly(int row, int col) const;
/**
- Returns @true if there are currently rows, columns or blocks of cells selected.
- */
- bool IsSelection() const;
+ @name Accessors for component windows.
- //@{
- /**
- Returns @true if a cell is either wholly visible (the default) or at least
- partially
- visible in the grid window.
- */
- bool IsVisible(int row, int col, bool wholeCellVisible = true) const;
- const bool IsVisible(const wxGridCellCoords& coords,
- bool wholeCellVisible = true) const;
- //@}
+ Return the various child windows of wxGrid.
+ wxGrid is an empty parent window for 4 children representing the column
+ labels window (top), the row labels window (left), the corner window
+ (top left) and the main grid window. It may be necessary to use these
+ individual windows and not the wxGrid window itself if you need to
+ handle events for them (this can be done using wxEvtHandler::Connect()
+ or wxWindow::PushEventHandler()) or do something else requiring the use
+ of the correct window pointer. Notice that you should not, however,
+ change these windows (e.g. reposition them or draw over them) because
+ they are managed by wxGrid itself.
+ */
//@{
- /**
- 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);
- void MakeCellVisible(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);
+ Return the main grid window containing the grid cells.
- /**
- 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);
+ This window is always shown.
+ */
+ wxWindow *GetGridWindow() const;
/**
- 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);
+ Return the row labels window.
- /**
- 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);
+ This window is not shown if the row labels were hidden using
+ HideRowLabels().
+ */
+ wxWindow *GetGridRowLabelWindow() const;
/**
- 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);
+ Return the column labels window.
- /**
- 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);
+ This window is not shown if the columns labels were hidden using
+ HideColLabels().
- /**
- 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);
+ Depending on whether UseNativeColHeader() was called or not this can be
+ either a wxHeaderCtrl or a plain wxWindow. This function returns a valid
+ window pointer in either case but in the former case you can also use
+ GetGridColHeader() to access it if you need wxHeaderCtrl-specific
+ functionality.
+ */
+ wxWindow *GetGridColLabelWindow() const;
/**
- 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);
+ Return the window in the top left grid corner.
- /**
- Moves the grid cursor down by some number of rows so that the previous bottom
- visible row
- becomes the top visible row.
- */
- bool MovePageDown();
+ This window is shown only of both columns and row labels are shown and
+ normally doesn't contain anything. Clicking on it is handled by wxGrid
+ however and can be used to select the entire grid.
+ */
+ wxWindow *GetGridCornerLabelWindow() const;
/**
- Moves the grid cursor up by some number of rows so that the previous top
- visible row
- becomes the bottom visible row.
- */
- bool MovePageUp();
+ Return the header control used for column labels display.
- /**
- Methods for a registry for mapping data types to Renderers/Editors
- */
- void RegisterDataType(const wxString& typeName,
- wxGridCellRenderer* renderer,
- wxGridCellEditor* editor);
+ This function can only be called if UseNativeColHeader() had been
+ called.
+ */
+ wxHeaderCtrl *GetGridColHeader() const;
- /**
- 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();
+ //@}
+protected:
/**
- Selects all cells in the grid.
- */
- void SelectAll();
+ Returns @true if this grid has support for cell attributes.
- //@{
- /**
- Selects a rectangular block of cells. If addToSelected is @false then any
- existing selection will be
- deselected; if @true the column will be added to the existing selection.
+ The grid supports attributes if it has the associated table which, in
+ turn, has attributes support, i.e. wxGridTableBase::CanHaveAttributes()
+ returns @true.
*/
- void SelectBlock(int topRow, int leftCol, int bottomRow,
- int rightCol,
- bool addToSelected = false);
- void SelectBlock(const wxGridCellCoords& topLeft,
- const wxGridCellCoords& bottomRight,
- bool addToSelected = false);
- //@}
+ bool CanHaveAttributes() const;
/**
- Selects the specified column. If addToSelected is @false then any existing
- selection will be
- deselected; if @true the column will be added to the existing selection.
+ Get the minimal width of the given column/row.
+
+ The value returned by this function may be different than that returned
+ by GetColMinimalAcceptableWidth() if SetColMinimalWidth() had been
+ called for this column.
*/
- void SelectCol(int col, bool addToSelected = false);
+ int GetColMinimalWidth(int col) const;
/**
- Selects the specified row. If addToSelected is @false then any existing
- selection will be
- deselected; if @true the row will be added to the existing selection.
+ Returns the coordinate of the right border specified column.
*/
- void SelectRow(int row, bool addToSelected = false);
+ int GetColRight(int col) const;
/**
- This function returns the rectangle that encloses the selected cells
- in device coords and clipped to the client size of the grid window.
+ Returns the coordinate of the left border specified column.
*/
- wxRect SelectionToDeviceRect() const;
+ int GetColLeft(int col) const;
- //@{
/**
- Sets the horizontal and vertical alignment for grid cell text at the specified
- location.
- Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
- wxALIGN_RIGHT.
+ Returns the minimal size for the given column.
- Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
- wxALIGN_BOTTOM.
+ The value returned by this function may be different than that returned
+ by GetRowMinimalAcceptableHeight() if SetRowMinimalHeight() had been
+ called for this row.
*/
- void SetCellAlignment(int row, int col, int horiz, int vert);
- void SetCellAlignment(int align, int row, int col);
- //@}
+ int GetRowMinimalHeight(int col) const;
+};
- /**
- */
- void SetCellBackgroundColour(int row, int col,
- const wxColour& colour);
- /**
- 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_gridoverview "wxGrid overview" for more information about
- cell editors and renderers.
- */
- void SetCellEditor(int row, int col, wxGridCellEditor* editor);
+/**
+ @class wxGridUpdateLocker
- /**
- Sets the font for text in the grid cell at the specified location.
- */
- void SetCellFont(int row, int col, const wxFont& font);
+ This small class can be used to prevent wxGrid from redrawing during its
+ lifetime by calling wxGrid::BeginBatch() in its constructor and
+ wxGrid::EndBatch() in its destructor. It is typically used in a function
+ performing several operations with a grid which would otherwise result in
+ flicker. For example:
- /**
- 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_gridoverview "wxGrid overview" for more information about
- cell editors and renderers.
- */
- void SetCellRenderer(int row, int col,
- wxGridCellRenderer* renderer);
+ @code
+ void MyFrame::Foo()
+ {
+ m_grid = new wxGrid(this, ...);
- //@{
- /**
- Sets the text colour for the grid cell at the specified location.
- */
- void SetCellTextColour(int row, int col, const wxColour& colour);
- void SetCellTextColour(const wxColour& val, int row, int col);
- void SetCellTextColour(const wxColour& colour);
- //@}
+ wxGridUpdateLocker noUpdates(m_grid);
+ m_grid-AppendColumn();
+ // ... many other operations with m_grid ...
+ m_grid-AppendRow();
- //@{
- /**
- 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.
- The last form is for backward compatibility only.
- See wxGridTableBase::CanSetValueAs
- and the @ref overview_gridoverview "wxGrid overview" for more information.
- */
- void SetCellValue(int row, int col, const wxString& s);
- void SetCellValue(const wxGridCellCoords& coords,
- const wxString& s);
- void SetCellValue(const wxString& val, int row, int col);
- //@}
+ // destructor called, grid refreshed
+ }
+ @endcode
+
+ Using this class is easier and safer than calling wxGrid::BeginBatch() and
+ wxGrid::EndBatch() because you don't risk missing the call the latter (due
+ to an exception for example).
+ @library{wxadv}
+ @category{grid}
+*/
+class wxGridUpdateLocker
+{
+public:
/**
- Sets the cell attributes for all cells in the specified column.
- For more information about controlling grid cell attributes see the
- wxGridCellAttr cell attribute class and the
- @ref overview_gridoverview.
- */
- void SetColAttr(int col, wxGridCellAttr* attr);
+ Creates an object preventing the updates of the specified @a grid. The
+ parameter could be @NULL in which case nothing is done. If @a grid is
+ non-@NULL then the grid must exist for longer than this
+ wxGridUpdateLocker object itself.
- /**
- Sets the specified column to display boolean values. wxGrid displays boolean
- values with a checkbox.
+ The default constructor could be followed by a call to Create() to set
+ the grid object later.
*/
- void SetColFormatBool(int col);
+ wxGridUpdateLocker(wxGrid* grid = NULL);
/**
- Sets the specified column to display data in a custom format.
- See the @ref overview_gridoverview "wxGrid overview" for more information on
- working
- with custom data types.
+ Destructor reenables updates for the grid this object is associated
+ with.
*/
- void SetColFormatCustom(int col, const wxString& typeName);
+ ~wxGridUpdateLocker();
/**
- Sets the specified column to display floating point values with the given width
- and precision.
+ This method can be called if the object had been constructed using the
+ default constructor. It must not be called more than once.
*/
- void SetColFormatFloat(int col, int width = -1,
- int precision = -1);
+ void Create(wxGrid* grid);
+};
- /**
- Sets the specified column to display integer values.
- */
- void SetColFormatNumber(int col);
- /**
- Sets the horizontal and vertical alignment of column label text.
- Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
- wxALIGN_RIGHT.
- Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
- wxALIGN_BOTTOM.
- */
- void SetColLabelAlignment(int horiz, int vert);
- /**
- 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);
+/**
+ @class wxGridEvent
- /**
- Set the value for the given column label. If you are using a derived grid table
- you must
- override wxGridTableBase::SetColLabelValue
- for this to have any effect.
- */
- void SetColLabelValue(int col, const wxString& value);
+ This event class contains information about various grid events.
- /**
- This modifies the minimum column width that can be handled correctly.
- Specifying a low value here
- allows smaller grid cells to be dealt with correctly. Specifying a value here
- which is much smaller
- than the actual minimum size will incur a performance penalty in the functions
- which perform
- grid cell index lookup on the basis of screen coordinates.
- This should normally be called when creating the grid because it will not
- resize existing columns
- with sizes smaller than the value specified here.
- */
- void SetColMinimalAcceptableWidth(int width);
+ Notice that all grid event table macros are available in two versions:
+ @c EVT_GRID_XXX and @c EVT_GRID_CMD_XXX. The only difference between the
+ two is that the former doesn't allow to specify the grid window identifier
+ and so takes a single parameter, the event handler, but is not suitable if
+ there is more than one grid control in the window where the event table is
+ used (as it would catch the events from all the grids). The version with @c
+ CMD takes the id as first argument and the event handler as the second one
+ and so can be used with multiple grids as well. Otherwise there are no
+ difference between the two and only the versions without the id are
+ documented below for brevity.
+
+ @beginEventTable{wxGridEvent}
+ @event{EVT_GRID_CELL_CHANGING(func)}
+ The user is about to change the data in a cell. The new cell value as
+ string is available from GetString() event object method. This event
+ can be vetoed if the change is not allowed.
+ Processes a @c wxEVT_GRID_CELL_CHANGING event type.
+ @event{EVT_GRID_CELL_CHANGED(func)}
+ The user changed the data in a cell. The old cell value as string is
+ available from GetString() event object method. Notice that vetoing
+ this event still works for backwards compatibility reasons but any new
+ code should only veto EVT_GRID_CELL_CHANGING event and not this one.
+ Processes a @c wxEVT_GRID_CELL_CHANGED event type.
+ @event{EVT_GRID_CELL_LEFT_CLICK(func)}
+ The user clicked a cell with the left mouse button. Processes a
+ @c wxEVT_GRID_CELL_LEFT_CLICK event type.
+ @event{EVT_GRID_CELL_LEFT_DCLICK(func)}
+ The user double-clicked a cell with the left mouse button. Processes a
+ @c wxEVT_GRID_CELL_LEFT_DCLICK event type.
+ @event{EVT_GRID_CELL_RIGHT_CLICK(func)}
+ The user clicked a cell with the right mouse button. Processes a
+ @c wxEVT_GRID_CELL_RIGHT_CLICK event type.
+ @event{EVT_GRID_CELL_RIGHT_DCLICK(func)}
+ The user double-clicked a cell with the right mouse button. Processes a
+ @c wxEVT_GRID_CELL_RIGHT_DCLICK event type.
+ @event{EVT_GRID_EDITOR_HIDDEN(func)}
+ The editor for a cell was hidden. Processes a
+ @c wxEVT_GRID_EDITOR_HIDDEN event type.
+ @event{EVT_GRID_EDITOR_SHOWN(func)}
+ The editor for a cell was shown. Processes a
+ @c wxEVT_GRID_EDITOR_SHOWN event type.
+ @event{EVT_GRID_LABEL_LEFT_CLICK(func)}
+ The user clicked a label with the left mouse button. Processes a
+ @c wxEVT_GRID_LABEL_LEFT_CLICK event type.
+ @event{EVT_GRID_LABEL_LEFT_DCLICK(func)}
+ The user double-clicked a label with the left mouse button. Processes a
+ @c wxEVT_GRID_LABEL_LEFT_DCLICK event type.
+ @event{EVT_GRID_LABEL_RIGHT_CLICK(func)}
+ The user clicked a label with the right mouse button. Processes a
+ @c wxEVT_GRID_LABEL_RIGHT_CLICK event type.
+ @event{EVT_GRID_LABEL_RIGHT_DCLICK(func)}
+ The user double-clicked a label with the right mouse button. Processes
+ a @c wxEVT_GRID_LABEL_RIGHT_DCLICK event type.
+ @event{EVT_GRID_SELECT_CELL(func)}
+ The given cell was made current, either by user or by the program via a
+ call to SetGridCursor() or GoToCell(). Processes a
+ @c wxEVT_GRID_SELECT_CELL event type.
+ @event{EVT_GRID_COL_MOVE(func)}
+ The user tries to change the order of the columns in the grid by
+ dragging the column specified by GetCol(). This event can be vetoed to
+ either prevent the user from reordering the column change completely
+ (but notice that if you don't want to allow it at all, you simply
+ shouldn't call wxGrid::EnableDragColMove() in the first place), vetoed
+ but handled in some way in the handler, e.g. by really moving the
+ column to the new position at the associated table level, or allowed to
+ proceed in which case wxGrid::SetColPos() is used to reorder the
+ columns display order without affecting the use of the column indices
+ otherwise.
+ This event macro corresponds to @c wxEVT_GRID_COL_MOVE event type.
+ @event{EVT_GRID_COL_SORT(func)}
+ This event is generated when a column is clicked by the user and its
+ name is explained by the fact that the custom reaction to a click on a
+ column is to sort the grid contents by this column. However the grid
+ itself has no special support for sorting and it's up to the handler of
+ this event to update the associated table. But if the event is handled
+ (and not vetoed) the grid supposes that the table was indeed resorted
+ and updates the column to indicate the new sort order and refreshes
+ itself.
+ This event macro corresponds to @c wxEVT_GRID_COL_SORT event type.
+ @event{EVT_GRID_TABBING(func)}
+ This event is generated when the user presses TAB or Shift-TAB in the
+ grid. It can be used to customize the simple default TAB handling
+ logic, e.g. to go to the next non-empty cell instead of just the next
+ cell. See also wxGrid::SetTabBehaviour(). This event is new since
+ wxWidgets 2.9.5.
+ @endEventTable
+ @library{wxadv}
+ @category{grid,events}
+*/
+class wxGridEvent : public wxNotifyEvent
+{
+public:
/**
- Sets the minimal width for the specified column. This should normally be called
- when creating the grid
- because it will not resize a column that is already narrower than the minimal
- width.
- The width argument must be higher than the minimimal acceptable column width,
- see
- GetColMinimalAcceptableWidth().
+ Default constructor.
*/
- void SetColMinimalWidth(int col, int width);
-
+ wxGridEvent();
/**
- Sets the position of the specified column.
+ Constructor for initializing all event attributes.
*/
- void SetColPos(int colID, int newPos);
+ wxGridEvent(int id, wxEventType type, wxObject* obj,
+ int row = -1, int col = -1, int x = -1, int y = -1,
+ bool sel = true, const wxKeyboardState& kbd = wxKeyboardState());
/**
- Sets the width of the specified column.
- This function does not refresh the grid. If you are calling it outside of a
- BeginBatch / EndBatch
- block you can use ForceRefresh() to see the changes.
- Automatically sizes the column to fit its contents. If setAsMin is @true the
- calculated width will
- also be set as the minimal width for the column.
+ Returns @true if the Alt key was down at the time of the event.
*/
- void SetColSize(int col, int width);
+ bool AltDown() const;
/**
- Sets the default horizontal and vertical alignment for grid cell text.
- Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
- wxALIGN_RIGHT.
- Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
- wxALIGN_BOTTOM.
+ Returns @true if the Control key was down at the time of the event.
*/
- void SetDefaultCellAlignment(int horiz, int vert);
+ bool ControlDown() const;
/**
- Sets the default background colour for grid cells.
- */
- void SetDefaultCellBackgroundColour(const wxColour& colour);
+ Column at which the event occurred.
- /**
- Sets the default font to be used for grid cell text.
+ Notice that for a @c wxEVT_GRID_SELECT_CELL event this column is the
+ column of the newly selected cell while the previously selected cell
+ can be retrieved using wxGrid::GetGridCursorCol().
*/
- void SetDefaultCellFont(const wxFont& font);
+ virtual int GetCol();
/**
- Sets the current default colour for grid cell text.
+ Position in pixels at which the event occurred.
*/
- void SetDefaultCellTextColour(const wxColour& colour);
+ wxPoint GetPosition();
/**
- Sets the default width for columns in the grid. This will only affect columns
- subsequently added to
- the grid unless resizeExistingCols is @true.
- */
- void SetDefaultColSize(int width,
- bool resizeExistingCols = false);
+ Row at which the event occurred.
- /**
- Sets the default editor for grid cells. The grid will take ownership of the
- pointer.
- See wxGridCellEditor and
- the @ref overview_gridoverview "wxGrid overview" for more information about
- cell editors and renderers.
+ Notice that for a @c wxEVT_GRID_SELECT_CELL event this row is the row
+ of the newly selected cell while the previously selected cell can be
+ retrieved using wxGrid::GetGridCursorRow().
*/
- void SetDefaultEditor(wxGridCellEditor* editor);
+ virtual int GetRow();
/**
- Sets the default renderer for grid cells. The grid will take ownership of the
- pointer.
- See wxGridCellRenderer and
- the @ref overview_gridoverview "wxGrid overview" for more information about
- cell editors and renderers.
+ Returns @true if the Meta key was down at the time of the event.
*/
- void SetDefaultRenderer(wxGridCellRenderer* renderer);
+ bool MetaDown() const;
/**
- Sets the default height for rows in the grid. This will only affect rows
- subsequently added
- to the grid unless resizeExistingRows is @true.
+ Returns @true if the user is selecting grid cells, or @false if
+ deselecting.
*/
- void SetDefaultRowSize(int height,
- bool resizeExistingRows = false);
+ bool Selecting();
/**
- Set the grid cursor to the specified cell.
- This function calls MakeCellVisible().
+ Returns @true if the Shift key was down at the time of the event.
*/
- void SetGridCursor(int row, int col);
+ bool ShiftDown() const;
+};
- /**
- Sets the colour used to draw grid lines.
- */
- void SetGridLineColour(const wxColour& colour);
- /**
- 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);
+/**
+ @class wxGridSizeEvent
- /**
- Sets the colour for row and column label text.
- */
- void SetLabelTextColour(const wxColour& colour);
+ This event class contains information about a row/column resize event.
- /**
- A grid may occupy more space than needed for its rows/columns. This
- function allows to set how big this extra space is
- */
- void SetMargins(int extraWidth, int extraHeight);
+ @beginEventTable{wxGridSizeEvent}
+ @event{EVT_GRID_CMD_COL_SIZE(id, func)}
+ The user resized a column, corresponds to @c wxEVT_GRID_COL_SIZE event
+ type.
+ @event{EVT_GRID_CMD_ROW_SIZE(id, func)}
+ The user resized a row, corresponds to @c wxEVT_GRID_ROW_SIZE event
+ type.
+ @event{EVT_GRID_COL_SIZE(func)}
+ Same as EVT_GRID_CMD_COL_SIZE() but uses `wxID_ANY` id.
+ @event{EVT_GRID_COL_AUTO_SIZE(func)}
+ This event is sent when a column must be resized to its best size, e.g.
+ when the user double clicks the column divider. The default
+ implementation simply resizes the column to fit the column label (but
+ not its contents as this could be too slow for big grids). This macro
+ corresponds to @c wxEVT_GRID_COL_AUTO_SIZE event type and is new since
+ wxWidgets 2.9.5.
+ @event{EVT_GRID_ROW_SIZE(func)}
+ Same as EVT_GRID_CMD_ROW_SIZE() but uses `wxID_ANY` id.
+ @endEventTable
+ @library{wxadv}
+ @category{grid,events}
+*/
+class wxGridSizeEvent : public wxNotifyEvent
+{
+public:
/**
- Common part of AutoSizeColumn/Row() and GetBestSize()
+ Default constructor.
*/
- int SetOrCalcColumnSizes(bool calcOnly, bool setAsMin = true);
-
+ wxGridSizeEvent();
/**
-
+ Constructor for initializing all event attributes.
*/
- int SetOrCalcRowSizes(bool calcOnly, bool setAsMin = true);
+ wxGridSizeEvent(int id, wxEventType type, wxObject* obj,
+ int rowOrCol = -1, int x = -1, int y = -1,
+ const wxKeyboardState& kbd = wxKeyboardState());
/**
- Makes the cell at the specified location read-only or editable.
- See also IsReadOnly().
+ Returns @true if the Alt key was down at the time of the event.
*/
- void SetReadOnly(int row, int col, bool isReadOnly = true);
+ bool AltDown() const;
/**
- Sets the cell attributes for all cells in the specified row.
- See the wxGridCellAttr class for more information
- about controlling cell attributes.
+ Returns @true if the Control key was down at the time of the event.
*/
- void SetRowAttr(int row, wxGridCellAttr* attr);
+ bool ControlDown() const;
/**
- Sets the horizontal and vertical alignment of row label text.
- Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
- wxALIGN_RIGHT.
- Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
- wxALIGN_BOTTOM.
+ Position in pixels at which the event occurred.
*/
- void SetRowLabelAlignment(int horiz, int vert);
+ wxPoint GetPosition();
/**
- 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.
+ Row or column at that was resized.
*/
- void SetRowLabelSize(int width);
+ int GetRowOrCol();
/**
- Set 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.
+ Returns @true if the Meta key was down at the time of the event.
*/
- void SetRowLabelValue(int row, const wxString& value);
+ bool MetaDown() const;
/**
- This modifies the minimum row width that can be handled correctly. Specifying a
- low value here
- allows smaller grid cells to be dealt with correctly. Specifying a value here
- which is much smaller
- than the actual minimum size will incur a performance penalty in the functions
- which perform
- grid cell index lookup on the basis of screen coordinates.
- This should normally be called when creating the grid because it will not
- resize existing rows
- with sizes smaller than the value specified here.
+ Returns @true if the Shift key was down at the time of the event.
*/
- void SetRowMinimalAcceptableHeight(int height);
+ bool ShiftDown() const;
+};
- /**
- Sets the minimal height for the specified row. This should normally be called
- when creating the grid
- because it will not resize a row that is already shorter than the minimal
- height.
- The height argument must be higher than the minimimal acceptable row height, see
- GetRowMinimalAcceptableHeight().
- */
- void SetRowMinimalHeight(int row, int height);
+
+/**
+ @class wxGridRangeSelectEvent
+
+ @beginEventTable{wxGridRangeSelectEvent}
+ @event{EVT_GRID_RANGE_SELECT(func)}
+ The user selected a group of contiguous cells. Processes a
+ @c wxEVT_GRID_RANGE_SELECT event type.
+ @event{EVT_GRID_CMD_RANGE_SELECT(id, func)}
+ The user selected a group of contiguous cells; variant taking a window
+ identifier. Processes a @c wxEVT_GRID_RANGE_SELECT event type.
+ @endEventTable
+
+ @library{wxadv}
+ @category{grid,events}
+*/
+class wxGridRangeSelectEvent : public wxNotifyEvent
+{
+public:
/**
- Sets the height of the specified row.
- This function does not refresh the grid. If you are calling it outside of a
- BeginBatch / EndBatch
- block you can use ForceRefresh() to see the changes.
- Automatically sizes the column to fit its contents. If setAsMin is @true the
- calculated width will
- also be set as the minimal width for the column.
+ Default constructor.
*/
- void SetRowSize(int row, int height);
-
+ wxGridRangeSelectEvent();
/**
- Sets the number of pixels per horizontal scroll increment. The default is 15.
- Sometimes wxGrid has trouble setting the scrollbars correctly due to rounding
- errors: setting this to 1 can help.
-
- @see GetScrollLineX(), GetScrollLineY(), SetScrollLineY()
+ Constructor for initializing all event attributes.
*/
- void SetScrollLineX(int x);
+ wxGridRangeSelectEvent(int id, wxEventType type,
+ wxObject* obj,
+ const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight,
+ bool sel = true, const wxKeyboardState& kbd = wxKeyboardState());
/**
- Sets the number of pixels per vertical scroll increment. The default is 15.
- Sometimes wxGrid has trouble setting the scrollbars correctly due to rounding
- errors: setting this to 1 can help.
-
- @see GetScrollLineX(), GetScrollLineY(), SetScrollLineX()
+ Returns @true if the Alt key was down at the time of the event.
*/
- void SetScrollLineY(int y);
+ bool AltDown() const;
/**
-
+ Returns @true if the Control key was down at the time of the event.
*/
- void SetSelectionBackground(const wxColour& c);
+ bool ControlDown() const;
/**
-
+ Top left corner of the rectangular area that was (de)selected.
*/
- void SetSelectionForeground(const wxColour& c);
+ wxGridCellCoords GetBottomRightCoords();
/**
- 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).
+ Bottom row of the rectangular area that was (de)selected.
*/
- void SetSelectionMode(wxGridSelectionModes selmode);
+ int GetBottomRow();
/**
- 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 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.
+ Left column of the rectangular area that was (de)selected.
*/
- bool SetTable(wxGridTableBase* table,
- bool takeOwnership = false,
- wxGridSelectionModes selmode = wxGridSelectCells);
+ int GetLeftCol();
/**
- Call this in order to make the column labels use a native look by using
- wxRenderer::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.
+ Right column of the rectangular area that was (de)selected.
*/
- void SetUseNativeColLabels(bool native = true);
+ int GetRightCol();
/**
- Displays the in-place cell edit control for the current cell.
+ Top left corner of the rectangular area that was (de)selected.
*/
- void ShowCellEditControl();
+ wxGridCellCoords GetTopLeftCoords();
/**
- @param x
- The x position to evaluate.
- @param clipToMinMax
- If @true, rather than returning wxNOT_FOUND, it returns either the first or
- last column depending on whether x is too far to the left or right respectively.
+ Top row of the rectangular area that was (de)selected.
*/
- int XToCol(int x, bool clipToMinMax = false) const;
+ int GetTopRow();
/**
- Returns the column whose right hand edge is close to the given logical x
- position.
- If no column edge is near to this position @c wxNOT_FOUND is returned.
+ Returns @true if the Meta key was down at the time of the event.
*/
- int XToEdgeOfCol(int x) const;
+ bool MetaDown() const;
/**
- Returns the row whose bottom edge is close to the given logical y position.
- If no row edge is near to this position @c wxNOT_FOUND is returned.
+ Returns @true if the area was selected, @false otherwise.
*/
- int YToEdgeOfRow(int y) const;
+ bool Selecting();
/**
- Returns the grid row that corresponds to the logical y coordinate. Returns
- @c wxNOT_FOUND if there is no row at the y position.
+ Returns @true if the Shift key was down at the time of the event.
*/
- int YToRow(int y) const;
+ bool ShiftDown() const;
};
/**
- @class wxGridCellBoolEditor
+ @class wxGridEditorCreatedEvent
- The editor for boolean data.
+ @beginEventTable{wxGridEditorCreatedEvent}
+ @event{EVT_GRID_EDITOR_CREATED(func)}
+ The editor for a cell was created. Processes a
+ @c wxEVT_GRID_EDITOR_CREATED event type.
+ @event{EVT_GRID_CMD_EDITOR_CREATED(id, func)}
+ The editor for a cell was created; variant taking a window identifier.
+ Processes a @c wxEVT_GRID_EDITOR_CREATED event type.
+ @endEventTable
@library{wxadv}
- @category{grid}
-
- @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellNumberEditor,
- wxGridCellTextEditor, wxGridCellChoiceEditor
+ @category{grid,events}
*/
-class wxGridCellBoolEditor : public wxGridCellEditor
+class wxGridEditorCreatedEvent : public wxCommandEvent
{
public:
/**
Default constructor.
*/
- wxGridCellBoolEditor();
-
+ wxGridEditorCreatedEvent();
/**
- Returns @true if the given @a value is equal to the string representation of
- the truth value we currently use (see
- wxGridCellBoolEditor::UseStringValues).
+ Constructor for initializing all event attributes.
*/
- static bool IsTrueValue(const wxString& value);
+ wxGridEditorCreatedEvent(int id, wxEventType type, wxObject* obj,
+ int row, int col, wxControl* ctrl);
/**
- , wxString&@e valueFalse = _T(""))
- This method allows to customize the values returned by GetValue() method for
- the cell using this editor. By default, the default values of the arguments are
- used, i.e. @c "1" is returned if the cell is checked and an empty string
- otherwise, using this method allows to change this.
+ Returns the column at which the event occurred.
*/
- static void UseStringValues() const;
-};
-
-
-
-/**
- @class wxGridUpdateLocker
-
- This small class can be used to prevent wxGrid from redrawing
- during its lifetime by calling wxGrid::BeginBatch
- in its constructor and wxGrid::EndBatch in its
- destructor. It is typically used in a function performing several operations
- with a grid which would otherwise result in flicker. For example:
-
- @code
- void MyFrame::Foo()
- {
- m_grid = new wxGrid(this, ...);
-
- wxGridUpdateLocker noUpdates(m_grid);
- m_grid-AppendColumn();
- ... many other operations with m_grid...
- m_grid-AppendRow();
+ int GetCol();
- // destructor called, grid refreshed
- }
- @endcode
+ /**
+ Returns the edit control.
+ */
+ wxControl* GetControl();
- Using this class is easier and safer than calling
- wxGrid::BeginBatch and wxGrid::EndBatch
- because you don't risk not to call the latter (due to an exception for example).
+ /**
+ Returns the row at which the event occurred.
+ */
+ int GetRow();
- @library{wxadv}
- @category{grid}
-*/
-class wxGridUpdateLocker
-{
-public:
/**
- Creates an object preventing the updates of the specified @e grid. The
- parameter could be @NULL in which case nothing is done. If @a grid is
- non-@NULL then the grid must exist for longer than wxGridUpdateLocker object
- itself.
- The default constructor could be followed by a call to
- Create() to set the
- grid object later.
+ Sets the column at which the event occurred.
*/
- wxGridUpdateLocker(wxGrid* grid = NULL);
+ void SetCol(int col);
/**
- Destructor reenables updates for the grid this object is associated with.
+ Sets the edit control.
*/
- ~wxGridUpdateLocker();
+ void SetControl(wxControl* ctrl);
/**
- This method can be called if the object had been constructed using the default
- constructor. It must not be called more than once.
+ Sets the row at which the event occurred.
*/
- void Create(wxGrid* grid);
+ void SetRow(int row);
};
+
+wxEventType wxEVT_GRID_CELL_LEFT_CLICK;
+wxEventType wxEVT_GRID_CELL_RIGHT_CLICK;
+wxEventType wxEVT_GRID_CELL_LEFT_DCLICK;
+wxEventType wxEVT_GRID_CELL_RIGHT_DCLICK;
+wxEventType wxEVT_GRID_LABEL_LEFT_CLICK;
+wxEventType wxEVT_GRID_LABEL_RIGHT_CLICK;
+wxEventType wxEVT_GRID_LABEL_LEFT_DCLICK;
+wxEventType wxEVT_GRID_LABEL_RIGHT_DCLICK;
+wxEventType wxEVT_GRID_ROW_SIZE;
+wxEventType wxEVT_GRID_COL_SIZE;
+wxEventType wxEVT_GRID_COL_AUTO_SIZE;
+wxEventType wxEVT_GRID_RANGE_SELECT;
+wxEventType wxEVT_GRID_CELL_CHANGING;
+wxEventType wxEVT_GRID_CELL_CHANGED;
+wxEventType wxEVT_GRID_SELECT_CELL;
+wxEventType wxEVT_GRID_EDITOR_SHOWN;
+wxEventType wxEVT_GRID_EDITOR_HIDDEN;
+wxEventType wxEVT_GRID_EDITOR_CREATED;
+wxEventType wxEVT_GRID_CELL_BEGIN_DRAG;
+wxEventType wxEVT_GRID_COL_MOVE;
+wxEventType wxEVT_GRID_COL_SORT;
+wxEventType wxEVT_GRID_TABBING;
+
projects / wxWidgets.git / blobdiff