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