// constants
// ----------------------------------------------------------------------------
-extern WXDLLIMPEXP_DATA_ADV(const wxChar) wxGridNameStr[];
+extern WXDLLIMPEXP_DATA_ADV(const char) wxGridNameStr[];
// Default parameters for wxGrid
//
#define wxGRID_VALUE_TEXT wxGRID_VALUE_STRING
#define wxGRID_VALUE_LONG wxGRID_VALUE_NUMBER
+// magic constant which tells (to some functions) to automatically calculate
+// the appropriate size
+#define wxGRID_AUTOSIZE (-1)
+
+// many wxGrid methods work either with columns or rows, this enum is used for
+// the parameter indicating which one should it be
+enum wxGridDirection
+{
+ wxGRID_COLUMN,
+ wxGRID_ROW
+};
+
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_ADV wxGrid;
-class WXDLLIMPEXP_ADV wxGridCellAttr;
-class WXDLLIMPEXP_ADV wxGridCellAttrProviderData;
-class WXDLLIMPEXP_ADV wxGridColLabelWindow;
-class WXDLLIMPEXP_ADV wxGridCornerLabelWindow;
-class WXDLLIMPEXP_ADV wxGridRowLabelWindow;
-class WXDLLIMPEXP_ADV wxGridWindow;
-class WXDLLIMPEXP_ADV wxGridTypeRegistry;
-class WXDLLIMPEXP_ADV wxGridSelection;
-
-class WXDLLEXPORT wxCheckBox;
-class WXDLLEXPORT wxComboBox;
-class WXDLLEXPORT wxTextCtrl;
+class WXDLLIMPEXP_FWD_ADV wxGrid;
+class WXDLLIMPEXP_FWD_ADV wxGridCellAttr;
+class WXDLLIMPEXP_FWD_ADV wxGridCellAttrProviderData;
+class WXDLLIMPEXP_FWD_ADV wxGridColLabelWindow;
+class WXDLLIMPEXP_FWD_ADV wxGridCornerLabelWindow;
+class WXDLLIMPEXP_FWD_ADV wxGridRowLabelWindow;
+class WXDLLIMPEXP_FWD_ADV wxGridWindow;
+class WXDLLIMPEXP_FWD_ADV wxGridTypeRegistry;
+class WXDLLIMPEXP_FWD_ADV wxGridSelection;
+
+class WXDLLIMPEXP_FWD_CORE wxCheckBox;
+class WXDLLIMPEXP_FWD_CORE wxComboBox;
+class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
#if wxUSE_SPINCTRL
-class WXDLLEXPORT wxSpinCtrl;
+class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
#endif
+class wxGridOperations;
+class wxGridRowOperations;
+class wxGridColumnOperations;
+class wxGridDirectionOperations;
+
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
// Show or hide the edit control, use the specified attributes to set
// colours/fonts for it
- virtual void Show(bool show, wxGridCellAttr *attr = (wxGridCellAttr *)NULL);
+ virtual void Show(bool show, wxGridCellAttr *attr = NULL);
// Draws the part of the cell not occupied by the control: the base class
// version just fills it with background colour from the attribute
// create a new object which is the copy of this one
virtual wxGridCellEditor *Clone() const = 0;
- // DJC MAPTEK
// added GetValue so we can get the value which is in the control
virtual wxString GetValue() const = 0;
virtual wxGridCellEditor *Clone() const
{ return new wxGridCellTextEditor; }
- // DJC MAPTEK
// added GetValue so we can get the value which is in the control
virtual wxString GetValue() const;
+
protected:
wxTextCtrl *Text() const { return (wxTextCtrl *)m_control; }
// parts of our virtual functions reused by the derived classes
+ void DoCreate(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler,
+ long style = 0);
void DoBeginEdit(const wxString& startValue);
void DoReset(const wxString& startValue);
virtual wxGridCellEditor *Clone() const
{ return new wxGridCellNumberEditor(m_min, m_max); }
- // DJC MAPTEK
+
// added GetValue so we can get the value which is in the control
virtual wxString GetValue() const;
wxEvtHandler* evtHandler);
virtual void SetSize(const wxRect& rect);
- virtual void Show(bool show, wxGridCellAttr *attr = (wxGridCellAttr *)NULL);
+ virtual void Show(bool show, wxGridCellAttr *attr = NULL);
virtual bool IsAcceptedKey(wxKeyEvent& event);
virtual void BeginEdit(int row, int col, wxGrid* grid);
virtual wxGridCellEditor *Clone() const
{ return new wxGridCellBoolEditor; }
- // DJC MAPTEK
- // added GetValue so we can get the value which is in the control
+
+ // added GetValue so we can get the value which is in the control, see
+ // also UseStringValues()
virtual wxString GetValue() const;
+ // set the string values returned by GetValue() for the true and false
+ // states, respectively
+ static void UseStringValues(const wxString& valueTrue = _T("1"),
+ const wxString& valueFalse = wxEmptyString);
+
+ // return true if the given string is equal to the string representation of
+ // true value which we currently use
+ static bool IsTrueValue(const wxString& value);
+
protected:
wxCheckBox *CBox() const { return (wxCheckBox *)m_control; }
private:
bool m_startValue;
+ static wxString ms_stringValues[2];
+
DECLARE_NO_COPY_CLASS(wxGridCellBoolEditor)
};
virtual void SetParameters(const wxString& params);
virtual wxGridCellEditor *Clone() const;
- // DJC MAPTEK
+
// added GetValue so we can get the value which is in the control
virtual wxString GetValue() const;
void GetSize(int *num_rows, int *num_cols) const;
bool GetOverflow() const
{ return m_overflow != SingleCell; }
- wxGridCellRenderer *GetRenderer(wxGrid* grid, int row, int col) const;
- wxGridCellEditor *GetEditor(wxGrid* grid, int row, int col) const;
+ wxGridCellRenderer *GetRenderer(const wxGrid* grid, int row, int col) const;
+ wxGridCellEditor *GetEditor(const wxGrid* grid, int row, int col) const;
bool IsReadOnly() const { return m_isReadOnly == wxGridCellAttr::ReadOnly; }
DECLARE_NO_COPY_CLASS(wxGridCellAttrProvider)
};
-//////////////////////////////////////////////////////////////////////
+// ----------------------------------------------------------------------------
+// wxGridCellCoords: location of a cell in the grid
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxGridCellCoords
+{
+public:
+ wxGridCellCoords() { m_row = m_col = -1; }
+ wxGridCellCoords( int r, int c ) { m_row = r; m_col = c; }
+
+ // default copy ctor is ok
+
+ int GetRow() const { return m_row; }
+ void SetRow( int n ) { m_row = n; }
+ int GetCol() const { return m_col; }
+ void SetCol( int n ) { m_col = n; }
+ void Set( int row, int col ) { m_row = row; m_col = col; }
+
+ wxGridCellCoords& operator=( const wxGridCellCoords& other )
+ {
+ if ( &other != this )
+ {
+ m_row=other.m_row;
+ m_col=other.m_col;
+ }
+ return *this;
+ }
+
+ bool operator==( const wxGridCellCoords& other ) const
+ {
+ return (m_row == other.m_row && m_col == other.m_col);
+ }
+
+ bool operator!=( const wxGridCellCoords& other ) const
+ {
+ return (m_row != other.m_row || m_col != other.m_col);
+ }
+
+ bool operator!() const
+ {
+ return (m_row == -1 && m_col == -1 );
+ }
+
+private:
+ int m_row;
+ int m_col;
+};
+
+
+// For comparisons...
//
-// Grid table classes
+extern WXDLLIMPEXP_ADV wxGridCellCoords wxGridNoCellCoords;
+extern WXDLLIMPEXP_ADV wxRect wxGridNoCellRect;
+
+// An array of cell coords...
//
-//////////////////////////////////////////////////////////////////////
+WX_DECLARE_OBJARRAY_WITH_DECL(wxGridCellCoords, wxGridCellCoordsArray,
+ class WXDLLIMPEXP_ADV);
+// ----------------------------------------------------------------------------
+// Grid table classes
+// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_ADV wxGridTableBase : public wxObject, public wxClientDataContainer
+// the abstract base class
+class WXDLLIMPEXP_ADV wxGridTableBase : public wxObject,
+ public wxClientDataContainer
{
public:
wxGridTableBase();
// You must override these functions in a derived table class
//
+
+ // return the number of rows and columns in this table
virtual int GetNumberRows() = 0;
virtual int GetNumberCols() = 0;
+
+ // the methods above are unfortunately non-const even though they should
+ // have been const -- but changing it now is not possible any longer as it
+ // would break the existing code overriding them, so instead we provide
+ // these const synonyms which can be used from const-correct code
+ int GetRowsCount() const
+ { return const_cast<wxGridTableBase *>(this)->GetNumberRows(); }
+ int GetColsCount() const
+ { return const_cast<wxGridTableBase *>(this)->GetNumberCols(); }
+
+
virtual bool IsEmptyCell( int row, int col ) = 0;
+
+ bool IsEmpty(const wxGridCellCoords& coord)
+ {
+ return IsEmptyCell(coord.GetRow(), coord.GetCol());
+ }
+
virtual wxString GetValue( int row, int col ) = 0;
virtual void SetValue( int row, int col, const wxString& value ) = 0;
// ============================================================================
// ----------------------------------------------------------------------------
-// wxGridCellCoords: location of a cell in the grid
+// wxGrid
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_ADV wxGridCellCoords
+class WXDLLIMPEXP_ADV wxGrid : public wxScrolledWindow
{
public:
- wxGridCellCoords() { m_row = m_col = -1; }
- wxGridCellCoords( int r, int c ) { m_row = r; m_col = c; }
-
- // default copy ctor is ok
-
- int GetRow() const { return m_row; }
- void SetRow( int n ) { m_row = n; }
- int GetCol() const { return m_col; }
- void SetCol( int n ) { m_col = n; }
- void Set( int row, int col ) { m_row = row; m_col = col; }
-
- wxGridCellCoords& operator=( const wxGridCellCoords& other )
+ // possible selection modes
+ enum wxGridSelectionModes
{
- if ( &other != this )
- {
- m_row=other.m_row;
- m_col=other.m_col;
- }
- return *this;
- }
-
- bool operator==( const wxGridCellCoords& other ) const
- {
- return (m_row == other.m_row && m_col == other.m_col);
- }
-
- bool operator!=( const wxGridCellCoords& other ) const
- {
- return (m_row != other.m_row || m_col != other.m_col);
- }
-
- bool operator!() const
- {
- return (m_row == -1 && m_col == -1 );
- }
-
-private:
- int m_row;
- int m_col;
-};
-
-
-// For comparisons...
-//
-extern WXDLLIMPEXP_ADV wxGridCellCoords wxGridNoCellCoords;
-extern WXDLLIMPEXP_ADV wxRect wxGridNoCellRect;
-
-// An array of cell coords...
-//
-WX_DECLARE_OBJARRAY_WITH_DECL(wxGridCellCoords, wxGridCellCoordsArray,
- class WXDLLIMPEXP_ADV);
+ wxGridSelectCells = 0, // allow selecting anything
+ wxGridSelectRows = 1, // allow selecting only entire rows
+ wxGridSelectColumns = 2, // allow selecting only entire columns
+ wxGridSelectRowsOrColumns = wxGridSelectRows | wxGridSelectColumns
+ };
-// ----------------------------------------------------------------------------
-// wxGrid
-// ----------------------------------------------------------------------------
+ // creation and destruction
+ // ------------------------
-class WXDLLIMPEXP_ADV wxGrid : public wxScrolledWindow
-{
-public:
- wxGrid() ;
+ // ctor and Create() create the grid window, as with the other controls
+ wxGrid();
- wxGrid( wxWindow *parent,
+ wxGrid(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxWANTS_CHARS,
- const wxString& name = wxGridNameStr );
+ const wxString& name = wxGridNameStr);
- bool Create( wxWindow *parent,
- wxWindowID id,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = wxWANTS_CHARS,
- const wxString& name = wxGridNameStr );
+ bool Create(wxWindow *parent,
+ wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxWANTS_CHARS,
+ const wxString& name = wxGridNameStr);
virtual ~wxGrid();
- enum wxGridSelectionModes {wxGridSelectCells,
- wxGridSelectRows,
- wxGridSelectColumns};
+ // however to initialize grid data either CreateGrid() or SetTable() must
+ // be also called
+ // this is basically equivalent to
+ //
+ // SetTable(new wxGridStringTable(numRows, numCols), true, selmode)
+ //
bool CreateGrid( int numRows, int numCols,
- wxGrid::wxGridSelectionModes selmode =
- wxGrid::wxGridSelectCells );
+ wxGridSelectionModes selmode = wxGridSelectCells );
+
+ bool SetTable( wxGridTableBase *table,
+ bool takeOwnership = false,
+ wxGridSelectionModes selmode = wxGridSelectCells );
+
+ bool ProcessTableMessage(wxGridTableMessage&);
+
+ wxGridTableBase *GetTable() const { return m_table; }
+
- void SetSelectionMode(wxGrid::wxGridSelectionModes selmode);
- wxGrid::wxGridSelectionModes GetSelectionMode() const;
+ void SetSelectionMode(wxGridSelectionModes selmode);
+ wxGridSelectionModes GetSelectionMode() const;
// ------ grid dimensions
//
- int GetNumberRows() { return m_numRows; }
- int GetNumberCols() { return m_numCols; }
+ int GetNumberRows() const { return m_numRows; }
+ int GetNumberCols() const { return m_numCols; }
// ------ display update functions
//
- wxArrayInt CalcRowLabelsExposed( const wxRegion& reg );
+ wxArrayInt CalcRowLabelsExposed( const wxRegion& reg ) const;
- wxArrayInt CalcColLabelsExposed( const wxRegion& reg );
- wxGridCellCoordsArray CalcCellsExposed( const wxRegion& reg );
+ wxArrayInt CalcColLabelsExposed( const wxRegion& reg ) const;
+ wxGridCellCoordsArray CalcCellsExposed( const wxRegion& reg ) const;
- // ------ event handlers
- //
- void ProcessRowLabelMouseEvent( wxMouseEvent& event );
- void ProcessColLabelMouseEvent( wxMouseEvent& event );
- void ProcessCornerLabelMouseEvent( wxMouseEvent& event );
- void ProcessGridCellMouseEvent( wxMouseEvent& event );
- bool ProcessTableMessage( wxGridTableMessage& );
-
- void DoEndDragResizeRow();
- void DoEndDragResizeCol();
- void DoEndDragMoveCol();
+ void ClearGrid();
+ bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true)
+ {
+ return DoModifyLines(&wxGridTableBase::InsertRows,
+ pos, numRows, updateLabels);
+ }
+ bool InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true)
+ {
+ return DoModifyLines(&wxGridTableBase::InsertCols,
+ pos, numCols, updateLabels);
+ }
- wxGridTableBase * GetTable() const { return m_table; }
- bool SetTable( wxGridTableBase *table, bool takeOwnership = false,
- wxGrid::wxGridSelectionModes selmode =
- wxGrid::wxGridSelectCells );
+ bool AppendRows(int numRows = 1, bool updateLabels = true)
+ {
+ return DoAppendLines(&wxGridTableBase::AppendRows, numRows, updateLabels);
+ }
+ bool AppendCols(int numCols = 1, bool updateLabels = true)
+ {
+ return DoAppendLines(&wxGridTableBase::AppendCols, numCols, updateLabels);
+ }
- void ClearGrid();
- bool InsertRows( int pos = 0, int numRows = 1, bool updateLabels = true );
- bool AppendRows( int numRows = 1, bool updateLabels = true );
- bool DeleteRows( int pos = 0, int numRows = 1, bool updateLabels = true );
- bool InsertCols( int pos = 0, int numCols = 1, bool updateLabels = true );
- bool AppendCols( int numCols = 1, bool updateLabels = true );
- bool DeleteCols( int pos = 0, int numCols = 1, bool updateLabels = true );
+ bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true)
+ {
+ return DoModifyLines(&wxGridTableBase::DeleteRows,
+ pos, numRows, updateLabels);
+ }
+ bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true)
+ {
+ return DoModifyLines(&wxGridTableBase::DeleteCols,
+ pos, numCols, updateLabels);
+ }
void DrawGridCellArea( wxDC& dc , const wxGridCellCoordsArray& cells );
void DrawGridSpace( wxDC& dc );
virtual void DrawColLabels( wxDC& dc, const wxArrayInt& cols );
virtual void DrawColLabel( wxDC& dc, int col );
+ virtual void DrawCornerLabel(wxDC& dc);
// ------ Cell text drawing functions
//
int textOrientation = wxHORIZONTAL );
- // Split a string containing newline chararcters into an array of
+ // Split a string containing newline characters into an array of
// strings and return the number of lines
//
- void StringToLines( const wxString& value, wxArrayString& lines );
+ void StringToLines( const wxString& value, wxArrayString& lines ) const;
void GetTextBoxSize( const wxDC& dc,
const wxArrayString& lines,
- long *width, long *height );
+ long *width, long *height ) const;
// ------
int GetBatchCount() { return m_batchCount; }
- virtual void Refresh(bool eraseb = true,
- const wxRect* rect = (const wxRect *) NULL);
+ virtual void Refresh(bool eraseb = true, const wxRect* rect = NULL);
// Use this, rather than wxWindow::Refresh(), to force an
// immediate repainting of the grid. Has no effect if you are
// grid cells and labels so you will need to convert from device
// coordinates for mouse events etc.
//
- void XYToCell( int x, int y, wxGridCellCoords& );
- int YToRow( int y );
- int XToCol( int x, bool clipToMinMax = false );
+ wxGridCellCoords XYToCell(int x, int y) const;
+ void XYToCell(int x, int y, wxGridCellCoords& coords) const
+ { coords = XYToCell(x, y); }
+ wxGridCellCoords XYToCell(const wxPoint& pos) const
+ { return XYToCell(pos.x, pos.y); }
- int YToEdgeOfRow( int y );
- int XToEdgeOfCol( int x );
+ int YToRow( int y, bool clipToMinMax = false ) const;
+ int XToCol( int x, bool clipToMinMax = false ) const;
- wxRect CellToRect( int row, int col );
- wxRect CellToRect( const wxGridCellCoords& coords )
+ int YToEdgeOfRow( int y ) const;
+ int XToEdgeOfCol( int x ) const;
+
+ wxRect CellToRect( int row, int col ) const;
+ wxRect CellToRect( const wxGridCellCoords& coords ) const
{ return CellToRect( coords.GetRow(), coords.GetCol() ); }
- int GetGridCursorRow() { return m_currentCellCoords.GetRow(); }
- int GetGridCursorCol() { return m_currentCellCoords.GetCol(); }
+ int GetGridCursorRow() const { return m_currentCellCoords.GetRow(); }
+ int GetGridCursorCol() const { return m_currentCellCoords.GetCol(); }
// check to see if a cell is either wholly visible (the default arg) or
// at least partially visible in the grid window
//
- bool IsVisible( int row, int col, bool wholeCellVisible = true );
- bool IsVisible( const wxGridCellCoords& coords, bool wholeCellVisible = true )
+ bool IsVisible( int row, int col, bool wholeCellVisible = true ) const;
+ bool IsVisible( const wxGridCellCoords& coords, bool wholeCellVisible = true ) const
{ return IsVisible( coords.GetRow(), coords.GetCol(), wholeCellVisible ); }
void MakeCellVisible( int row, int col );
void MakeCellVisible( const wxGridCellCoords& coords )
// ------ grid cursor movement functions
//
- void SetGridCursor( int row, int col )
- { SetCurrentCell( wxGridCellCoords(row, col) ); }
+ void SetGridCursor(int row, int col) { SetCurrentCell(row, col); }
+ void SetGridCursor(const wxGridCellCoords& c) { SetCurrentCell(c); }
+
+ void GoToCell(int row, int col)
+ {
+ if ( SetCurrentCell(row, col) )
+ MakeCellVisible(row, col);
+ }
+
+ void GoToCell(const wxGridCellCoords& coords)
+ {
+ if ( SetCurrentCell(coords) )
+ MakeCellVisible(coords);
+ }
bool MoveCursorUp( bool expandSelection );
bool MoveCursorDown( bool expandSelection );
// ------ label and gridline formatting
//
- int GetDefaultRowLabelSize() { return WXGRID_DEFAULT_ROW_LABEL_WIDTH; }
- int GetRowLabelSize() { return m_rowLabelWidth; }
- int GetDefaultColLabelSize() { return WXGRID_DEFAULT_COL_LABEL_HEIGHT; }
- int GetColLabelSize() { return m_colLabelHeight; }
- wxColour GetLabelBackgroundColour() { return m_labelBackgroundColour; }
- wxColour GetLabelTextColour() { return m_labelTextColour; }
- wxFont GetLabelFont() { return m_labelFont; }
- void GetRowLabelAlignment( int *horiz, int *vert );
- void GetColLabelAlignment( int *horiz, int *vert );
- int GetColLabelTextOrientation();
- wxString GetRowLabelValue( int row );
- wxString GetColLabelValue( int col );
- wxColour GetGridLineColour() { return m_gridLineColour; }
-
- // these methods may be overridden to customize individual grid lines
- // appearance
- virtual wxPen GetDefaultGridLinePen();
- virtual wxPen GetRowGridLinePen(int row);
- virtual wxPen GetColGridLinePen(int col);
- wxColour GetCellHighlightColour() { return m_cellHighlightColour; }
- int GetCellHighlightPenWidth() { return m_cellHighlightPenWidth; }
- int GetCellHighlightROPenWidth() { return m_cellHighlightROPenWidth; }
-
+ int GetDefaultRowLabelSize() const { return WXGRID_DEFAULT_ROW_LABEL_WIDTH; }
+ int GetRowLabelSize() const { return m_rowLabelWidth; }
+ int GetDefaultColLabelSize() const { return WXGRID_DEFAULT_COL_LABEL_HEIGHT; }
+ int GetColLabelSize() const { return m_colLabelHeight; }
+ wxColour GetLabelBackgroundColour() const { return m_labelBackgroundColour; }
+ wxColour GetLabelTextColour() const { return m_labelTextColour; }
+ wxFont GetLabelFont() const { return m_labelFont; }
+ void GetRowLabelAlignment( int *horiz, int *vert ) const;
+ void GetColLabelAlignment( int *horiz, int *vert ) const;
+ int GetColLabelTextOrientation() const;
+ wxString GetRowLabelValue( int row ) const;
+ wxString GetColLabelValue( int col ) const;
+
+ wxColour GetCellHighlightColour() const { return m_cellHighlightColour; }
+ int GetCellHighlightPenWidth() const { return m_cellHighlightPenWidth; }
+ int GetCellHighlightROPenWidth() const { return m_cellHighlightROPenWidth; }
+
+ void SetUseNativeColLabels( bool native = true );
void SetRowLabelSize( int width );
void SetColLabelSize( int height );
+ void HideRowLabels() { SetRowLabelSize( 0 ); }
+ void HideColLabels() { SetColLabelSize( 0 ); }
void SetLabelBackgroundColour( const wxColour& );
void SetLabelTextColour( const wxColour& );
void SetLabelFont( const wxFont& );
void SetColLabelTextOrientation( int textOrientation );
void SetRowLabelValue( int row, const wxString& );
void SetColLabelValue( int col, const wxString& );
- void SetGridLineColour( const wxColour& );
void SetCellHighlightColour( const wxColour& );
void SetCellHighlightPenWidth(int width);
void SetCellHighlightROPenWidth(int width);
void EnableDragRowSize( bool enable = true );
void DisableDragRowSize() { EnableDragRowSize( false ); }
- bool CanDragRowSize() { return m_canDragRowSize; }
+ bool CanDragRowSize() const { return m_canDragRowSize; }
void EnableDragColSize( bool enable = true );
void DisableDragColSize() { EnableDragColSize( false ); }
- bool CanDragColSize() { return m_canDragColSize; }
+ bool CanDragColSize() const { return m_canDragColSize; }
void EnableDragColMove( bool enable = true );
void DisableDragColMove() { EnableDragColMove( false ); }
- bool CanDragColMove() { return m_canDragColMove; }
+ bool CanDragColMove() const { return m_canDragColMove; }
void EnableDragGridSize(bool enable = true);
void DisableDragGridSize() { EnableDragGridSize(false); }
- bool CanDragGridSize() { return m_canDragGridSize; }
+ bool CanDragGridSize() const { return m_canDragGridSize; }
void EnableDragCell( bool enable = true );
void DisableDragCell() { EnableDragCell( false ); }
- bool CanDragCell() { return m_canDragCell; }
+ bool CanDragCell() const { return m_canDragCell; }
+
+
+ // grid lines
+ // ----------
+
+ // enable or disable drawing of the lines
+ void EnableGridLines(bool enable = true);
+ bool GridLinesEnabled() const { return m_gridLinesEnabled; }
+
+ // by default grid lines stop at last column/row, but this may be changed
+ void ClipHorzGridLines(bool clip)
+ { DoClipGridLines(m_gridLinesClipHorz, clip); }
+ void ClipVertGridLines(bool clip)
+ { DoClipGridLines(m_gridLinesClipVert, clip); }
+ bool AreHorzGridLinesClipped() const { return m_gridLinesClipHorz; }
+ bool AreVertGridLinesClipped() const { return m_gridLinesClipVert; }
+
+ // this can be used to change the global grid lines colour
+ void SetGridLineColour(const wxColour& col);
+ wxColour GetGridLineColour() const { return m_gridLineColour; }
+
+ // these methods may be overridden to customize individual grid lines
+ // appearance
+ virtual wxPen GetDefaultGridLinePen();
+ virtual wxPen GetRowGridLinePen(int row);
+ virtual wxPen GetColGridLinePen(int col);
+
+
+ // attributes
+ // ----------
// this sets the specified attribute for this cell or in this row/col
void SetAttr(int row, int col, wxGridCellAttr *attr);
void SetColFormatFloat(int col, int width = -1, int precision = -1);
void SetColFormatCustom(int col, const wxString& typeName);
- void EnableGridLines( bool enable = true );
- bool GridLinesEnabled() { return m_gridLinesEnabled; }
-
// ------ row and col formatting
//
- int GetDefaultRowSize();
- int GetRowSize( int row );
- int GetDefaultColSize();
- int GetColSize( int col );
- wxColour GetDefaultCellBackgroundColour();
- wxColour GetCellBackgroundColour( int row, int col );
- wxColour GetDefaultCellTextColour();
- wxColour GetCellTextColour( int row, int col );
- wxFont GetDefaultCellFont();
- wxFont GetCellFont( int row, int col );
- void GetDefaultCellAlignment( int *horiz, int *vert );
- void GetCellAlignment( int row, int col, int *horiz, int *vert );
- bool GetDefaultCellOverflow();
- bool GetCellOverflow( int row, int col );
- void GetCellSize( int row, int col, int *num_rows, int *num_cols );
+ int GetDefaultRowSize() const;
+ int GetRowSize( int row ) const;
+ int GetDefaultColSize() const;
+ int GetColSize( int col ) const;
+ wxColour GetDefaultCellBackgroundColour() const;
+ wxColour GetCellBackgroundColour( int row, int col ) const;
+ wxColour GetDefaultCellTextColour() const;
+ wxColour GetCellTextColour( int row, int col ) const;
+ wxFont GetDefaultCellFont() const;
+ wxFont GetCellFont( int row, int col ) const;
+ void GetDefaultCellAlignment( int *horiz, int *vert ) const;
+ void GetCellAlignment( int row, int col, int *horiz, int *vert ) const;
+ bool GetDefaultCellOverflow() const;
+ bool GetCellOverflow( int row, int col ) const;
+ void GetCellSize( int row, int col, int *num_rows, int *num_cols ) const;
+ wxSize GetCellSize(const wxGridCellCoords& coords)
+ {
+ wxSize s;
+ GetCellSize(coords.GetRow(), coords.GetCol(), &s.x, &s.y);
+ return s;
+ }
void SetDefaultRowSize( int height, bool resizeExistingRows = false );
void SetRowSize( int row, int height );
// setAsMin is true, this optimal width will also be set as minimal width
// for this column
void AutoSizeColumn( int col, bool setAsMin = true )
- { AutoSizeColOrRow(col, setAsMin, true); }
+ { AutoSizeColOrRow(col, setAsMin, wxGRID_COLUMN); }
void AutoSizeRow( int row, bool setAsMin = true )
- { AutoSizeColOrRow(row, setAsMin, false); }
+ { AutoSizeColOrRow(row, setAsMin, wxGRID_ROW); }
// auto size all columns (very ineffective for big grids!)
void AutoSizeColumns( bool setAsMin = true )
// and also set the grid size to just fit its contents
void AutoSize();
+ // Note for both AutoSizeRowLabelSize and AutoSizeColLabelSize:
+ // If col equals to wxGRID_AUTOSIZE value then function autosizes labels column
+ // instead of data column. Note that this operation may be slow for large
+ // tables.
// autosize row height depending on label text
void AutoSizeRowLabelSize( int row );
void SetDefaultRenderer(wxGridCellRenderer *renderer);
void SetCellRenderer(int row, int col, wxGridCellRenderer *renderer);
wxGridCellRenderer *GetDefaultRenderer() const;
- wxGridCellRenderer* GetCellRenderer(int row, int col);
+ wxGridCellRenderer* GetCellRenderer(int row, int col) const;
// takes ownership of the pointer
void SetDefaultEditor(wxGridCellEditor *editor);
void SetCellEditor(int row, int col, wxGridCellEditor *editor);
wxGridCellEditor *GetDefaultEditor() const;
- wxGridCellEditor* GetCellEditor(int row, int col);
+ wxGridCellEditor* GetCellEditor(int row, int col) const;
// ------ cell value accessors
//
- wxString GetCellValue( int row, int col )
+ wxString GetCellValue( int row, int col ) const
{
if ( m_table )
{
}
}
- wxString GetCellValue( const wxGridCellCoords& coords )
+ wxString GetCellValue( const wxGridCellCoords& coords ) const
{ return GetCellValue( coords.GetRow(), coords.GetCol() ); }
void SetCellValue( int row, int col, const wxString& s );
void SelectAll();
- bool IsSelection();
+ bool IsSelection() const;
// ------ deselect blocks or cells
//
// to the client size of the grid window.
//
wxRect BlockToDeviceRect( const wxGridCellCoords & topLeft,
- const wxGridCellCoords & bottomRight );
+ const wxGridCellCoords & bottomRight ) const;
// Access or update the selection fore/back colours
wxColour GetSelectionBackground() const
}
// Accessors for component windows
- wxWindow* GetGridWindow() { return (wxWindow*)m_gridWin; }
- wxWindow* GetGridRowLabelWindow() { return (wxWindow*)m_rowLabelWin; }
- wxWindow* GetGridColLabelWindow() { return (wxWindow*)m_colLabelWin; }
- wxWindow* GetGridCornerLabelWindow() { return (wxWindow*)m_cornerLabelWin; }
+ wxWindow* GetGridWindow() const { return (wxWindow*)m_gridWin; }
+ wxWindow* GetGridRowLabelWindow() const { return (wxWindow*)m_rowLabelWin; }
+ wxWindow* GetGridColLabelWindow() const { return (wxWindow*)m_colLabelWin; }
+ wxWindow* GetGridCornerLabelWindow() const { return (wxWindow*)m_cornerLabelWin; }
// Allow adjustment of scroll increment. The default is (15, 15).
void SetScrollLineX(int x) { m_scrollLineX = x; }
int GetScrollLineX() const { return m_scrollLineX; }
int GetScrollLineY() const { return m_scrollLineY; }
- // Implementation
- int GetScrollX(int x) const
- {
- return (x + GetScrollLineX() - 1) / GetScrollLineX();
- }
-
- int GetScrollY(int y) const
- {
- return (y + GetScrollLineY() - 1) / GetScrollLineY();
- }
-
-
- // override some base class functions
- virtual bool Enable(bool enable = true);
+ // ------- drag and drop
+#if wxUSE_DRAG_AND_DROP
+ virtual void SetDropTarget(wxDropTarget *dropTarget);
+#endif // wxUSE_DRAG_AND_DROP
+#ifdef WXWIN_COMPATIBILITY_2_8
// ------ For compatibility with previous wxGrid only...
//
// ************************************************
: wxScrolledWindow( parent, wxID_ANY, wxPoint(x,y), wxSize(w,h),
(style|wxWANTS_CHARS), name )
{
+ InitVars();
Create();
}
void UpdateDimensions()
{ CalcDimensions(); }
- int GetRows() { return GetNumberRows(); }
- int GetCols() { return GetNumberCols(); }
- int GetCursorRow() { return GetGridCursorRow(); }
- int GetCursorColumn() { return GetGridCursorCol(); }
+ int GetRows() const { return GetNumberRows(); }
+ int GetCols() const { return GetNumberCols(); }
+ int GetCursorRow() const { return GetGridCursorRow(); }
+ int GetCursorColumn() const { return GetGridCursorCol(); }
- int GetScrollPosX() { return 0; }
- int GetScrollPosY() { return 0; }
+ int GetScrollPosX() const { return 0; }
+ int GetScrollPosY() const { return 0; }
void SetScrollX( int WXUNUSED(x) ) { }
void SetScrollY( int WXUNUSED(y) ) { }
void SetColumnWidth( int col, int width )
{ SetColSize( col, width ); }
- int GetColumnWidth( int col )
+ int GetColumnWidth( int col ) const
{ return GetColSize( col ); }
void SetRowHeight( int row, int height )
// GetRowHeight() is below
- int GetViewHeight() // returned num whole rows visible
+ int GetViewHeight() const // returned num whole rows visible
{ return 0; }
- int GetViewWidth() // returned num whole cols visible
+ int GetViewWidth() const // returned num whole cols visible
{ return 0; }
void SetLabelSize( int orientation, int sz )
SetRowLabelSize( sz );
}
- int GetLabelSize( int orientation )
+ int GetLabelSize( int orientation ) const
{
if ( orientation == wxHORIZONTAL )
return GetColLabelSize();
SetRowLabelAlignment( align, -1 );
}
- int GetLabelAlignment( int orientation, int WXUNUSED(align) )
+ int GetLabelAlignment( int orientation, int WXUNUSED(align) ) const
{
int h, v;
if ( orientation == wxHORIZONTAL )
SetRowLabelValue( pos, val );
}
- wxString GetLabelValue( int orientation, int pos)
+ wxString GetLabelValue( int orientation, int pos) const
{
if ( orientation == wxHORIZONTAL )
return GetColLabelValue( pos );
void SetCellBackgroundColour(const wxColour& colour, int row, int col)
{ SetCellBackgroundColour( row, col, colour ); }
- bool GetEditable() { return IsEditable(); }
+ bool GetEditable() const { return IsEditable(); }
void SetEditable( bool edit = true ) { EnableEditing( edit ); }
- bool GetEditInPlace() { return IsCellEditControlEnabled(); }
+ bool GetEditInPlace() const { return IsCellEditControlEnabled(); }
void SetEditInPlace(bool WXUNUSED(edit) = true) { }
wxGRID_CHECKBOX,
wxGRID_CHOICE,
wxGRID_COMBOBOX };
+#endif // WXWIN_COMPATIBILITY_2_8
+
- // overridden wxWindow methods
+ // override some base class functions
+ virtual bool Enable(bool enable = true);
+ virtual wxWindow *GetMainWindowOfCompositeControl()
+ { return (wxWindow*)m_gridWin; }
virtual void Fit();
+ // implementation only
+ void CancelMouseCapture();
+
protected:
virtual wxSize DoGetBestSize() const;
wxGridCellCoords m_currentCellCoords;
- wxGridCellCoords m_selectingTopLeft;
- wxGridCellCoords m_selectingBottomRight;
- wxGridCellCoords m_selectingKeyboard;
+ // the corners of the block being currently selected or wxGridNoCellCoords
+ wxGridCellCoords m_selectedBlockTopLeft;
+ wxGridCellCoords m_selectedBlockBottomRight;
+
+ // when selecting blocks of cells (either from the keyboard using Shift
+ // with cursor keys, or by dragging the mouse), the selection is anchored
+ // at m_currentCellCoords which defines one of the corners of the rectangle
+ // being selected -- and this variable defines the other corner, i.e. it's
+ // either m_selectedBlockTopLeft or m_selectedBlockBottomRight depending on
+ // which of them is not m_currentCellCoords
+ //
+ // if no block selection is in process, it is set to wxGridNoCellCoords
+ wxGridCellCoords m_selectedBlockCorner;
+
wxGridSelection *m_selection;
+
wxColour m_selectionBackground;
wxColour m_selectionForeground;
wxArrayInt m_colWidths;
wxArrayInt m_colRights;
+ bool m_nativeColumnLabels;
+
// get the col/row coords
int GetColWidth(int col) const;
int GetColLeft(int col) const;
wxColour m_gridLineColour;
bool m_gridLinesEnabled;
+ bool m_gridLinesClipHorz,
+ m_gridLinesClipVert;
wxColour m_cellHighlightColour;
int m_cellHighlightPenWidth;
int m_cellHighlightROPenWidth;
int SetOrCalcRowSizes(bool calcOnly, bool setAsMin = true);
// common part of AutoSizeColumn/Row()
- void AutoSizeColOrRow(int n, bool setAsMin, bool column /* or row? */);
+ void AutoSizeColOrRow(int n, bool setAsMin, wxGridDirection direction);
+
+ // Calculate the minimum acceptable size for labels area
+ wxCoord CalcColOrRowLabelAreaMinSize(wxGridDirection direction);
// if a column has a minimal width, it will be the value for it in this
// hash table
int GetRowMinimalHeight(int col) const;
// do we have some place to store attributes in?
- bool CanHaveAttributes();
+ bool CanHaveAttributes() const;
// cell attribute cache (currently we only cache 1, may be will do
// more/better later)
// looks for the attr in cache, if not found asks the table and caches the
// result
wxGridCellAttr *GetCellAttr(int row, int col) const;
- wxGridCellAttr *GetCellAttr(const wxGridCellCoords& coords )
+ wxGridCellAttr *GetCellAttr(const wxGridCellCoords& coords ) const
{ return GetCellAttr( coords.GetRow(), coords.GetCol() ); }
// the default cell attr object for cells that don't have their own
// for this to work, you should always use it and not set m_cursorMode
// directly!
void ChangeCursorMode(CursorMode mode,
- wxWindow *win = (wxWindow *)NULL,
+ wxWindow *win = NULL,
bool captureMouse = true);
wxWindow *m_winCapture; // the window which captured the mouse
+
+ // this variable is used not for finding the correct current cursor but
+ // mainly for finding out what is going to happen if the mouse starts being
+ // dragged right now
+ //
+ // by default it is WXGRID_CURSOR_SELECT_CELL meaning that nothing else is
+ // going on, and it is set to one of RESIZE/SELECT/MOVE values while the
+ // corresponding operation will be started if the user starts dragging the
+ // mouse from the current position
CursorMode m_cursorMode;
+
//Column positions
wxArrayInt m_colAt;
int m_moveToCol;
bool m_canDragColMove;
bool m_canDragGridSize;
bool m_canDragCell;
+
+ // the last position (horizontal or vertical depending on whether the user
+ // is resizing a column or a row) where a row or column separator line was
+ // dragged by the user or -1 of there is no drag operation in progress
int m_dragLastPos;
int m_dragRowOrCol;
+
+ // true if a drag operation is in progress; when this is true,
+ // m_startDragPos is valid, i.e. not wxDefaultPosition
bool m_isDragging;
+
+ // the position (in physical coordinates) where the user started dragging
+ // the mouse or wxDefaultPosition if mouse isn't being dragged
+ //
+ // notice that this can be != wxDefaultPosition while m_isDragging is still
+ // false because we wait until the mouse is moved some distance away before
+ // setting m_isDragging to true
wxPoint m_startDragPos;
bool m_waitForSlowClick;
void Create();
void Init();
+ void InitVars();
void CalcDimensions();
void CalcWindowSizes();
bool Redimension( wxGridTableMessage& );
- int SendEvent( const wxEventType, int row, int col, wxMouseEvent& );
- int SendEvent( const wxEventType, int row, int col );
- int SendEvent( const wxEventType type)
- {
- return SendEvent(type,
- m_currentCellCoords.GetRow(),
- m_currentCellCoords.GetCol());
- }
+ // generate the appropriate grid event and return -1 if it was vetoed, 1 if
+ // it was processed (but not vetoed) and 0 if it wasn't processed
+ int SendEvent(const wxEventType evtType,
+ int row, int col,
+ wxMouseEvent& e);
+ int SendEvent(const wxEventType evtType,
+ const wxGridCellCoords& coords,
+ wxMouseEvent& e)
+ { return SendEvent(evtType, coords.GetRow(), coords.GetCol(), e); }
+ int SendEvent(const wxEventType evtType, int row, int col);
+ int SendEvent(const wxEventType evtType, const wxGridCellCoords& coords)
+ { return SendEvent(evtType, coords.GetRow(), coords.GetCol()); }
+ int SendEvent(const wxEventType evtType)
+ { return SendEvent(evtType, m_currentCellCoords); }
void OnPaint( wxPaintEvent& );
void OnSize( wxSizeEvent& );
void OnEraseBackground( wxEraseEvent& );
- void SetCurrentCell( const wxGridCellCoords& coords );
- void SetCurrentCell( int row, int col )
- { SetCurrentCell( wxGridCellCoords(row, col) ); }
+ bool SetCurrentCell( const wxGridCellCoords& coords );
+ bool SetCurrentCell( int row, int col )
+ { return SetCurrentCell( wxGridCellCoords(row, col) ); }
+
- void HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCol );
+ // this function is called to extend the block being currently selected
+ // from mouse and keyboard event handlers
+ void UpdateBlockBeingSelected(int topRow, int leftCol,
+ int bottomRow, int rightCol);
- void HighlightBlock( const wxGridCellCoords& topLeft,
- const wxGridCellCoords& bottomRight )
- { HighlightBlock( topLeft.GetRow(), topLeft.GetCol(),
- bottomRight.GetRow(), bottomRight.GetCol() ); }
+ void UpdateBlockBeingSelected(const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight)
+ { UpdateBlockBeingSelected(topLeft.GetRow(), topLeft.GetCol(),
+ bottomRight.GetRow(), bottomRight.GetCol()); }
// ------ functions to get/send data (see also public functions)
//
bool GetModelValues();
bool SetModelValues();
- friend class WXDLLIMPEXP_ADV wxGridSelection;
+ friend class WXDLLIMPEXP_FWD_ADV wxGridSelection;
+ friend class wxGridRowOperations;
+ friend class wxGridColumnOperations;
+
+ // they call our private Process{{Corner,Col,Row}Label,GridCell}MouseEvent()
+ friend class wxGridCornerLabelWindow;
+ friend class wxGridColLabelWindow;
+ friend class wxGridRowLabelWindow;
+ friend class wxGridWindow;
+
+private:
+ // implement wxScrolledWindow method to return m_gridWin size
+ virtual wxSize GetSizeAvailableForScrollTarget(const wxSize& size);
+
+ // redraw the grid lines, should be called after changing their attributes
+ void RedrawGridLines();
+
+ // common part of Clip{Horz,Vert}GridLines
+ void DoClipGridLines(bool& var, bool clip);
+
+
+ // event handlers and their helpers
+ // --------------------------------
+
+ // process mouse drag event in WXGRID_CURSOR_SELECT_CELL mode
+ void DoGridCellDrag(wxMouseEvent& event,
+ const wxGridCellCoords& coords,
+ bool isFirstDrag);
+
+ // process row/column resizing drag event
+ void DoGridLineDrag(wxMouseEvent& event, const wxGridOperations& oper);
+
+ // process mouse drag event in the grid window
+ void DoGridDragEvent(wxMouseEvent& event, const wxGridCellCoords& coords);
+
+ // process different clicks on grid cells
+ void DoGridCellLeftDown(wxMouseEvent& event,
+ const wxGridCellCoords& coords,
+ const wxPoint& pos);
+ void DoGridCellLeftDClick(wxMouseEvent& event,
+ const wxGridCellCoords& coords,
+ const wxPoint& pos);
+ void DoGridCellLeftUp(wxMouseEvent& event, const wxGridCellCoords& coords);
+
+ // process movement (but not dragging) event in the grid cell area
+ void DoGridMouseMoveEvent(wxMouseEvent& event,
+ const wxGridCellCoords& coords,
+ const wxPoint& pos);
+
+ // process mouse events in the grid window
+ void ProcessGridCellMouseEvent(wxMouseEvent& event);
+
+ // process mouse events in the row/column labels/corner windows
+ void ProcessRowLabelMouseEvent(wxMouseEvent& event);
+ void ProcessColLabelMouseEvent(wxMouseEvent& event);
+ void ProcessCornerLabelMouseEvent(wxMouseEvent& event);
+
+ void DoEndDragResizeRow();
+ void DoEndDragResizeCol();
+ void DoEndDragMoveCol();
+
+
+ // common implementations of methods defined for both rows and columns
+ void DeselectLine(int line, const wxGridOperations& oper);
+ void DoEndDragResizeLine(const wxGridOperations& oper);
+ int PosToLine(int pos, bool clipToMinMax,
+ const wxGridOperations& oper) const;
+ int PosToEdgeOfLine(int pos, const wxGridOperations& oper) const;
+
+ bool DoMoveCursor(bool expandSelection,
+ const wxGridDirectionOperations& diroper);
+ bool DoMoveCursorByPage(const wxGridDirectionOperations& diroper);
+ bool DoMoveCursorByBlock(bool expandSelection,
+ const wxGridDirectionOperations& diroper);
+ void AdvanceToNextNonEmpty(wxGridCellCoords& coords,
+ const wxGridDirectionOperations& diroper);
+
+ // common part of {Insert,Delete}{Rows,Cols}
+ bool DoModifyLines(bool (wxGridTableBase::*funcModify)(size_t, size_t),
+ int pos, int num, bool updateLabels);
+ // Append{Rows,Cols} is a bit different because of one less parameter
+ bool DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
+ int num, bool updateLabels);
DECLARE_DYNAMIC_CLASS( wxGrid )
DECLARE_EVENT_TABLE()
DECLARE_NO_COPY_CLASS(wxGrid)
};
+// ----------------------------------------------------------------------------
+// wxGridUpdateLocker prevents updates to a grid during its lifetime
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxGridUpdateLocker
+{
+public:
+ // if the pointer is NULL, Create() can be called later
+ wxGridUpdateLocker(wxGrid *grid = NULL)
+ {
+ Init(grid);
+ }
+
+ // can be called if ctor was used with a NULL pointer, must not be called
+ // more than once
+ void Create(wxGrid *grid)
+ {
+ wxASSERT_MSG( !m_grid, _T("shouldn't be called more than once") );
+
+ Init(grid);
+ }
+
+ ~wxGridUpdateLocker()
+ {
+ if ( m_grid )
+ m_grid->EndBatch();
+ }
+
+private:
+ void Init(wxGrid *grid)
+ {
+ m_grid = grid;
+ if ( m_grid )
+ m_grid->BeginBatch();
+ }
+
+ wxGrid *m_grid;
+
+ DECLARE_NO_COPY_CLASS(wxGridUpdateLocker)
+};
// ----------------------------------------------------------------------------
// Grid event class and event types
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_ADV wxGridEvent : public wxNotifyEvent
+class WXDLLIMPEXP_ADV wxGridEvent : public wxNotifyEvent,
+ public wxKeyboardState
{
public:
wxGridEvent()
- : wxNotifyEvent(), m_row(-1), m_col(-1), m_x(-1), m_y(-1),
- m_selecting(0), m_control(0), m_meta(0), m_shift(0), m_alt(0)
- {
- }
+ : wxNotifyEvent()
+ {
+ Init(-1, -1, -1, -1, false);
+ }
+
+ 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())
+ : wxNotifyEvent(type, id),
+ wxKeyboardState(kbd)
+ {
+ Init(row, col, x, y, sel);
+ SetEventObject(obj);
+ }
- 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);
+ // explicitly specifying inline allows gcc < 3.4 to
+ // handle the deprecation attribute even in the constructor.
+ wxDEPRECATED( inline
+ wxGridEvent(int id,
+ wxEventType type,
+ wxObject* obj,
+ int row, int col,
+ int x, int y,
+ bool sel,
+ bool control,
+ bool shift = false, bool alt = false, bool meta = false));
virtual int GetRow() { return m_row; }
virtual int GetCol() { return m_col; }
wxPoint GetPosition() { return wxPoint( m_x, m_y ); }
bool Selecting() { return m_selecting; }
- bool ControlDown() { return m_control; }
- bool MetaDown() { return m_meta; }
- bool ShiftDown() { return m_shift; }
- bool AltDown() { return m_alt; }
- bool CmdDown()
- {
-#if defined(__WXMAC__) || defined(__WXCOCOA__)
- return MetaDown();
-#else
- return ControlDown();
-#endif
- }
virtual wxEvent *Clone() const { return new wxGridEvent(*this); }
int m_x;
int m_y;
bool m_selecting;
- bool m_control;
- bool m_meta;
- bool m_shift;
- bool m_alt;
+
+private:
+ void Init(int row, int col, int x, int y, bool sel)
+ {
+ m_row = row;
+ m_col = col;
+ m_x = x;
+ m_y = y;
+ m_selecting = sel;
+ }
DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridEvent)
};
-class WXDLLIMPEXP_ADV wxGridSizeEvent : public wxNotifyEvent
+class WXDLLIMPEXP_ADV wxGridSizeEvent : public wxNotifyEvent,
+ public wxKeyboardState
{
public:
wxGridSizeEvent()
- : wxNotifyEvent(), m_rowOrCol(-1), m_x(-1), m_y(-1),
- m_control(0), m_meta(0), m_shift(0), m_alt(0)
- {
- }
+ : wxNotifyEvent()
+ {
+ Init(-1, -1, -1);
+ }
- 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);
+ wxGridSizeEvent(int id,
+ wxEventType type,
+ wxObject* obj,
+ int rowOrCol = -1,
+ int x = -1, int y = -1,
+ const wxKeyboardState& kbd = wxKeyboardState())
+ : wxNotifyEvent(type, id),
+ wxKeyboardState(kbd)
+ {
+ Init(rowOrCol, x, y);
+
+ SetEventObject(obj);
+ }
+
+ wxDEPRECATED( inline
+ wxGridSizeEvent(int id,
+ wxEventType type,
+ wxObject* obj,
+ int rowOrCol,
+ int x, int y,
+ bool control,
+ bool shift = false,
+ bool alt = false,
+ bool meta = false) );
int GetRowOrCol() { return m_rowOrCol; }
wxPoint GetPosition() { return wxPoint( m_x, m_y ); }
- bool ControlDown() { return m_control; }
- bool MetaDown() { return m_meta; }
- bool ShiftDown() { return m_shift; }
- bool AltDown() { return m_alt; }
- bool CmdDown()
- {
-#if defined(__WXMAC__) || defined(__WXCOCOA__)
- return MetaDown();
-#else
- return ControlDown();
-#endif
- }
-
+
virtual wxEvent *Clone() const { return new wxGridSizeEvent(*this); }
protected:
int m_rowOrCol;
int m_x;
int m_y;
- bool m_control;
- bool m_meta;
- bool m_shift;
- bool m_alt;
+
+private:
+ void Init(int rowOrCol, int x, int y)
+ {
+ m_rowOrCol = rowOrCol;
+ m_x = x;
+ m_y = y;
+ }
DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridSizeEvent)
};
-class WXDLLIMPEXP_ADV wxGridRangeSelectEvent : public wxNotifyEvent
+class WXDLLIMPEXP_ADV wxGridRangeSelectEvent : public wxNotifyEvent,
+ public wxKeyboardState
{
public:
wxGridRangeSelectEvent()
: wxNotifyEvent()
- {
- m_topLeft = wxGridNoCellCoords;
- m_bottomRight = wxGridNoCellCoords;
- m_selecting = false;
- m_control = false;
- m_meta = false;
- m_shift = false;
- m_alt = false;
- }
+ {
+ Init(wxGridNoCellCoords, wxGridNoCellCoords, false);
+ }
- wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
+ 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);
+ const wxKeyboardState& kbd = wxKeyboardState())
+ : wxNotifyEvent(type, id),
+ wxKeyboardState(kbd)
+ {
+ Init(topLeft, bottomRight, sel);
+
+ SetEventObject(obj);
+ }
+
+ wxDEPRECATED( inline
+ wxGridRangeSelectEvent(int id,
+ wxEventType type,
+ wxObject* obj,
+ const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight,
+ bool sel,
+ bool control,
+ bool shift = false,
+ bool alt = false,
+ bool meta = false) );
wxGridCellCoords GetTopLeftCoords() { return m_topLeft; }
wxGridCellCoords GetBottomRightCoords() { return m_bottomRight; }
int GetLeftCol() { return m_topLeft.GetCol(); }
int GetRightCol() { return m_bottomRight.GetCol(); }
bool Selecting() { return m_selecting; }
- bool ControlDown() { return m_control; }
- bool MetaDown() { return m_meta; }
- bool ShiftDown() { return m_shift; }
- bool AltDown() { return m_alt; }
- bool CmdDown()
- {
-#if defined(__WXMAC__) || defined(__WXCOCOA__)
- return MetaDown();
-#else
- return ControlDown();
-#endif
- }
-
+
virtual wxEvent *Clone() const { return new wxGridRangeSelectEvent(*this); }
protected:
+ void Init(const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight,
+ bool selecting)
+ {
+ m_topLeft = topLeft;
+ m_bottomRight = bottomRight;
+ m_selecting = selecting;
+ }
+
wxGridCellCoords m_topLeft;
wxGridCellCoords m_bottomRight;
bool m_selecting;
- bool m_control;
- bool m_meta;
- bool m_shift;
- bool m_alt;
DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridRangeSelectEvent)
};
-class WXDLLIMPEXP_ADV wxGridEditorCreatedEvent : public wxCommandEvent {
+class WXDLLIMPEXP_ADV wxGridEditorCreatedEvent : public wxCommandEvent
+{
public:
wxGridEditorCreatedEvent()
: wxCommandEvent()
void SetRow(int row) { m_row = row; }
void SetCol(int col) { m_col = col; }
void SetControl(wxControl* ctrl) { m_ctrl = ctrl; }
-
+
virtual wxEvent *Clone() const { return new wxGridEditorCreatedEvent(*this); }
private:
};
-BEGIN_DECLARE_EVENT_TYPES()
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_LEFT_CLICK, 1580)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_RIGHT_CLICK, 1581)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_LEFT_DCLICK, 1582)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_RIGHT_DCLICK, 1583)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_LEFT_CLICK, 1584)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_RIGHT_CLICK, 1585)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_LEFT_DCLICK, 1586)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_RIGHT_DCLICK, 1587)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_ROW_SIZE, 1588)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_COL_SIZE, 1589)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_RANGE_SELECT, 1590)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_CHANGE, 1591)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_SELECT_CELL, 1592)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_SHOWN, 1593)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_HIDDEN, 1594)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_CREATED, 1595)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_BEGIN_DRAG, 1596)
-END_DECLARE_EVENT_TYPES()
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_LEFT_CLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_RIGHT_CLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_LEFT_DCLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_RIGHT_DCLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_LABEL_LEFT_CLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_LABEL_RIGHT_CLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_LABEL_LEFT_DCLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_LABEL_RIGHT_DCLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_ROW_SIZE;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_COL_SIZE;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_RANGE_SELECT;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_CHANGE;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_SELECT_CELL;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_EDITOR_SHOWN;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_EDITOR_HIDDEN;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_EDITOR_CREATED;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_BEGIN_DRAG;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_COL_MOVE;
typedef void (wxEvtHandler::*wxGridEventFunction)(wxGridEvent&);
#define EVT_GRID_CMD_LABEL_RIGHT_DCLICK(id, fn) wx__DECLARE_GRIDEVT(LABEL_RIGHT_DCLICK, id, fn)
#define EVT_GRID_CMD_ROW_SIZE(id, fn) wx__DECLARE_GRIDSIZEEVT(ROW_SIZE, id, fn)
#define EVT_GRID_CMD_COL_SIZE(id, fn) wx__DECLARE_GRIDSIZEEVT(COL_SIZE, id, fn)
+#define EVT_GRID_CMD_COL_MOVE(id, fn) wx__DECLARE_GRIDEVT(COL_MOVE, id, fn)
#define EVT_GRID_CMD_RANGE_SELECT(id, fn) wx__DECLARE_GRIDRANGESELEVT(RANGE_SELECT, id, fn)
#define EVT_GRID_CMD_CELL_CHANGE(id, fn) wx__DECLARE_GRIDEVT(CELL_CHANGE, id, fn)
#define EVT_GRID_CMD_SELECT_CELL(id, fn) wx__DECLARE_GRIDEVT(SELECT_CELL, id, fn)
#define EVT_GRID_LABEL_RIGHT_DCLICK(fn) EVT_GRID_CMD_LABEL_RIGHT_DCLICK(wxID_ANY, fn)
#define EVT_GRID_ROW_SIZE(fn) EVT_GRID_CMD_ROW_SIZE(wxID_ANY, fn)
#define EVT_GRID_COL_SIZE(fn) EVT_GRID_CMD_COL_SIZE(wxID_ANY, fn)
+#define EVT_GRID_COL_MOVE(fn) EVT_GRID_CMD_COL_MOVE(wxID_ANY, fn)
#define EVT_GRID_RANGE_SELECT(fn) EVT_GRID_CMD_RANGE_SELECT(wxID_ANY, fn)
#define EVT_GRID_CELL_CHANGE(fn) EVT_GRID_CMD_CELL_CHANGE(wxID_ANY, fn)
#define EVT_GRID_SELECT_CELL(fn) EVT_GRID_CMD_SELECT_CELL(wxID_ANY, fn)
projects / wxWidgets.git / blobdiff