]> git.saurik.com Git - wxWidgets.git/blob - include/wx/generic/grid.h
removing outdated code
[wxWidgets.git] / include / wx / generic / grid.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/generic/grid.h
3 // Purpose: wxGrid and related classes
4 // Author: Michael Bedward (based on code by Julian Smart, Robin Dunn)
5 // Modified by: Santiago Palacios
6 // Created: 1/08/1999
7 // RCS-ID: $Id$
8 // Copyright: (c) Michael Bedward
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_GENERIC_GRID_H_
13 #define _WX_GENERIC_GRID_H_
14
15 #include "wx/defs.h"
16
17 #if wxUSE_GRID
18
19 #include "wx/hashmap.h"
20
21 #include "wx/scrolwin.h"
22
23 // ----------------------------------------------------------------------------
24 // constants
25 // ----------------------------------------------------------------------------
26
27 extern WXDLLIMPEXP_DATA_ADV(const char) wxGridNameStr[];
28
29 // Default parameters for wxGrid
30 //
31 #define WXGRID_DEFAULT_NUMBER_ROWS 10
32 #define WXGRID_DEFAULT_NUMBER_COLS 10
33 #if defined(__WXMSW__) || defined(__WXGTK20__)
34 #define WXGRID_DEFAULT_ROW_HEIGHT 25
35 #else
36 #define WXGRID_DEFAULT_ROW_HEIGHT 30
37 #endif // __WXMSW__
38 #define WXGRID_DEFAULT_COL_WIDTH 80
39 #define WXGRID_DEFAULT_COL_LABEL_HEIGHT 32
40 #define WXGRID_DEFAULT_ROW_LABEL_WIDTH 82
41 #define WXGRID_LABEL_EDGE_ZONE 2
42 #define WXGRID_MIN_ROW_HEIGHT 15
43 #define WXGRID_MIN_COL_WIDTH 15
44 #define WXGRID_DEFAULT_SCROLLBAR_WIDTH 16
45
46 // type names for grid table values
47 #define wxGRID_VALUE_STRING wxT("string")
48 #define wxGRID_VALUE_BOOL wxT("bool")
49 #define wxGRID_VALUE_NUMBER wxT("long")
50 #define wxGRID_VALUE_FLOAT wxT("double")
51 #define wxGRID_VALUE_CHOICE wxT("choice")
52
53 #define wxGRID_VALUE_TEXT wxGRID_VALUE_STRING
54 #define wxGRID_VALUE_LONG wxGRID_VALUE_NUMBER
55
56 // magic constant which tells (to some functions) to automatically calculate
57 // the appropriate size
58 #define wxGRID_AUTOSIZE (-1)
59
60 // many wxGrid methods work either with columns or rows, this enum is used for
61 // the parameter indicating which one should it be
62 enum wxGridDirection
63 {
64 wxGRID_COLUMN,
65 wxGRID_ROW
66 };
67
68 // Flags used with wxGrid::Render() to select parts of the grid to draw.
69 enum wxGridRenderStyle
70 {
71 wxGRID_DRAW_ROWS_HEADER = 0x001,
72 wxGRID_DRAW_COLS_HEADER = 0x002,
73 wxGRID_DRAW_CELL_LINES = 0x004,
74 wxGRID_DRAW_BOX_RECT = 0x008,
75 wxGRID_DRAW_SELECTION = 0x010,
76 wxGRID_DRAW_DEFAULT = wxGRID_DRAW_ROWS_HEADER |
77 wxGRID_DRAW_COLS_HEADER |
78 wxGRID_DRAW_CELL_LINES |
79 wxGRID_DRAW_BOX_RECT
80 };
81
82 // ----------------------------------------------------------------------------
83 // forward declarations
84 // ----------------------------------------------------------------------------
85
86 class WXDLLIMPEXP_FWD_ADV wxGrid;
87 class WXDLLIMPEXP_FWD_ADV wxGridCellAttr;
88 class WXDLLIMPEXP_FWD_ADV wxGridCellAttrProviderData;
89 class WXDLLIMPEXP_FWD_ADV wxGridColLabelWindow;
90 class WXDLLIMPEXP_FWD_ADV wxGridCornerLabelWindow;
91 class WXDLLIMPEXP_FWD_ADV wxGridRowLabelWindow;
92 class WXDLLIMPEXP_FWD_ADV wxGridWindow;
93 class WXDLLIMPEXP_FWD_ADV wxGridTypeRegistry;
94 class WXDLLIMPEXP_FWD_ADV wxGridSelection;
95
96 class WXDLLIMPEXP_FWD_CORE wxHeaderCtrl;
97 class WXDLLIMPEXP_FWD_CORE wxCheckBox;
98 class WXDLLIMPEXP_FWD_CORE wxComboBox;
99 class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
100 #if wxUSE_SPINCTRL
101 class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
102 #endif
103
104 class wxGridFixedIndicesSet;
105
106 class wxGridOperations;
107 class wxGridRowOperations;
108 class wxGridColumnOperations;
109 class wxGridDirectionOperations;
110
111
112 // ----------------------------------------------------------------------------
113 // macros
114 // ----------------------------------------------------------------------------
115
116 #define wxSafeIncRef(p) if ( p ) (p)->IncRef()
117 #define wxSafeDecRef(p) if ( p ) (p)->DecRef()
118
119 // ----------------------------------------------------------------------------
120 // wxGridCellWorker: common base class for wxGridCellRenderer and
121 // wxGridCellEditor
122 //
123 // NB: this is more an implementation convenience than a design issue, so this
124 // class is not documented and is not public at all
125 // ----------------------------------------------------------------------------
126
127 class WXDLLIMPEXP_ADV wxGridCellWorker : public wxClientDataContainer, public wxRefCounter
128 {
129 public:
130 wxGridCellWorker() { }
131
132 // interpret renderer parameters: arbitrary string whose interpretation is
133 // left to the derived classes
134 virtual void SetParameters(const wxString& params);
135
136 protected:
137 // virtual dtor for any base class - private because only DecRef() can
138 // delete us
139 virtual ~wxGridCellWorker();
140
141 private:
142 // suppress the stupid gcc warning about the class having private dtor and
143 // no friends
144 friend class wxGridCellWorkerDummyFriend;
145 };
146
147 // ----------------------------------------------------------------------------
148 // wxGridCellRenderer: this class is responsible for actually drawing the cell
149 // in the grid. You may pass it to the wxGridCellAttr (below) to change the
150 // format of one given cell or to wxGrid::SetDefaultRenderer() to change the
151 // view of all cells. This is an ABC, you will normally use one of the
152 // predefined derived classes or derive your own class from it.
153 // ----------------------------------------------------------------------------
154
155 class WXDLLIMPEXP_ADV wxGridCellRenderer : public wxGridCellWorker
156 {
157 public:
158 // draw the given cell on the provided DC inside the given rectangle
159 // using the style specified by the attribute and the default or selected
160 // state corresponding to the isSelected value.
161 //
162 // this pure virtual function has a default implementation which will
163 // prepare the DC using the given attribute: it will draw the rectangle
164 // with the bg colour from attr and set the text colour and font
165 virtual void Draw(wxGrid& grid,
166 wxGridCellAttr& attr,
167 wxDC& dc,
168 const wxRect& rect,
169 int row, int col,
170 bool isSelected) = 0;
171
172 // get the preferred size of the cell for its contents
173 virtual wxSize GetBestSize(wxGrid& grid,
174 wxGridCellAttr& attr,
175 wxDC& dc,
176 int row, int col) = 0;
177
178 // create a new object which is the copy of this one
179 virtual wxGridCellRenderer *Clone() const = 0;
180 };
181
182 // ----------------------------------------------------------------------------
183 // wxGridCellEditor: This class is responsible for providing and manipulating
184 // the in-place edit controls for the grid. Instances of wxGridCellEditor
185 // (actually, instances of derived classes since it is an ABC) can be
186 // associated with the cell attributes for individual cells, rows, columns, or
187 // even for the entire grid.
188 // ----------------------------------------------------------------------------
189
190 class WXDLLIMPEXP_ADV wxGridCellEditor : public wxGridCellWorker
191 {
192 public:
193 wxGridCellEditor();
194
195 bool IsCreated() { return m_control != NULL; }
196 wxControl* GetControl() { return m_control; }
197 void SetControl(wxControl* control) { m_control = control; }
198
199 wxGridCellAttr* GetCellAttr() { return m_attr; }
200 void SetCellAttr(wxGridCellAttr* attr) { m_attr = attr; }
201
202 // Creates the actual edit control
203 virtual void Create(wxWindow* parent,
204 wxWindowID id,
205 wxEvtHandler* evtHandler) = 0;
206
207 // Size and position the edit control
208 virtual void SetSize(const wxRect& rect);
209
210 // Show or hide the edit control, use the specified attributes to set
211 // colours/fonts for it
212 virtual void Show(bool show, wxGridCellAttr *attr = NULL);
213
214 // Draws the part of the cell not occupied by the control: the base class
215 // version just fills it with background colour from the attribute
216 virtual void PaintBackground(wxDC& dc,
217 const wxRect& rectCell,
218 const wxGridCellAttr& attr);
219
220
221 // The methods called by wxGrid when a cell is edited: first BeginEdit() is
222 // called, then EndEdit() is and if it returns true and if the change is
223 // not vetoed by a user-defined event handler, finally ApplyEdit() is called
224
225 // Fetch the value from the table and prepare the edit control
226 // to begin editing. Set the focus to the edit control.
227 virtual void BeginEdit(int row, int col, wxGrid* grid) = 0;
228
229 // Returns false if nothing changed, otherwise returns true and return the
230 // new value in its string form in the newval output parameter.
231 //
232 // This should also store the new value in its real type internally so that
233 // it could be used by ApplyEdit() but it must not modify the grid as the
234 // change could still be vetoed.
235 virtual bool EndEdit(int row, int col, const wxGrid *grid,
236 const wxString& oldval, wxString *newval) = 0;
237
238 // Complete the editing of the current cell by storing the value saved by
239 // the previous call to EndEdit() in the grid
240 virtual void ApplyEdit(int row, int col, wxGrid* grid) = 0;
241
242
243 // Reset the value in the control back to its starting value
244 virtual void Reset() = 0;
245
246 // return true to allow the given key to start editing: the base class
247 // version only checks that the event has no modifiers. The derived
248 // classes are supposed to do "if ( base::IsAcceptedKey() && ... )" in
249 // their IsAcceptedKey() implementation, although, of course, it is not a
250 // mandatory requirment.
251 //
252 // NB: if the key is F2 (special), editing will always start and this
253 // method will not be called at all (but StartingKey() will)
254 virtual bool IsAcceptedKey(wxKeyEvent& event);
255
256 // If the editor is enabled by pressing keys on the grid, this will be
257 // called to let the editor do something about that first key if desired
258 virtual void StartingKey(wxKeyEvent& event);
259
260 // if the editor is enabled by clicking on the cell, this method will be
261 // called
262 virtual void StartingClick();
263
264 // Some types of controls on some platforms may need some help
265 // with the Return key.
266 virtual void HandleReturn(wxKeyEvent& event);
267
268 // Final cleanup
269 virtual void Destroy();
270
271 // create a new object which is the copy of this one
272 virtual wxGridCellEditor *Clone() const = 0;
273
274 // added GetValue so we can get the value which is in the control
275 virtual wxString GetValue() const = 0;
276
277 protected:
278 // the dtor is private because only DecRef() can delete us
279 virtual ~wxGridCellEditor();
280
281 // the control we show on screen
282 wxControl* m_control;
283
284 // a temporary pointer to the attribute being edited
285 wxGridCellAttr* m_attr;
286
287 // if we change the colours/font of the control from the default ones, we
288 // must restore the default later and we save them here between calls to
289 // Show(true) and Show(false)
290 wxColour m_colFgOld,
291 m_colBgOld;
292 wxFont m_fontOld;
293
294 // suppress the stupid gcc warning about the class having private dtor and
295 // no friends
296 friend class wxGridCellEditorDummyFriend;
297
298 wxDECLARE_NO_COPY_CLASS(wxGridCellEditor);
299 };
300
301 // ----------------------------------------------------------------------------
302 // wxGridHeaderRenderer and company: like wxGridCellRenderer but for headers
303 // ----------------------------------------------------------------------------
304
305 // Base class for corner window renderer: it is the simplest of all renderers
306 // and only has a single function
307 class WXDLLIMPEXP_ADV wxGridCornerHeaderRenderer
308 {
309 public:
310 // Draw the border around the corner window.
311 virtual void DrawBorder(const wxGrid& grid,
312 wxDC& dc,
313 wxRect& rect) const = 0;
314
315 // make the dtor of a class with virtual functions virtual to avoid g++
316 // warnings, even though this class is not supposed to be used
317 // polymorphically
318 virtual ~wxGridCornerHeaderRenderer() { }
319 };
320
321
322 // Base class for the row/column header cells renderers
323 class WXDLLIMPEXP_ADV wxGridHeaderLabelsRenderer
324 : public wxGridCornerHeaderRenderer
325 {
326 public:
327 // Draw header cell label
328 virtual void DrawLabel(const wxGrid& grid,
329 wxDC& dc,
330 const wxString& value,
331 const wxRect& rect,
332 int horizAlign,
333 int vertAlign,
334 int textOrientation) const;
335 };
336
337 // Currently the row/column/corner renders don't need any methods other than
338 // those already in wxGridHeaderLabelsRenderer but still define separate classes
339 // for them for future extensions and also for better type safety (i.e. to
340 // avoid inadvertently using a column header renderer for the row headers)
341 class WXDLLIMPEXP_ADV wxGridRowHeaderRenderer
342 : public wxGridHeaderLabelsRenderer
343 {
344 };
345
346 class WXDLLIMPEXP_ADV wxGridColumnHeaderRenderer
347 : public wxGridHeaderLabelsRenderer
348 {
349 };
350
351 // Also define the default renderers which are used by wxGridCellAttrProvider
352 // by default
353 class WXDLLIMPEXP_ADV wxGridRowHeaderRendererDefault
354 : public wxGridRowHeaderRenderer
355 {
356 public:
357 virtual void DrawBorder(const wxGrid& grid,
358 wxDC& dc,
359 wxRect& rect) const;
360 };
361
362 // Column header cells renderers
363 class WXDLLIMPEXP_ADV wxGridColumnHeaderRendererDefault
364 : public wxGridColumnHeaderRenderer
365 {
366 public:
367 virtual void DrawBorder(const wxGrid& grid,
368 wxDC& dc,
369 wxRect& rect) const;
370 };
371
372 // Header corner renderer
373 class WXDLLIMPEXP_ADV wxGridCornerHeaderRendererDefault
374 : public wxGridCornerHeaderRenderer
375 {
376 public:
377 virtual void DrawBorder(const wxGrid& grid,
378 wxDC& dc,
379 wxRect& rect) const;
380 };
381
382
383 // ----------------------------------------------------------------------------
384 // wxGridCellAttr: this class can be used to alter the cells appearance in
385 // the grid by changing their colour/font/... from default. An object of this
386 // class may be returned by wxGridTable::GetAttr().
387 // ----------------------------------------------------------------------------
388
389 class WXDLLIMPEXP_ADV wxGridCellAttr : public wxClientDataContainer, public wxRefCounter
390 {
391 public:
392 enum wxAttrKind
393 {
394 Any,
395 Default,
396 Cell,
397 Row,
398 Col,
399 Merged
400 };
401
402 // ctors
403 wxGridCellAttr(wxGridCellAttr *attrDefault = NULL)
404 {
405 Init(attrDefault);
406
407 SetAlignment(wxALIGN_INVALID, wxALIGN_INVALID);
408 }
409
410 // VZ: considering the number of members wxGridCellAttr has now, this ctor
411 // seems to be pretty useless... may be we should just remove it?
412 wxGridCellAttr(const wxColour& colText,
413 const wxColour& colBack,
414 const wxFont& font,
415 int hAlign,
416 int vAlign)
417 : m_colText(colText), m_colBack(colBack), m_font(font)
418 {
419 Init();
420 SetAlignment(hAlign, vAlign);
421 }
422
423 // creates a new copy of this object
424 wxGridCellAttr *Clone() const;
425 void MergeWith(wxGridCellAttr *mergefrom);
426
427 // setters
428 void SetTextColour(const wxColour& colText) { m_colText = colText; }
429 void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; }
430 void SetFont(const wxFont& font) { m_font = font; }
431 void SetAlignment(int hAlign, int vAlign)
432 {
433 m_hAlign = hAlign;
434 m_vAlign = vAlign;
435 }
436 void SetSize(int num_rows, int num_cols);
437 void SetOverflow(bool allow = true)
438 { m_overflow = allow ? Overflow : SingleCell; }
439 void SetReadOnly(bool isReadOnly = true)
440 { m_isReadOnly = isReadOnly ? ReadOnly : ReadWrite; }
441
442 // takes ownership of the pointer
443 void SetRenderer(wxGridCellRenderer *renderer)
444 { wxSafeDecRef(m_renderer); m_renderer = renderer; }
445 void SetEditor(wxGridCellEditor* editor)
446 { wxSafeDecRef(m_editor); m_editor = editor; }
447
448 void SetKind(wxAttrKind kind) { m_attrkind = kind; }
449
450 // accessors
451 bool HasTextColour() const { return m_colText.IsOk(); }
452 bool HasBackgroundColour() const { return m_colBack.IsOk(); }
453 bool HasFont() const { return m_font.IsOk(); }
454 bool HasAlignment() const
455 {
456 return m_hAlign != wxALIGN_INVALID || m_vAlign != wxALIGN_INVALID;
457 }
458 bool HasRenderer() const { return m_renderer != NULL; }
459 bool HasEditor() const { return m_editor != NULL; }
460 bool HasReadWriteMode() const { return m_isReadOnly != Unset; }
461 bool HasOverflowMode() const { return m_overflow != UnsetOverflow; }
462 bool HasSize() const { return m_sizeRows != 1 || m_sizeCols != 1; }
463
464 const wxColour& GetTextColour() const;
465 const wxColour& GetBackgroundColour() const;
466 const wxFont& GetFont() const;
467 void GetAlignment(int *hAlign, int *vAlign) const;
468
469 // unlike GetAlignment() which always overwrites its output arguments with
470 // the alignment values to use, falling back on default alignment if this
471 // attribute doesn't have any, this function will preserve the values of
472 // parameters on entry if the corresponding alignment is not set in this
473 // attribute meaning that they can be initialized to default alignment (and
474 // also that they must be initialized, unlike with GetAlignment())
475 void GetNonDefaultAlignment(int *hAlign, int *vAlign) const;
476
477 void GetSize(int *num_rows, int *num_cols) const;
478 bool GetOverflow() const
479 { return m_overflow != SingleCell; }
480 wxGridCellRenderer *GetRenderer(const wxGrid* grid, int row, int col) const;
481 wxGridCellEditor *GetEditor(const wxGrid* grid, int row, int col) const;
482
483 bool IsReadOnly() const { return m_isReadOnly == wxGridCellAttr::ReadOnly; }
484
485 wxAttrKind GetKind() { return m_attrkind; }
486
487 void SetDefAttr(wxGridCellAttr* defAttr) { m_defGridAttr = defAttr; }
488
489 protected:
490 // the dtor is private because only DecRef() can delete us
491 virtual ~wxGridCellAttr()
492 {
493 wxSafeDecRef(m_renderer);
494 wxSafeDecRef(m_editor);
495 }
496
497 private:
498 enum wxAttrReadMode
499 {
500 Unset = -1,
501 ReadWrite,
502 ReadOnly
503 };
504
505 enum wxAttrOverflowMode
506 {
507 UnsetOverflow = -1,
508 Overflow,
509 SingleCell
510 };
511
512 // the common part of all ctors
513 void Init(wxGridCellAttr *attrDefault = NULL);
514
515
516 wxColour m_colText,
517 m_colBack;
518 wxFont m_font;
519 int m_hAlign,
520 m_vAlign;
521 int m_sizeRows,
522 m_sizeCols;
523
524 wxAttrOverflowMode m_overflow;
525
526 wxGridCellRenderer* m_renderer;
527 wxGridCellEditor* m_editor;
528 wxGridCellAttr* m_defGridAttr;
529
530 wxAttrReadMode m_isReadOnly;
531
532 wxAttrKind m_attrkind;
533
534 // use Clone() instead
535 wxDECLARE_NO_COPY_CLASS(wxGridCellAttr);
536
537 // suppress the stupid gcc warning about the class having private dtor and
538 // no friends
539 friend class wxGridCellAttrDummyFriend;
540 };
541
542 // ----------------------------------------------------------------------------
543 // wxGridCellAttrProvider: class used by wxGridTableBase to retrieve/store the
544 // cell attributes.
545 // ----------------------------------------------------------------------------
546
547 // implementation note: we separate it from wxGridTableBase because we wish to
548 // avoid deriving a new table class if possible, and sometimes it will be
549 // enough to just derive another wxGridCellAttrProvider instead
550 //
551 // the default implementation is reasonably efficient for the generic case,
552 // but you might still wish to implement your own for some specific situations
553 // if you have performance problems with the stock one
554 class WXDLLIMPEXP_ADV wxGridCellAttrProvider : public wxClientDataContainer
555 {
556 public:
557 wxGridCellAttrProvider();
558 virtual ~wxGridCellAttrProvider();
559
560 // DecRef() must be called on the returned pointer
561 virtual wxGridCellAttr *GetAttr(int row, int col,
562 wxGridCellAttr::wxAttrKind kind ) const;
563
564 // all these functions take ownership of the pointer, don't call DecRef()
565 // on it
566 virtual void SetAttr(wxGridCellAttr *attr, int row, int col);
567 virtual void SetRowAttr(wxGridCellAttr *attr, int row);
568 virtual void SetColAttr(wxGridCellAttr *attr, int col);
569
570 // these functions must be called whenever some rows/cols are deleted
571 // because the internal data must be updated then
572 void UpdateAttrRows( size_t pos, int numRows );
573 void UpdateAttrCols( size_t pos, int numCols );
574
575
576 // get renderers for the given row/column header label and the corner
577 // window: unlike cell renderers, these objects are not reference counted
578 // and are never NULL so they are returned by reference
579 virtual const wxGridColumnHeaderRenderer& GetColumnHeaderRenderer(int col);
580 virtual const wxGridRowHeaderRenderer& GetRowHeaderRenderer(int row);
581 virtual const wxGridCornerHeaderRenderer& GetCornerRenderer();
582
583 private:
584 void InitData();
585
586 wxGridCellAttrProviderData *m_data;
587
588 wxDECLARE_NO_COPY_CLASS(wxGridCellAttrProvider);
589 };
590
591 // ----------------------------------------------------------------------------
592 // wxGridCellCoords: location of a cell in the grid
593 // ----------------------------------------------------------------------------
594
595 class WXDLLIMPEXP_ADV wxGridCellCoords
596 {
597 public:
598 wxGridCellCoords() { m_row = m_col = -1; }
599 wxGridCellCoords( int r, int c ) { m_row = r; m_col = c; }
600
601 // default copy ctor is ok
602
603 int GetRow() const { return m_row; }
604 void SetRow( int n ) { m_row = n; }
605 int GetCol() const { return m_col; }
606 void SetCol( int n ) { m_col = n; }
607 void Set( int row, int col ) { m_row = row; m_col = col; }
608
609 wxGridCellCoords& operator=( const wxGridCellCoords& other )
610 {
611 if ( &other != this )
612 {
613 m_row=other.m_row;
614 m_col=other.m_col;
615 }
616 return *this;
617 }
618
619 bool operator==( const wxGridCellCoords& other ) const
620 {
621 return (m_row == other.m_row && m_col == other.m_col);
622 }
623
624 bool operator!=( const wxGridCellCoords& other ) const
625 {
626 return (m_row != other.m_row || m_col != other.m_col);
627 }
628
629 bool operator!() const
630 {
631 return (m_row == -1 && m_col == -1 );
632 }
633
634 private:
635 int m_row;
636 int m_col;
637 };
638
639
640 // For comparisons...
641 //
642 extern WXDLLIMPEXP_ADV wxGridCellCoords wxGridNoCellCoords;
643 extern WXDLLIMPEXP_ADV wxRect wxGridNoCellRect;
644
645 // An array of cell coords...
646 //
647 WX_DECLARE_OBJARRAY_WITH_DECL(wxGridCellCoords, wxGridCellCoordsArray,
648 class WXDLLIMPEXP_ADV);
649
650 // ----------------------------------------------------------------------------
651 // Grid table classes
652 // ----------------------------------------------------------------------------
653
654 // the abstract base class
655 class WXDLLIMPEXP_ADV wxGridTableBase : public wxObject,
656 public wxClientDataContainer
657 {
658 public:
659 wxGridTableBase();
660 virtual ~wxGridTableBase();
661
662 // You must override these functions in a derived table class
663 //
664
665 // return the number of rows and columns in this table
666 virtual int GetNumberRows() = 0;
667 virtual int GetNumberCols() = 0;
668
669 // the methods above are unfortunately non-const even though they should
670 // have been const -- but changing it now is not possible any longer as it
671 // would break the existing code overriding them, so instead we provide
672 // these const synonyms which can be used from const-correct code
673 int GetRowsCount() const
674 { return const_cast<wxGridTableBase *>(this)->GetNumberRows(); }
675 int GetColsCount() const
676 { return const_cast<wxGridTableBase *>(this)->GetNumberCols(); }
677
678
679 virtual bool IsEmptyCell( int row, int col )
680 {
681 return GetValue(row, col).empty();
682 }
683
684 bool IsEmpty(const wxGridCellCoords& coord)
685 {
686 return IsEmptyCell(coord.GetRow(), coord.GetCol());
687 }
688
689 virtual wxString GetValue( int row, int col ) = 0;
690 virtual void SetValue( int row, int col, const wxString& value ) = 0;
691
692 // Data type determination and value access
693 virtual wxString GetTypeName( int row, int col );
694 virtual bool CanGetValueAs( int row, int col, const wxString& typeName );
695 virtual bool CanSetValueAs( int row, int col, const wxString& typeName );
696
697 virtual long GetValueAsLong( int row, int col );
698 virtual double GetValueAsDouble( int row, int col );
699 virtual bool GetValueAsBool( int row, int col );
700
701 virtual void SetValueAsLong( int row, int col, long value );
702 virtual void SetValueAsDouble( int row, int col, double value );
703 virtual void SetValueAsBool( int row, int col, bool value );
704
705 // For user defined types
706 virtual void* GetValueAsCustom( int row, int col, const wxString& typeName );
707 virtual void SetValueAsCustom( int row, int col, const wxString& typeName, void* value );
708
709
710 // Overriding these is optional
711 //
712 virtual void SetView( wxGrid *grid ) { m_view = grid; }
713 virtual wxGrid * GetView() const { return m_view; }
714
715 virtual void Clear() {}
716 virtual bool InsertRows( size_t pos = 0, size_t numRows = 1 );
717 virtual bool AppendRows( size_t numRows = 1 );
718 virtual bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
719 virtual bool InsertCols( size_t pos = 0, size_t numCols = 1 );
720 virtual bool AppendCols( size_t numCols = 1 );
721 virtual bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
722
723 virtual wxString GetRowLabelValue( int row );
724 virtual wxString GetColLabelValue( int col );
725 virtual void SetRowLabelValue( int WXUNUSED(row), const wxString& ) {}
726 virtual void SetColLabelValue( int WXUNUSED(col), const wxString& ) {}
727
728 // Attribute handling
729 //
730
731 // give us the attr provider to use - we take ownership of the pointer
732 void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
733
734 // get the currently used attr provider (may be NULL)
735 wxGridCellAttrProvider *GetAttrProvider() const { return m_attrProvider; }
736
737 // Does this table allow attributes? Default implementation creates
738 // a wxGridCellAttrProvider if necessary.
739 virtual bool CanHaveAttributes();
740
741 // by default forwarded to wxGridCellAttrProvider if any. May be
742 // overridden to handle attributes directly in the table.
743 virtual wxGridCellAttr *GetAttr( int row, int col,
744 wxGridCellAttr::wxAttrKind kind );
745
746
747 // these functions take ownership of the pointer
748 virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
749 virtual void SetRowAttr(wxGridCellAttr *attr, int row);
750 virtual void SetColAttr(wxGridCellAttr *attr, int col);
751
752 private:
753 wxGrid * m_view;
754 wxGridCellAttrProvider *m_attrProvider;
755
756 DECLARE_ABSTRACT_CLASS(wxGridTableBase)
757 wxDECLARE_NO_COPY_CLASS(wxGridTableBase);
758 };
759
760
761 // ----------------------------------------------------------------------------
762 // wxGridTableMessage
763 // ----------------------------------------------------------------------------
764
765 // IDs for messages sent from grid table to view
766 //
767 enum wxGridTableRequest
768 {
769 wxGRIDTABLE_REQUEST_VIEW_GET_VALUES = 2000,
770 wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES,
771 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
772 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
773 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
774 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
775 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
776 wxGRIDTABLE_NOTIFY_COLS_DELETED
777 };
778
779 class WXDLLIMPEXP_ADV wxGridTableMessage
780 {
781 public:
782 wxGridTableMessage();
783 wxGridTableMessage( wxGridTableBase *table, int id,
784 int comInt1 = -1,
785 int comInt2 = -1 );
786
787 void SetTableObject( wxGridTableBase *table ) { m_table = table; }
788 wxGridTableBase * GetTableObject() const { return m_table; }
789 void SetId( int id ) { m_id = id; }
790 int GetId() { return m_id; }
791 void SetCommandInt( int comInt1 ) { m_comInt1 = comInt1; }
792 int GetCommandInt() { return m_comInt1; }
793 void SetCommandInt2( int comInt2 ) { m_comInt2 = comInt2; }
794 int GetCommandInt2() { return m_comInt2; }
795
796 private:
797 wxGridTableBase *m_table;
798 int m_id;
799 int m_comInt1;
800 int m_comInt2;
801
802 wxDECLARE_NO_COPY_CLASS(wxGridTableMessage);
803 };
804
805
806
807 // ------ wxGridStringArray
808 // A 2-dimensional array of strings for data values
809 //
810
811 WX_DECLARE_OBJARRAY_WITH_DECL(wxArrayString, wxGridStringArray,
812 class WXDLLIMPEXP_ADV);
813
814
815
816 // ------ wxGridStringTable
817 //
818 // Simplest type of data table for a grid for small tables of strings
819 // that are stored in memory
820 //
821
822 class WXDLLIMPEXP_ADV wxGridStringTable : public wxGridTableBase
823 {
824 public:
825 wxGridStringTable();
826 wxGridStringTable( int numRows, int numCols );
827
828 // these are pure virtual in wxGridTableBase
829 //
830 virtual int GetNumberRows() { return static_cast<int>(m_data.size()); }
831 virtual int GetNumberCols() { return m_numCols; }
832 virtual wxString GetValue( int row, int col );
833 virtual void SetValue( int row, int col, const wxString& s );
834
835 // overridden functions from wxGridTableBase
836 //
837 void Clear();
838 bool InsertRows( size_t pos = 0, size_t numRows = 1 );
839 bool AppendRows( size_t numRows = 1 );
840 bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
841 bool InsertCols( size_t pos = 0, size_t numCols = 1 );
842 bool AppendCols( size_t numCols = 1 );
843 bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
844
845 void SetRowLabelValue( int row, const wxString& );
846 void SetColLabelValue( int col, const wxString& );
847 wxString GetRowLabelValue( int row );
848 wxString GetColLabelValue( int col );
849
850 private:
851 wxGridStringArray m_data;
852
853 // notice that while we don't need to store the number of our rows as it's
854 // always equal to the size of m_data array, we do need to store the number
855 // of our columns as we can't retrieve it from m_data when the number of
856 // rows is 0 (see #10818)
857 int m_numCols;
858
859 // These only get used if you set your own labels, otherwise the
860 // GetRow/ColLabelValue functions return wxGridTableBase defaults
861 //
862 wxArrayString m_rowLabels;
863 wxArrayString m_colLabels;
864
865 DECLARE_DYNAMIC_CLASS_NO_COPY( wxGridStringTable )
866 };
867
868
869
870 // ============================================================================
871 // Grid view classes
872 // ============================================================================
873
874 // ----------------------------------------------------------------------------
875 // wxGridSizesInfo stores information about sizes of the rows or columns.
876 //
877 // It assumes that most of the columns or rows have default size and so stores
878 // the default size separately and uses a hash to map column or row numbers to
879 // their non default size for those which don't have the default size.
880 // ----------------------------------------------------------------------------
881
882 // hash map to store positions as the keys and sizes as the values
883 WX_DECLARE_HASH_MAP_WITH_DECL( unsigned, int, wxIntegerHash, wxIntegerEqual,
884 wxUnsignedToIntHashMap, class WXDLLIMPEXP_ADV );
885
886 struct WXDLLIMPEXP_ADV wxGridSizesInfo
887 {
888 // default ctor, initialize m_sizeDefault and m_customSizes later
889 wxGridSizesInfo() { }
890
891 // ctor used by wxGrid::Get{Col,Row}Sizes()
892 wxGridSizesInfo(int defSize, const wxArrayInt& allSizes);
893
894 // default copy ctor, assignment operator and dtor are ok
895
896 // Get the size of the element with the given index
897 int GetSize(unsigned pos) const;
898
899
900 // default size
901 int m_sizeDefault;
902
903 // position -> size map containing all elements with non-default size
904 wxUnsignedToIntHashMap m_customSizes;
905 };
906
907 // ----------------------------------------------------------------------------
908 // wxGrid
909 // ----------------------------------------------------------------------------
910
911 class WXDLLIMPEXP_ADV wxGrid : public wxScrolledWindow
912 {
913 public:
914 // possible selection modes
915 enum wxGridSelectionModes
916 {
917 wxGridSelectCells = 0, // allow selecting anything
918 wxGridSelectRows = 1, // allow selecting only entire rows
919 wxGridSelectColumns = 2, // allow selecting only entire columns
920 wxGridSelectRowsOrColumns = wxGridSelectRows | wxGridSelectColumns
921 };
922
923 // Different behaviour of the TAB key when the end (or the beginning, for
924 // Shift-TAB) of the current row is reached:
925 enum TabBehaviour
926 {
927 Tab_Stop, // Do nothing, this is default.
928 Tab_Wrap, // Move to the next (or previous) row.
929 Tab_Leave // Move to the next (or previous) control.
930 };
931
932 // creation and destruction
933 // ------------------------
934
935 // ctor and Create() create the grid window, as with the other controls
936 wxGrid() { Init(); }
937
938 wxGrid(wxWindow *parent,
939 wxWindowID id,
940 const wxPoint& pos = wxDefaultPosition,
941 const wxSize& size = wxDefaultSize,
942 long style = wxWANTS_CHARS,
943 const wxString& name = wxGridNameStr)
944 {
945 Init();
946
947 Create(parent, id, pos, size, style, name);
948 }
949
950 bool Create(wxWindow *parent,
951 wxWindowID id,
952 const wxPoint& pos = wxDefaultPosition,
953 const wxSize& size = wxDefaultSize,
954 long style = wxWANTS_CHARS,
955 const wxString& name = wxGridNameStr);
956
957 virtual ~wxGrid();
958
959 // however to initialize grid data either CreateGrid() or SetTable() must
960 // be also called
961
962 // this is basically equivalent to
963 //
964 // SetTable(new wxGridStringTable(numRows, numCols), true, selmode)
965 //
966 bool CreateGrid( int numRows, int numCols,
967 wxGridSelectionModes selmode = wxGridSelectCells );
968
969 bool SetTable( wxGridTableBase *table,
970 bool takeOwnership = false,
971 wxGridSelectionModes selmode = wxGridSelectCells );
972
973 bool ProcessTableMessage(wxGridTableMessage&);
974
975 wxGridTableBase *GetTable() const { return m_table; }
976
977
978 void SetSelectionMode(wxGridSelectionModes selmode);
979 wxGridSelectionModes GetSelectionMode() const;
980
981 // ------ grid dimensions
982 //
983 int GetNumberRows() const { return m_numRows; }
984 int GetNumberCols() const { return m_numCols; }
985
986
987 // ------ display update functions
988 //
989 wxArrayInt CalcRowLabelsExposed( const wxRegion& reg ) const;
990
991 wxArrayInt CalcColLabelsExposed( const wxRegion& reg ) const;
992 wxGridCellCoordsArray CalcCellsExposed( const wxRegion& reg ) const;
993
994
995 void ClearGrid();
996 bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true)
997 {
998 return DoModifyLines(&wxGridTableBase::InsertRows,
999 pos, numRows, updateLabels);
1000 }
1001 bool InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true)
1002 {
1003 return DoModifyLines(&wxGridTableBase::InsertCols,
1004 pos, numCols, updateLabels);
1005 }
1006
1007 bool AppendRows(int numRows = 1, bool updateLabels = true)
1008 {
1009 return DoAppendLines(&wxGridTableBase::AppendRows, numRows, updateLabels);
1010 }
1011 bool AppendCols(int numCols = 1, bool updateLabels = true)
1012 {
1013 return DoAppendLines(&wxGridTableBase::AppendCols, numCols, updateLabels);
1014 }
1015
1016 bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true)
1017 {
1018 return DoModifyLines(&wxGridTableBase::DeleteRows,
1019 pos, numRows, updateLabels);
1020 }
1021 bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true)
1022 {
1023 return DoModifyLines(&wxGridTableBase::DeleteCols,
1024 pos, numCols, updateLabels);
1025 }
1026
1027 void DrawGridCellArea( wxDC& dc , const wxGridCellCoordsArray& cells );
1028 void DrawGridSpace( wxDC& dc );
1029 void DrawCellBorder( wxDC& dc, const wxGridCellCoords& );
1030 void DrawAllGridLines( wxDC& dc, const wxRegion & reg );
1031 void DrawCell( wxDC& dc, const wxGridCellCoords& );
1032 void DrawHighlight(wxDC& dc, const wxGridCellCoordsArray& cells);
1033
1034 // this function is called when the current cell highlight must be redrawn
1035 // and may be overridden by the user
1036 virtual void DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr );
1037
1038 virtual void DrawRowLabels( wxDC& dc, const wxArrayInt& rows );
1039 virtual void DrawRowLabel( wxDC& dc, int row );
1040
1041 virtual void DrawColLabels( wxDC& dc, const wxArrayInt& cols );
1042 virtual void DrawColLabel( wxDC& dc, int col );
1043
1044 virtual void DrawCornerLabel(wxDC& dc);
1045
1046 // ------ Cell text drawing functions
1047 //
1048 void DrawTextRectangle( wxDC& dc, const wxString&, const wxRect&,
1049 int horizontalAlignment = wxALIGN_LEFT,
1050 int verticalAlignment = wxALIGN_TOP,
1051 int textOrientation = wxHORIZONTAL ) const;
1052
1053 void DrawTextRectangle( wxDC& dc, const wxArrayString& lines, const wxRect&,
1054 int horizontalAlignment = wxALIGN_LEFT,
1055 int verticalAlignment = wxALIGN_TOP,
1056 int textOrientation = wxHORIZONTAL ) const;
1057
1058 // ------ grid render function for printing
1059 //
1060 void Render( wxDC& dc,
1061 const wxPoint& pos = wxDefaultPosition,
1062 const wxSize& size = wxDefaultSize,
1063 const wxGridCellCoords& topLeft = wxGridCellCoords(-1, -1),
1064 const wxGridCellCoords& bottomRight = wxGridCellCoords(-1, -1),
1065 int style = wxGRID_DRAW_DEFAULT );
1066
1067 // Split a string containing newline characters into an array of
1068 // strings and return the number of lines
1069 //
1070 void StringToLines( const wxString& value, wxArrayString& lines ) const;
1071
1072 void GetTextBoxSize( const wxDC& dc,
1073 const wxArrayString& lines,
1074 long *width, long *height ) const;
1075
1076
1077 // ------
1078 // Code that does a lot of grid modification can be enclosed
1079 // between BeginBatch() and EndBatch() calls to avoid screen
1080 // flicker
1081 //
1082 void BeginBatch() { m_batchCount++; }
1083 void EndBatch();
1084
1085 int GetBatchCount() { return m_batchCount; }
1086
1087 virtual void Refresh(bool eraseb = true, const wxRect* rect = NULL);
1088
1089 // Use this, rather than wxWindow::Refresh(), to force an
1090 // immediate repainting of the grid. Has no effect if you are
1091 // already inside a BeginBatch / EndBatch block.
1092 //
1093 // This function is necessary because wxGrid has a minimal OnPaint()
1094 // handler to reduce screen flicker.
1095 //
1096 void ForceRefresh();
1097
1098
1099 // ------ edit control functions
1100 //
1101 bool IsEditable() const { return m_editable; }
1102 void EnableEditing( bool edit );
1103
1104 void EnableCellEditControl( bool enable = true );
1105 void DisableCellEditControl() { EnableCellEditControl(false); }
1106 bool CanEnableCellControl() const;
1107 bool IsCellEditControlEnabled() const;
1108 bool IsCellEditControlShown() const;
1109
1110 bool IsCurrentCellReadOnly() const;
1111
1112 void ShowCellEditControl();
1113 void HideCellEditControl();
1114 void SaveEditControlValue();
1115
1116
1117 // ------ grid location functions
1118 // Note that all of these functions work with the logical coordinates of
1119 // grid cells and labels so you will need to convert from device
1120 // coordinates for mouse events etc.
1121 //
1122 wxGridCellCoords XYToCell(int x, int y) const;
1123 void XYToCell(int x, int y, wxGridCellCoords& coords) const
1124 { coords = XYToCell(x, y); }
1125 wxGridCellCoords XYToCell(const wxPoint& pos) const
1126 { return XYToCell(pos.x, pos.y); }
1127
1128 // these functions return the index of the row/columns corresponding to the
1129 // given logical position in pixels
1130 //
1131 // if clipToMinMax is false (default, wxNOT_FOUND is returned if the
1132 // position is outside any row/column, otherwise the first/last element is
1133 // returned in this case
1134 int YToRow( int y, bool clipToMinMax = false ) const;
1135 int XToCol( int x, bool clipToMinMax = false ) const;
1136
1137 int YToEdgeOfRow( int y ) const;
1138 int XToEdgeOfCol( int x ) const;
1139
1140 wxRect CellToRect( int row, int col ) const;
1141 wxRect CellToRect( const wxGridCellCoords& coords ) const
1142 { return CellToRect( coords.GetRow(), coords.GetCol() ); }
1143
1144 int GetGridCursorRow() const { return m_currentCellCoords.GetRow(); }
1145 int GetGridCursorCol() const { return m_currentCellCoords.GetCol(); }
1146
1147 // check to see if a cell is either wholly visible (the default arg) or
1148 // at least partially visible in the grid window
1149 //
1150 bool IsVisible( int row, int col, bool wholeCellVisible = true ) const;
1151 bool IsVisible( const wxGridCellCoords& coords, bool wholeCellVisible = true ) const
1152 { return IsVisible( coords.GetRow(), coords.GetCol(), wholeCellVisible ); }
1153 void MakeCellVisible( int row, int col );
1154 void MakeCellVisible( const wxGridCellCoords& coords )
1155 { MakeCellVisible( coords.GetRow(), coords.GetCol() ); }
1156
1157
1158 // ------ grid cursor movement functions
1159 //
1160 void SetGridCursor(int row, int col) { SetCurrentCell(row, col); }
1161 void SetGridCursor(const wxGridCellCoords& c) { SetCurrentCell(c); }
1162
1163 void GoToCell(int row, int col)
1164 {
1165 if ( SetCurrentCell(row, col) )
1166 MakeCellVisible(row, col);
1167 }
1168
1169 void GoToCell(const wxGridCellCoords& coords)
1170 {
1171 if ( SetCurrentCell(coords) )
1172 MakeCellVisible(coords);
1173 }
1174
1175 bool MoveCursorUp( bool expandSelection );
1176 bool MoveCursorDown( bool expandSelection );
1177 bool MoveCursorLeft( bool expandSelection );
1178 bool MoveCursorRight( bool expandSelection );
1179 bool MovePageDown();
1180 bool MovePageUp();
1181 bool MoveCursorUpBlock( bool expandSelection );
1182 bool MoveCursorDownBlock( bool expandSelection );
1183 bool MoveCursorLeftBlock( bool expandSelection );
1184 bool MoveCursorRightBlock( bool expandSelection );
1185
1186 void SetTabBehaviour(TabBehaviour behaviour) { m_tabBehaviour = behaviour; }
1187
1188
1189 // ------ label and gridline formatting
1190 //
1191 int GetDefaultRowLabelSize() const { return WXGRID_DEFAULT_ROW_LABEL_WIDTH; }
1192 int GetRowLabelSize() const { return m_rowLabelWidth; }
1193 int GetDefaultColLabelSize() const { return WXGRID_DEFAULT_COL_LABEL_HEIGHT; }
1194 int GetColLabelSize() const { return m_colLabelHeight; }
1195 wxColour GetLabelBackgroundColour() const { return m_labelBackgroundColour; }
1196 wxColour GetLabelTextColour() const { return m_labelTextColour; }
1197 wxFont GetLabelFont() const { return m_labelFont; }
1198 void GetRowLabelAlignment( int *horiz, int *vert ) const;
1199 void GetColLabelAlignment( int *horiz, int *vert ) const;
1200 int GetColLabelTextOrientation() const;
1201 wxString GetRowLabelValue( int row ) const;
1202 wxString GetColLabelValue( int col ) const;
1203
1204 wxColour GetCellHighlightColour() const { return m_cellHighlightColour; }
1205 int GetCellHighlightPenWidth() const { return m_cellHighlightPenWidth; }
1206 int GetCellHighlightROPenWidth() const { return m_cellHighlightROPenWidth; }
1207
1208 // this one will use wxHeaderCtrl for the column labels
1209 void UseNativeColHeader(bool native = true);
1210
1211 // this one will still draw them manually but using the native renderer
1212 // instead of using the same appearance as for the row labels
1213 void SetUseNativeColLabels( bool native = true );
1214
1215 void SetRowLabelSize( int width );
1216 void SetColLabelSize( int height );
1217 void HideRowLabels() { SetRowLabelSize( 0 ); }
1218 void HideColLabels() { SetColLabelSize( 0 ); }
1219 void SetLabelBackgroundColour( const wxColour& );
1220 void SetLabelTextColour( const wxColour& );
1221 void SetLabelFont( const wxFont& );
1222 void SetRowLabelAlignment( int horiz, int vert );
1223 void SetColLabelAlignment( int horiz, int vert );
1224 void SetColLabelTextOrientation( int textOrientation );
1225 void SetRowLabelValue( int row, const wxString& );
1226 void SetColLabelValue( int col, const wxString& );
1227 void SetCellHighlightColour( const wxColour& );
1228 void SetCellHighlightPenWidth(int width);
1229 void SetCellHighlightROPenWidth(int width);
1230
1231
1232 // interactive grid mouse operations control
1233 // -----------------------------------------
1234
1235 // functions globally enabling row/column interactive resizing (enabled by
1236 // default)
1237 void EnableDragRowSize( bool enable = true );
1238 void DisableDragRowSize() { EnableDragRowSize( false ); }
1239
1240 void EnableDragColSize( bool enable = true );
1241 void DisableDragColSize() { EnableDragColSize( false ); }
1242
1243 // if interactive resizing is enabled, some rows/columns can still have
1244 // fixed size
1245 void DisableRowResize(int row) { DoDisableLineResize(row, m_setFixedRows); }
1246 void DisableColResize(int col) { DoDisableLineResize(col, m_setFixedCols); }
1247
1248 // these functions return whether the given row/column can be
1249 // effectively resized: for this interactive resizing must be enabled
1250 // and this index must not have been passed to DisableRow/ColResize()
1251 bool CanDragRowSize(int row) const
1252 { return m_canDragRowSize && DoCanResizeLine(row, m_setFixedRows); }
1253 bool CanDragColSize(int col) const
1254 { return m_canDragColSize && DoCanResizeLine(col, m_setFixedCols); }
1255
1256 // interactive column reordering (disabled by default)
1257 void EnableDragColMove( bool enable = true );
1258 void DisableDragColMove() { EnableDragColMove( false ); }
1259 bool CanDragColMove() const { return m_canDragColMove; }
1260
1261 // interactive resizing of grid cells (enabled by default)
1262 void EnableDragGridSize(bool enable = true);
1263 void DisableDragGridSize() { EnableDragGridSize(false); }
1264 bool CanDragGridSize() const { return m_canDragGridSize; }
1265
1266 // interactive dragging of cells (disabled by default)
1267 void EnableDragCell( bool enable = true );
1268 void DisableDragCell() { EnableDragCell( false ); }
1269 bool CanDragCell() const { return m_canDragCell; }
1270
1271
1272 // grid lines
1273 // ----------
1274
1275 // enable or disable drawing of the lines
1276 void EnableGridLines(bool enable = true);
1277 bool GridLinesEnabled() const { return m_gridLinesEnabled; }
1278
1279 // by default grid lines stop at last column/row, but this may be changed
1280 void ClipHorzGridLines(bool clip)
1281 { DoClipGridLines(m_gridLinesClipHorz, clip); }
1282 void ClipVertGridLines(bool clip)
1283 { DoClipGridLines(m_gridLinesClipVert, clip); }
1284 bool AreHorzGridLinesClipped() const { return m_gridLinesClipHorz; }
1285 bool AreVertGridLinesClipped() const { return m_gridLinesClipVert; }
1286
1287 // this can be used to change the global grid lines colour
1288 void SetGridLineColour(const wxColour& col);
1289 wxColour GetGridLineColour() const { return m_gridLineColour; }
1290
1291 // these methods may be overridden to customize individual grid lines
1292 // appearance
1293 virtual wxPen GetDefaultGridLinePen();
1294 virtual wxPen GetRowGridLinePen(int row);
1295 virtual wxPen GetColGridLinePen(int col);
1296
1297
1298 // attributes
1299 // ----------
1300
1301 // this sets the specified attribute for this cell or in this row/col
1302 void SetAttr(int row, int col, wxGridCellAttr *attr);
1303 void SetRowAttr(int row, wxGridCellAttr *attr);
1304 void SetColAttr(int col, wxGridCellAttr *attr);
1305
1306 // the grid can cache attributes for the recently used cells (currently it
1307 // only caches one attribute for the most recently used one) and might
1308 // notice that its value in the attribute provider has changed -- if this
1309 // happens, call this function to force it
1310 void RefreshAttr(int row, int col);
1311
1312 // returns the attribute we may modify in place: a new one if this cell
1313 // doesn't have any yet or the existing one if it does
1314 //
1315 // DecRef() must be called on the returned pointer, as usual
1316 wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
1317
1318
1319 // shortcuts for setting the column parameters
1320
1321 // set the format for the data in the column: default is string
1322 void SetColFormatBool(int col);
1323 void SetColFormatNumber(int col);
1324 void SetColFormatFloat(int col, int width = -1, int precision = -1);
1325 void SetColFormatCustom(int col, const wxString& typeName);
1326
1327 // ------ row and col formatting
1328 //
1329 int GetDefaultRowSize() const;
1330 int GetRowSize( int row ) const;
1331 bool IsRowShown(int row) const { return GetRowSize(row) != 0; }
1332 int GetDefaultColSize() const;
1333 int GetColSize( int col ) const;
1334 bool IsColShown(int col) const { return GetColSize(col) != 0; }
1335 wxColour GetDefaultCellBackgroundColour() const;
1336 wxColour GetCellBackgroundColour( int row, int col ) const;
1337 wxColour GetDefaultCellTextColour() const;
1338 wxColour GetCellTextColour( int row, int col ) const;
1339 wxFont GetDefaultCellFont() const;
1340 wxFont GetCellFont( int row, int col ) const;
1341 void GetDefaultCellAlignment( int *horiz, int *vert ) const;
1342 void GetCellAlignment( int row, int col, int *horiz, int *vert ) const;
1343 bool GetDefaultCellOverflow() const;
1344 bool GetCellOverflow( int row, int col ) const;
1345
1346 // this function returns 1 in num_rows and num_cols for normal cells,
1347 // positive numbers for a cell spanning multiple columns/rows (as set with
1348 // SetCellSize()) and _negative_ numbers corresponding to the offset of the
1349 // top left cell of the span from this one for the other cells covered by
1350 // this cell
1351 //
1352 // the return value is CellSpan_None, CellSpan_Main or CellSpan_Inside for
1353 // each of these cases respectively
1354 enum CellSpan
1355 {
1356 CellSpan_Inside = -1,
1357 CellSpan_None = 0,
1358 CellSpan_Main
1359 };
1360
1361 CellSpan GetCellSize( int row, int col, int *num_rows, int *num_cols ) const;
1362
1363 wxSize GetCellSize(const wxGridCellCoords& coords)
1364 {
1365 wxSize s;
1366 GetCellSize(coords.GetRow(), coords.GetCol(), &s.x, &s.y);
1367 return s;
1368 }
1369
1370 // ------ row and col sizes
1371 void SetDefaultRowSize( int height, bool resizeExistingRows = false );
1372 void SetRowSize( int row, int height );
1373 void HideRow(int row) { DoSetRowSize(row, 0); }
1374 void ShowRow(int row) { DoSetRowSize(row, -1); }
1375
1376 void SetDefaultColSize( int width, bool resizeExistingCols = false );
1377 void SetColSize( int col, int width );
1378 void HideCol(int col) { DoSetColSize(col, 0); }
1379 void ShowCol(int col) { DoSetColSize(col, -1); }
1380
1381 // the row and column sizes can be also set all at once using
1382 // wxGridSizesInfo which holds all of them at once
1383
1384 wxGridSizesInfo GetColSizes() const
1385 { return wxGridSizesInfo(GetDefaultColSize(), m_colWidths); }
1386 wxGridSizesInfo GetRowSizes() const
1387 { return wxGridSizesInfo(GetDefaultRowSize(), m_rowHeights); }
1388
1389 void SetColSizes(const wxGridSizesInfo& sizeInfo);
1390 void SetRowSizes(const wxGridSizesInfo& sizeInfo);
1391
1392
1393 // ------- columns (only, for now) reordering
1394
1395 // columns index <-> positions mapping: by default, the position of the
1396 // column is the same as its index, but the columns can also be reordered
1397 // (either by calling SetColPos() explicitly or by the user dragging the
1398 // columns around) in which case their indices don't correspond to their
1399 // positions on display any longer
1400 //
1401 // internally we always work with indices except for the functions which
1402 // have "Pos" in their names (and which work with columns, not pixels) and
1403 // only the display and hit testing code really cares about display
1404 // positions at all
1405
1406 // set the positions of all columns at once (this method uses the same
1407 // conventions as wxHeaderCtrl::SetColumnsOrder() for the order array)
1408 void SetColumnsOrder(const wxArrayInt& order);
1409
1410 // return the column index corresponding to the given (valid) position
1411 int GetColAt(int pos) const
1412 {
1413 return m_colAt.empty() ? pos : m_colAt[pos];
1414 }
1415
1416 // reorder the columns so that the column with the given index is now shown
1417 // as the position pos
1418 void SetColPos(int idx, int pos);
1419
1420 // return the position at which the column with the given index is
1421 // displayed: notice that this is a slow operation as we don't maintain the
1422 // reverse mapping currently
1423 int GetColPos(int idx) const
1424 {
1425 if ( m_colAt.IsEmpty() )
1426 return idx;
1427
1428 for ( int i = 0; i < m_numCols; i++ )
1429 {
1430 if ( m_colAt[i] == idx )
1431 return i;
1432 }
1433
1434 wxFAIL_MSG( "invalid column index" );
1435
1436 return wxNOT_FOUND;
1437 }
1438
1439 // reset the columns positions to the default order
1440 void ResetColPos();
1441
1442
1443 // automatically size the column or row to fit to its contents, if
1444 // setAsMin is true, this optimal width will also be set as minimal width
1445 // for this column
1446 void AutoSizeColumn( int col, bool setAsMin = true )
1447 { AutoSizeColOrRow(col, setAsMin, wxGRID_COLUMN); }
1448 void AutoSizeRow( int row, bool setAsMin = true )
1449 { AutoSizeColOrRow(row, setAsMin, wxGRID_ROW); }
1450
1451 // auto size all columns (very ineffective for big grids!)
1452 void AutoSizeColumns( bool setAsMin = true )
1453 { (void)SetOrCalcColumnSizes(false, setAsMin); }
1454
1455 void AutoSizeRows( bool setAsMin = true )
1456 { (void)SetOrCalcRowSizes(false, setAsMin); }
1457
1458 // auto size the grid, that is make the columns/rows of the "right" size
1459 // and also set the grid size to just fit its contents
1460 void AutoSize();
1461
1462 // Note for both AutoSizeRowLabelSize and AutoSizeColLabelSize:
1463 // If col equals to wxGRID_AUTOSIZE value then function autosizes labels column
1464 // instead of data column. Note that this operation may be slow for large
1465 // tables.
1466 // autosize row height depending on label text
1467 void AutoSizeRowLabelSize( int row );
1468
1469 // autosize column width depending on label text
1470 void AutoSizeColLabelSize( int col );
1471
1472 // column won't be resized to be lesser width - this must be called during
1473 // the grid creation because it won't resize the column if it's already
1474 // narrower than the minimal width
1475 void SetColMinimalWidth( int col, int width );
1476 void SetRowMinimalHeight( int row, int width );
1477
1478 /* These members can be used to query and modify the minimal
1479 * acceptable size of grid rows and columns. Call this function in
1480 * your code which creates the grid if you want to display cells
1481 * with a size smaller than the default acceptable minimum size.
1482 * Like the members SetColMinimalWidth and SetRowMinimalWidth,
1483 * the existing rows or columns will not be checked/resized.
1484 */
1485 void SetColMinimalAcceptableWidth( int width );
1486 void SetRowMinimalAcceptableHeight( int width );
1487 int GetColMinimalAcceptableWidth() const;
1488 int GetRowMinimalAcceptableHeight() const;
1489
1490 void SetDefaultCellBackgroundColour( const wxColour& );
1491 void SetCellBackgroundColour( int row, int col, const wxColour& );
1492 void SetDefaultCellTextColour( const wxColour& );
1493
1494 void SetCellTextColour( int row, int col, const wxColour& );
1495 void SetDefaultCellFont( const wxFont& );
1496 void SetCellFont( int row, int col, const wxFont& );
1497 void SetDefaultCellAlignment( int horiz, int vert );
1498 void SetCellAlignment( int row, int col, int horiz, int vert );
1499 void SetDefaultCellOverflow( bool allow );
1500 void SetCellOverflow( int row, int col, bool allow );
1501 void SetCellSize( int row, int col, int num_rows, int num_cols );
1502
1503 // takes ownership of the pointer
1504 void SetDefaultRenderer(wxGridCellRenderer *renderer);
1505 void SetCellRenderer(int row, int col, wxGridCellRenderer *renderer);
1506 wxGridCellRenderer *GetDefaultRenderer() const;
1507 wxGridCellRenderer* GetCellRenderer(int row, int col) const;
1508
1509 // takes ownership of the pointer
1510 void SetDefaultEditor(wxGridCellEditor *editor);
1511 void SetCellEditor(int row, int col, wxGridCellEditor *editor);
1512 wxGridCellEditor *GetDefaultEditor() const;
1513 wxGridCellEditor* GetCellEditor(int row, int col) const;
1514
1515
1516
1517 // ------ cell value accessors
1518 //
1519 wxString GetCellValue( int row, int col ) const
1520 {
1521 if ( m_table )
1522 {
1523 return m_table->GetValue( row, col );
1524 }
1525 else
1526 {
1527 return wxEmptyString;
1528 }
1529 }
1530
1531 wxString GetCellValue( const wxGridCellCoords& coords ) const
1532 { return GetCellValue( coords.GetRow(), coords.GetCol() ); }
1533
1534 void SetCellValue( int row, int col, const wxString& s );
1535 void SetCellValue( const wxGridCellCoords& coords, const wxString& s )
1536 { SetCellValue( coords.GetRow(), coords.GetCol(), s ); }
1537
1538 // returns true if the cell can't be edited
1539 bool IsReadOnly(int row, int col) const;
1540
1541 // make the cell editable/readonly
1542 void SetReadOnly(int row, int col, bool isReadOnly = true);
1543
1544 // ------ select blocks of cells
1545 //
1546 void SelectRow( int row, bool addToSelected = false );
1547 void SelectCol( int col, bool addToSelected = false );
1548
1549 void SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
1550 bool addToSelected = false );
1551
1552 void SelectBlock( const wxGridCellCoords& topLeft,
1553 const wxGridCellCoords& bottomRight,
1554 bool addToSelected = false )
1555 { SelectBlock( topLeft.GetRow(), topLeft.GetCol(),
1556 bottomRight.GetRow(), bottomRight.GetCol(),
1557 addToSelected ); }
1558
1559 void SelectAll();
1560
1561 bool IsSelection() const;
1562
1563 // ------ deselect blocks or cells
1564 //
1565 void DeselectRow( int row );
1566 void DeselectCol( int col );
1567 void DeselectCell( int row, int col );
1568
1569 void ClearSelection();
1570
1571 bool IsInSelection( int row, int col ) const;
1572
1573 bool IsInSelection( const wxGridCellCoords& coords ) const
1574 { return IsInSelection( coords.GetRow(), coords.GetCol() ); }
1575
1576 wxGridCellCoordsArray GetSelectedCells() const;
1577 wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
1578 wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
1579 wxArrayInt GetSelectedRows() const;
1580 wxArrayInt GetSelectedCols() const;
1581
1582 // This function returns the rectangle that encloses the block of cells
1583 // limited by TopLeft and BottomRight cell in device coords and clipped
1584 // to the client size of the grid window.
1585 //
1586 wxRect BlockToDeviceRect( const wxGridCellCoords & topLeft,
1587 const wxGridCellCoords & bottomRight ) const;
1588
1589 // Access or update the selection fore/back colours
1590 wxColour GetSelectionBackground() const
1591 { return m_selectionBackground; }
1592 wxColour GetSelectionForeground() const
1593 { return m_selectionForeground; }
1594
1595 void SetSelectionBackground(const wxColour& c) { m_selectionBackground = c; }
1596 void SetSelectionForeground(const wxColour& c) { m_selectionForeground = c; }
1597
1598
1599 // Methods for a registry for mapping data types to Renderers/Editors
1600 void RegisterDataType(const wxString& typeName,
1601 wxGridCellRenderer* renderer,
1602 wxGridCellEditor* editor);
1603 // DJC MAPTEK
1604 virtual wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
1605 wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const
1606 { return GetDefaultEditorForCell(c.GetRow(), c.GetCol()); }
1607 virtual wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
1608 virtual wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
1609 virtual wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
1610
1611 // grid may occupy more space than needed for its rows/columns, this
1612 // function allows to set how big this extra space is
1613 void SetMargins(int extraWidth, int extraHeight)
1614 {
1615 m_extraWidth = extraWidth;
1616 m_extraHeight = extraHeight;
1617
1618 CalcDimensions();
1619 }
1620
1621 // Accessors for component windows
1622 wxWindow* GetGridWindow() const { return (wxWindow*)m_gridWin; }
1623 wxWindow* GetGridRowLabelWindow() const { return (wxWindow*)m_rowLabelWin; }
1624 wxWindow* GetGridColLabelWindow() const { return m_colWindow; }
1625 wxWindow* GetGridCornerLabelWindow() const { return (wxWindow*)m_cornerLabelWin; }
1626
1627 // This one can only be called if we are using the native header window
1628 wxHeaderCtrl *GetGridColHeader() const
1629 {
1630 wxASSERT_MSG( m_useNativeHeader, "no column header window" );
1631
1632 // static_cast<> doesn't work without the full class declaration in
1633 // view and we prefer to avoid adding more compile-time dependencies
1634 // even at the cost of using reinterpret_cast<>
1635 return reinterpret_cast<wxHeaderCtrl *>(m_colWindow);
1636 }
1637
1638 // Allow adjustment of scroll increment. The default is (15, 15).
1639 void SetScrollLineX(int x) { m_xScrollPixelsPerLine = x; }
1640 void SetScrollLineY(int y) { m_yScrollPixelsPerLine = y; }
1641 int GetScrollLineX() const { return m_xScrollPixelsPerLine; }
1642 int GetScrollLineY() const { return m_yScrollPixelsPerLine; }
1643
1644 // ------- drag and drop
1645 #if wxUSE_DRAG_AND_DROP
1646 virtual void SetDropTarget(wxDropTarget *dropTarget);
1647 #endif // wxUSE_DRAG_AND_DROP
1648
1649
1650 // ------- sorting support
1651
1652 // wxGrid doesn't support sorting on its own but it can indicate the sort
1653 // order in the column header (currently only if native header control is
1654 // used though)
1655
1656 // return the column currently displaying the sort indicator or wxNOT_FOUND
1657 // if none
1658 int GetSortingColumn() const { return m_sortCol; }
1659
1660 // return true if this column is currently used for sorting
1661 bool IsSortingBy(int col) const { return GetSortingColumn() == col; }
1662
1663 // return the current sorting order (on GetSortingColumn()): true for
1664 // ascending sort and false for descending; it doesn't make sense to call
1665 // it if GetSortingColumn() returns wxNOT_FOUND
1666 bool IsSortOrderAscending() const { return m_sortIsAscending; }
1667
1668 // set the sorting column (or unsets any existing one if wxNOT_FOUND) and
1669 // the order in which to sort
1670 void SetSortingColumn(int col, bool ascending = true);
1671
1672 // unset any existing sorting column
1673 void UnsetSortingColumn() { SetSortingColumn(wxNOT_FOUND); }
1674
1675 #if WXWIN_COMPATIBILITY_2_8
1676 // ------ For compatibility with previous wxGrid only...
1677 //
1678 // ************************************************
1679 // ** Don't use these in new code because they **
1680 // ** are liable to disappear in a future **
1681 // ** revision **
1682 // ************************************************
1683 //
1684
1685 wxGrid( wxWindow *parent,
1686 int x, int y, int w = wxDefaultCoord, int h = wxDefaultCoord,
1687 long style = wxWANTS_CHARS,
1688 const wxString& name = wxPanelNameStr )
1689 {
1690 Init();
1691 Create(parent, wxID_ANY, wxPoint(x, y), wxSize(w, h), style, name);
1692 }
1693
1694 void SetCellValue( const wxString& val, int row, int col )
1695 { SetCellValue( row, col, val ); }
1696
1697 void UpdateDimensions()
1698 { CalcDimensions(); }
1699
1700 int GetRows() const { return GetNumberRows(); }
1701 int GetCols() const { return GetNumberCols(); }
1702 int GetCursorRow() const { return GetGridCursorRow(); }
1703 int GetCursorColumn() const { return GetGridCursorCol(); }
1704
1705 int GetScrollPosX() const { return 0; }
1706 int GetScrollPosY() const { return 0; }
1707
1708 void SetScrollX( int WXUNUSED(x) ) { }
1709 void SetScrollY( int WXUNUSED(y) ) { }
1710
1711 void SetColumnWidth( int col, int width )
1712 { SetColSize( col, width ); }
1713
1714 int GetColumnWidth( int col ) const
1715 { return GetColSize( col ); }
1716
1717 void SetRowHeight( int row, int height )
1718 { SetRowSize( row, height ); }
1719
1720 // GetRowHeight() is below
1721
1722 int GetViewHeight() const // returned num whole rows visible
1723 { return 0; }
1724
1725 int GetViewWidth() const // returned num whole cols visible
1726 { return 0; }
1727
1728 void SetLabelSize( int orientation, int sz )
1729 {
1730 if ( orientation == wxHORIZONTAL )
1731 SetColLabelSize( sz );
1732 else
1733 SetRowLabelSize( sz );
1734 }
1735
1736 int GetLabelSize( int orientation ) const
1737 {
1738 if ( orientation == wxHORIZONTAL )
1739 return GetColLabelSize();
1740 else
1741 return GetRowLabelSize();
1742 }
1743
1744 void SetLabelAlignment( int orientation, int align )
1745 {
1746 if ( orientation == wxHORIZONTAL )
1747 SetColLabelAlignment( align, wxALIGN_INVALID );
1748 else
1749 SetRowLabelAlignment( align, wxALIGN_INVALID );
1750 }
1751
1752 int GetLabelAlignment( int orientation, int WXUNUSED(align) ) const
1753 {
1754 int h, v;
1755 if ( orientation == wxHORIZONTAL )
1756 {
1757 GetColLabelAlignment( &h, &v );
1758 return h;
1759 }
1760 else
1761 {
1762 GetRowLabelAlignment( &h, &v );
1763 return h;
1764 }
1765 }
1766
1767 void SetLabelValue( int orientation, const wxString& val, int pos )
1768 {
1769 if ( orientation == wxHORIZONTAL )
1770 SetColLabelValue( pos, val );
1771 else
1772 SetRowLabelValue( pos, val );
1773 }
1774
1775 wxString GetLabelValue( int orientation, int pos) const
1776 {
1777 if ( orientation == wxHORIZONTAL )
1778 return GetColLabelValue( pos );
1779 else
1780 return GetRowLabelValue( pos );
1781 }
1782
1783 wxFont GetCellTextFont() const
1784 { return m_defaultCellAttr->GetFont(); }
1785
1786 wxFont GetCellTextFont(int WXUNUSED(row), int WXUNUSED(col)) const
1787 { return m_defaultCellAttr->GetFont(); }
1788
1789 void SetCellTextFont(const wxFont& fnt)
1790 { SetDefaultCellFont( fnt ); }
1791
1792 void SetCellTextFont(const wxFont& fnt, int row, int col)
1793 { SetCellFont( row, col, fnt ); }
1794
1795 void SetCellTextColour(const wxColour& val, int row, int col)
1796 { SetCellTextColour( row, col, val ); }
1797
1798 void SetCellTextColour(const wxColour& col)
1799 { SetDefaultCellTextColour( col ); }
1800
1801 void SetCellBackgroundColour(const wxColour& col)
1802 { SetDefaultCellBackgroundColour( col ); }
1803
1804 void SetCellBackgroundColour(const wxColour& colour, int row, int col)
1805 { SetCellBackgroundColour( row, col, colour ); }
1806
1807 bool GetEditable() const { return IsEditable(); }
1808 void SetEditable( bool edit = true ) { EnableEditing( edit ); }
1809 bool GetEditInPlace() const { return IsCellEditControlEnabled(); }
1810
1811 void SetEditInPlace(bool WXUNUSED(edit) = true) { }
1812
1813 void SetCellAlignment( int align, int row, int col)
1814 { SetCellAlignment(row, col, align, wxALIGN_CENTER); }
1815 void SetCellAlignment( int WXUNUSED(align) ) {}
1816 void SetCellBitmap(wxBitmap *WXUNUSED(bitmap), int WXUNUSED(row), int WXUNUSED(col))
1817 { }
1818 void SetDividerPen(const wxPen& WXUNUSED(pen)) { }
1819 wxPen& GetDividerPen() const;
1820 void OnActivate(bool WXUNUSED(active)) {}
1821
1822 // ******** End of compatibility functions **********
1823
1824
1825
1826 // ------ control IDs
1827 enum { wxGRID_CELLCTRL = 2000,
1828 wxGRID_TOPCTRL };
1829
1830 // ------ control types
1831 enum { wxGRID_TEXTCTRL = 2100,
1832 wxGRID_CHECKBOX,
1833 wxGRID_CHOICE,
1834 wxGRID_COMBOBOX };
1835
1836 wxDEPRECATED_INLINE(bool CanDragRowSize() const, return m_canDragRowSize; )
1837 wxDEPRECATED_INLINE(bool CanDragColSize() const, return m_canDragColSize; )
1838 #endif // WXWIN_COMPATIBILITY_2_8
1839
1840
1841 // override some base class functions
1842 virtual bool Enable(bool enable = true);
1843 virtual wxWindow *GetMainWindowOfCompositeControl()
1844 { return (wxWindow*)m_gridWin; }
1845 virtual void Fit();
1846
1847 // implementation only
1848 void CancelMouseCapture();
1849
1850 protected:
1851 virtual wxSize DoGetBestSize() const;
1852
1853 bool m_created;
1854
1855 wxGridWindow *m_gridWin;
1856 wxGridCornerLabelWindow *m_cornerLabelWin;
1857 wxGridRowLabelWindow *m_rowLabelWin;
1858
1859 // the real type of the column window depends on m_useNativeHeader value:
1860 // if it is true, its dynamic type is wxHeaderCtrl, otherwise it is
1861 // wxGridColLabelWindow, use accessors below when the real type matters
1862 wxWindow *m_colWindow;
1863
1864 wxGridColLabelWindow *GetColLabelWindow() const
1865 {
1866 wxASSERT_MSG( !m_useNativeHeader, "no column label window" );
1867
1868 return reinterpret_cast<wxGridColLabelWindow *>(m_colWindow);
1869 }
1870
1871 wxGridTableBase *m_table;
1872 bool m_ownTable;
1873
1874 int m_numRows;
1875 int m_numCols;
1876
1877 wxGridCellCoords m_currentCellCoords;
1878
1879 // the corners of the block being currently selected or wxGridNoCellCoords
1880 wxGridCellCoords m_selectedBlockTopLeft;
1881 wxGridCellCoords m_selectedBlockBottomRight;
1882
1883 // when selecting blocks of cells (either from the keyboard using Shift
1884 // with cursor keys, or by dragging the mouse), the selection is anchored
1885 // at m_currentCellCoords which defines one of the corners of the rectangle
1886 // being selected -- and this variable defines the other corner, i.e. it's
1887 // either m_selectedBlockTopLeft or m_selectedBlockBottomRight depending on
1888 // which of them is not m_currentCellCoords
1889 //
1890 // if no block selection is in process, it is set to wxGridNoCellCoords
1891 wxGridCellCoords m_selectedBlockCorner;
1892
1893 wxGridSelection *m_selection;
1894
1895 wxColour m_selectionBackground;
1896 wxColour m_selectionForeground;
1897
1898 // NB: *never* access m_row/col arrays directly because they are created
1899 // on demand, *always* use accessor functions instead!
1900
1901 // init the m_rowHeights/Bottoms arrays with default values
1902 void InitRowHeights();
1903
1904 int m_defaultRowHeight;
1905 int m_minAcceptableRowHeight;
1906 wxArrayInt m_rowHeights;
1907 wxArrayInt m_rowBottoms;
1908
1909 // init the m_colWidths/Rights arrays
1910 void InitColWidths();
1911
1912 int m_defaultColWidth;
1913 int m_minAcceptableColWidth;
1914 wxArrayInt m_colWidths;
1915 wxArrayInt m_colRights;
1916
1917 int m_sortCol;
1918 bool m_sortIsAscending;
1919
1920 bool m_useNativeHeader,
1921 m_nativeColumnLabels;
1922
1923 // get the col/row coords
1924 int GetColWidth(int col) const;
1925 int GetColLeft(int col) const;
1926 int GetColRight(int col) const;
1927
1928 // this function must be public for compatibility...
1929 public:
1930 int GetRowHeight(int row) const;
1931 protected:
1932
1933 int GetRowTop(int row) const;
1934 int GetRowBottom(int row) const;
1935
1936 int m_rowLabelWidth;
1937 int m_colLabelHeight;
1938
1939 // the size of the margin left to the right and bottom of the cell area
1940 int m_extraWidth,
1941 m_extraHeight;
1942
1943 wxColour m_labelBackgroundColour;
1944 wxColour m_labelTextColour;
1945 wxFont m_labelFont;
1946
1947 int m_rowLabelHorizAlign;
1948 int m_rowLabelVertAlign;
1949 int m_colLabelHorizAlign;
1950 int m_colLabelVertAlign;
1951 int m_colLabelTextOrientation;
1952
1953 bool m_defaultRowLabelValues;
1954 bool m_defaultColLabelValues;
1955
1956 wxColour m_gridLineColour;
1957 bool m_gridLinesEnabled;
1958 bool m_gridLinesClipHorz,
1959 m_gridLinesClipVert;
1960 wxColour m_cellHighlightColour;
1961 int m_cellHighlightPenWidth;
1962 int m_cellHighlightROPenWidth;
1963
1964
1965 // common part of AutoSizeColumn/Row() and GetBestSize()
1966 int SetOrCalcColumnSizes(bool calcOnly, bool setAsMin = true);
1967 int SetOrCalcRowSizes(bool calcOnly, bool setAsMin = true);
1968
1969 // common part of AutoSizeColumn/Row()
1970 void AutoSizeColOrRow(int n, bool setAsMin, wxGridDirection direction);
1971
1972 // Calculate the minimum acceptable size for labels area
1973 wxCoord CalcColOrRowLabelAreaMinSize(wxGridDirection direction);
1974
1975 // if a column has a minimal width, it will be the value for it in this
1976 // hash table
1977 wxLongToLongHashMap m_colMinWidths,
1978 m_rowMinHeights;
1979
1980 // get the minimal width of the given column/row
1981 int GetColMinimalWidth(int col) const;
1982 int GetRowMinimalHeight(int col) const;
1983
1984 // do we have some place to store attributes in?
1985 bool CanHaveAttributes() const;
1986
1987 // cell attribute cache (currently we only cache 1, may be will do
1988 // more/better later)
1989 struct CachedAttr
1990 {
1991 int row, col;
1992 wxGridCellAttr *attr;
1993 } m_attrCache;
1994
1995 // invalidates the attribute cache
1996 void ClearAttrCache();
1997
1998 // adds an attribute to cache
1999 void CacheAttr(int row, int col, wxGridCellAttr *attr) const;
2000
2001 // looks for an attr in cache, returns true if found
2002 bool LookupAttr(int row, int col, wxGridCellAttr **attr) const;
2003
2004 // looks for the attr in cache, if not found asks the table and caches the
2005 // result
2006 wxGridCellAttr *GetCellAttr(int row, int col) const;
2007 wxGridCellAttr *GetCellAttr(const wxGridCellCoords& coords ) const
2008 { return GetCellAttr( coords.GetRow(), coords.GetCol() ); }
2009
2010 // the default cell attr object for cells that don't have their own
2011 wxGridCellAttr* m_defaultCellAttr;
2012
2013
2014 bool m_inOnKeyDown;
2015 int m_batchCount;
2016
2017
2018 wxGridTypeRegistry* m_typeRegistry;
2019
2020 enum CursorMode
2021 {
2022 WXGRID_CURSOR_SELECT_CELL,
2023 WXGRID_CURSOR_RESIZE_ROW,
2024 WXGRID_CURSOR_RESIZE_COL,
2025 WXGRID_CURSOR_SELECT_ROW,
2026 WXGRID_CURSOR_SELECT_COL,
2027 WXGRID_CURSOR_MOVE_COL
2028 };
2029
2030 // this method not only sets m_cursorMode but also sets the correct cursor
2031 // for the given mode and, if captureMouse is not false releases the mouse
2032 // if it was captured and captures it if it must be captured
2033 //
2034 // for this to work, you should always use it and not set m_cursorMode
2035 // directly!
2036 void ChangeCursorMode(CursorMode mode,
2037 wxWindow *win = NULL,
2038 bool captureMouse = true);
2039
2040 wxWindow *m_winCapture; // the window which captured the mouse
2041
2042 // this variable is used not for finding the correct current cursor but
2043 // mainly for finding out what is going to happen if the mouse starts being
2044 // dragged right now
2045 //
2046 // by default it is WXGRID_CURSOR_SELECT_CELL meaning that nothing else is
2047 // going on, and it is set to one of RESIZE/SELECT/MOVE values while the
2048 // corresponding operation will be started if the user starts dragging the
2049 // mouse from the current position
2050 CursorMode m_cursorMode;
2051
2052
2053 //Column positions
2054 wxArrayInt m_colAt;
2055
2056 bool m_canDragRowSize;
2057 bool m_canDragColSize;
2058 bool m_canDragColMove;
2059 bool m_canDragGridSize;
2060 bool m_canDragCell;
2061
2062 // the last position (horizontal or vertical depending on whether the user
2063 // is resizing a column or a row) where a row or column separator line was
2064 // dragged by the user or -1 of there is no drag operation in progress
2065 int m_dragLastPos;
2066 int m_dragRowOrCol;
2067
2068 // true if a drag operation is in progress; when this is true,
2069 // m_startDragPos is valid, i.e. not wxDefaultPosition
2070 bool m_isDragging;
2071
2072 // the position (in physical coordinates) where the user started dragging
2073 // the mouse or wxDefaultPosition if mouse isn't being dragged
2074 //
2075 // notice that this can be != wxDefaultPosition while m_isDragging is still
2076 // false because we wait until the mouse is moved some distance away before
2077 // setting m_isDragging to true
2078 wxPoint m_startDragPos;
2079
2080 bool m_waitForSlowClick;
2081
2082 wxGridCellCoords m_selectionStart;
2083
2084 wxCursor m_rowResizeCursor;
2085 wxCursor m_colResizeCursor;
2086
2087 bool m_editable; // applies to whole grid
2088 bool m_cellEditCtrlEnabled; // is in-place edit currently shown?
2089
2090 TabBehaviour m_tabBehaviour; // determines how the TAB key behaves
2091
2092 void Init(); // common part of all ctors
2093 void Create();
2094 void CreateColumnWindow();
2095 void CalcDimensions();
2096 void CalcWindowSizes();
2097 bool Redimension( wxGridTableMessage& );
2098
2099
2100 // generate the appropriate grid event and return -1 if it was vetoed, 1 if
2101 // it was processed (but not vetoed) and 0 if it wasn't processed
2102 int SendEvent(const wxEventType evtType,
2103 int row, int col,
2104 const wxMouseEvent& e);
2105 int SendEvent(const wxEventType evtType,
2106 const wxGridCellCoords& coords,
2107 const wxMouseEvent& e)
2108 { return SendEvent(evtType, coords.GetRow(), coords.GetCol(), e); }
2109 int SendEvent(const wxEventType evtType,
2110 int row, int col,
2111 const wxString& s = wxString());
2112 int SendEvent(const wxEventType evtType,
2113 const wxGridCellCoords& coords,
2114 const wxString& s = wxString())
2115 { return SendEvent(evtType, coords.GetRow(), coords.GetCol(), s); }
2116 int SendEvent(const wxEventType evtType, const wxString& s = wxString())
2117 { return SendEvent(evtType, m_currentCellCoords, s); }
2118
2119 // send wxEVT_GRID_{ROW,COL}_SIZE
2120 void SendGridSizeEvent(wxEventType type,
2121 int row, int col,
2122 const wxMouseEvent& mouseEv);
2123
2124 void OnPaint( wxPaintEvent& );
2125 void OnSize( wxSizeEvent& );
2126 void OnKeyDown( wxKeyEvent& );
2127 void OnKeyUp( wxKeyEvent& );
2128 void OnChar( wxKeyEvent& );
2129 void OnEraseBackground( wxEraseEvent& );
2130
2131
2132 bool SetCurrentCell( const wxGridCellCoords& coords );
2133 bool SetCurrentCell( int row, int col )
2134 { return SetCurrentCell( wxGridCellCoords(row, col) ); }
2135
2136
2137 // this function is called to extend the block being currently selected
2138 // from mouse and keyboard event handlers
2139 void UpdateBlockBeingSelected(int topRow, int leftCol,
2140 int bottomRow, int rightCol);
2141
2142 void UpdateBlockBeingSelected(const wxGridCellCoords& topLeft,
2143 const wxGridCellCoords& bottomRight)
2144 { UpdateBlockBeingSelected(topLeft.GetRow(), topLeft.GetCol(),
2145 bottomRight.GetRow(), bottomRight.GetCol()); }
2146
2147 // ------ functions to get/send data (see also public functions)
2148 //
2149 bool GetModelValues();
2150 bool SetModelValues();
2151
2152 friend class WXDLLIMPEXP_FWD_ADV wxGridSelection;
2153 friend class wxGridRowOperations;
2154 friend class wxGridColumnOperations;
2155
2156 // they call our private Process{{Corner,Col,Row}Label,GridCell}MouseEvent()
2157 friend class wxGridCornerLabelWindow;
2158 friend class wxGridColLabelWindow;
2159 friend class wxGridRowLabelWindow;
2160 friend class wxGridWindow;
2161 friend class wxGridHeaderRenderer;
2162
2163 friend class wxGridHeaderCtrl;
2164
2165 private:
2166
2167 // implement wxScrolledWindow method to return m_gridWin size
2168 virtual wxSize GetSizeAvailableForScrollTarget(const wxSize& size);
2169
2170 // redraw the grid lines, should be called after changing their attributes
2171 void RedrawGridLines();
2172
2173 // draw all grid lines in the given cell region (unlike the public
2174 // DrawAllGridLines() which just draws all of them)
2175 void DrawRangeGridLines(wxDC& dc, const wxRegion& reg,
2176 const wxGridCellCoords& topLeft,
2177 const wxGridCellCoords& bottomRight);
2178
2179 // draw all lines from top to bottom row and left to right column in the
2180 // rectangle determined by (top, left)-(bottom, right) -- but notice that
2181 // the caller must have set up the clipping correctly, this rectangle is
2182 // only used here for optimization
2183 void DoDrawGridLines(wxDC& dc,
2184 int top, int left,
2185 int bottom, int right,
2186 int topRow, int leftCol,
2187 int bottomRight, int rightCol);
2188
2189 // common part of Clip{Horz,Vert}GridLines
2190 void DoClipGridLines(bool& var, bool clip);
2191
2192 // update the sorting indicator shown in the specified column (whose index
2193 // must be valid)
2194 //
2195 // this will use GetSortingColumn() and IsSortOrderAscending() to determine
2196 // the sorting indicator to effectively show
2197 void UpdateColumnSortingIndicator(int col);
2198
2199 // update the grid after changing the columns order (common part of
2200 // SetColPos() and ResetColPos())
2201 void RefreshAfterColPosChange();
2202
2203
2204 // return the position (not index) of the column at the given logical pixel
2205 // position
2206 //
2207 // this always returns a valid position, even if the coordinate is out of
2208 // bounds (in which case first/last column is returned)
2209 int XToPos(int x) const;
2210
2211
2212 // event handlers and their helpers
2213 // --------------------------------
2214
2215 // process mouse drag event in WXGRID_CURSOR_SELECT_CELL mode
2216 bool DoGridCellDrag(wxMouseEvent& event,
2217 const wxGridCellCoords& coords,
2218 bool isFirstDrag);
2219
2220 // process row/column resizing drag event
2221 void DoGridLineDrag(wxMouseEvent& event, const wxGridOperations& oper);
2222
2223 // process mouse drag event in the grid window
2224 void DoGridDragEvent(wxMouseEvent& event, const wxGridCellCoords& coords);
2225
2226 // process different clicks on grid cells
2227 void DoGridCellLeftDown(wxMouseEvent& event,
2228 const wxGridCellCoords& coords,
2229 const wxPoint& pos);
2230 void DoGridCellLeftDClick(wxMouseEvent& event,
2231 const wxGridCellCoords& coords,
2232 const wxPoint& pos);
2233 void DoGridCellLeftUp(wxMouseEvent& event, const wxGridCellCoords& coords);
2234
2235 // process movement (but not dragging) event in the grid cell area
2236 void DoGridMouseMoveEvent(wxMouseEvent& event,
2237 const wxGridCellCoords& coords,
2238 const wxPoint& pos);
2239
2240 // process mouse events in the grid window
2241 void ProcessGridCellMouseEvent(wxMouseEvent& event);
2242
2243 // process mouse events in the row/column labels/corner windows
2244 void ProcessRowLabelMouseEvent(wxMouseEvent& event);
2245 void ProcessColLabelMouseEvent(wxMouseEvent& event);
2246 void ProcessCornerLabelMouseEvent(wxMouseEvent& event);
2247
2248 void DoColHeaderClick(int col);
2249
2250 void DoStartResizeCol(int col);
2251 void DoUpdateResizeCol(int x);
2252 void DoUpdateResizeColWidth(int w);
2253 void DoStartMoveCol(int col);
2254
2255 void DoEndDragResizeRow(const wxMouseEvent& event);
2256 void DoEndDragResizeCol(const wxMouseEvent& event);
2257 void DoEndMoveCol(int pos);
2258
2259 // process a TAB keypress
2260 void DoGridProcessTab(wxKeyboardState& kbdState);
2261
2262 // common implementations of methods defined for both rows and columns
2263 void DeselectLine(int line, const wxGridOperations& oper);
2264 bool DoEndDragResizeLine(const wxGridOperations& oper);
2265 int PosToLinePos(int pos, bool clipToMinMax,
2266 const wxGridOperations& oper) const;
2267 int PosToLine(int pos, bool clipToMinMax,
2268 const wxGridOperations& oper) const;
2269 int PosToEdgeOfLine(int pos, const wxGridOperations& oper) const;
2270
2271 bool DoMoveCursor(bool expandSelection,
2272 const wxGridDirectionOperations& diroper);
2273 bool DoMoveCursorByPage(const wxGridDirectionOperations& diroper);
2274 bool DoMoveCursorByBlock(bool expandSelection,
2275 const wxGridDirectionOperations& diroper);
2276 void AdvanceToNextNonEmpty(wxGridCellCoords& coords,
2277 const wxGridDirectionOperations& diroper);
2278
2279 // common part of {Insert,Delete}{Rows,Cols}
2280 bool DoModifyLines(bool (wxGridTableBase::*funcModify)(size_t, size_t),
2281 int pos, int num, bool updateLabels);
2282 // Append{Rows,Cols} is a bit different because of one less parameter
2283 bool DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
2284 int num, bool updateLabels);
2285
2286 // common part of Set{Col,Row}Sizes
2287 void DoSetSizes(const wxGridSizesInfo& sizeInfo,
2288 const wxGridOperations& oper);
2289
2290 // common part of Disable{Row,Col}Resize and CanDrag{Row,Col}Size
2291 void DoDisableLineResize(int line, wxGridFixedIndicesSet *& setFixed);
2292 bool DoCanResizeLine(int line, const wxGridFixedIndicesSet *setFixed) const;
2293
2294 // Helper of Render(): get grid size, origin offset and fill cell arrays
2295 void GetRenderSizes( const wxGridCellCoords& topLeft,
2296 const wxGridCellCoords& bottomRight,
2297 wxPoint& pointOffSet, wxSize& sizeGrid,
2298 wxGridCellCoordsArray& renderCells,
2299 wxArrayInt& arrayCols, wxArrayInt& arrayRows );
2300
2301 // Helper of Render(): set the scale to draw the cells at the right size.
2302 void SetRenderScale( wxDC& dc, const wxPoint& pos, const wxSize& size,
2303 const wxSize& sizeGrid );
2304
2305 // Helper of Render(): get render start position from passed parameter
2306 wxPoint GetRenderPosition( wxDC& dc, const wxPoint& position );
2307
2308 // Helper of Render(): draws a box around the rendered area
2309 void DoRenderBox( wxDC& dc, const int& style,
2310 const wxPoint& pointOffSet,
2311 const wxSize& sizeCellArea,
2312 const wxGridCellCoords& topLeft,
2313 const wxGridCellCoords& bottomRight );
2314
2315 // Implementation of public Set{Row,Col}Size() and {Hide,Show}{Row,Col}().
2316 // They interpret their height or width parameter slightly different from
2317 // the public methods where -1 in it means "auto fit to the label" for the
2318 // compatibility reasons. Here it means "show a previously hidden row or
2319 // column" while 0 means "hide it" just as in the public methods. And any
2320 // positive values are handled naturally, i.e. they just specify the size.
2321 void DoSetRowSize( int row, int height );
2322 void DoSetColSize( int col, int width );
2323
2324
2325 // these sets contain the indices of fixed, i.e. non-resizable
2326 // interactively, grid rows or columns and are NULL if there are no fixed
2327 // elements (which is the default)
2328 wxGridFixedIndicesSet *m_setFixedRows,
2329 *m_setFixedCols;
2330
2331 DECLARE_DYNAMIC_CLASS( wxGrid )
2332 DECLARE_EVENT_TABLE()
2333 wxDECLARE_NO_COPY_CLASS(wxGrid);
2334 };
2335
2336 // ----------------------------------------------------------------------------
2337 // wxGridUpdateLocker prevents updates to a grid during its lifetime
2338 // ----------------------------------------------------------------------------
2339
2340 class WXDLLIMPEXP_ADV wxGridUpdateLocker
2341 {
2342 public:
2343 // if the pointer is NULL, Create() can be called later
2344 wxGridUpdateLocker(wxGrid *grid = NULL)
2345 {
2346 Init(grid);
2347 }
2348
2349 // can be called if ctor was used with a NULL pointer, must not be called
2350 // more than once
2351 void Create(wxGrid *grid)
2352 {
2353 wxASSERT_MSG( !m_grid, wxT("shouldn't be called more than once") );
2354
2355 Init(grid);
2356 }
2357
2358 ~wxGridUpdateLocker()
2359 {
2360 if ( m_grid )
2361 m_grid->EndBatch();
2362 }
2363
2364 private:
2365 void Init(wxGrid *grid)
2366 {
2367 m_grid = grid;
2368 if ( m_grid )
2369 m_grid->BeginBatch();
2370 }
2371
2372 wxGrid *m_grid;
2373
2374 wxDECLARE_NO_COPY_CLASS(wxGridUpdateLocker);
2375 };
2376
2377 // ----------------------------------------------------------------------------
2378 // Grid event class and event types
2379 // ----------------------------------------------------------------------------
2380
2381 class WXDLLIMPEXP_ADV wxGridEvent : public wxNotifyEvent,
2382 public wxKeyboardState
2383 {
2384 public:
2385 wxGridEvent()
2386 : wxNotifyEvent()
2387 {
2388 Init(-1, -1, -1, -1, false);
2389 }
2390
2391 wxGridEvent(int id,
2392 wxEventType type,
2393 wxObject* obj,
2394 int row = -1, int col = -1,
2395 int x = -1, int y = -1,
2396 bool sel = true,
2397 const wxKeyboardState& kbd = wxKeyboardState())
2398 : wxNotifyEvent(type, id),
2399 wxKeyboardState(kbd)
2400 {
2401 Init(row, col, x, y, sel);
2402 SetEventObject(obj);
2403 }
2404
2405 // explicitly specifying inline allows gcc < 3.4 to
2406 // handle the deprecation attribute even in the constructor.
2407 wxDEPRECATED_CONSTRUCTOR(
2408 wxGridEvent(int id,
2409 wxEventType type,
2410 wxObject* obj,
2411 int row, int col,
2412 int x, int y,
2413 bool sel,
2414 bool control,
2415 bool shift = false, bool alt = false, bool meta = false));
2416
2417 virtual int GetRow() { return m_row; }
2418 virtual int GetCol() { return m_col; }
2419 wxPoint GetPosition() { return wxPoint( m_x, m_y ); }
2420 bool Selecting() { return m_selecting; }
2421
2422 virtual wxEvent *Clone() const { return new wxGridEvent(*this); }
2423
2424 protected:
2425 int m_row;
2426 int m_col;
2427 int m_x;
2428 int m_y;
2429 bool m_selecting;
2430
2431 private:
2432 void Init(int row, int col, int x, int y, bool sel)
2433 {
2434 m_row = row;
2435 m_col = col;
2436 m_x = x;
2437 m_y = y;
2438 m_selecting = sel;
2439 }
2440
2441 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridEvent)
2442 };
2443
2444 class WXDLLIMPEXP_ADV wxGridSizeEvent : public wxNotifyEvent,
2445 public wxKeyboardState
2446 {
2447 public:
2448 wxGridSizeEvent()
2449 : wxNotifyEvent()
2450 {
2451 Init(-1, -1, -1);
2452 }
2453
2454 wxGridSizeEvent(int id,
2455 wxEventType type,
2456 wxObject* obj,
2457 int rowOrCol = -1,
2458 int x = -1, int y = -1,
2459 const wxKeyboardState& kbd = wxKeyboardState())
2460 : wxNotifyEvent(type, id),
2461 wxKeyboardState(kbd)
2462 {
2463 Init(rowOrCol, x, y);
2464
2465 SetEventObject(obj);
2466 }
2467
2468 wxDEPRECATED_CONSTRUCTOR(
2469 wxGridSizeEvent(int id,
2470 wxEventType type,
2471 wxObject* obj,
2472 int rowOrCol,
2473 int x, int y,
2474 bool control,
2475 bool shift = false,
2476 bool alt = false,
2477 bool meta = false) );
2478
2479 int GetRowOrCol() { return m_rowOrCol; }
2480 wxPoint GetPosition() { return wxPoint( m_x, m_y ); }
2481
2482 virtual wxEvent *Clone() const { return new wxGridSizeEvent(*this); }
2483
2484 protected:
2485 int m_rowOrCol;
2486 int m_x;
2487 int m_y;
2488
2489 private:
2490 void Init(int rowOrCol, int x, int y)
2491 {
2492 m_rowOrCol = rowOrCol;
2493 m_x = x;
2494 m_y = y;
2495 }
2496
2497 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridSizeEvent)
2498 };
2499
2500
2501 class WXDLLIMPEXP_ADV wxGridRangeSelectEvent : public wxNotifyEvent,
2502 public wxKeyboardState
2503 {
2504 public:
2505 wxGridRangeSelectEvent()
2506 : wxNotifyEvent()
2507 {
2508 Init(wxGridNoCellCoords, wxGridNoCellCoords, false);
2509 }
2510
2511 wxGridRangeSelectEvent(int id,
2512 wxEventType type,
2513 wxObject* obj,
2514 const wxGridCellCoords& topLeft,
2515 const wxGridCellCoords& bottomRight,
2516 bool sel = true,
2517 const wxKeyboardState& kbd = wxKeyboardState())
2518 : wxNotifyEvent(type, id),
2519 wxKeyboardState(kbd)
2520 {
2521 Init(topLeft, bottomRight, sel);
2522
2523 SetEventObject(obj);
2524 }
2525
2526 wxDEPRECATED_CONSTRUCTOR(
2527 wxGridRangeSelectEvent(int id,
2528 wxEventType type,
2529 wxObject* obj,
2530 const wxGridCellCoords& topLeft,
2531 const wxGridCellCoords& bottomRight,
2532 bool sel,
2533 bool control,
2534 bool shift = false,
2535 bool alt = false,
2536 bool meta = false) );
2537
2538 wxGridCellCoords GetTopLeftCoords() { return m_topLeft; }
2539 wxGridCellCoords GetBottomRightCoords() { return m_bottomRight; }
2540 int GetTopRow() { return m_topLeft.GetRow(); }
2541 int GetBottomRow() { return m_bottomRight.GetRow(); }
2542 int GetLeftCol() { return m_topLeft.GetCol(); }
2543 int GetRightCol() { return m_bottomRight.GetCol(); }
2544 bool Selecting() { return m_selecting; }
2545
2546 virtual wxEvent *Clone() const { return new wxGridRangeSelectEvent(*this); }
2547
2548 protected:
2549 void Init(const wxGridCellCoords& topLeft,
2550 const wxGridCellCoords& bottomRight,
2551 bool selecting)
2552 {
2553 m_topLeft = topLeft;
2554 m_bottomRight = bottomRight;
2555 m_selecting = selecting;
2556 }
2557
2558 wxGridCellCoords m_topLeft;
2559 wxGridCellCoords m_bottomRight;
2560 bool m_selecting;
2561
2562 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridRangeSelectEvent)
2563 };
2564
2565
2566 class WXDLLIMPEXP_ADV wxGridEditorCreatedEvent : public wxCommandEvent
2567 {
2568 public:
2569 wxGridEditorCreatedEvent()
2570 : wxCommandEvent()
2571 {
2572 m_row = 0;
2573 m_col = 0;
2574 m_ctrl = NULL;
2575 }
2576
2577 wxGridEditorCreatedEvent(int id, wxEventType type, wxObject* obj,
2578 int row, int col, wxControl* ctrl);
2579
2580 int GetRow() { return m_row; }
2581 int GetCol() { return m_col; }
2582 wxControl* GetControl() { return m_ctrl; }
2583 void SetRow(int row) { m_row = row; }
2584 void SetCol(int col) { m_col = col; }
2585 void SetControl(wxControl* ctrl) { m_ctrl = ctrl; }
2586
2587 virtual wxEvent *Clone() const { return new wxGridEditorCreatedEvent(*this); }
2588
2589 private:
2590 int m_row;
2591 int m_col;
2592 wxControl* m_ctrl;
2593
2594 DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridEditorCreatedEvent)
2595 };
2596
2597
2598 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_LEFT_CLICK, wxGridEvent );
2599 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_RIGHT_CLICK, wxGridEvent );
2600 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_LEFT_DCLICK, wxGridEvent );
2601 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_RIGHT_DCLICK, wxGridEvent );
2602 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_LEFT_CLICK, wxGridEvent );
2603 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_RIGHT_CLICK, wxGridEvent );
2604 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_LEFT_DCLICK, wxGridEvent );
2605 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_RIGHT_DCLICK, wxGridEvent );
2606 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_ROW_SIZE, wxGridSizeEvent );
2607 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_SIZE, wxGridSizeEvent );
2608 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_RANGE_SELECT, wxGridRangeSelectEvent );
2609 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_CHANGING, wxGridEvent );
2610 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_CHANGED, wxGridEvent );
2611 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_SELECT_CELL, wxGridEvent );
2612 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_SHOWN, wxGridEvent );
2613 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_HIDDEN, wxGridEvent );
2614 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_CREATED, wxGridEditorCreatedEvent );
2615 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_BEGIN_DRAG, wxGridEvent );
2616 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_MOVE, wxGridEvent );
2617 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_SORT, wxGridEvent );
2618 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_TABBING, wxGridEvent );
2619
2620 typedef void (wxEvtHandler::*wxGridEventFunction)(wxGridEvent&);
2621 typedef void (wxEvtHandler::*wxGridSizeEventFunction)(wxGridSizeEvent&);
2622 typedef void (wxEvtHandler::*wxGridRangeSelectEventFunction)(wxGridRangeSelectEvent&);
2623 typedef void (wxEvtHandler::*wxGridEditorCreatedEventFunction)(wxGridEditorCreatedEvent&);
2624
2625 #define wxGridEventHandler(func) \
2626 wxEVENT_HANDLER_CAST(wxGridEventFunction, func)
2627
2628 #define wxGridSizeEventHandler(func) \
2629 wxEVENT_HANDLER_CAST(wxGridSizeEventFunction, func)
2630
2631 #define wxGridRangeSelectEventHandler(func) \
2632 wxEVENT_HANDLER_CAST(wxGridRangeSelectEventFunction, func)
2633
2634 #define wxGridEditorCreatedEventHandler(func) \
2635 wxEVENT_HANDLER_CAST(wxGridEditorCreatedEventFunction, func)
2636
2637 #define wx__DECLARE_GRIDEVT(evt, id, fn) \
2638 wx__DECLARE_EVT1(wxEVT_GRID_ ## evt, id, wxGridEventHandler(fn))
2639
2640 #define wx__DECLARE_GRIDSIZEEVT(evt, id, fn) \
2641 wx__DECLARE_EVT1(wxEVT_GRID_ ## evt, id, wxGridSizeEventHandler(fn))
2642
2643 #define wx__DECLARE_GRIDRANGESELEVT(evt, id, fn) \
2644 wx__DECLARE_EVT1(wxEVT_GRID_ ## evt, id, wxGridRangeSelectEventHandler(fn))
2645
2646 #define wx__DECLARE_GRIDEDITOREVT(evt, id, fn) \
2647 wx__DECLARE_EVT1(wxEVT_GRID_ ## evt, id, wxGridEditorCreatedEventHandler(fn))
2648
2649 #define EVT_GRID_CMD_CELL_LEFT_CLICK(id, fn) wx__DECLARE_GRIDEVT(CELL_LEFT_CLICK, id, fn)
2650 #define EVT_GRID_CMD_CELL_RIGHT_CLICK(id, fn) wx__DECLARE_GRIDEVT(CELL_RIGHT_CLICK, id, fn)
2651 #define EVT_GRID_CMD_CELL_LEFT_DCLICK(id, fn) wx__DECLARE_GRIDEVT(CELL_LEFT_DCLICK, id, fn)
2652 #define EVT_GRID_CMD_CELL_RIGHT_DCLICK(id, fn) wx__DECLARE_GRIDEVT(CELL_RIGHT_DCLICK, id, fn)
2653 #define EVT_GRID_CMD_LABEL_LEFT_CLICK(id, fn) wx__DECLARE_GRIDEVT(LABEL_LEFT_CLICK, id, fn)
2654 #define EVT_GRID_CMD_LABEL_RIGHT_CLICK(id, fn) wx__DECLARE_GRIDEVT(LABEL_RIGHT_CLICK, id, fn)
2655 #define EVT_GRID_CMD_LABEL_LEFT_DCLICK(id, fn) wx__DECLARE_GRIDEVT(LABEL_LEFT_DCLICK, id, fn)
2656 #define EVT_GRID_CMD_LABEL_RIGHT_DCLICK(id, fn) wx__DECLARE_GRIDEVT(LABEL_RIGHT_DCLICK, id, fn)
2657 #define EVT_GRID_CMD_ROW_SIZE(id, fn) wx__DECLARE_GRIDSIZEEVT(ROW_SIZE, id, fn)
2658 #define EVT_GRID_CMD_COL_SIZE(id, fn) wx__DECLARE_GRIDSIZEEVT(COL_SIZE, id, fn)
2659 #define EVT_GRID_CMD_COL_MOVE(id, fn) wx__DECLARE_GRIDEVT(COL_MOVE, id, fn)
2660 #define EVT_GRID_CMD_COL_SORT(id, fn) wx__DECLARE_GRIDEVT(COL_SORT, id, fn)
2661 #define EVT_GRID_CMD_RANGE_SELECT(id, fn) wx__DECLARE_GRIDRANGESELEVT(RANGE_SELECT, id, fn)
2662 #define EVT_GRID_CMD_CELL_CHANGING(id, fn) wx__DECLARE_GRIDEVT(CELL_CHANGING, id, fn)
2663 #define EVT_GRID_CMD_CELL_CHANGED(id, fn) wx__DECLARE_GRIDEVT(CELL_CHANGED, id, fn)
2664 #define EVT_GRID_CMD_SELECT_CELL(id, fn) wx__DECLARE_GRIDEVT(SELECT_CELL, id, fn)
2665 #define EVT_GRID_CMD_EDITOR_SHOWN(id, fn) wx__DECLARE_GRIDEVT(EDITOR_SHOWN, id, fn)
2666 #define EVT_GRID_CMD_EDITOR_HIDDEN(id, fn) wx__DECLARE_GRIDEVT(EDITOR_HIDDEN, id, fn)
2667 #define EVT_GRID_CMD_EDITOR_CREATED(id, fn) wx__DECLARE_GRIDEDITOREVT(EDITOR_CREATED, id, fn)
2668 #define EVT_GRID_CMD_CELL_BEGIN_DRAG(id, fn) wx__DECLARE_GRIDEVT(CELL_BEGIN_DRAG, id, fn)
2669 #define EVT_GRID_CMD_TABBING(id, fn) wx__DECLARE_GRIDEVT(TABBING, id, fn)
2670
2671 // same as above but for any id (exists mainly for backwards compatibility but
2672 // then it's also true that you rarely have multiple grid in the same window)
2673 #define EVT_GRID_CELL_LEFT_CLICK(fn) EVT_GRID_CMD_CELL_LEFT_CLICK(wxID_ANY, fn)
2674 #define EVT_GRID_CELL_RIGHT_CLICK(fn) EVT_GRID_CMD_CELL_RIGHT_CLICK(wxID_ANY, fn)
2675 #define EVT_GRID_CELL_LEFT_DCLICK(fn) EVT_GRID_CMD_CELL_LEFT_DCLICK(wxID_ANY, fn)
2676 #define EVT_GRID_CELL_RIGHT_DCLICK(fn) EVT_GRID_CMD_CELL_RIGHT_DCLICK(wxID_ANY, fn)
2677 #define EVT_GRID_LABEL_LEFT_CLICK(fn) EVT_GRID_CMD_LABEL_LEFT_CLICK(wxID_ANY, fn)
2678 #define EVT_GRID_LABEL_RIGHT_CLICK(fn) EVT_GRID_CMD_LABEL_RIGHT_CLICK(wxID_ANY, fn)
2679 #define EVT_GRID_LABEL_LEFT_DCLICK(fn) EVT_GRID_CMD_LABEL_LEFT_DCLICK(wxID_ANY, fn)
2680 #define EVT_GRID_LABEL_RIGHT_DCLICK(fn) EVT_GRID_CMD_LABEL_RIGHT_DCLICK(wxID_ANY, fn)
2681 #define EVT_GRID_ROW_SIZE(fn) EVT_GRID_CMD_ROW_SIZE(wxID_ANY, fn)
2682 #define EVT_GRID_COL_SIZE(fn) EVT_GRID_CMD_COL_SIZE(wxID_ANY, fn)
2683 #define EVT_GRID_COL_MOVE(fn) EVT_GRID_CMD_COL_MOVE(wxID_ANY, fn)
2684 #define EVT_GRID_COL_SORT(fn) EVT_GRID_CMD_COL_SORT(wxID_ANY, fn)
2685 #define EVT_GRID_RANGE_SELECT(fn) EVT_GRID_CMD_RANGE_SELECT(wxID_ANY, fn)
2686 #define EVT_GRID_CELL_CHANGING(fn) EVT_GRID_CMD_CELL_CHANGING(wxID_ANY, fn)
2687 #define EVT_GRID_CELL_CHANGED(fn) EVT_GRID_CMD_CELL_CHANGED(wxID_ANY, fn)
2688 #define EVT_GRID_SELECT_CELL(fn) EVT_GRID_CMD_SELECT_CELL(wxID_ANY, fn)
2689 #define EVT_GRID_EDITOR_SHOWN(fn) EVT_GRID_CMD_EDITOR_SHOWN(wxID_ANY, fn)
2690 #define EVT_GRID_EDITOR_HIDDEN(fn) EVT_GRID_CMD_EDITOR_HIDDEN(wxID_ANY, fn)
2691 #define EVT_GRID_EDITOR_CREATED(fn) EVT_GRID_CMD_EDITOR_CREATED(wxID_ANY, fn)
2692 #define EVT_GRID_CELL_BEGIN_DRAG(fn) EVT_GRID_CMD_CELL_BEGIN_DRAG(wxID_ANY, fn)
2693 #define EVT_GRID_TABBING(fn) EVT_GRID_CMD_TABBING(wxID_ANY, fn)
2694
2695 // we used to have a single wxEVT_GRID_CELL_CHANGE event but it was split into
2696 // wxEVT_GRID_CELL_CHANGING and CHANGED ones in wx 2.9.0, however the CHANGED
2697 // is basically the same as the old CHANGE event so we keep the name for
2698 // compatibility
2699 #if WXWIN_COMPATIBILITY_2_8
2700 #define wxEVT_GRID_CELL_CHANGE wxEVT_GRID_CELL_CHANGED
2701
2702 #define EVT_GRID_CMD_CELL_CHANGE EVT_GRID_CMD_CELL_CHANGED
2703 #define EVT_GRID_CELL_CHANGE EVT_GRID_CELL_CHANGED
2704 #endif // WXWIN_COMPATIBILITY_2_8
2705
2706 #if 0 // TODO: implement these ? others ?
2707
2708 extern const int wxEVT_GRID_CREATE_CELL;
2709 extern const int wxEVT_GRID_CHANGE_LABELS;
2710 extern const int wxEVT_GRID_CHANGE_SEL_LABEL;
2711
2712 #define EVT_GRID_CREATE_CELL(fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_GRID_CREATE_CELL, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxGridEventFunction, &fn ), NULL ),
2713 #define EVT_GRID_CHANGE_LABELS(fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_GRID_CHANGE_LABELS, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxGridEventFunction, &fn ), NULL ),
2714 #define EVT_GRID_CHANGE_SEL_LABEL(fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_GRID_CHANGE_SEL_LABEL, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxGridEventFunction, &fn ), NULL ),
2715
2716 #endif
2717
2718 #endif // wxUSE_GRID
2719 #endif // _WX_GENERIC_GRID_H_