projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added ForceRefresh() to request immediate repainting of a grid.
[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:
6 // Created: 1/08/1999
7 // RCS-ID: $Id$
8 // Copyright: (c) Michael Bedward
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/defs.h"
13
14 #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
15 #include "gridg.h"
16 #else
17
18 #ifndef __WXGRID_H__
19 #define __WXGRID_H__
20
21 #ifdef __GNUG__
22 #pragma interface "grid.h"
23 #endif
24
25 #include "wx/hash.h"
26 #include "wx/panel.h"
27 #include "wx/scrolwin.h"
28 #include "wx/string.h"
29 #include "wx/scrolbar.h"
30 #include "wx/event.h"
31 #include "wx/combobox.h"
32 #include "wx/dynarray.h"
33 #include "wx/timer.h"
34
35 // ----------------------------------------------------------------------------
36 // constants
37 // ----------------------------------------------------------------------------
38
39 // Default parameters for wxGrid
40 //
41 #define WXGRID_DEFAULT_NUMBER_ROWS 10
42 #define WXGRID_DEFAULT_NUMBER_COLS 10
43 #ifdef __WXMSW__
44 #define WXGRID_DEFAULT_ROW_HEIGHT 25
45 #else
46 #define WXGRID_DEFAULT_ROW_HEIGHT 30
47 #endif // __WXMSW__
48 #define WXGRID_DEFAULT_COL_WIDTH 80
49 #define WXGRID_DEFAULT_COL_LABEL_HEIGHT 32
50 #define WXGRID_DEFAULT_ROW_LABEL_WIDTH 82
51 #define WXGRID_LABEL_EDGE_ZONE 2
52 #define WXGRID_MIN_ROW_HEIGHT 15
53 #define WXGRID_MIN_COL_WIDTH 15
54 #define WXGRID_DEFAULT_SCROLLBAR_WIDTH 16
55
56 // type names for grid table values
57 #define wxGRID_VALUE_STRING _T("string")
58 #define wxGRID_VALUE_BOOL _T("bool")
59 #define wxGRID_VALUE_NUMBER _T("long")
60 #define wxGRID_VALUE_FLOAT _T("double")
61 #define wxGRID_VALUE_CHOICE _T("choice")
62
63 #define wxGRID_VALUE_TEXT wxGRID_VALUE_STRING
64 #define wxGRID_VALUE_LONG wxGRID_VALUE_NUMBER
65
66 // ----------------------------------------------------------------------------
67 // forward declarations
68 // ----------------------------------------------------------------------------
69
70 class WXDLLEXPORT wxGrid;
71 class WXDLLEXPORT wxGridCellAttr;
72 class WXDLLEXPORT wxGridCellAttrProviderData;
73 class WXDLLEXPORT wxGridColLabelWindow;
74 class WXDLLEXPORT wxGridCornerLabelWindow;
75 class WXDLLEXPORT wxGridRowLabelWindow;
76 class WXDLLEXPORT wxGridTableBase;
77 class WXDLLEXPORT wxGridWindow;
78 class WXDLLEXPORT wxGridTypeRegistry;
79 class WXDLLEXPORT wxGridSelection;
80
81 class WXDLLEXPORT wxCheckBox;
82 class WXDLLEXPORT wxComboBox;
83 class WXDLLEXPORT wxTextCtrl;
84 class WXDLLEXPORT wxSpinCtrl;
85
86 // ----------------------------------------------------------------------------
87 // macros
88 // ----------------------------------------------------------------------------
89
90 #define wxSafeIncRef(p) if ( p ) (p)->IncRef()
91 #define wxSafeDecRef(p) if ( p ) (p)->DecRef()
92
93 // ----------------------------------------------------------------------------
94 // wxGridCellWorker: common base class for wxGridCellRenderer and
95 // wxGridCellEditor
96 //
97 // NB: this is more an implementation convenience than a design issue, so this
98 // class is not documented and is not public at all
99 // ----------------------------------------------------------------------------
100
101 class WXDLLEXPORT wxGridCellWorker
102 {
103 public:
104 wxGridCellWorker() { m_nRef = 1; }
105
106 // this class is ref counted: it is created with ref count of 1, so
107 // calling DecRef() once will delete it. Calling IncRef() allows to lock
108 // it until the matching DecRef() is called
109 void IncRef() { m_nRef++; }
110 void DecRef() { if ( !--m_nRef ) delete this; }
111
112 // interpret renderer parameters: arbitrary string whose interpretatin is
113 // left to the derived classes
114 virtual void SetParameters(const wxString& params);
115
116 protected:
117 // virtual dtor for any base class - private because only DecRef() can
118 // delete us
119 virtual ~wxGridCellWorker();
120
121 private:
122 size_t m_nRef;
123
124 // suppress the stupid gcc warning about the class having private dtor and
125 // no friends
126 friend class wxGridCellWorkerDummyFriend;
127 };
128
129 // ----------------------------------------------------------------------------
130 // wxGridCellRenderer: this class is responsible for actually drawing the cell
131 // in the grid. You may pass it to the wxGridCellAttr (below) to change the
132 // format of one given cell or to wxGrid::SetDefaultRenderer() to change the
133 // view of all cells. This is an ABC, you will normally use one of the
134 // predefined derived classes or derive your own class from it.
135 // ----------------------------------------------------------------------------
136
137 class WXDLLEXPORT wxGridCellRenderer : public wxGridCellWorker
138 {
139 public:
140 // draw the given cell on the provided DC inside the given rectangle
141 // using the style specified by the attribute and the default or selected
142 // state corresponding to the isSelected value.
143 //
144 // this pure virtual function has a default implementation which will
145 // prepare the DC using the given attribute: it will draw the rectangle
146 // with the bg colour from attr and set the text colour and font
147 virtual void Draw(wxGrid& grid,
148 wxGridCellAttr& attr,
149 wxDC& dc,
150 const wxRect& rect,
151 int row, int col,
152 bool isSelected) = 0;
153
154 // get the preferred size of the cell for its contents
155 virtual wxSize GetBestSize(wxGrid& grid,
156 wxGridCellAttr& attr,
157 wxDC& dc,
158 int row, int col) = 0;
159
160 // create a new object which is the copy of this one
161 virtual wxGridCellRenderer *Clone() const = 0;
162 };
163
164 // the default renderer for the cells containing string data
165 class WXDLLEXPORT wxGridCellStringRenderer : public wxGridCellRenderer
166 {
167 public:
168 // draw the string
169 virtual void Draw(wxGrid& grid,
170 wxGridCellAttr& attr,
171 wxDC& dc,
172 const wxRect& rect,
173 int row, int col,
174 bool isSelected);
175
176 // return the string extent
177 virtual wxSize GetBestSize(wxGrid& grid,
178 wxGridCellAttr& attr,
179 wxDC& dc,
180 int row, int col);
181
182 virtual wxGridCellRenderer *Clone() const
183 { return new wxGridCellStringRenderer; }
184
185 protected:
186 // set the text colours before drawing
187 void SetTextColoursAndFont(wxGrid& grid,
188 wxGridCellAttr& attr,
189 wxDC& dc,
190 bool isSelected);
191
192 // calc the string extent for given string/font
193 wxSize DoGetBestSize(wxGridCellAttr& attr,
194 wxDC& dc,
195 const wxString& text);
196 };
197
198 // the default renderer for the cells containing numeric (long) data
199 class WXDLLEXPORT wxGridCellNumberRenderer : public wxGridCellStringRenderer
200 {
201 public:
202 // draw the string right aligned
203 virtual void Draw(wxGrid& grid,
204 wxGridCellAttr& attr,
205 wxDC& dc,
206 const wxRect& rect,
207 int row, int col,
208 bool isSelected);
209
210 virtual wxSize GetBestSize(wxGrid& grid,
211 wxGridCellAttr& attr,
212 wxDC& dc,
213 int row, int col);
214
215 virtual wxGridCellRenderer *Clone() const
216 { return new wxGridCellNumberRenderer; }
217
218 protected:
219 wxString GetString(wxGrid& grid, int row, int col);
220 };
221
222 class WXDLLEXPORT wxGridCellFloatRenderer : public wxGridCellStringRenderer
223 {
224 public:
225 wxGridCellFloatRenderer(int width = -1, int precision = -1);
226
227 // get/change formatting parameters
228 int GetWidth() const { return m_width; }
229 void SetWidth(int width) { m_width = width; m_format.clear(); }
230 int GetPrecision() const { return m_precision; }
231 void SetPrecision(int precision) { m_precision = precision; m_format.clear(); }
232
233 // draw the string right aligned with given width/precision
234 virtual void Draw(wxGrid& grid,
235 wxGridCellAttr& attr,
236 wxDC& dc,
237 const wxRect& rect,
238 int row, int col,
239 bool isSelected);
240
241 virtual wxSize GetBestSize(wxGrid& grid,
242 wxGridCellAttr& attr,
243 wxDC& dc,
244 int row, int col);
245
246 // parameters string format is "width[,precision]"
247 virtual void SetParameters(const wxString& params);
248
249 virtual wxGridCellRenderer *Clone() const;
250
251 protected:
252 wxString GetString(wxGrid& grid, int row, int col);
253
254 private:
255 // formatting parameters
256 int m_width,
257 m_precision;
258
259 wxString m_format;
260 };
261
262 // renderer for boolean fields
263 class WXDLLEXPORT wxGridCellBoolRenderer : public wxGridCellRenderer
264 {
265 public:
266 // draw a check mark or nothing
267 virtual void Draw(wxGrid& grid,
268 wxGridCellAttr& attr,
269 wxDC& dc,
270 const wxRect& rect,
271 int row, int col,
272 bool isSelected);
273
274 // return the checkmark size
275 virtual wxSize GetBestSize(wxGrid& grid,
276 wxGridCellAttr& attr,
277 wxDC& dc,
278 int row, int col);
279
280 virtual wxGridCellRenderer *Clone() const
281 { return new wxGridCellBoolRenderer; }
282
283 private:
284 static wxSize ms_sizeCheckMark;
285 };
286
287 // ----------------------------------------------------------------------------
288 // wxGridCellEditor: This class is responsible for providing and manipulating
289 // the in-place edit controls for the grid. Instances of wxGridCellEditor
290 // (actually, instances of derived classes since it is an ABC) can be
291 // associated with the cell attributes for individual cells, rows, columns, or
292 // even for the entire grid.
293 // ----------------------------------------------------------------------------
294
295 class WXDLLEXPORT wxGridCellEditor : public wxGridCellWorker
296 {
297 public:
298 wxGridCellEditor();
299
300 bool IsCreated() { return m_control != NULL; }
301 wxControl* GetControl() { return m_control; }
302 void SetControl(wxControl* control) { m_control = control; }
303
304 // Creates the actual edit control
305 virtual void Create(wxWindow* parent,
306 wxWindowID id,
307 wxEvtHandler* evtHandler) = 0;
308
309 // Size and position the edit control
310 virtual void SetSize(const wxRect& rect);
311
312 // Show or hide the edit control, use the specified attributes to set
313 // colours/fonts for it
314 virtual void Show(bool show, wxGridCellAttr *attr = (wxGridCellAttr *)NULL);
315
316 // Draws the part of the cell not occupied by the control: the base class
317 // version just fills it with background colour from the attribute
318 virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr);
319
320 // Fetch the value from the table and prepare the edit control
321 // to begin editing. Set the focus to the edit control.
322 virtual void BeginEdit(int row, int col, wxGrid* grid) = 0;
323
324 // Complete the editing of the current cell. Returns true if the value has
325 // changed. If necessary, the control may be destroyed.
326 virtual bool EndEdit(int row, int col, wxGrid* grid) = 0;
327
328 // Reset the value in the control back to its starting value
329 virtual void Reset() = 0;
330
331 // return TRUE to allow the given key to start editing: the base class
332 // version only checks that the event has no modifiers. The derived
333 // classes are supposed to do "if ( base::IsAcceptedKey() && ... )" in
334 // their IsAcceptedKey() implementation, although, of course, it is not a
335 // mandatory requirment.
336 //
337 // NB: if the key is F2 (special), editing will always start and this
338 // method will not be called at all (but StartingKey() will)
339 virtual bool IsAcceptedKey(wxKeyEvent& event);
340
341 // If the editor is enabled by pressing keys on the grid, this will be
342 // called to let the editor do something about that first key if desired
343 virtual void StartingKey(wxKeyEvent& event);
344
345 // if the editor is enabled by clicking on the cell, this method will be
346 // called
347 virtual void StartingClick();
348
349 // Some types of controls on some platforms may need some help
350 // with the Return key.
351 virtual void HandleReturn(wxKeyEvent& event);
352
353 // Final cleanup
354 virtual void Destroy();
355
356 // create a new object which is the copy of this one
357 virtual wxGridCellEditor *Clone() const = 0;
358
359 protected:
360 // the dtor is private because only DecRef() can delete us
361 virtual ~wxGridCellEditor();
362
363 // the control we show on screen
364 wxControl* m_control;
365
366 // if we change the colours/font of the control from the default ones, we
367 // must restore the default later and we save them here between calls to
368 // Show(TRUE) and Show(FALSE)
369 wxColour m_colFgOld,
370 m_colBgOld;
371 wxFont m_fontOld;
372
373 // suppress the stupid gcc warning about the class having private dtor and
374 // no friends
375 friend class wxGridCellEditorDummyFriend;
376 };
377
378 // the editor for string/text data
379 class WXDLLEXPORT wxGridCellTextEditor : public wxGridCellEditor
380 {
381 public:
382 wxGridCellTextEditor();
383
384 virtual void Create(wxWindow* parent,
385 wxWindowID id,
386 wxEvtHandler* evtHandler);
387 virtual void SetSize(const wxRect& rect);
388
389 virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr);
390
391 virtual bool IsAcceptedKey(wxKeyEvent& event);
392 virtual void BeginEdit(int row, int col, wxGrid* grid);
393 virtual bool EndEdit(int row, int col, wxGrid* grid);
394
395 virtual void Reset();
396 virtual void StartingKey(wxKeyEvent& event);
397 virtual void HandleReturn(wxKeyEvent& event);
398
399 // parameters string format is "max_width"
400 virtual void SetParameters(const wxString& params);
401
402 virtual wxGridCellEditor *Clone() const
403 { return new wxGridCellTextEditor; }
404
405 protected:
406 wxTextCtrl *Text() const { return (wxTextCtrl *)m_control; }
407
408 // parts of our virtual functions reused by the derived classes
409 void DoBeginEdit(const wxString& startValue);
410 void DoReset(const wxString& startValue);
411
412 private:
413 size_t m_maxChars; // max number of chars allowed
414 wxString m_startValue;
415 };
416
417 // the editor for numeric (long) data
418 class WXDLLEXPORT wxGridCellNumberEditor : public wxGridCellTextEditor
419 {
420 public:
421 // allows to specify the range - if min == max == -1, no range checking is
422 // done
423 wxGridCellNumberEditor(int min = -1, int max = -1);
424
425 virtual void Create(wxWindow* parent,
426 wxWindowID id,
427 wxEvtHandler* evtHandler);
428
429 virtual bool IsAcceptedKey(wxKeyEvent& event);
430 virtual void BeginEdit(int row, int col, wxGrid* grid);
431 virtual bool EndEdit(int row, int col, wxGrid* grid);
432
433 virtual void Reset();
434 virtual void StartingKey(wxKeyEvent& event);
435
436 // parameters string format is "min,max"
437 virtual void SetParameters(const wxString& params);
438
439 virtual wxGridCellEditor *Clone() const
440 { return new wxGridCellNumberEditor(m_min, m_max); }
441
442 protected:
443 wxSpinCtrl *Spin() const { return (wxSpinCtrl *)m_control; }
444
445 // if HasRange(), we use wxSpinCtrl - otherwise wxTextCtrl
446 bool HasRange() const { return m_min != m_max; }
447
448 // string representation of m_valueOld
449 wxString GetString() const
450 { return wxString::Format(_T("%ld"), m_valueOld); }
451
452 private:
453 int m_min,
454 m_max;
455
456 long m_valueOld;
457 };
458
459 // the editor for floating point numbers (double) data
460 class WXDLLEXPORT wxGridCellFloatEditor : public wxGridCellTextEditor
461 {
462 public:
463 wxGridCellFloatEditor(int width = -1, int precision = -1);
464
465 virtual void Create(wxWindow* parent,
466 wxWindowID id,
467 wxEvtHandler* evtHandler);
468
469 virtual bool IsAcceptedKey(wxKeyEvent& event);
470 virtual void BeginEdit(int row, int col, wxGrid* grid);
471 virtual bool EndEdit(int row, int col, wxGrid* grid);
472
473 virtual void Reset();
474 virtual void StartingKey(wxKeyEvent& event);
475
476 virtual wxGridCellEditor *Clone() const
477 { return new wxGridCellFloatEditor; }
478
479 // parameters string format is "width,precision"
480 virtual void SetParameters(const wxString& params);
481
482 protected:
483 // string representation of m_valueOld
484 wxString GetString() const;
485
486 private:
487 int m_width,
488 m_precision;
489 double m_valueOld;
490 };
491
492 // the editor for boolean data
493 class WXDLLEXPORT wxGridCellBoolEditor : public wxGridCellEditor
494 {
495 public:
496 virtual void Create(wxWindow* parent,
497 wxWindowID id,
498 wxEvtHandler* evtHandler);
499
500 virtual void SetSize(const wxRect& rect);
501 virtual void Show(bool show, wxGridCellAttr *attr = (wxGridCellAttr *)NULL);
502
503 virtual bool IsAcceptedKey(wxKeyEvent& event);
504 virtual void BeginEdit(int row, int col, wxGrid* grid);
505 virtual bool EndEdit(int row, int col, wxGrid* grid);
506
507 virtual void Reset();
508 virtual void StartingClick();
509
510 virtual wxGridCellEditor *Clone() const
511 { return new wxGridCellBoolEditor; }
512
513 protected:
514 wxCheckBox *CBox() const { return (wxCheckBox *)m_control; }
515
516 private:
517 bool m_startValue;
518 };
519
520 // the editor for string data allowing to choose from the list of strings
521 class WXDLLEXPORT wxGridCellChoiceEditor : public wxGridCellEditor
522 {
523 public:
524 // if !allowOthers, user can't type a string not in choices array
525 wxGridCellChoiceEditor(size_t count = 0,
526 const wxString choices[] = NULL,
527 bool allowOthers = FALSE);
528
529 virtual void Create(wxWindow* parent,
530 wxWindowID id,
531 wxEvtHandler* evtHandler);
532
533 virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr);
534
535 virtual void BeginEdit(int row, int col, wxGrid* grid);
536 virtual bool EndEdit(int row, int col, wxGrid* grid);
537
538 virtual void Reset();
539
540 // parameters string format is "item1[,item2[...,itemN]]"
541 virtual void SetParameters(const wxString& params);
542
543 virtual wxGridCellEditor *Clone() const;
544
545 protected:
546 wxComboBox *Combo() const { return (wxComboBox *)m_control; }
547
548 private:
549 wxString m_startValue;
550 wxArrayString m_choices;
551 bool m_allowOthers;
552 };
553
554 // ----------------------------------------------------------------------------
555 // wxGridCellAttr: this class can be used to alter the cells appearance in
556 // the grid by changing their colour/font/... from default. An object of this
557 // class may be returned by wxGridTable::GetAttr().
558 // ----------------------------------------------------------------------------
559
560 class WXDLLEXPORT wxGridCellAttr
561 {
562 public:
563 // ctors
564 wxGridCellAttr()
565 {
566 Init();
567 SetAlignment(0, 0);
568 }
569
570 // VZ: considering the number of members wxGridCellAttr has now, this ctor
571 // seems to be pretty useless... may be we should just remove it?
572 wxGridCellAttr(const wxColour& colText,
573 const wxColour& colBack,
574 const wxFont& font,
575 int hAlign,
576 int vAlign)
577 : m_colText(colText), m_colBack(colBack), m_font(font)
578 {
579 Init();
580 SetAlignment(hAlign, vAlign);
581 }
582
583 // creates a new copy of this object
584 wxGridCellAttr *Clone() const;
585
586 // this class is ref counted: it is created with ref count of 1, so
587 // calling DecRef() once will delete it. Calling IncRef() allows to lock
588 // it until the matching DecRef() is called
589 void IncRef() { m_nRef++; }
590 void DecRef() { if ( !--m_nRef ) delete this; }
591
592 // setters
593 void SetTextColour(const wxColour& colText) { m_colText = colText; }
594 void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; }
595 void SetFont(const wxFont& font) { m_font = font; }
596 void SetAlignment(int hAlign, int vAlign)
597 {
598 m_hAlign = hAlign;
599 m_vAlign = vAlign;
600 }
601 void SetReadOnly(bool isReadOnly = TRUE) { m_isReadOnly = isReadOnly; }
602
603 // takes ownership of the pointer
604 void SetRenderer(wxGridCellRenderer *renderer)
605 { wxSafeDecRef(m_renderer); m_renderer = renderer; }
606 void SetEditor(wxGridCellEditor* editor)
607 { wxSafeDecRef(m_editor); m_editor = editor; }
608
609 // accessors
610 bool HasTextColour() const { return m_colText.Ok(); }
611 bool HasBackgroundColour() const { return m_colBack.Ok(); }
612 bool HasFont() const { return m_font.Ok(); }
613 bool HasAlignment() const { return m_hAlign || m_vAlign; }
614 bool HasRenderer() const { return m_renderer != NULL; }
615 bool HasEditor() const { return m_editor != NULL; }
616
617 const wxColour& GetTextColour() const;
618 const wxColour& GetBackgroundColour() const;
619 const wxFont& GetFont() const;
620 void GetAlignment(int *hAlign, int *vAlign) const;
621 wxGridCellRenderer *GetRenderer(wxGrid* grid, int row, int col) const;
622 wxGridCellEditor *GetEditor(wxGrid* grid, int row, int col) const;
623
624 bool IsReadOnly() const { return m_isReadOnly; }
625
626 void SetDefAttr(wxGridCellAttr* defAttr) { m_defGridAttr = defAttr; }
627
628 private:
629 // the common part of all ctors
630 void Init()
631 {
632 m_nRef = 1;
633
634 m_isReadOnly = FALSE;
635
636 m_renderer = NULL;
637 m_editor = NULL;
638 }
639
640 // the dtor is private because only DecRef() can delete us
641 ~wxGridCellAttr()
642 {
643 wxSafeDecRef(m_renderer);
644 wxSafeDecRef(m_editor);
645 }
646
647 // the ref count - when it goes to 0, we die
648 size_t m_nRef;
649
650 wxColour m_colText,
651 m_colBack;
652 wxFont m_font;
653 int m_hAlign,
654 m_vAlign;
655
656 wxGridCellRenderer* m_renderer;
657 wxGridCellEditor* m_editor;
658 wxGridCellAttr* m_defGridAttr;
659
660 bool m_isReadOnly;
661
662 // use Clone() instead
663 DECLARE_NO_COPY_CLASS(wxGridCellAttr);
664
665 // suppress the stupid gcc warning about the class having private dtor and
666 // no friends
667 friend class wxGridCellAttrDummyFriend;
668 };
669
670 // ----------------------------------------------------------------------------
671 // wxGridCellAttrProvider: class used by wxGridTableBase to retrieve/store the
672 // cell attributes.
673 // ----------------------------------------------------------------------------
674
675 // implementation note: we separate it from wxGridTableBase because we wish to
676 // avoid deriving a new table class if possible, and sometimes it will be
677 // enough to just derive another wxGridCellAttrProvider instead
678 //
679 // the default implementation is reasonably efficient for the generic case,
680 // but you might still wish to implement your own for some specific situations
681 // if you have performance problems with the stock one
682 class WXDLLEXPORT wxGridCellAttrProvider
683 {
684 public:
685 wxGridCellAttrProvider();
686 virtual ~wxGridCellAttrProvider();
687
688 // DecRef() must be called on the returned pointer
689 virtual wxGridCellAttr *GetAttr(int row, int col) const;
690
691 // all these functions take ownership of the pointer, don't call DecRef()
692 // on it
693 virtual void SetAttr(wxGridCellAttr *attr, int row, int col);
694 virtual void SetRowAttr(wxGridCellAttr *attr, int row);
695 virtual void SetColAttr(wxGridCellAttr *attr, int col);
696
697 // these functions must be called whenever some rows/cols are deleted
698 // because the internal data must be updated then
699 void UpdateAttrRows( size_t pos, int numRows );
700 void UpdateAttrCols( size_t pos, int numCols );
701
702 private:
703 void InitData();
704
705 wxGridCellAttrProviderData *m_data;
706 };
707
708 //////////////////////////////////////////////////////////////////////
709 //
710 // Grid table classes
711 //
712 //////////////////////////////////////////////////////////////////////
713
714
715 class WXDLLEXPORT wxGridTableBase : public wxObject
716 {
717 public:
718 wxGridTableBase();
719 virtual ~wxGridTableBase();
720
721 // You must override these functions in a derived table class
722 //
723 virtual int GetNumberRows() = 0;
724 virtual int GetNumberCols() = 0;
725 virtual bool IsEmptyCell( int row, int col ) = 0;
726 virtual wxString GetValue( int row, int col ) = 0;
727 virtual void SetValue( int row, int col, const wxString& value ) = 0;
728
729 // Data type determination and value access
730 virtual wxString GetTypeName( int row, int col );
731 virtual bool CanGetValueAs( int row, int col, const wxString& typeName );
732 virtual bool CanSetValueAs( int row, int col, const wxString& typeName );
733
734 virtual long GetValueAsLong( int row, int col );
735 virtual double GetValueAsDouble( int row, int col );
736 virtual bool GetValueAsBool( int row, int col );
737
738 virtual void SetValueAsLong( int row, int col, long value );
739 virtual void SetValueAsDouble( int row, int col, double value );
740 virtual void SetValueAsBool( int row, int col, bool value );
741
742 // For user defined types
743 virtual void* GetValueAsCustom( int row, int col, const wxString& typeName );
744 virtual void SetValueAsCustom( int row, int col, const wxString& typeName, void* value );
745
746
747 // Overriding these is optional
748 //
749 virtual void SetView( wxGrid *grid ) { m_view = grid; }
750 virtual wxGrid * GetView() const { return m_view; }
751
752 virtual void Clear() {}
753 virtual bool InsertRows( size_t pos = 0, size_t numRows = 1 );
754 virtual bool AppendRows( size_t numRows = 1 );
755 virtual bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
756 virtual bool InsertCols( size_t pos = 0, size_t numCols = 1 );
757 virtual bool AppendCols( size_t numCols = 1 );
758 virtual bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
759
760 virtual wxString GetRowLabelValue( int row );
761 virtual wxString GetColLabelValue( int col );
762 virtual void SetRowLabelValue( int WXUNUSED(row), const wxString& ) {}
763 virtual void SetColLabelValue( int WXUNUSED(col), const wxString& ) {}
764
765 // Attribute handling
766 //
767
768 // give us the attr provider to use - we take ownership of the pointer
769 void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
770
771 // get the currently used attr provider (may be NULL)
772 wxGridCellAttrProvider *GetAttrProvider() const { return m_attrProvider; }
773
774 // Does this table allow attributes? Default implementation creates
775 // a wxGridCellAttrProvider if necessary.
776 virtual bool CanHaveAttributes();
777
778 // by default forwarded to wxGridCellAttrProvider if any. May be
779 // overridden to handle attributes directly in the table.
780 virtual wxGridCellAttr *GetAttr( int row, int col );
781
782 // these functions take ownership of the pointer
783 virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
784 virtual void SetRowAttr(wxGridCellAttr *attr, int row);
785 virtual void SetColAttr(wxGridCellAttr *attr, int col);
786
787 private:
788 wxGrid * m_view;
789 wxGridCellAttrProvider *m_attrProvider;
790
791 DECLARE_ABSTRACT_CLASS( wxGridTableBase );
792 };
793
794
795 // ----------------------------------------------------------------------------
796 // wxGridTableMessage
797 // ----------------------------------------------------------------------------
798
799 // IDs for messages sent from grid table to view
800 //
801 enum wxGridTableRequest
802 {
803 wxGRIDTABLE_REQUEST_VIEW_GET_VALUES = 2000,
804 wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES,
805 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
806 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
807 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
808 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
809 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
810 wxGRIDTABLE_NOTIFY_COLS_DELETED
811 };
812
813 class WXDLLEXPORT wxGridTableMessage
814 {
815 public:
816 wxGridTableMessage();
817 wxGridTableMessage( wxGridTableBase *table, int id,
818 int comInt1 = -1,
819 int comInt2 = -1 );
820
821 void SetTableObject( wxGridTableBase *table ) { m_table = table; }
822 wxGridTableBase * GetTableObject() const { return m_table; }
823 void SetId( int id ) { m_id = id; }
824 int GetId() { return m_id; }
825 void SetCommandInt( int comInt1 ) { m_comInt1 = comInt1; }
826 int GetCommandInt() { return m_comInt1; }
827 void SetCommandInt2( int comInt2 ) { m_comInt2 = comInt2; }
828 int GetCommandInt2() { return m_comInt2; }
829
830 private:
831 wxGridTableBase *m_table;
832 int m_id;
833 int m_comInt1;
834 int m_comInt2;
835 };
836
837
838
839 // ------ wxGridStringArray
840 // A 2-dimensional array of strings for data values
841 //
842
843 WX_DECLARE_EXPORTED_OBJARRAY(wxArrayString, wxGridStringArray);
844
845
846
847 // ------ wxGridStringTable
848 //
849 // Simplest type of data table for a grid for small tables of strings
850 // that are stored in memory
851 //
852
853 class WXDLLEXPORT wxGridStringTable : public wxGridTableBase
854 {
855 public:
856 wxGridStringTable();
857 wxGridStringTable( int numRows, int numCols );
858 ~wxGridStringTable();
859
860 // these are pure virtual in wxGridTableBase
861 //
862 int GetNumberRows();
863 int GetNumberCols();
864 wxString GetValue( int row, int col );
865 void SetValue( int row, int col, const wxString& s );
866 bool IsEmptyCell( int row, int col );
867
868 // overridden functions from wxGridTableBase
869 //
870 void Clear();
871 bool InsertRows( size_t pos = 0, size_t numRows = 1 );
872 bool AppendRows( size_t numRows = 1 );
873 bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
874 bool InsertCols( size_t pos = 0, size_t numCols = 1 );
875 bool AppendCols( size_t numCols = 1 );
876 bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
877
878 void SetRowLabelValue( int row, const wxString& );
879 void SetColLabelValue( int col, const wxString& );
880 wxString GetRowLabelValue( int row );
881 wxString GetColLabelValue( int col );
882
883 private:
884 wxGridStringArray m_data;
885
886 // These only get used if you set your own labels, otherwise the
887 // GetRow/ColLabelValue functions return wxGridTableBase defaults
888 //
889 wxArrayString m_rowLabels;
890 wxArrayString m_colLabels;
891
892 DECLARE_DYNAMIC_CLASS( wxGridStringTable )
893 };
894
895
896
897 // ============================================================================
898 // Grid view classes
899 // ============================================================================
900
901 // ----------------------------------------------------------------------------
902 // wxGridCellCoords: location of a cell in the grid
903 // ----------------------------------------------------------------------------
904
905 class WXDLLEXPORT wxGridCellCoords
906 {
907 public:
908 wxGridCellCoords() { m_row = m_col = -1; }
909 wxGridCellCoords( int r, int c ) { m_row = r; m_col = c; }
910
911 // default copy ctor is ok
912
913 int GetRow() const { return m_row; }
914 void SetRow( int n ) { m_row = n; }
915 int GetCol() const { return m_col; }
916 void SetCol( int n ) { m_col = n; }
917 void Set( int row, int col ) { m_row = row; m_col = col; }
918
919 wxGridCellCoords& operator=( const wxGridCellCoords& other )
920 {
921 if ( &other != this )
922 {
923 m_row=other.m_row;
924 m_col=other.m_col;
925 }
926 return *this;
927 }
928
929 bool operator==( const wxGridCellCoords& other ) const
930 {
931 return (m_row == other.m_row && m_col == other.m_col);
932 }
933
934 bool operator!=( const wxGridCellCoords& other ) const
935 {
936 return (m_row != other.m_row || m_col != other.m_col);
937 }
938
939 bool operator!() const
940 {
941 return (m_row == -1 && m_col == -1 );
942 }
943
944 private:
945 int m_row;
946 int m_col;
947 };
948
949
950 // For comparisons...
951 //
952 extern WXDLLEXPORT wxGridCellCoords wxGridNoCellCoords;
953 extern WXDLLEXPORT wxRect wxGridNoCellRect;
954
955 // An array of cell coords...
956 //
957 WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellCoords, wxGridCellCoordsArray);
958
959 // ----------------------------------------------------------------------------
960 // wxGrid
961 // ----------------------------------------------------------------------------
962
963 class WXDLLEXPORT wxGrid : public wxScrolledWindow
964 {
965 public:
966 wxGrid()
967 {
968 Create();
969 }
970
971 wxGrid( wxWindow *parent,
972 wxWindowID id,
973 const wxPoint& pos = wxDefaultPosition,
974 const wxSize& size = wxDefaultSize,
975 long style = wxWANTS_CHARS,
976 const wxString& name = wxPanelNameStr );
977
978 ~wxGrid();
979
980 enum wxGridSelectionModes {wxGridSelectCells,
981 wxGridSelectRows,
982 wxGridSelectColumns};
983
984 bool CreateGrid( int numRows, int numCols,
985 wxGrid::wxGridSelectionModes selmode =
986 wxGrid::wxGridSelectCells );
987
988 void SetSelectionMode(wxGrid::wxGridSelectionModes selmode);
989
990 // ------ grid dimensions
991 //
992 int GetNumberRows() { return m_numRows; }
993 int GetNumberCols() { return m_numCols; }
994
995
996 // ------ display update functions
997 //
998 void CalcRowLabelsExposed( const wxRegion& reg );
999
1000 void CalcColLabelsExposed( const wxRegion& reg );
1001 void CalcCellsExposed( const wxRegion& reg );
1002
1003
1004 // ------ event handlers
1005 //
1006 void ProcessRowLabelMouseEvent( wxMouseEvent& event );
1007 void ProcessColLabelMouseEvent( wxMouseEvent& event );
1008 void ProcessCornerLabelMouseEvent( wxMouseEvent& event );
1009 void ProcessGridCellMouseEvent( wxMouseEvent& event );
1010 bool ProcessTableMessage( wxGridTableMessage& );
1011
1012 void DoEndDragResizeRow();
1013 void DoEndDragResizeCol();
1014
1015 wxGridTableBase * GetTable() const { return m_table; }
1016 bool SetTable( wxGridTableBase *table, bool takeOwnership=FALSE,
1017 wxGrid::wxGridSelectionModes selmode =
1018 wxGrid::wxGridSelectCells );
1019
1020 void ClearGrid();
1021 bool InsertRows( int pos = 0, int numRows = 1, bool updateLabels=TRUE );
1022 bool AppendRows( int numRows = 1, bool updateLabels=TRUE );
1023 bool DeleteRows( int pos = 0, int numRows = 1, bool updateLabels=TRUE );
1024 bool InsertCols( int pos = 0, int numCols = 1, bool updateLabels=TRUE );
1025 bool AppendCols( int numCols = 1, bool updateLabels=TRUE );
1026 bool DeleteCols( int pos = 0, int numCols = 1, bool updateLabels=TRUE );
1027
1028 void DrawGridCellArea( wxDC& dc );
1029 void DrawGridSpace( wxDC& dc );
1030 void DrawCellBorder( wxDC& dc, const wxGridCellCoords& );
1031 void DrawAllGridLines( wxDC& dc, const wxRegion & reg );
1032 void DrawCell( wxDC& dc, const wxGridCellCoords& );
1033 void DrawHighlight(wxDC& dc);
1034
1035 // this function is called when the current cell highlight must be redrawn
1036 // and may be overridden by the user
1037 virtual void DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr );
1038
1039 void DrawRowLabels( wxDC& dc );
1040 void DrawRowLabel( wxDC& dc, int row );
1041
1042 void DrawColLabels( wxDC& dc );
1043 void DrawColLabel( wxDC& dc, int col );
1044
1045
1046 // ------ Cell text drawing functions
1047 //
1048 void DrawTextRectangle( wxDC& dc, const wxString&, const wxRect&,
1049 int horizontalAlignment = wxLEFT,
1050 int verticalAlignment = wxTOP );
1051
1052 // Split a string containing newline chararcters into an array of
1053 // strings and return the number of lines
1054 //
1055 void StringToLines( const wxString& value, wxArrayString& lines );
1056
1057 void GetTextBoxSize( wxDC& dc,
1058 wxArrayString& lines,
1059 long *width, long *height );
1060
1061
1062 // ------
1063 // Code that does a lot of grid modification can be enclosed
1064 // between BeginBatch() and EndBatch() calls to avoid screen
1065 // flicker
1066 //
1067 void BeginBatch() { m_batchCount++; }
1068 void EndBatch();
1069
1070 int GetBatchCount() { return m_batchCount; }
1071
1072 // Use this, rather than wxWindow::Refresh(), to force an
1073 // immediate repainting of the grid. Has no effect if you are
1074 // already inside a BeginBatch / EndBatch block.
1075 //
1076 // This function is necessary because wxGrid has a minimal OnPaint()
1077 // handler to reduce screen flicker.
1078 //
1079 void ForceRefresh();
1080
1081
1082 // ------ edit control functions
1083 //
1084 bool IsEditable() { return m_editable; }
1085 void EnableEditing( bool edit );
1086
1087 void EnableCellEditControl( bool enable = TRUE );
1088 void DisableCellEditControl() { EnableCellEditControl(FALSE); }
1089 bool CanEnableCellControl() const;
1090 bool IsCellEditControlEnabled() const;
1091 bool IsCellEditControlShown() const;
1092
1093 bool IsCurrentCellReadOnly() const;
1094
1095 void ShowCellEditControl();
1096 void HideCellEditControl();
1097 void SaveEditControlValue();
1098
1099
1100 // ------ grid location functions
1101 // Note that all of these functions work with the logical coordinates of
1102 // grid cells and labels so you will need to convert from device
1103 // coordinates for mouse events etc.
1104 //
1105 void XYToCell( int x, int y, wxGridCellCoords& );
1106 int YToRow( int y );
1107 int XToCol( int x );
1108
1109 int YToEdgeOfRow( int y );
1110 int XToEdgeOfCol( int x );
1111
1112 wxRect CellToRect( int row, int col );
1113 wxRect CellToRect( const wxGridCellCoords& coords )
1114 { return CellToRect( coords.GetRow(), coords.GetCol() ); }
1115
1116 int GetGridCursorRow() { return m_currentCellCoords.GetRow(); }
1117 int GetGridCursorCol() { return m_currentCellCoords.GetCol(); }
1118
1119 // check to see if a cell is either wholly visible (the default arg) or
1120 // at least partially visible in the grid window
1121 //
1122 bool IsVisible( int row, int col, bool wholeCellVisible = TRUE );
1123 bool IsVisible( const wxGridCellCoords& coords, bool wholeCellVisible = TRUE )
1124 { return IsVisible( coords.GetRow(), coords.GetCol(), wholeCellVisible ); }
1125 void MakeCellVisible( int row, int col );
1126 void MakeCellVisible( const wxGridCellCoords& coords )
1127 { MakeCellVisible( coords.GetRow(), coords.GetCol() ); }
1128
1129
1130 // ------ grid cursor movement functions
1131 //
1132 void SetGridCursor( int row, int col )
1133 { SetCurrentCell( wxGridCellCoords(row, col) ); }
1134
1135 bool MoveCursorUp( bool expandSelection );
1136 bool MoveCursorDown( bool expandSelection );
1137 bool MoveCursorLeft( bool expandSelection );
1138 bool MoveCursorRight( bool expandSelection );
1139 bool MovePageDown();
1140 bool MovePageUp();
1141 bool MoveCursorUpBlock( bool expandSelection );
1142 bool MoveCursorDownBlock( bool expandSelection );
1143 bool MoveCursorLeftBlock( bool expandSelection );
1144 bool MoveCursorRightBlock( bool expandSelection );
1145
1146
1147 // ------ label and gridline formatting
1148 //
1149 int GetDefaultRowLabelSize() { return WXGRID_DEFAULT_ROW_LABEL_WIDTH; }
1150 int GetRowLabelSize() { return m_rowLabelWidth; }
1151 int GetDefaultColLabelSize() { return WXGRID_DEFAULT_COL_LABEL_HEIGHT; }
1152 int GetColLabelSize() { return m_colLabelHeight; }
1153 wxColour GetLabelBackgroundColour() { return m_labelBackgroundColour; }
1154 wxColour GetLabelTextColour() { return m_labelTextColour; }
1155 wxFont GetLabelFont() { return m_labelFont; }
1156 void GetRowLabelAlignment( int *horiz, int *vert );
1157 void GetColLabelAlignment( int *horiz, int *vert );
1158 wxString GetRowLabelValue( int row );
1159 wxString GetColLabelValue( int col );
1160 wxColour GetGridLineColour() { return m_gridLineColour; }
1161 wxColour GetCellHighlightColour() { return m_cellHighlightColour; }
1162
1163 void SetRowLabelSize( int width );
1164 void SetColLabelSize( int height );
1165 void SetLabelBackgroundColour( const wxColour& );
1166 void SetLabelTextColour( const wxColour& );
1167 void SetLabelFont( const wxFont& );
1168 void SetRowLabelAlignment( int horiz, int vert );
1169 void SetColLabelAlignment( int horiz, int vert );
1170 void SetRowLabelValue( int row, const wxString& );
1171 void SetColLabelValue( int col, const wxString& );
1172 void SetGridLineColour( const wxColour& );
1173 void SetCellHighlightColour( const wxColour& );
1174
1175 void EnableDragRowSize( bool enable = TRUE );
1176 void DisableDragRowSize() { EnableDragRowSize( FALSE ); }
1177 bool CanDragRowSize() { return m_canDragRowSize; }
1178 void EnableDragColSize( bool enable = TRUE );
1179 void DisableDragColSize() { EnableDragColSize( FALSE ); }
1180 bool CanDragColSize() { return m_canDragColSize; }
1181 void EnableDragGridSize(bool enable = TRUE);
1182 void DisableDragGridSize() { EnableDragGridSize(FALSE); }
1183 bool CanDragGridSize() { return m_canDragGridSize; }
1184
1185 // this sets the specified attribute for all cells in this row/col
1186 void SetRowAttr(int row, wxGridCellAttr *attr);
1187 void SetColAttr(int col, wxGridCellAttr *attr);
1188
1189 // shortcuts for setting the column parameters
1190
1191 // set the format for the data in the column: default is string
1192 void SetColFormatBool(int col);
1193 void SetColFormatNumber(int col);
1194 void SetColFormatFloat(int col, int width = -1, int precision = -1);
1195 void SetColFormatCustom(int col, const wxString& typeName);
1196
1197 void EnableGridLines( bool enable = TRUE );
1198 bool GridLinesEnabled() { return m_gridLinesEnabled; }
1199
1200 // ------ row and col formatting
1201 //
1202 int GetDefaultRowSize();
1203 int GetRowSize( int row );
1204 int GetDefaultColSize();
1205 int GetColSize( int col );
1206 wxColour GetDefaultCellBackgroundColour();
1207 wxColour GetCellBackgroundColour( int row, int col );
1208 wxColour GetDefaultCellTextColour();
1209 wxColour GetCellTextColour( int row, int col );
1210 wxFont GetDefaultCellFont();
1211 wxFont GetCellFont( int row, int col );
1212 void GetDefaultCellAlignment( int *horiz, int *vert );
1213 void GetCellAlignment( int row, int col, int *horiz, int *vert );
1214
1215 void SetDefaultRowSize( int height, bool resizeExistingRows = FALSE );
1216 void SetRowSize( int row, int height );
1217 void SetDefaultColSize( int width, bool resizeExistingCols = FALSE );
1218
1219 void SetColSize( int col, int width );
1220
1221 // automatically size the column or row to fit to its contents, if
1222 // setAsMin is TRUE, this optimal width will also be set as minimal width
1223 // for this column
1224 void AutoSizeColumn( int col, bool setAsMin = TRUE )
1225 { AutoSizeColOrRow(col, setAsMin, TRUE); }
1226 void AutoSizeRow( int row, bool setAsMin = TRUE )
1227 { AutoSizeColOrRow(row, setAsMin, FALSE); }
1228
1229 // auto size all columns (very ineffective for big grids!)
1230 void AutoSizeColumns( bool setAsMin = TRUE )
1231 { (void)SetOrCalcColumnSizes(FALSE, setAsMin); }
1232
1233 void AutoSizeRows( bool setAsMin = TRUE )
1234 { (void)SetOrCalcRowSizes(FALSE, setAsMin); }
1235
1236 // auto size the grid, that is make the columns/rows of the "right" size
1237 // and also set the grid size to just fit its contents
1238 void AutoSize();
1239
1240 // column won't be resized to be lesser width - this must be called during
1241 // the grid creation because it won't resize the column if it's already
1242 // narrower than the minimal width
1243 void SetColMinimalWidth( int col, int width );
1244 void SetRowMinimalHeight( int row, int width );
1245
1246 void SetDefaultCellBackgroundColour( const wxColour& );
1247 void SetCellBackgroundColour( int row, int col, const wxColour& );
1248 void SetDefaultCellTextColour( const wxColour& );
1249
1250 void SetCellTextColour( int row, int col, const wxColour& );
1251 void SetDefaultCellFont( const wxFont& );
1252 void SetCellFont( int row, int col, const wxFont& );
1253 void SetDefaultCellAlignment( int horiz, int vert );
1254 void SetCellAlignment( int row, int col, int horiz, int vert );
1255
1256 // takes ownership of the pointer
1257 void SetDefaultRenderer(wxGridCellRenderer *renderer);
1258 void SetCellRenderer(int row, int col, wxGridCellRenderer *renderer);
1259 wxGridCellRenderer *GetDefaultRenderer() const;
1260 wxGridCellRenderer* GetCellRenderer(int row, int col);
1261
1262 // takes ownership of the pointer
1263 void SetDefaultEditor(wxGridCellEditor *editor);
1264 void SetCellEditor(int row, int col, wxGridCellEditor *editor);
1265 wxGridCellEditor *GetDefaultEditor() const;
1266 wxGridCellEditor* GetCellEditor(int row, int col);
1267
1268
1269
1270 // ------ cell value accessors
1271 //
1272 wxString GetCellValue( int row, int col )
1273 {
1274 if ( m_table )
1275 {
1276 return m_table->GetValue( row, col );
1277 }
1278 else
1279 {
1280 return wxEmptyString;
1281 }
1282 }
1283
1284 wxString GetCellValue( const wxGridCellCoords& coords )
1285 { return GetCellValue( coords.GetRow(), coords.GetCol() ); }
1286
1287 void SetCellValue( int row, int col, const wxString& s );
1288 void SetCellValue( const wxGridCellCoords& coords, const wxString& s )
1289 { SetCellValue( coords.GetRow(), coords.GetCol(), s ); }
1290
1291 // returns TRUE if the cell can't be edited
1292 bool IsReadOnly(int row, int col) const;
1293
1294 // make the cell editable/readonly
1295 void SetReadOnly(int row, int col, bool isReadOnly = TRUE);
1296
1297 // ------ selections of blocks of cells
1298 //
1299 void SelectRow( int row, bool addToSelected = FALSE );
1300 void SelectCol( int col, bool addToSelected = FALSE );
1301
1302 void SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol );
1303
1304 void SelectBlock( const wxGridCellCoords& topLeft,
1305 const wxGridCellCoords& bottomRight )
1306 { SelectBlock( topLeft.GetRow(), topLeft.GetCol(),
1307 bottomRight.GetRow(), bottomRight.GetCol() ); }
1308
1309 void SelectAll();
1310
1311 bool IsSelection();
1312
1313 void ClearSelection();
1314
1315 bool IsInSelection( int row, int col );
1316
1317 bool IsInSelection( const wxGridCellCoords& coords )
1318 { return IsInSelection( coords.GetRow(), coords.GetCol() ); }
1319
1320
1321 // This function returns the rectangle that encloses the block of cells
1322 // limited by TopLeft and BottomRight cell in device coords and clipped
1323 // to the client size of the grid window.
1324 //
1325 wxRect BlockToDeviceRect( const wxGridCellCoords & topLeft,
1326 const wxGridCellCoords & bottomRight );
1327
1328 // Access or update the selection fore/back colours
1329 wxColour GetSelectionBackground() const
1330 { return m_selectionBackground; }
1331 wxColour GetSelectionForeground() const
1332 { return m_selectionForeground; }
1333
1334 void SetSelectionBackground(const wxColour& c) { m_selectionBackground = c; }
1335 void SetSelectionForeground(const wxColour& c) { m_selectionForeground = c; }
1336
1337
1338 // Methods for a registry for mapping data types to Renderers/Editors
1339 void RegisterDataType(const wxString& typeName,
1340 wxGridCellRenderer* renderer,
1341 wxGridCellEditor* editor);
1342 wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
1343 wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const
1344 { return GetDefaultEditorForCell(c.GetRow(), c.GetCol()); }
1345 wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
1346 wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
1347 wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
1348
1349 // grid may occupy more space than needed for its rows/columns, this
1350 // function allows to set how big this extra space is
1351 void SetMargins(int extraWidth, int extraHeight)
1352 {
1353 m_extraWidth = extraWidth;
1354 m_extraHeight = extraHeight;
1355 }
1356
1357 // ------ For compatibility with previous wxGrid only...
1358 //
1359 // ************************************************
1360 // ** Don't use these in new code because they **
1361 // ** are liable to disappear in a future **
1362 // ** revision **
1363 // ************************************************
1364 //
1365
1366 wxGrid( wxWindow *parent,
1367 int x, int y, int w = -1, int h = -1,
1368 long style = wxWANTS_CHARS,
1369 const wxString& name = wxPanelNameStr )
1370 : wxScrolledWindow( parent, -1, wxPoint(x,y), wxSize(w,h),
1371 (style|wxWANTS_CHARS), name )
1372 {
1373 Create();
1374 }
1375
1376 void SetCellValue( const wxString& val, int row, int col )
1377 { SetCellValue( row, col, val ); }
1378
1379 void UpdateDimensions()
1380 { CalcDimensions(); }
1381
1382 int GetRows() { return GetNumberRows(); }
1383 int GetCols() { return GetNumberCols(); }
1384 int GetCursorRow() { return GetGridCursorRow(); }
1385 int GetCursorColumn() { return GetGridCursorCol(); }
1386
1387 int GetScrollPosX() { return 0; }
1388 int GetScrollPosY() { return 0; }
1389
1390 void SetScrollX( int WXUNUSED(x) ) { }
1391 void SetScrollY( int WXUNUSED(y) ) { }
1392
1393 void SetColumnWidth( int col, int width )
1394 { SetColSize( col, width ); }
1395
1396 int GetColumnWidth( int col )
1397 { return GetColSize( col ); }
1398
1399 void SetRowHeight( int row, int height )
1400 { SetRowSize( row, height ); }
1401
1402 // GetRowHeight() is below
1403
1404 int GetViewHeight() // returned num whole rows visible
1405 { return 0; }
1406
1407 int GetViewWidth() // returned num whole cols visible
1408 { return 0; }
1409
1410 void SetLabelSize( int orientation, int sz )
1411 {
1412 if ( orientation == wxHORIZONTAL )
1413 SetColLabelSize( sz );
1414 else
1415 SetRowLabelSize( sz );
1416 }
1417
1418 int GetLabelSize( int orientation )
1419 {
1420 if ( orientation == wxHORIZONTAL )
1421 return GetColLabelSize();
1422 else
1423 return GetRowLabelSize();
1424 }
1425
1426 void SetLabelAlignment( int orientation, int align )
1427 {
1428 if ( orientation == wxHORIZONTAL )
1429 SetColLabelAlignment( align, -1 );
1430 else
1431 SetRowLabelAlignment( align, -1 );
1432 }
1433
1434 int GetLabelAlignment( int orientation, int WXUNUSED(align) )
1435 {
1436 int h, v;
1437 if ( orientation == wxHORIZONTAL )
1438 {
1439 GetColLabelAlignment( &h, &v );
1440 return h;
1441 }
1442 else
1443 {
1444 GetRowLabelAlignment( &h, &v );
1445 return h;
1446 }
1447 }
1448
1449 void SetLabelValue( int orientation, const wxString& val, int pos )
1450 {
1451 if ( orientation == wxHORIZONTAL )
1452 SetColLabelValue( pos, val );
1453 else
1454 SetRowLabelValue( pos, val );
1455 }
1456
1457 wxString GetLabelValue( int orientation, int pos)
1458 {
1459 if ( orientation == wxHORIZONTAL )
1460 return GetColLabelValue( pos );
1461 else
1462 return GetRowLabelValue( pos );
1463 }
1464
1465 wxFont GetCellTextFont() const
1466 { return m_defaultCellAttr->GetFont(); }
1467
1468 wxFont GetCellTextFont(int WXUNUSED(row), int WXUNUSED(col)) const
1469 { return m_defaultCellAttr->GetFont(); }
1470
1471 void SetCellTextFont(const wxFont& fnt)
1472 { SetDefaultCellFont( fnt ); }
1473
1474 void SetCellTextFont(const wxFont& fnt, int row, int col)
1475 { SetCellFont( row, col, fnt ); }
1476
1477 void SetCellTextColour(const wxColour& val, int row, int col)
1478 { SetCellTextColour( row, col, val ); }
1479
1480 void SetCellTextColour(const wxColour& col)
1481 { SetDefaultCellTextColour( col ); }
1482
1483 void SetCellBackgroundColour(const wxColour& col)
1484 { SetDefaultCellBackgroundColour( col ); }
1485
1486 void SetCellBackgroundColour(const wxColour& colour, int row, int col)
1487 { SetCellBackgroundColour( row, col, colour ); }
1488
1489 bool GetEditable() { return IsEditable(); }
1490 void SetEditable( bool edit = TRUE ) { EnableEditing( edit ); }
1491 bool GetEditInPlace() { return IsCellEditControlEnabled(); }
1492
1493 void SetEditInPlace(bool WXUNUSED(edit) = TRUE) { }
1494
1495 void SetCellAlignment( int align, int row, int col)
1496 { SetCellAlignment(row, col, align, wxCENTER); }
1497 void SetCellAlignment( int WXUNUSED(align) ) {}
1498 void SetCellBitmap(wxBitmap *WXUNUSED(bitmap), int WXUNUSED(row), int WXUNUSED(col))
1499 { }
1500 void SetDividerPen(const wxPen& WXUNUSED(pen)) { }
1501 wxPen& GetDividerPen() const;
1502 void OnActivate(bool WXUNUSED(active)) {}
1503
1504 // ******** End of compatibility functions **********
1505
1506
1507
1508 // ------ control IDs
1509 enum { wxGRID_CELLCTRL = 2000,
1510 wxGRID_TOPCTRL };
1511
1512 // ------ control types
1513 enum { wxGRID_TEXTCTRL = 2100,
1514 wxGRID_CHECKBOX,
1515 wxGRID_CHOICE,
1516 wxGRID_COMBOBOX };
1517
1518 // overridden wxWindow methods
1519 virtual void Fit();
1520
1521 protected:
1522 virtual wxSize DoGetBestSize() const;
1523
1524 bool m_created;
1525
1526 wxGridWindow *m_gridWin;
1527 wxGridRowLabelWindow *m_rowLabelWin;
1528 wxGridColLabelWindow *m_colLabelWin;
1529 wxGridCornerLabelWindow *m_cornerLabelWin;
1530
1531 wxGridTableBase *m_table;
1532 bool m_ownTable;
1533
1534 int m_left;
1535 int m_top;
1536 int m_right;
1537 int m_bottom;
1538
1539 int m_numRows;
1540 int m_numCols;
1541
1542 wxGridCellCoords m_currentCellCoords;
1543
1544 wxGridCellCoords m_selectingTopLeft;
1545 wxGridCellCoords m_selectingBottomRight;
1546 wxGridCellCoords m_selectingKeyboard;
1547 wxGridSelection *m_selection;
1548 wxColour m_selectionBackground;
1549 wxColour m_selectionForeground;
1550
1551 // NB: *never* access m_row/col arrays directly because they are created
1552 // on demand, *always* use accessor functions instead!
1553
1554 // init the m_rowHeights/Bottoms arrays with default values
1555 void InitRowHeights();
1556
1557 int m_defaultRowHeight;
1558 wxArrayInt m_rowHeights;
1559 wxArrayInt m_rowBottoms;
1560
1561 // init the m_colWidths/Rights arrays
1562 void InitColWidths();
1563
1564 int m_defaultColWidth;
1565 wxArrayInt m_colWidths;
1566 wxArrayInt m_colRights;
1567
1568 // get the col/row coords
1569 int GetColWidth(int col) const;
1570 int GetColLeft(int col) const;
1571 int GetColRight(int col) const;
1572
1573 // this function must be public for compatibility...
1574 public:
1575 int GetRowHeight(int row) const;
1576 protected:
1577
1578 int GetRowTop(int row) const;
1579 int GetRowBottom(int row) const;
1580
1581 int m_rowLabelWidth;
1582 int m_colLabelHeight;
1583
1584 // the size of the margin left to the right and bottom of the cell area
1585 int m_extraWidth,
1586 m_extraHeight;
1587
1588 wxColour m_labelBackgroundColour;
1589 wxColour m_labelTextColour;
1590 wxFont m_labelFont;
1591
1592 int m_rowLabelHorizAlign;
1593 int m_rowLabelVertAlign;
1594 int m_colLabelHorizAlign;
1595 int m_colLabelVertAlign;
1596
1597 bool m_defaultRowLabelValues;
1598 bool m_defaultColLabelValues;
1599
1600 wxColour m_gridLineColour;
1601 bool m_gridLinesEnabled;
1602 wxColour m_cellHighlightColour;
1603
1604 // common part of AutoSizeColumn/Row() and GetBestSize()
1605 int SetOrCalcColumnSizes(bool calcOnly, bool setAsMin = TRUE);
1606 int SetOrCalcRowSizes(bool calcOnly, bool setAsMin = TRUE);
1607
1608 // common part of AutoSizeColumn/Row()
1609 void AutoSizeColOrRow(int n, bool setAsMin, bool column /* or row? */);
1610
1611 // if a column has a minimal width, it will be the value for it in this
1612 // hash table
1613 wxHashTableLong m_colMinWidths,
1614 m_rowMinHeights;
1615
1616 // get the minimal width of the given column/row
1617 int GetColMinimalWidth(int col) const;
1618 int GetRowMinimalHeight(int col) const;
1619
1620 // do we have some place to store attributes in?
1621 bool CanHaveAttributes();
1622
1623 // returns the attribute we may modify in place: a new one if this cell
1624 // doesn't have any yet or the existing one if it does
1625 //
1626 // DecRef() must be called on the returned pointer, as usual
1627 wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
1628
1629 // cell attribute cache (currently we only cache 1, may be will do
1630 // more/better later)
1631 struct CachedAttr
1632 {
1633 int row, col;
1634 wxGridCellAttr *attr;
1635 } m_attrCache;
1636
1637 // invalidates the attribute cache
1638 void ClearAttrCache();
1639
1640 // adds an attribute to cache
1641 void CacheAttr(int row, int col, wxGridCellAttr *attr) const;
1642
1643 // looks for an attr in cache, returns TRUE if found
1644 bool LookupAttr(int row, int col, wxGridCellAttr **attr) const;
1645
1646 // looks for the attr in cache, if not found asks the table and caches the
1647 // result
1648 wxGridCellAttr *GetCellAttr(int row, int col) const;
1649 wxGridCellAttr *GetCellAttr(const wxGridCellCoords& coords )
1650 { return GetCellAttr( coords.GetRow(), coords.GetCol() ); }
1651
1652 // the default cell attr object for cells that don't have their own
1653 wxGridCellAttr* m_defaultCellAttr;
1654
1655
1656 wxGridCellCoordsArray m_cellsExposed;
1657 wxArrayInt m_rowsExposed;
1658 wxArrayInt m_colsExposed;
1659 wxArrayInt m_rowLabelsExposed;
1660 wxArrayInt m_colLabelsExposed;
1661
1662 bool m_inOnKeyDown;
1663 int m_batchCount;
1664
1665
1666 wxGridTypeRegistry* m_typeRegistry;
1667
1668 enum CursorMode
1669 {
1670 WXGRID_CURSOR_SELECT_CELL,
1671 WXGRID_CURSOR_RESIZE_ROW,
1672 WXGRID_CURSOR_RESIZE_COL,
1673 WXGRID_CURSOR_SELECT_ROW,
1674 WXGRID_CURSOR_SELECT_COL
1675 };
1676
1677 // this method not only sets m_cursorMode but also sets the correct cursor
1678 // for the given mode and, if captureMouse is not FALSE releases the mouse
1679 // if it was captured and captures it if it must be captured
1680 //
1681 // for this to work, you should always use it and not set m_cursorMode
1682 // directly!
1683 void ChangeCursorMode(CursorMode mode,
1684 wxWindow *win = (wxWindow *)NULL,
1685 bool captureMouse = TRUE);
1686
1687 wxWindow *m_winCapture; // the window which captured the mouse
1688 CursorMode m_cursorMode;
1689
1690 bool m_canDragRowSize;
1691 bool m_canDragColSize;
1692 bool m_canDragGridSize;
1693 int m_dragLastPos;
1694 int m_dragRowOrCol;
1695 bool m_isDragging;
1696 wxPoint m_startDragPos;
1697
1698 bool m_waitForSlowClick;
1699
1700 wxGridCellCoords m_selectionStart;
1701
1702 wxCursor m_rowResizeCursor;
1703 wxCursor m_colResizeCursor;
1704
1705 bool m_editable; // applies to whole grid
1706 bool m_cellEditCtrlEnabled; // is in-place edit currently shown?
1707
1708
1709 void Create();
1710 void Init();
1711 void CalcDimensions();
1712 void CalcWindowSizes();
1713 bool Redimension( wxGridTableMessage& );
1714
1715
1716 bool SendEvent( const wxEventType, int row, int col, wxMouseEvent& );
1717 bool SendEvent( const wxEventType, int row, int col );
1718 bool SendEvent( const wxEventType type)
1719 {
1720 return SendEvent(type,
1721 m_currentCellCoords.GetRow(),
1722 m_currentCellCoords.GetCol());
1723 }
1724
1725 void OnPaint( wxPaintEvent& );
1726 void OnSize( wxSizeEvent& );
1727 void OnKeyDown( wxKeyEvent& );
1728 void OnKeyUp( wxKeyEvent& );
1729 void OnEraseBackground( wxEraseEvent& );
1730
1731
1732 void SetCurrentCell( const wxGridCellCoords& coords );
1733 void SetCurrentCell( int row, int col )
1734 { SetCurrentCell( wxGridCellCoords(row, col) ); }
1735
1736
1737 // ------ functions to get/send data (see also public functions)
1738 //
1739 bool GetModelValues();
1740 bool SetModelValues();
1741
1742 friend class wxGridSelection;
1743
1744 DECLARE_DYNAMIC_CLASS( wxGrid )
1745 DECLARE_EVENT_TABLE()
1746 };
1747
1748 // ----------------------------------------------------------------------------
1749 // Grid event class and event types
1750 // ----------------------------------------------------------------------------
1751
1752 class WXDLLEXPORT wxGridEvent : public wxNotifyEvent
1753 {
1754 public:
1755 wxGridEvent()
1756 : wxNotifyEvent(), m_row(-1), m_col(-1), m_x(-1), m_y(-1),
1757 m_selecting(0), m_control(0), m_meta(0), m_shift(0), m_alt(0)
1758 {
1759 }
1760
1761 wxGridEvent(int id, wxEventType type, wxObject* obj,
1762 int row=-1, int col=-1, int x=-1, int y=-1, bool sel = TRUE,
1763 bool control=FALSE, bool shift=FALSE, bool alt=FALSE, bool meta=FALSE);
1764
1765 virtual int GetRow() { return m_row; }
1766 virtual int GetCol() { return m_col; }
1767 wxPoint GetPosition() { return wxPoint( m_x, m_y ); }
1768 bool Selecting() { return m_selecting; }
1769 bool ControlDown() { return m_control; }
1770 bool MetaDown() { return m_meta; }
1771 bool ShiftDown() { return m_shift; }
1772 bool AltDown() { return m_alt; }
1773
1774 protected:
1775 int m_row;
1776 int m_col;
1777 int m_x;
1778 int m_y;
1779 bool m_selecting;
1780 bool m_control;
1781 bool m_meta;
1782 bool m_shift;
1783 bool m_alt;
1784
1785 DECLARE_DYNAMIC_CLASS(wxGridEvent)
1786 };
1787
1788 class WXDLLEXPORT wxGridSizeEvent : public wxNotifyEvent
1789 {
1790 public:
1791 wxGridSizeEvent()
1792 : wxNotifyEvent(), m_rowOrCol(-1), m_x(-1), m_y(-1),
1793 m_control(0), m_meta(0), m_shift(0), m_alt(0)
1794 {
1795 }
1796
1797 wxGridSizeEvent(int id, wxEventType type, wxObject* obj,
1798 int rowOrCol=-1, int x=-1, int y=-1,
1799 bool control=FALSE, bool shift=FALSE, bool alt=FALSE, bool meta=FALSE);
1800
1801 int GetRowOrCol() { return m_rowOrCol; }
1802 wxPoint GetPosition() { return wxPoint( m_x, m_y ); }
1803 bool ControlDown() { return m_control; }
1804 bool MetaDown() { return m_meta; }
1805 bool ShiftDown() { return m_shift; }
1806 bool AltDown() { return m_alt; }
1807
1808 protected:
1809 int m_rowOrCol;
1810 int m_x;
1811 int m_y;
1812 bool m_control;
1813 bool m_meta;
1814 bool m_shift;
1815 bool m_alt;
1816
1817 DECLARE_DYNAMIC_CLASS(wxGridSizeEvent)
1818 };
1819
1820
1821 class WXDLLEXPORT wxGridRangeSelectEvent : public wxNotifyEvent
1822 {
1823 public:
1824 wxGridRangeSelectEvent()
1825 : wxNotifyEvent()
1826 {
1827 m_topLeft = wxGridNoCellCoords;
1828 m_bottomRight = wxGridNoCellCoords;
1829 m_selecting = FALSE;
1830 m_control = FALSE;
1831 m_meta = FALSE;
1832 m_shift = FALSE;
1833 m_alt = FALSE;
1834 }
1835
1836 wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
1837 const wxGridCellCoords& topLeft,
1838 const wxGridCellCoords& bottomRight,
1839 bool sel = TRUE,
1840 bool control=FALSE, bool shift=FALSE,
1841 bool alt=FALSE, bool meta=FALSE);
1842
1843 wxGridCellCoords GetTopLeftCoords() { return m_topLeft; }
1844 wxGridCellCoords GetBottomRightCoords() { return m_bottomRight; }
1845 int GetTopRow() { return m_topLeft.GetRow(); }
1846 int GetBottomRow() { return m_bottomRight.GetRow(); }
1847 int GetLeftCol() { return m_topLeft.GetCol(); }
1848 int GetRightCol() { return m_bottomRight.GetCol(); }
1849 bool Selecting() { return m_selecting; }
1850 bool ControlDown() { return m_control; }
1851 bool MetaDown() { return m_meta; }
1852 bool ShiftDown() { return m_shift; }
1853 bool AltDown() { return m_alt; }
1854
1855 protected:
1856 wxGridCellCoords m_topLeft;
1857 wxGridCellCoords m_bottomRight;
1858 bool m_selecting;
1859 bool m_control;
1860 bool m_meta;
1861 bool m_shift;
1862 bool m_alt;
1863
1864 DECLARE_DYNAMIC_CLASS(wxGridRangeSelectEvent)
1865 };
1866
1867 // TODO move to wx/event.h
1868 const wxEventType wxEVT_GRID_CELL_LEFT_CLICK = wxEVT_FIRST + 1580;
1869 const wxEventType wxEVT_GRID_CELL_RIGHT_CLICK = wxEVT_FIRST + 1581;
1870 const wxEventType wxEVT_GRID_CELL_LEFT_DCLICK = wxEVT_FIRST + 1582;
1871 const wxEventType wxEVT_GRID_CELL_RIGHT_DCLICK = wxEVT_FIRST + 1583;
1872 const wxEventType wxEVT_GRID_LABEL_LEFT_CLICK = wxEVT_FIRST + 1584;
1873 const wxEventType wxEVT_GRID_LABEL_RIGHT_CLICK = wxEVT_FIRST + 1585;
1874 const wxEventType wxEVT_GRID_LABEL_LEFT_DCLICK = wxEVT_FIRST + 1586;
1875 const wxEventType wxEVT_GRID_LABEL_RIGHT_DCLICK = wxEVT_FIRST + 1587;
1876 const wxEventType wxEVT_GRID_ROW_SIZE = wxEVT_FIRST + 1588;
1877 const wxEventType wxEVT_GRID_COL_SIZE = wxEVT_FIRST + 1589;
1878 const wxEventType wxEVT_GRID_RANGE_SELECT = wxEVT_FIRST + 1590;
1879 const wxEventType wxEVT_GRID_CELL_CHANGE = wxEVT_FIRST + 1591;
1880 const wxEventType wxEVT_GRID_SELECT_CELL = wxEVT_FIRST + 1592;
1881 const wxEventType wxEVT_GRID_EDITOR_SHOWN = wxEVT_FIRST + 1593;
1882 const wxEventType wxEVT_GRID_EDITOR_HIDDEN = wxEVT_FIRST + 1594;
1883
1884
1885 typedef void (wxEvtHandler::*wxGridEventFunction)(wxGridEvent&);
1886 typedef void (wxEvtHandler::*wxGridSizeEventFunction)(wxGridSizeEvent&);
1887 typedef void (wxEvtHandler::*wxGridRangeSelectEventFunction)(wxGridRangeSelectEvent&);
1888
1889 #define EVT_GRID_CELL_LEFT_CLICK(fn) { wxEVT_GRID_CELL_LEFT_CLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1890 #define EVT_GRID_CELL_RIGHT_CLICK(fn) { wxEVT_GRID_CELL_RIGHT_CLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1891 #define EVT_GRID_CELL_LEFT_DCLICK(fn) { wxEVT_GRID_CELL_LEFT_DCLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1892 #define EVT_GRID_CELL_RIGHT_DCLICK(fn) { wxEVT_GRID_CELL_RIGHT_DCLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1893 #define EVT_GRID_LABEL_LEFT_CLICK(fn) { wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1894 #define EVT_GRID_LABEL_RIGHT_CLICK(fn) { wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1895 #define EVT_GRID_LABEL_LEFT_DCLICK(fn) { wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1896 #define EVT_GRID_LABEL_RIGHT_DCLICK(fn) { wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1897 #define EVT_GRID_ROW_SIZE(fn) { wxEVT_GRID_ROW_SIZE, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridSizeEventFunction) &fn, NULL },
1898 #define EVT_GRID_COL_SIZE(fn) { wxEVT_GRID_COL_SIZE, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridSizeEventFunction) &fn, NULL },
1899 #define EVT_GRID_RANGE_SELECT(fn) { wxEVT_GRID_RANGE_SELECT, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridRangeSelectEventFunction) &fn, NULL },
1900 #define EVT_GRID_CELL_CHANGE(fn) { wxEVT_GRID_CELL_CHANGE, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1901 #define EVT_GRID_SELECT_CELL(fn) { wxEVT_GRID_SELECT_CELL, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1902 #define EVT_GRID_EDITOR_SHOWN(fn) { wxEVT_GRID_EDITOR_SHOWN, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1903 #define EVT_GRID_EDITOR_HIDDEN(fn) { wxEVT_GRID_EDITOR_HIDDEN, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1904
1905
1906 #if 0 // TODO: implement these ? others ?
1907
1908 const wxEventType wxEVT_GRID_CREATE_CELL = wxEVT_FIRST + 1576;
1909 const wxEventType wxEVT_GRID_CHANGE_LABELS = wxEVT_FIRST + 1577;
1910 const wxEventType wxEVT_GRID_CHANGE_SEL_LABEL = wxEVT_FIRST + 1578;
1911
1912 #define EVT_GRID_CREATE_CELL(fn) { wxEVT_GRID_CREATE_CELL, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1913 #define EVT_GRID_CHANGE_LABELS(fn) { wxEVT_GRID_CHANGE_LABELS, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1914 #define EVT_GRID_CHANGE_SEL_LABEL(fn) { wxEVT_GRID_CHANGE_SEL_LABEL, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxGridEventFunction) &fn, NULL },
1915
1916 #endif
1917
1918 #endif // #ifndef __WXGRID_H__
1919
1920 #endif // ifndef wxUSE_NEW_GRID
wxWidgets (Impactor)