+ wxDEPRECATED_INLINE(bool CanDragRowSize() const, return m_canDragRowSize; )
+ wxDEPRECATED_INLINE(bool CanDragColSize() const, return m_canDragColSize; )
+#endif // WXWIN_COMPATIBILITY_2_8
+
+
+ // 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;
+
+ bool m_created;
+
+ wxGridWindow *m_gridWin;
+ wxGridCornerLabelWindow *m_cornerLabelWin;
+ wxGridRowLabelWindow *m_rowLabelWin;
+
+ // the real type of the column window depends on m_useNativeHeader value:
+ // if it is true, its dynamic type is wxHeaderCtrl, otherwise it is
+ // wxGridColLabelWindow, use accessors below when the real type matters
+ wxWindow *m_colWindow;
+
+ wxGridColLabelWindow *GetColLabelWindow() const
+ {
+ wxASSERT_MSG( !m_useNativeHeader, "no column label window" );
+
+ return reinterpret_cast<wxGridColLabelWindow *>(m_colWindow);
+ }
+
+ wxGridTableBase *m_table;
+ bool m_ownTable;
+
+ int m_numRows;
+ int m_numCols;
+
+ wxGridCellCoords m_currentCellCoords;
+
+ // 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;
+
+ // NB: *never* access m_row/col arrays directly because they are created
+ // on demand, *always* use accessor functions instead!
+
+ // init the m_rowHeights/Bottoms arrays with default values
+ void InitRowHeights();
+
+ int m_defaultRowHeight;
+ int m_minAcceptableRowHeight;
+ wxArrayInt m_rowHeights;
+ wxArrayInt m_rowBottoms;
+
+ // init the m_colWidths/Rights arrays
+ void InitColWidths();
+
+ int m_defaultColWidth;
+ int m_minAcceptableColWidth;
+ wxArrayInt m_colWidths;
+ wxArrayInt m_colRights;
+
+ int m_sortCol;
+ bool m_sortIsAscending;
+
+ bool m_useNativeHeader,
+ m_nativeColumnLabels;
+
+ // get the col/row coords
+ int GetColWidth(int col) const;
+ int GetColLeft(int col) const;
+ int GetColRight(int col) const;
+
+ // this function must be public for compatibility...
+public:
+ int GetRowHeight(int row) const;
+protected:
+
+ int GetRowTop(int row) const;
+ int GetRowBottom(int row) const;
+
+ int m_rowLabelWidth;
+ int m_colLabelHeight;
+
+ // the size of the margin left to the right and bottom of the cell area
+ int m_extraWidth,
+ m_extraHeight;
+
+ wxColour m_labelBackgroundColour;
+ wxColour m_labelTextColour;
+ wxFont m_labelFont;
+
+ int m_rowLabelHorizAlign;
+ int m_rowLabelVertAlign;
+ int m_colLabelHorizAlign;
+ int m_colLabelVertAlign;
+ int m_colLabelTextOrientation;
+
+ bool m_defaultRowLabelValues;
+ bool m_defaultColLabelValues;
+
+ wxColour m_gridLineColour;
+ bool m_gridLinesEnabled;
+ bool m_gridLinesClipHorz,
+ m_gridLinesClipVert;
+ wxColour m_cellHighlightColour;
+ int m_cellHighlightPenWidth;
+ int m_cellHighlightROPenWidth;
+
+
+ // common part of AutoSizeColumn/Row() and GetBestSize()
+ int SetOrCalcColumnSizes(bool calcOnly, bool setAsMin = true);
+ int SetOrCalcRowSizes(bool calcOnly, bool setAsMin = true);
+
+ // common part of AutoSizeColumn/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
+ wxLongToLongHashMap m_colMinWidths,
+ m_rowMinHeights;
+
+ // get the minimal width of the given column/row
+ int GetColMinimalWidth(int col) const;
+ int GetRowMinimalHeight(int col) const;
+
+ // do we have some place to store attributes in?
+ bool CanHaveAttributes() const;
+
+ // cell attribute cache (currently we only cache 1, may be will do
+ // more/better later)
+ struct CachedAttr
+ {
+ int row, col;
+ wxGridCellAttr *attr;
+ } m_attrCache;
+
+ // invalidates the attribute cache
+ void ClearAttrCache();
+
+ // adds an attribute to cache
+ void CacheAttr(int row, int col, wxGridCellAttr *attr) const;
+
+ // looks for an attr in cache, returns true if found
+ bool LookupAttr(int row, int col, wxGridCellAttr **attr) const;
+
+ // 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 ) const
+ { return GetCellAttr( coords.GetRow(), coords.GetCol() ); }
+
+ // the default cell attr object for cells that don't have their own
+ wxGridCellAttr* m_defaultCellAttr;
+
+
+ bool m_inOnKeyDown;
+ int m_batchCount;
+
+
+ wxGridTypeRegistry* m_typeRegistry;
+
+ enum CursorMode
+ {
+ WXGRID_CURSOR_SELECT_CELL,
+ WXGRID_CURSOR_RESIZE_ROW,
+ WXGRID_CURSOR_RESIZE_COL,
+ WXGRID_CURSOR_SELECT_ROW,
+ WXGRID_CURSOR_SELECT_COL,
+ WXGRID_CURSOR_MOVE_COL
+ };
+
+ // this method not only sets m_cursorMode but also sets the correct cursor
+ // for the given mode and, if captureMouse is not false releases the mouse
+ // if it was captured and captures it if it must be captured
+ //
+ // for this to work, you should always use it and not set m_cursorMode
+ // directly!
+ void ChangeCursorMode(CursorMode mode,
+ 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;
+
+ bool m_canDragRowSize;
+ bool m_canDragColSize;
+ 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;
+
+ wxGridCellCoords m_selectionStart;
+
+ wxCursor m_rowResizeCursor;
+ wxCursor m_colResizeCursor;
+
+ bool m_editable; // applies to whole grid
+ bool m_cellEditCtrlEnabled; // is in-place edit currently shown?
+
+ int m_scrollLineX; // X scroll increment
+ int m_scrollLineY; // Y scroll increment
+
+ void Init(); // common part of all ctors
+ void Create();
+ void CreateColumnWindow();
+ void CalcDimensions();
+ void CalcWindowSizes();
+ bool Redimension( wxGridTableMessage& );
+
+
+ // 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,
+ const wxMouseEvent& e);
+ int SendEvent(const wxEventType evtType,
+ const wxGridCellCoords& coords,
+ const wxMouseEvent& e)
+ { return SendEvent(evtType, coords.GetRow(), coords.GetCol(), e); }
+ int SendEvent(const wxEventType evtType,
+ int row, int col,
+ const wxString& s = wxString());
+ int SendEvent(const wxEventType evtType,
+ const wxGridCellCoords& coords,
+ const wxString& s = wxString())
+ { return SendEvent(evtType, coords.GetRow(), coords.GetCol(), s); }
+ int SendEvent(const wxEventType evtType, const wxString& s = wxString())
+ { return SendEvent(evtType, m_currentCellCoords, s); }
+
+ // send wxEVT_GRID_{ROW,COL}_SIZE
+ void SendGridSizeEvent(wxEventType type,
+ int row, int col,
+ const wxMouseEvent& mouseEv);
+
+ void OnPaint( wxPaintEvent& );
+ void OnSize( wxSizeEvent& );
+ void OnKeyDown( wxKeyEvent& );
+ void OnKeyUp( wxKeyEvent& );
+ void OnChar( wxKeyEvent& );
+ void OnEraseBackground( wxEraseEvent& );
+
+
+ bool SetCurrentCell( const wxGridCellCoords& coords );
+ bool SetCurrentCell( int row, int col )
+ { return SetCurrentCell( wxGridCellCoords(row, col) ); }
+
+
+ // 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 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_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;
+ friend class wxGridHeaderRenderer;
+
+ friend class wxGridHeaderCtrl;
+
+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);
+
+ // update the sorting indicator shown in the specified column (whose index
+ // must be valid)
+ //
+ // this will use GetSortingColumn() and IsSortOrderAscending() to determine
+ // the sorting indicator to effectively show
+ void UpdateColumnSortingIndicator(int col);
+
+ // update the grid after changing the columns order (common part of
+ // SetColPos() and ResetColPos())
+ void RefreshAfterColPosChange();
+
+
+ // return the position (not index) of the column at the given logical pixel
+ // position
+ //
+ // this always returns a valid position, even if the coordinate is out of
+ // bounds (in which case first/last column is returned)
+ int XToPos(int x) const;
+
+
+ // 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 DoColHeaderClick(int col);
+
+ void DoStartResizeCol(int col);
+ void DoUpdateResizeCol(int x);
+ void DoUpdateResizeColWidth(int w);
+ void DoStartMoveCol(int col);
+
+ void DoEndDragResizeRow(const wxMouseEvent& event);
+ void DoEndDragResizeCol(const wxMouseEvent& event);
+ void DoEndMoveCol(int pos);
+
+
+ // common implementations of methods defined for both rows and columns
+ void DeselectLine(int line, const wxGridOperations& oper);
+ bool DoEndDragResizeLine(const wxGridOperations& oper);
+ int PosToLinePos(int pos, bool clipToMinMax,
+ const wxGridOperations& oper) const;
+ 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);
+
+ // common part of Set{Col,Row}Sizes
+ void DoSetSizes(const wxGridSizesInfo& sizeInfo,
+ const wxGridOperations& oper);
+
+ // common part of Disable{Row,Col}Resize and CanDrag{Row,Col}Size
+ void DoDisableLineResize(int line, wxGridFixedIndicesSet *& setFixed);
+ bool DoCanResizeLine(int line, const wxGridFixedIndicesSet *setFixed) const;
+
+
+
+ // these sets contain the indices of fixed, i.e. non-resizable
+ // interactively, grid rows or columns and are NULL if there are no fixed
+ // elements (which is the default)
+ wxGridFixedIndicesSet *m_setFixedRows,
+ *m_setFixedCols;
+