]> git.saurik.com Git - wxWidgets.git/blob - interface/wx/grid.h
added the possibility to rescale the image during loading, especially useful with...
[wxWidgets.git] / interface / wx / grid.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: grid.h
3 // Purpose: interface of wxGridCellFloatRenderer
4 // Author: wxWidgets team
5 // RCS-ID: $Id$
6 // Licence: wxWindows license
7 /////////////////////////////////////////////////////////////////////////////
8
9 /**
10 @class wxGridCellFloatRenderer
11
12 This class may be used to format floating point data in a cell.
13
14 @library{wxadv}
15 @category{grid}
16
17 @see wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellStringRenderer,
18 wxGridCellBoolRenderer
19 */
20 class wxGridCellFloatRenderer : public wxGridCellStringRenderer
21 {
22 public:
23 /**
24 @param width
25 Minimum number of characters to be shown.
26 @param precision
27 Number of digits after the decimal dot.
28 */
29 wxGridCellFloatRenderer(int width = -1, int precision = -1);
30
31 /**
32 Returns the precision.
33 */
34 int GetPrecision() const;
35
36 /**
37 Returns the width.
38 */
39 int GetWidth() const;
40
41 /**
42 Parameters string format is "width[,precision]".
43 */
44 virtual void SetParameters(const wxString& params);
45
46 /**
47 Sets the precision.
48 */
49 void SetPrecision(int precision);
50
51 /**
52 Sets the width.
53 */
54 void SetWidth(int width);
55 };
56
57
58
59 /**
60 @class wxGridTableBase
61
62 The almost abstract base class for grid tables.
63
64 A grid table is responsible for storing the grid data and, indirectly, grid
65 cell attributes. The data can be stored in the way most convenient for the
66 application but has to be provided in string form to wxGrid. It is also
67 possible to provide cells values in other formats if appropriate, e.g. as
68 numbers.
69
70 This base class is not quite abstract as it implements a trivial strategy
71 for storing the attributes by forwarding it to wxGridCellAttrProvider and
72 also provides stubs for some other functions. However it does have a number
73 of pure virtual methods which must be implemented in the derived classes.
74
75 @see wxGridStringTable
76
77 @library{wxadv}
78 @category{grid}
79 */
80 class wxGridTableBase : public wxObject
81 {
82 public:
83 /// Default constructor.
84 wxGridTableBase();
85
86 /// Destructor frees the attribute provider if it was created.
87 virtual ~wxGridTableBase();
88
89 /**
90 Must be overridden to return the number of rows in the table.
91
92 For backwards compatibility reasons, this method is not const.
93 Use GetRowsCount() instead of it in const methods of derived table
94 classes.
95 */
96 virtual int GetNumberRows() = 0;
97
98 /**
99 Must be overridden to return the number of columns in the table.
100
101 For backwards compatibility reasons, this method is not const.
102 Use GetColsCount() instead of it in const methods of derived table
103 classes,
104 */
105 virtual int GetNumberCols() = 0;
106
107 /**
108 Return the number of rows in the table.
109
110 This method is not virtual and is only provided as a convenience for
111 the derived classes which can't call GetNumberRows() without a @c
112 const_cast from their const methods.
113 */
114 int GetRowsCount() const;
115
116 /**
117 Return the number of columns in the table.
118
119 This method is not virtual and is only provided as a convenience for
120 the derived classes which can't call GetNumberCols() without a @c
121 const_cast from their const methods.
122 */
123 int GetColsCount() const;
124
125
126 /**
127 Accessing table cells.
128 */
129 //@{
130
131 /// Must be overridden to implement testing for empty cells.
132 virtual bool IsEmptyCell(int row, int col) = 0;
133
134 /**
135 Same as IsEmptyCell() but taking wxGridCellCoords.
136
137 Notice that this method is not virtual, only IsEmptyCell() should be
138 overridden.
139 */
140 bool IsEmpty(const wxGridCellCoords& coords);
141
142 /// Must be overridden to implement accessing the table values as text.
143 virtual wxString GetValue(int row, int col) = 0;
144
145 /// Must be overridden to implement setting the table values as text.
146 virtual void SetValue(int row, int col, const wxString& value) = 0;
147
148 /**
149 Returns the type of the value in the given cell.
150
151 By default all cells are strings and this method returns @c
152 wxGRID_VALUE_STRING.
153 */
154 virtual wxString GetTypeName(int row, int col);
155
156 /**
157 Returns true if the value of the given cell can be accessed as if it
158 were of the specified type.
159
160 By default the cells can only be accessed as strings. Note that a cell
161 could be accessible in different ways, e.g. a numeric cell may return
162 @true for @c wxGRID_VALUE_NUMBER but also for @c wxGRID_VALUE_STRING
163 indicating that the value can be coerced to a string form.
164 */
165 virtual bool CanGetValueAs(int row, int col, const wxString& typeName);
166
167 /**
168 Returns true if the value of the given cell can be set as if it were of
169 the specified type.
170
171 @see CanGetValueAs()
172 */
173 virtual bool CanSetValueAs(int row, int col, const wxString& typeName);
174
175 /**
176 Returns the value of the given cell as a long.
177
178 This should only be called if CanGetValueAs() returns @true when called
179 with @c wxGRID_VALUE_NUMBER argument. Default implementation always
180 return 0.
181 */
182 virtual long GetValueAsLong(int row, int col);
183
184 /**
185 Returns the value of the given cell as a double.
186
187 This should only be called if CanGetValueAs() returns @true when called
188 with @c wxGRID_VALUE_FLOAT argument. Default implementation always
189 return 0.0.
190 */
191 virtual double GetValueAsDouble(int row, int col);
192
193 /**
194 Returns the value of the given cell as a boolean.
195
196 This should only be called if CanGetValueAs() returns @true when called
197 with @c wxGRID_VALUE_BOOL argument. Default implementation always
198 return false.
199 */
200 virtual bool GetValueAsBool(int row, int col);
201
202 /**
203 Returns the value of the given cell as a user-defined type.
204
205 This should only be called if CanGetValueAs() returns @true when called
206 with @a typeName. Default implementation always return @NULL.
207 */
208 virtual void *GetValueAsCustom(int row, int col, const wxString& typeName);
209
210
211 /**
212 Sets the value of the given cell as a long.
213
214 This should only be called if CanSetValueAs() returns @true when called
215 with @c wxGRID_VALUE_NUMBER argument. Default implementation doesn't do
216 anything.
217 */
218 virtual void SetValueAsLong(int row, int col, long value);
219
220 /**
221 Sets the value of the given cell as a double.
222
223 This should only be called if CanSetValueAs() returns @true when called
224 with @c wxGRID_VALUE_FLOAT argument. Default implementation doesn't do
225 anything.
226 */
227 virtual void SetValueAsDouble(int row, int col, double value);
228
229 /**
230 Sets the value of the given cell as a boolean.
231
232 This should only be called if CanSetValueAs() returns @true when called
233 with @c wxGRID_VALUE_BOOL argument. Default implementation doesn't do
234 anything.
235 */
236 virtual void SetValueAsBool( int row, int col, bool value );
237
238 /**
239 Sets the value of the given cell as a user-defined type.
240
241 This should only be called if CanSetValueAs() returns @true when called
242 with @a typeName. Default implementation doesn't do anything.
243 */
244 virtual void SetValueAsCustom(int row, int col, const wxString& typeName,
245 void *value);
246
247 //@}
248
249 /**
250 Called by the grid when the table is associated with it.
251
252 The default implementation stores the pointer and returns it from its
253 GetView() and so only makes sense if the table cannot be associated
254 with more than one grid at a time.
255 */
256 virtual void SetView(wxGrid *grid);
257
258 /**
259 Returns the last grid passed to SetView().
260 */
261 virtual wxGrid *GetView() const;
262
263
264 /**
265 Modifying the table structure.
266
267 Notice that none of these functions are pure virtual as they don't have
268 to be implemented if the table structure is never modified after
269 creation, i.e. neither rows nor columns are never added or deleted but
270 that you do need to implement them if they are called, i.e. if your
271 code either calls them directly or uses the matching wxGrid methods, as
272 by default they simply do nothing which is definitely inappropriate.
273 */
274 //@{
275
276 /**
277 Clear the table contents.
278
279 This method is used by wxGrid::ClearGrid().
280 */
281 virtual void Clear();
282
283 /**
284 Insert additional rows into the table.
285
286 @param pos
287 The position of the first new row.
288 @param numRows
289 The number of rows to insert.
290 */
291 virtual bool InsertRows(size_t pos = 0, size_t numRows = 1);
292
293 /**
294 Append additional rows at the end of the table.
295
296 This method is provided in addition to InsertRows() as some data models
297 may only support appending rows to them but not inserting them at
298 arbitrary locations. In such case you may implement this method only
299 and leave InsertRows() unimplemented.
300
301 @param numRows
302 The number of rows to add.
303 */
304 virtual bool AppendRows(size_t numRows = 1);
305
306 /**
307 Delete rows from the table.
308
309 @param pos
310 The first row to delete.
311 @param numRows
312 The number of rows to delete.
313 */
314 virtual bool DeleteRows(size_t pos = 0, size_t numRows = 1);
315
316 /// Exactly the same as InsertRows() but for columns.
317 virtual bool InsertCols(size_t pos = 0, size_t numCols = 1);
318
319 /// Exactly the same as AppendRows() but for columns.
320 virtual bool AppendCols(size_t numCols = 1);
321
322 /// Exactly the same as DeleteRows() but for columns.
323 virtual bool DeleteCols(size_t pos = 0, size_t numCols = 1);
324
325 //@}
326
327 /**
328 Table rows and columns labels.
329
330 By default the numbers are used for labeling rows and Latin letters for
331 labeling columns. If the table has more than 26 columns, the pairs of
332 letters are used starting from the 27-th one and so on, i.e. the
333 sequence of labels is A, B, ..., Z, AA, AB, ..., AZ, BA, ..., ..., ZZ,
334 AAA, ...
335 */
336 //@{
337
338 /// Return the label of the specified row.
339 virtual wxString GetRowLabelValue(int row);
340
341 /// Return the label of the specified column.
342 virtual wxString GetColLabelValue(int col);
343
344 /**
345 Set the given label for the specified row.
346
347 The default version does nothing, i.e. the label is not stored. You
348 must override this method in your derived class if you wish
349 wxGrid::SetRowLabelValue() to work.
350 */
351 virtual void SetRowLabelValue(int row, const wxString& label);
352
353 /// Exactly the same as SetRowLabelValue() but for columns.
354 virtual void SetColLabelValue(int col, const wxString& label);
355
356 //@}
357
358
359 /**
360 Attributes management.
361
362 By default the attributes management is delegated to
363 wxGridCellAttrProvider class. You may override the methods in this
364 section to handle the attributes directly if, for example, they can be
365 computed from the cell values.
366 */
367 //@{
368
369 /**
370 Associate this attributes provider with the table.
371
372 The table takes ownership of @a attrProvider pointer and will delete it
373 when it doesn't need it any more. The pointer can be @NULL, however
374 this won't disable attributes management in the table but will just
375 result in a default attributes being recreated the next time any of the
376 other functions in this section is called. To completely disable the
377 attributes support, should this be needed, you need to override
378 CanHaveAttributes() to return @false.
379 */
380 void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
381
382 /**
383 Returns the attribute provider currently being used.
384
385 This function may return @NULL if the attribute provider hasn't been
386 neither associated with this table by SetAttrProvider() nor created on
387 demand by any other methods.
388 */
389 wxGridCellAttrProvider *GetAttrProvider() const;
390
391 /**
392 Return the attribute for the given cell.
393
394 By default this function is simply forwarded to
395 wxGridCellAttrProvider::GetAttr() but it may be overridden to handle
396 attributes directly in the table.
397 */
398 virtual wxGridCellAttr *GetAttr(int row, int col,
399 wxGridCellAttr::wxAttrKind kind);
400
401 /**
402 Set attribute of the specified cell.
403
404 By default this function is simply forwarded to
405 wxGridCellAttrProvider::SetAttr().
406
407 The table takes ownership of @a attr, i.e. will call DecRef() on it.
408 */
409 virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
410
411 /**
412 Set attribute of the specified row.
413
414 By default this function is simply forwarded to
415 wxGridCellAttrProvider::SetRowAttr().
416
417 The table takes ownership of @a attr, i.e. will call DecRef() on it.
418 */
419 virtual void SetRowAttr(wxGridCellAttr *attr, int row);
420
421 /**
422 Set attribute of the specified column.
423
424 By default this function is simply forwarded to
425 wxGridCellAttrProvider::SetColAttr().
426
427 The table takes ownership of @a attr, i.e. will call DecRef() on it.
428 */
429 virtual void SetColAttr(wxGridCellAttr *attr, int col);
430
431 //@}
432
433 /**
434 Returns true if this table supports attributes or false otherwise.
435
436 By default, the table automatically creates a wxGridCellAttrProvider
437 when this function is called if it had no attribute provider before and
438 returns @true.
439 */
440 virtual bool CanHaveAttributes();
441 };
442
443
444
445 /**
446 @class wxGridCellEditor
447
448 This class is responsible for providing and manipulating
449 the in-place edit controls for the grid. Instances of wxGridCellEditor
450 (actually, instances of derived classes since it is an abstract class) can be
451 associated with the cell attributes for individual cells, rows, columns, or
452 even for the entire grid.
453
454 @library{wxadv}
455 @category{grid}
456
457 @see wxGridCellTextEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
458 wxGridCellNumberEditor, wxGridCellChoiceEditor
459 */
460 class wxGridCellEditor
461 {
462 public:
463 /**
464
465 */
466 wxGridCellEditor();
467
468 /**
469 Fetch the value from the table and prepare the edit control
470 to begin editing. Set the focus to the edit control.
471 */
472 virtual void BeginEdit(int row, int col, wxGrid* grid) = 0;
473
474 /**
475 Create a new object which is the copy of this one.
476 */
477 virtual wxGridCellEditor* Clone() const = 0;
478
479 /**
480 Creates the actual edit control.
481 */
482 virtual void Create(wxWindow* parent, wxWindowID id,
483 wxEvtHandler* evtHandler) = 0;
484
485 /**
486 Final cleanup.
487 */
488 virtual void Destroy();
489
490 /**
491 Complete the editing of the current cell. Returns @true if the value has
492 changed. If necessary, the control may be destroyed.
493 */
494 virtual bool EndEdit(int row, int col, wxGrid* grid) = 0;
495
496 /**
497 Some types of controls on some platforms may need some help
498 with the Return key.
499 */
500 virtual void HandleReturn(wxKeyEvent& event);
501
502 /**
503
504 */
505 bool IsCreated();
506
507 /**
508 Draws the part of the cell not occupied by the control: the base class
509 version just fills it with background colour from the attribute.
510 */
511 virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr* attr);
512
513 /**
514 Reset the value in the control back to its starting value.
515 */
516 virtual void Reset() = 0;
517
518 /**
519 Size and position the edit control.
520 */
521 virtual void SetSize(const wxRect& rect);
522
523 /**
524 Show or hide the edit control, use the specified attributes to set
525 colours/fonts for it.
526 */
527 virtual void Show(bool show, wxGridCellAttr* attr = NULL);
528
529 /**
530 If the editor is enabled by clicking on the cell, this method will be
531 called.
532 */
533 virtual void StartingClick();
534
535 /**
536 If the editor is enabled by pressing keys on the grid,
537 this will be called to let the editor do something about
538 that first key if desired.
539 */
540 virtual void StartingKey(wxKeyEvent& event);
541
542 protected:
543
544 /**
545 The dtor is private because only DecRef() can delete us.
546 */
547 virtual ~wxGridCellEditor();
548 };
549
550
551
552 /**
553 @class wxGridCellTextEditor
554
555 The editor for string/text data.
556
557 @library{wxadv}
558 @category{grid}
559
560 @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
561 wxGridCellNumberEditor, wxGridCellChoiceEditor
562 */
563 class wxGridCellTextEditor : public wxGridCellEditor
564 {
565 public:
566 /**
567 Default constructor.
568 */
569 wxGridCellTextEditor();
570
571 /**
572 The parameters string format is "n" where n is a number representing the
573 maximum width.
574 */
575 virtual void SetParameters(const wxString& params);
576 };
577
578
579
580 /**
581 @class wxGridCellStringRenderer
582
583 This class may be used to format string data in a cell; it is the default
584 for string cells.
585
586 @library{wxadv}
587 @category{grid}
588
589 @see wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellFloatRenderer,
590 wxGridCellBoolRenderer
591 */
592 class wxGridCellStringRenderer : public wxGridCellRenderer
593 {
594 public:
595 /**
596 Default constructor
597 */
598 wxGridCellStringRenderer();
599 };
600
601
602
603 /**
604 @class wxGridCellChoiceEditor
605
606 The editor for string data allowing to choose from a list of strings.
607
608 @library{wxadv}
609 @category{grid}
610
611 @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
612 wxGridCellTextEditor, wxGridCellNumberEditor
613 */
614 class wxGridCellChoiceEditor : public wxGridCellEditor
615 {
616 public:
617 //@{
618 /**
619 @param count
620 Number of strings from which the user can choose.
621 @param choices
622 An array of strings from which the user can choose.
623 @param allowOthers
624 If allowOthers is @true, the user can type a string not in choices array.
625 */
626 wxGridCellChoiceEditor(size_t count = 0,
627 const wxString choices[] = NULL,
628 bool allowOthers = false);
629 /**
630 @param choices
631 An array of strings from which the user can choose.
632 @param allowOthers
633 If allowOthers is @true, the user can type a string not in choices array.
634 */
635 wxGridCellChoiceEditor(const wxArrayString& choices,
636 bool allowOthers = false);
637 //@}
638
639 /**
640 Parameters string format is "item1[,item2[...,itemN]]"
641 */
642 virtual void SetParameters(const wxString& params);
643 };
644
645
646
647 /**
648 @class wxGridEditorCreatedEvent
649
650
651 @library{wxadv}
652 @category{grid}
653 */
654 class wxGridEditorCreatedEvent : public wxCommandEvent
655 {
656 public:
657 //@{
658 /**
659
660 */
661 wxGridEditorCreatedEvent();
662 wxGridEditorCreatedEvent(int id, wxEventType type,
663 wxObject* obj,
664 int row,
665 int col,
666 wxControl* ctrl);
667 //@}
668
669 /**
670 Returns the column at which the event occurred.
671 */
672 int GetCol();
673
674 /**
675 Returns the edit control.
676 */
677 wxControl* GetControl();
678
679 /**
680 Returns the row at which the event occurred.
681 */
682 int GetRow();
683
684 /**
685 Sets the column at which the event occurred.
686 */
687 void SetCol(int col);
688
689 /**
690 Sets the edit control.
691 */
692 void SetControl(wxControl* ctrl);
693
694 /**
695 Sets the row at which the event occurred.
696 */
697 void SetRow(int row);
698 };
699
700
701
702 /**
703 @class wxGridRangeSelectEvent
704
705
706 @library{wxadv}
707 @category{grid}
708 */
709 class wxGridRangeSelectEvent : public wxNotifyEvent
710 {
711 public:
712 //@{
713 /**
714
715 */
716 wxGridRangeSelectEvent();
717 wxGridRangeSelectEvent(int id, wxEventType type,
718 wxObject* obj,
719 const wxGridCellCoords& topLeft,
720 const wxGridCellCoords& bottomRight,
721 bool sel = true,
722 bool control = false,
723 bool shift = false,
724 bool alt = false,
725 bool meta = false);
726 //@}
727
728 /**
729 Returns @true if the Alt key was down at the time of the event.
730 */
731 bool AltDown() const;
732
733 /**
734 Returns @true if the Control key was down at the time of the event.
735 */
736 bool ControlDown() const;
737
738 /**
739 Top left corner of the rectangular area that was (de)selected.
740 */
741 wxGridCellCoords GetBottomRightCoords();
742
743 /**
744 Bottom row of the rectangular area that was (de)selected.
745 */
746 int GetBottomRow();
747
748 /**
749 Left column of the rectangular area that was (de)selected.
750 */
751 int GetLeftCol();
752
753 /**
754 Right column of the rectangular area that was (de)selected.
755 */
756 int GetRightCol();
757
758 /**
759 Top left corner of the rectangular area that was (de)selected.
760 */
761 wxGridCellCoords GetTopLeftCoords();
762
763 /**
764 Top row of the rectangular area that was (de)selected.
765 */
766 int GetTopRow();
767
768 /**
769 Returns @true if the Meta key was down at the time of the event.
770 */
771 bool MetaDown() const;
772
773 /**
774 Returns @true if the area was selected, @false otherwise.
775 */
776 bool Selecting();
777
778 /**
779 Returns @true if the Shift key was down at the time of the event.
780 */
781 bool ShiftDown() const;
782 };
783
784
785
786 /**
787 @class wxGridCellRenderer
788
789 This class is responsible for actually drawing the cell
790 in the grid. You may pass it to the wxGridCellAttr (below) to change the
791 format of one given cell or to wxGrid::SetDefaultRenderer() to change the
792 view of all cells. This is an abstract class, and you will normally use one of
793 the
794 predefined derived classes or derive your own class from it.
795
796 @library{wxadv}
797 @category{grid}
798
799 @see wxGridCellStringRenderer, wxGridCellNumberRenderer,
800 wxGridCellFloatRenderer, wxGridCellBoolRenderer
801 */
802 class wxGridCellRenderer
803 {
804 public:
805 /**
806
807 */
808 virtual wxGridCellRenderer* Clone() const = 0;
809
810 /**
811 Draw the given cell on the provided DC inside the given rectangle
812 using the style specified by the attribute and the default or selected
813 state corresponding to the isSelected value.
814 This pure virtual function has a default implementation which will
815 prepare the DC using the given attribute: it will draw the rectangle
816 with the background colour from attr and set the text colour and font.
817 */
818 virtual void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
819 const wxRect& rect, int row, int col,
820 bool isSelected) = 0;
821
822 /**
823 Get the preferred size of the cell for its contents.
824 */
825 virtual wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
826 int row, int col) = 0;
827 };
828
829
830
831 /**
832 @class wxGridCellNumberEditor
833
834 The editor for numeric integer data.
835
836 @library{wxadv}
837 @category{grid}
838
839 @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
840 wxGridCellTextEditor, wxGridCellChoiceEditor
841 */
842 class wxGridCellNumberEditor : public wxGridCellTextEditor
843 {
844 public:
845 /**
846 Allows to specify the range for acceptable data;
847 if min == max == -1, no range checking is done
848 */
849 wxGridCellNumberEditor(int min = -1, int max = -1);
850
851
852 /**
853 Parameters string format is "min,max".
854 */
855 virtual void SetParameters(const wxString& params);
856
857 protected:
858
859 /**
860 If the return value is @true, the editor uses a wxSpinCtrl to get user input,
861 otherwise it uses a wxTextCtrl.
862 */
863 bool HasRange() const;
864
865 /**
866 String representation of the value.
867 */
868 wxString GetString() const;
869 };
870
871
872
873 /**
874 @class wxGridSizeEvent
875
876 This event class contains information about a row/column resize event.
877
878 @library{wxadv}
879 @category{grid}
880 */
881 class wxGridSizeEvent : public wxNotifyEvent
882 {
883 public:
884 //@{
885 /**
886
887 */
888 wxGridSizeEvent();
889 wxGridSizeEvent(int id, wxEventType type, wxObject* obj,
890 int rowOrCol = -1,
891 int x = -1,
892 int y = -1,
893 bool control = false,
894 bool shift = false,
895 bool alt = false,
896 bool meta = false);
897 //@}
898
899 /**
900 Returns @true if the Alt key was down at the time of the event.
901 */
902 bool AltDown() const;
903
904 /**
905 Returns @true if the Control key was down at the time of the event.
906 */
907 bool ControlDown() const;
908
909 /**
910 Position in pixels at which the event occurred.
911 */
912 wxPoint GetPosition();
913
914 /**
915 Row or column at that was resized.
916 */
917 int GetRowOrCol();
918
919 /**
920 Returns @true if the Meta key was down at the time of the event.
921 */
922 bool MetaDown() const;
923
924 /**
925 Returns @true if the Shift key was down at the time of the event.
926 */
927 bool ShiftDown() const;
928 };
929
930
931
932 /**
933 @class wxGridCellNumberRenderer
934
935 This class may be used to format integer data in a cell.
936
937 @library{wxadv}
938 @category{grid}
939
940 @see wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
941 wxGridCellBoolRenderer
942 */
943 class wxGridCellNumberRenderer : public wxGridCellStringRenderer
944 {
945 public:
946 /**
947 Default constructor
948 */
949 wxGridCellNumberRenderer();
950 };
951
952
953
954 /**
955 @class wxGridCellAttr
956
957 This class can be used to alter the cells' appearance in
958 the grid by changing their colour/font/... from default. An object of this
959 class may be returned by wxGridTableBase::GetAttr.
960
961 @library{wxadv}
962 @category{grid}
963 */
964 class wxGridCellAttr
965 {
966 public:
967 //@{
968 /**
969 Constructor specifying some of the often used attributes.
970 */
971 wxGridCellAttr();
972 wxGridCellAttr(const wxColour& colText,
973 const wxColour& colBack,
974 const wxFont& font,
975 int hAlign, int vAlign);
976 //@}
977
978 /**
979 Creates a new copy of this object.
980 */
981 wxGridCellAttr* Clone() const;
982
983 /**
984
985 */
986 void DecRef();
987
988 /**
989 See SetAlignment() for the returned values.
990 */
991 void GetAlignment(int* hAlign, int* vAlign) const;
992
993 /**
994
995 */
996 const wxColour& GetBackgroundColour() const;
997
998 /**
999
1000 */
1001 wxGridCellEditor* GetEditor(const wxGrid* grid, int row, int col) const;
1002
1003 /**
1004
1005 */
1006 const wxFont& GetFont() const;
1007
1008 /**
1009
1010 */
1011 wxGridCellRenderer* GetRenderer(const wxGrid* grid, int row, int col) const;
1012
1013 /**
1014
1015 */
1016 const wxColour& GetTextColour() const;
1017
1018 /**
1019
1020 */
1021 bool HasAlignment() const;
1022
1023 /**
1024
1025 */
1026 bool HasBackgroundColour() const;
1027
1028 /**
1029
1030 */
1031 bool HasEditor() const;
1032
1033 /**
1034
1035 */
1036 bool HasFont() const;
1037
1038 /**
1039
1040 */
1041 bool HasRenderer() const;
1042
1043 /**
1044 accessors
1045 */
1046 bool HasTextColour() const;
1047
1048 /**
1049 This class is ref counted: it is created with ref count of 1, so
1050 calling DecRef() once will delete it. Calling IncRef() allows to lock
1051 it until the matching DecRef() is called
1052 */
1053 void IncRef();
1054
1055 /**
1056
1057 */
1058 bool IsReadOnly() const;
1059
1060 /**
1061 Sets the alignment. @a hAlign can be one of @c wxALIGN_LEFT,
1062 @c wxALIGN_CENTRE or @c wxALIGN_RIGHT and @a vAlign can be one
1063 of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
1064 */
1065 void SetAlignment(int hAlign, int vAlign);
1066
1067 /**
1068 Sets the background colour.
1069 */
1070 void SetBackgroundColour(const wxColour& colBack);
1071
1072 /**
1073
1074 */
1075 void SetDefAttr(wxGridCellAttr* defAttr);
1076
1077 /**
1078
1079 */
1080 void SetEditor(wxGridCellEditor* editor);
1081
1082 /**
1083 Sets the font.
1084 */
1085 void SetFont(const wxFont& font);
1086
1087 /**
1088
1089 */
1090 void SetReadOnly(bool isReadOnly = true);
1091
1092 /**
1093 takes ownership of the pointer
1094 */
1095 void SetRenderer(wxGridCellRenderer* renderer);
1096
1097 /**
1098 Sets the text colour.
1099 */
1100 void SetTextColour(const wxColour& colText);
1101 };
1102
1103
1104
1105 /**
1106 @class wxGridCellBoolRenderer
1107
1108 This class may be used to format boolean data in a cell.
1109 for string cells.
1110
1111 @library{wxadv}
1112 @category{grid}
1113
1114 @see wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
1115 wxGridCellNumberRenderer
1116 */
1117 class wxGridCellBoolRenderer : public wxGridCellRenderer
1118 {
1119 public:
1120 /**
1121 Default constructor
1122 */
1123 wxGridCellBoolRenderer();
1124 };
1125
1126
1127
1128 /**
1129 @class wxGridEvent
1130
1131 This event class contains information about various grid events.
1132
1133 @library{wxadv}
1134 @category{grid}
1135 */
1136 class wxGridEvent : public wxNotifyEvent
1137 {
1138 public:
1139 //@{
1140 /**
1141
1142 */
1143 wxGridEvent();
1144 wxGridEvent(int id, wxEventType type, wxObject* obj,
1145 int row = -1, int col = -1,
1146 int x = -1, int y = -1,
1147 bool sel = true,
1148 bool control = false,
1149 bool shift = false,
1150 bool alt = false,
1151 bool meta = false);
1152 //@}
1153
1154 /**
1155 Returns @true if the Alt key was down at the time of the event.
1156 */
1157 bool AltDown() const;
1158
1159 /**
1160 Returns @true if the Control key was down at the time of the event.
1161 */
1162 bool ControlDown() const;
1163
1164 /**
1165 Column at which the event occurred.
1166 */
1167 virtual int GetCol();
1168
1169 /**
1170 Position in pixels at which the event occurred.
1171 */
1172 wxPoint GetPosition();
1173
1174 /**
1175 Row at which the event occurred.
1176 */
1177 virtual int GetRow();
1178
1179 /**
1180 Returns @true if the Meta key was down at the time of the event.
1181 */
1182 bool MetaDown() const;
1183
1184 /**
1185 Returns @true if the user is selecting grid cells, @false -- if
1186 deselecting.
1187 */
1188 bool Selecting();
1189
1190 /**
1191 Returns @true if the Shift key was down at the time of the event.
1192 */
1193 bool ShiftDown() const;
1194 };
1195
1196
1197
1198 /**
1199 @class wxGridCellFloatEditor
1200
1201 The editor for floating point numbers data.
1202
1203 @library{wxadv}
1204 @category{grid}
1205
1206 @see wxGridCellEditor, wxGridCellNumberEditor, wxGridCellBoolEditor,
1207 wxGridCellTextEditor, wxGridCellChoiceEditor
1208 */
1209 class wxGridCellFloatEditor : public wxGridCellTextEditor
1210 {
1211 public:
1212 /**
1213 @param width
1214 Minimum number of characters to be shown.
1215 @param precision
1216 Number of digits after the decimal dot.
1217 */
1218 wxGridCellFloatEditor(int width = -1, int precision = -1);
1219
1220 /**
1221 Parameters string format is "width,precision"
1222 */
1223 virtual void SetParameters(const wxString& params);
1224 };
1225
1226
1227
1228 /**
1229 @class wxGrid
1230
1231 wxGrid and its related classes are used for displaying and editing tabular
1232 data.
1233 They provide a rich set of features for display, editing, and interacting
1234 with a variety of data sources. For simple applications, and to help you
1235 get started, wxGrid is the only class you need to refer to directly. It
1236 will set up default instances of the other classes and manage them for you.
1237 For more complex applications you can derive your own classes for custom
1238 grid views, grid data tables, cell editors and renderers. The @ref
1239 overview_grid "wxGrid overview" has examples of simple and more complex applications,
1240 explains the relationship between the various grid classes and has a
1241 summary of the keyboard shortcuts and mouse functions provided by wxGrid.
1242
1243 wxGrid has been greatly expanded and redesigned for wxWidgets 2.2 onwards.
1244 The new grid classes are reasonably backward-compatible but there are some
1245 exceptions. There are also easier ways of doing many things compared to the
1246 previous implementation.
1247
1248 A wxGridTableBase class holds the actual data to be displayed by a wxGrid
1249 class. One or more wxGrid classes may act as a view for one table class.
1250 The default table class is called wxGridStringTable and holds an array of
1251 strings. An instance of such a class is created by wxGrid::CreateGrid.
1252
1253 wxGridCellRenderer is the abstract base class for rendereing contents in a
1254 cell. The following renderers are predefined:
1255 - wxGridCellStringRenderer,
1256 - wxGridCellBoolRenderer,
1257 - wxGridCellFloatRenderer,
1258 - wxGridCellNumberRenderer.
1259 The look of a cell can be further defined using wxGridCellAttr. An object
1260 of this type may be returned by wxGridTableBase::GetAttr.
1261
1262 wxGridCellEditor is the abstract base class for editing the value of a
1263 cell. The following editors are predefined:
1264 - wxGridCellTextEditor
1265 - wxGridCellBoolEditor
1266 - wxGridCellChoiceEditor
1267 - wxGridCellNumberEditor.
1268
1269 @library{wxadv}
1270 @category{grid}
1271
1272 @see @ref overview_grid "wxGrid overview"
1273 */
1274 class wxGrid : public wxScrolledWindow
1275 {
1276 public:
1277 /**
1278 Different selection modes supported by the grid.
1279 */
1280 enum wxGridSelectionModes
1281 {
1282 /**
1283 The default selection mode allowing selection of the individual
1284 cells as well as of the entire rows and columns.
1285 */
1286 wxGridSelectCells,
1287
1288 /**
1289 The selection mode allowing the selection of the entire rows only.
1290
1291 The user won't be able to select any cells or columns in this mode.
1292 */
1293 wxGridSelectRows,
1294
1295 /**
1296 The selection mode allowing the selection of the entire columns only.
1297
1298 The user won't be able to select any cells or rows in this mode.
1299 */
1300 wxGridSelectColumns
1301 };
1302
1303 /**
1304 Default constructor.
1305
1306 You must call Create() to really create the grid window and also call
1307 CreateGrid() or SetTable() to initialize the grid contents.
1308 */
1309 wxGrid();
1310
1311 /**
1312 Constructor creating the grid window.
1313
1314 You must call either CreateGrid() or SetTable() to initialize the grid
1315 contents before using it.
1316 */
1317 wxGrid(wxWindow* parent,
1318 wxWindowID id,
1319 const wxPoint& pos = wxDefaultPosition,
1320 const wxSize& size = wxDefaultSize,
1321 long style = wxWANTS_CHARS,
1322 const wxString& name = wxGridNameStr);
1323
1324 /**
1325 Creates the grid window for an object initialized using the default
1326 constructor.
1327
1328 You must call either CreateGrid() or SetTable() to initialize the grid
1329 contents before using it.
1330 */
1331 bool Create(wxWindow* parent,
1332 wxWindowID id,
1333 const wxPoint& pos = wxDefaultPosition,
1334 const wxSize& size = wxDefaultSize,
1335 long style = wxWANTS_CHARS,
1336 const wxString& name = wxGridNameStr);
1337
1338 /**
1339 Destructor.
1340
1341 This will also destroy the associated grid table unless you passed a
1342 table object to the grid and specified that the grid should not take
1343 ownership of the table (see wxGrid::SetTable).
1344 */
1345 virtual ~wxGrid();
1346
1347 /**
1348 Appends one or more new columns to the right of the grid.
1349
1350 The @a updateLabels argument is not used at present. If you are using a
1351 derived grid table class you will need to override
1352 wxGridTableBase::AppendCols. See InsertCols() for further information.
1353
1354 @return @true on success or @false if appending columns failed.
1355 */
1356 bool AppendCols(int numCols = 1, bool updateLabels = true);
1357
1358 /**
1359 Appends one or more new rows to the bottom of the grid.
1360
1361 The @a updateLabels argument is not used at present. If you are using a
1362 derived grid table class you will need to override
1363 wxGridTableBase::AppendRows. See InsertRows() for further information.
1364
1365 @return @true on success or @false if appending rows failed.
1366 */
1367 bool AppendRows(int numRows = 1, bool updateLabels = true);
1368
1369 /**
1370 Return @true if the horizontal grid lines stop at the last column
1371 boundary or @false if they continue to the end of the window.
1372
1373 The default is to clip grid lines.
1374
1375 @see ClipHorzGridLines(), AreVertGridLinesClipped()
1376 */
1377 bool AreHorzGridLinesClipped() const;
1378
1379 /**
1380 Return @true if the vertical grid lines stop at the last row
1381 boundary or @false if they continue to the end of the window.
1382
1383 The default is to clip grid lines.
1384
1385 @see ClipVertGridLines(), AreHorzGridLinesClipped()
1386 */
1387 bool AreVertGridLinesClipped() const;
1388
1389 /**
1390 Automatically sets the height and width of all rows and columns to fit their
1391 contents.
1392 */
1393 void AutoSize();
1394
1395 /**
1396 Automatically adjusts width of the column to fit its label.
1397 */
1398 void AutoSizeColLabelSize(int col);
1399
1400 /**
1401 Automatically sizes the column to fit its contents. If setAsMin is @true the
1402 calculated width will
1403 also be set as the minimal width for the column.
1404 */
1405 void AutoSizeColumn(int col, bool setAsMin = true);
1406
1407 /**
1408 Automatically sizes all columns to fit their contents. If setAsMin is @true the
1409 calculated widths will
1410 also be set as the minimal widths for the columns.
1411 */
1412 void AutoSizeColumns(bool setAsMin = true);
1413
1414 /**
1415 Automatically sizes the row to fit its contents. If setAsMin is @true the
1416 calculated height will
1417 also be set as the minimal height for the row.
1418 */
1419 void AutoSizeRow(int row, bool setAsMin = true);
1420
1421 /**
1422 Automatically adjusts height of the row to fit its label.
1423 */
1424 void AutoSizeRowLabelSize(int col);
1425
1426 /**
1427 Automatically sizes all rows to fit their contents. If setAsMin is @true the
1428 calculated heights will
1429 also be set as the minimal heights for the rows.
1430 */
1431 void AutoSizeRows(bool setAsMin = true);
1432
1433 /**
1434 Increments the grid's batch count.
1435
1436 When the count is greater than zero repainting of the grid is
1437 suppressed. Each call to BeginBatch must be matched by a later call to
1438 EndBatch(). Code that does a lot of grid modification can be enclosed
1439 between BeginBatch and EndBatch calls to avoid screen flicker. The
1440 final EndBatch will cause the grid to be repainted.
1441
1442 Notice that you should use wxGridUpdateLocker which ensures that there
1443 is always a matching EndBatch() call for this BeginBatch() if possible
1444 instead of calling this method directly.
1445 */
1446 void BeginBatch();
1447
1448 /**
1449 Convert grid cell coordinates to grid window pixel coordinates.
1450
1451 This function returns the rectangle that encloses the block of cells
1452 limited by @a topLeft and @a bottomRight cell in device coords and
1453 clipped to the client size of the grid window.
1454
1455 @see CellToRect()
1456 */
1457 wxRect BlockToDeviceRect(const wxGridCellCoords& topLeft,
1458 const wxGridCellCoords& bottomRight) const;
1459
1460 /**
1461 Returns @true if columns can be moved by dragging with the mouse.
1462
1463 Columns can be moved by dragging on their labels.
1464 */
1465 bool CanDragColMove() const;
1466
1467 /**
1468 Returns @true if columns can be resized by dragging with the mouse.
1469
1470 Columns can be resized by dragging the edges of their labels. If grid
1471 line dragging is enabled they can also be resized by dragging the right
1472 edge of the column in the grid cell area (see
1473 wxGrid::EnableDragGridSize).
1474 */
1475 bool CanDragColSize() const;
1476
1477 /**
1478 Return @true if the dragging of grid lines to resize rows and columns
1479 is enabled or @false otherwise.
1480 */
1481 bool CanDragGridSize() const;
1482
1483 /**
1484 Returns @true if rows can be resized by dragging with the mouse.
1485
1486 Rows can be resized by dragging the edges of their labels. If grid line
1487 dragging is enabled they can also be resized by dragging the lower edge
1488 of the row in the grid cell area (see wxGrid::EnableDragGridSize).
1489 */
1490 bool CanDragRowSize() const;
1491
1492 /**
1493 Returns @true if the in-place edit control for the current grid cell
1494 can be used and @false otherwise.
1495
1496 This function always returns @false for the read-only cells.
1497 */
1498 bool CanEnableCellControl() const;
1499
1500 //@{
1501 /**
1502 Return the rectangle corresponding to the grid cell's size and position
1503 in logical coordinates.
1504
1505 @see BlockToDeviceRect()
1506 */
1507 wxRect CellToRect(int row, int col) const;
1508 const wxRect CellToRect(const wxGridCellCoords& coords) const;
1509
1510 //@}
1511
1512 /**
1513 Clears all data in the underlying grid table and repaints the grid.
1514
1515 The table is not deleted by this function. If you are using a derived
1516 table class then you need to override wxGridTableBase::Clear() for this
1517 function to have any effect.
1518 */
1519 void ClearGrid();
1520
1521 /**
1522 Deselects all cells that are currently selected.
1523 */
1524 void ClearSelection();
1525
1526 /**
1527 Change whether the horizontal grid lines are clipped by the end of the
1528 last column.
1529
1530 By default the grid lines are not drawn beyond the end of the last
1531 column but after calling this function with @a clip set to @false they
1532 will be drawn across the entire grid window.
1533
1534 @see AreHorzGridLinesClipped(), ClipVertGridLines()
1535 */
1536 void ClipHorzGridLines(bool clip);
1537
1538 /**
1539 Change whether the vertical grid lines are clipped by the end of the
1540 last row.
1541
1542 By default the grid lines are not drawn beyond the end of the last
1543 row but after calling this function with @a clip set to @false they
1544 will be drawn across the entire grid window.
1545
1546 @see AreVertzGridLinesClipped(), ClipHorzGridLines()
1547 */
1548 void ClipVertzGridLines(bool clip);
1549
1550 /**
1551 Creates a grid with the specified initial number of rows and columns.
1552
1553 Call this directly after the grid constructor. When you use this
1554 function wxGrid will create and manage a simple table of string values
1555 for you. All of the grid data will be stored in memory.
1556 For applications with more complex data types or relationships, or for
1557 dealing with very large datasets, you should derive your own grid table
1558 class and pass a table object to the grid with SetTable().
1559 */
1560 bool CreateGrid(int numRows, int numCols,
1561 wxGridSelectionModes selmode = wxGridSelectCells);
1562
1563 /**
1564 Deletes one or more columns from a grid starting at the specified
1565 position.
1566
1567 The @a updateLabels argument is not used at present. If you are using a
1568 derived grid table class you will need to override
1569 wxGridTableBase::DeleteCols. See InsertCols() for further information.
1570
1571 @return @true on success or @false if deleting columns failed.
1572 */
1573 bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true);
1574
1575 /**
1576 Deletes one or more rows from a grid starting at the specified position.
1577
1578 The @a updateLabels argument is not used at present. If you are using a
1579 derived grid table class you will need to override
1580 wxGridTableBase::DeleteRows. See InsertRows() for further information.
1581
1582 @return @true on success or @false if appending rows failed.
1583 */
1584 bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true);
1585
1586 /**
1587 Disables in-place editing of grid cells.
1588
1589 Equivalent to calling EnableCellEditControl(@false).
1590 */
1591 void DisableCellEditControl();
1592
1593 /**
1594 Disables column moving by dragging with the mouse.
1595
1596 Equivalent to passing @false to EnableDragColMove().
1597 */
1598 void DisableDragColMove();
1599
1600 /**
1601 Disables column sizing by dragging with the mouse.
1602
1603 Equivalent to passing @false to EnableDragColSize().
1604 */
1605 void DisableDragColSize();
1606
1607 /**
1608 Disable mouse dragging of grid lines to resize rows and columns.
1609
1610 Equivalent to passing @false to EnableDragGridSize()
1611 */
1612 void DisableDragGridSize();
1613
1614 /**
1615 Disables row sizing by dragging with the mouse.
1616
1617 Equivalent to passing @false to EnableDragRowSize().
1618 */
1619 void DisableDragRowSize();
1620
1621 /**
1622 Enables or disables in-place editing of grid cell data.
1623
1624 The grid will issue either a wxEVT_GRID_EDITOR_SHOWN or
1625 wxEVT_GRID_EDITOR_HIDDEN event.
1626 */
1627 void EnableCellEditControl(bool enable = true);
1628
1629 /**
1630 Enables or disables column moving by dragging with the mouse.
1631 */
1632 void EnableDragColMove(bool enable = true);
1633
1634 /**
1635 Enables or disables column sizing by dragging with the mouse.
1636 */
1637 void EnableDragColSize(bool enable = true);
1638
1639 /**
1640 Enables or disables row and column resizing by dragging gridlines with the
1641 mouse.
1642 */
1643 void EnableDragGridSize(bool enable = true);
1644
1645 /**
1646 Enables or disables row sizing by dragging with the mouse.
1647 */
1648 void EnableDragRowSize(bool enable = true);
1649
1650 /**
1651 Makes the grid globally editable or read-only.
1652
1653 If the edit argument is @false this function sets the whole grid as
1654 read-only. If the argument is @true the grid is set to the default
1655 state where cells may be editable. In the default state you can set
1656 single grid cells and whole rows and columns to be editable or
1657 read-only via wxGridCellAttribute::SetReadOnly. For single cells you
1658 can also use the shortcut function SetReadOnly().
1659
1660 For more information about controlling grid cell attributes see the
1661 wxGridCellAttr cell attribute class and the
1662 @ref overview_grid "wxGrid overview".
1663 */
1664 void EnableEditing(bool edit);
1665
1666 /**
1667 Turns the drawing of grid lines on or off.
1668 */
1669 void EnableGridLines(bool enable = true);
1670
1671 /**
1672 Decrements the grid's batch count.
1673
1674 When the count is greater than zero repainting of the grid is
1675 suppressed. Each previous call to BeginBatch() must be matched by a
1676 later call to EndBatch. Code that does a lot of grid modification can
1677 be enclosed between BeginBatch and EndBatch calls to avoid screen
1678 flicker. The final EndBatch will cause the grid to be repainted.
1679
1680 @see wxGridUpdateLocker
1681 */
1682 void EndBatch();
1683
1684 /**
1685 Overridden wxWindow method.
1686 */
1687 virtual void Fit();
1688
1689 /**
1690 Causes immediate repainting of the grid.
1691
1692 Use this instead of the usual wxWindow::Refresh.
1693 */
1694 void ForceRefresh();
1695
1696 /**
1697 Returns the number of times that BeginBatch() has been called
1698 without (yet) matching calls to EndBatch(). While
1699 the grid's batch count is greater than zero the display will not be updated.
1700 */
1701 int GetBatchCount();
1702
1703 /**
1704 Sets the arguments to the horizontal and vertical text alignment values
1705 for the grid cell at the specified location.
1706
1707 Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
1708 or @c wxALIGN_RIGHT.
1709
1710 Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
1711 @c wxALIGN_BOTTOM.
1712 */
1713 void GetCellAlignment(int row, int col, int* horiz, int* vert) const;
1714
1715 /**
1716 Returns the background colour of the cell at the specified location.
1717 */
1718 wxColour GetCellBackgroundColour(int row, int col) const;
1719
1720 /**
1721 Returns a pointer to the editor for the cell at the specified location.
1722
1723 See wxGridCellEditor and the @ref overview_grid "wxGrid overview"
1724 for more information about cell editors and renderers.
1725
1726 The caller must call DecRef() on the returned pointer.
1727 */
1728 wxGridCellEditor* GetCellEditor(int row, int col) const;
1729
1730 /**
1731 Returns the font for text in the grid cell at the specified location.
1732 */
1733 wxFont GetCellFont(int row, int col) const;
1734
1735 /**
1736 Returns a pointer to the renderer for the grid cell at the specified
1737 location.
1738
1739 See wxGridCellRenderer and the @ref overview_grid "wxGrid overview"
1740 for more information about cell editors and renderers.
1741
1742 The caller must call DecRef() on the returned pointer.
1743 */
1744 wxGridCellRenderer* GetCellRenderer(int row, int col) const;
1745
1746 /**
1747 Returns the text colour for the grid cell at the specified location.
1748 */
1749 wxColour GetCellTextColour(int row, int col) const;
1750
1751 //@{
1752 /**
1753 Returns the string contained in the cell at the specified location.
1754
1755 For simple applications where a grid object automatically uses a
1756 default grid table of string values you use this function together with
1757 SetCellValue() to access cell values. For more complex applications
1758 where you have derived your own grid table class that contains various
1759 data types (e.g. numeric, boolean or user-defined custom types) then
1760 you only use this function for those cells that contain string values.
1761
1762 See wxGridTableBase::CanGetValueAs and the @ref overview_grid "wxGrid overview"
1763 for more information.
1764 */
1765 wxString GetCellValue(int row, int col) const;
1766 const wxString GetCellValue(const wxGridCellCoords& coords) const;
1767 //@}
1768
1769 /**
1770 Returns the column ID of the specified column position.
1771 */
1772 int GetColAt(int colPos) const;
1773
1774 /**
1775 Returns the pen used for vertical grid lines.
1776
1777 This virtual function may be overridden in derived classes in order to
1778 change the appearance of individual grid lines for the given column @e
1779 col.
1780
1781 See GetRowGridLinePen() for an example.
1782 */
1783 virtual wxPen GetColGridLinePen(int col);
1784
1785 /**
1786 Sets the arguments to the current column label alignment values.
1787
1788 Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
1789 or @c wxALIGN_RIGHT.
1790
1791 Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
1792 @c wxALIGN_BOTTOM.
1793 */
1794 void GetColLabelAlignment(int* horiz, int* vert) const;
1795
1796 /**
1797 Returns the current height of the column labels.
1798 */
1799 int GetColLabelSize() const;
1800
1801 /**
1802 Returns the specified column label.
1803
1804 The default grid table class provides column labels of the form
1805 A,B...Z,AA,AB...ZZ,AAA... If you are using a custom grid table you can
1806 override wxGridTableBase::GetColLabelValue to provide your own labels.
1807 */
1808 wxString GetColLabelValue(int col) const;
1809
1810 /**
1811 Returns the minimal width to which a column may be resized.
1812
1813 Use SetColMinimalAcceptableWidth() to change this value globally or
1814 SetColMinimalWidth() to do it for individual columns.
1815 */
1816 int GetColMinimalAcceptableWidth() const;
1817
1818 /**
1819 Returns the position of the specified column.
1820 */
1821 int GetColPos(int colID) const;
1822
1823 /**
1824 Returns the width of the specified column.
1825 */
1826 int GetColSize(int col) const;
1827
1828 /**
1829 Returns the default cell alignment.
1830
1831 Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
1832 or @c wxALIGN_RIGHT.
1833
1834 Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
1835 @c wxALIGN_BOTTOM.
1836
1837 @see SetDefaultCellAlignment()
1838 */
1839 void GetDefaultCellAlignment(int* horiz, int* vert) const;
1840
1841 /**
1842 Returns the current default background colour for grid cells.
1843 */
1844 wxColour GetDefaultCellBackgroundColour() const;
1845
1846 /**
1847 Returns the current default font for grid cell text.
1848 */
1849 wxFont GetDefaultCellFont() const;
1850
1851 /**
1852 Returns the current default colour for grid cell text.
1853 */
1854 wxColour GetDefaultCellTextColour() const;
1855
1856 /**
1857 Returns the default height for column labels.
1858 */
1859 int GetDefaultColLabelSize() const;
1860
1861 /**
1862 Returns the current default width for grid columns.
1863 */
1864 int GetDefaultColSize() const;
1865
1866 /**
1867 Returns a pointer to the current default grid cell editor.
1868
1869 See wxGridCellEditor and the @ref overview_grid "wxGrid overview"
1870 for more information about cell editors and renderers.
1871 */
1872 wxGridCellEditor* GetDefaultEditor() const;
1873
1874 //@{
1875 /**
1876 Returns the default editor for the specified cell.
1877
1878 The base class version returns the editor appropriate for the current
1879 cell type but this method may be overridden in the derived classes to
1880 use custom editors for some cells by default.
1881
1882 Notice that the same may be usually achieved in simpler way by
1883 associating a custom editor with the given cell or cells.
1884
1885 The caller must call DecRef() on the returned pointer.
1886 */
1887 virtual wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
1888 wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const;
1889 //@}
1890
1891 /**
1892 Returns the default editor for the cells containing values of the given
1893 type.
1894
1895 The base class version returns the editor which was associated with the
1896 specified @a typeName when it was registered RegisterDataType() but
1897 this function may be overridden to return something different. This
1898 allows to override an editor used for one of the standard types.
1899
1900 The caller must call DecRef() on the returned pointer.
1901 */
1902 virtual wxGridCellEditor *
1903 GetDefaultEditorForType(const wxString& typeName) const;
1904
1905 /**
1906 Returns the pen used for grid lines.
1907
1908 This virtual function may be overridden in derived classes in order to
1909 change the appearance of grid lines. Note that currently the pen width
1910 must be 1.
1911
1912 @see GetColGridLinePen(), GetRowGridLinePen()
1913 */
1914 virtual wxPen GetDefaultGridLinePen();
1915
1916 /**
1917 Returns a pointer to the current default grid cell renderer.
1918
1919 See wxGridCellRenderer and the @ref overview_grid "wxGrid overview"
1920 for more information about cell editors and renderers.
1921
1922 The caller must call DecRef() on the returned pointer.
1923 */
1924 wxGridCellRenderer* GetDefaultRenderer() const;
1925
1926 /**
1927 Returns the default renderer for the given cell.
1928
1929 The base class version returns the renderer appropriate for the current
1930 cell type but this method may be overridden in the derived classes to
1931 use custom renderers for some cells by default.
1932
1933 The caller must call DecRef() on the returned pointer.
1934 */
1935 virtual wxGridCellRenderer *GetDefaultRendererForCell(int row, int col) const;
1936
1937 /**
1938 Returns the default renderer for the cell containing values of the
1939 given type.
1940
1941 @see GetDefaultEditorForType()
1942 */
1943 virtual wxGridCellRenderer *
1944 GetDefaultRendererForType(const wxString& typeName) const;
1945
1946 /**
1947 Returns the default width for the row labels.
1948 */
1949 int GetDefaultRowLabelSize() const;
1950
1951 /**
1952 Returns the current default height for grid rows.
1953 */
1954 int GetDefaultRowSize() const;
1955
1956 /**
1957 Returns the current grid cell column position.
1958 */
1959 int GetGridCursorCol() const;
1960
1961 /**
1962 Returns the current grid cell row position.
1963 */
1964 int GetGridCursorRow() const;
1965
1966 /**
1967 Returns the colour used for grid lines.
1968
1969 @see GetDefaultGridLinePen()
1970 */
1971 wxColour GetGridLineColour() const;
1972
1973 /**
1974 Returns the colour used for the background of row and column labels.
1975 */
1976 wxColour GetLabelBackgroundColour() const;
1977
1978 /**
1979 Returns the font used for row and column labels.
1980 */
1981 wxFont GetLabelFont() const;
1982
1983 /**
1984 Returns the colour used for row and column label text.
1985 */
1986 wxColour GetLabelTextColour() const;
1987
1988 /**
1989 Returns the total number of grid columns.
1990
1991 This is the same as the number of columns in the underlying grid
1992 table.
1993 */
1994 int GetNumberCols() const;
1995
1996 /**
1997 Returns the total number of grid rows.
1998
1999 This is the same as the number of rows in the underlying grid table.
2000 */
2001 int GetNumberRows() const;
2002
2003 /**
2004 Returns the attribute for the given cell creating one if necessary.
2005
2006 If the cell already has an attribute, it is returned. Otherwise a new
2007 attribute is created, associated with the cell and returned. In any
2008 case the caller must call DecRef() on the returned pointer.
2009
2010 This function may only be called if CanHaveAttributes() returns @true.
2011 */
2012 wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
2013
2014 /**
2015 Returns the pen used for horizontal grid lines.
2016
2017 This virtual function may be overridden in derived classes in order to
2018 change the appearance of individual grid line for the given row @e row.
2019
2020 Example:
2021 @code
2022 // in a grid displaying music notation, use a solid black pen between
2023 // octaves (C0=row 127, C1=row 115 etc.)
2024 wxPen MidiGrid::GetRowGridLinePen(int row)
2025 {
2026 if ( row % 12 == 7 )
2027 return wxPen(*wxBLACK, 1, wxSOLID);
2028 else
2029 return GetDefaultGridLinePen();
2030 }
2031 @endcode
2032 */
2033 virtual wxPen GetRowGridLinePen(int row);
2034
2035 /**
2036 Returns the alignment used for row labels.
2037
2038 Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
2039 or @c wxALIGN_RIGHT.
2040
2041 Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
2042 @c wxALIGN_BOTTOM.
2043 */
2044 void GetRowLabelAlignment(int* horiz, int* vert) const;
2045
2046 /**
2047 Returns the current width of the row labels.
2048 */
2049 int GetRowLabelSize() const;
2050
2051 /**
2052 Returns the specified row label.
2053
2054 The default grid table class provides numeric row labels. If you are
2055 using a custom grid table you can override
2056 wxGridTableBase::GetRowLabelValue to provide your own labels.
2057 */
2058 wxString GetRowLabelValue(int row) const;
2059
2060 /**
2061 Returns the minimal size to which rows can be resized.
2062
2063 Use SetRowMinimalAcceptableHeight() to change this value globally or
2064 SetRowMinimalHeight() to do it for individual cells.
2065
2066 @see GetColMinimalAcceptableWidth()
2067 */
2068 int GetRowMinimalAcceptableHeight() const;
2069
2070 /**
2071 Returns the height of the specified row.
2072 */
2073 int GetRowSize(int row) const;
2074
2075 /**
2076 Returns the number of pixels per horizontal scroll increment.
2077
2078 The default is 15.
2079
2080 @see GetScrollLineY(), SetScrollLineX(), SetScrollLineY()
2081 */
2082 int GetScrollLineX() const;
2083
2084 /**
2085 Returns the number of pixels per vertical scroll increment.
2086
2087 The default is 15.
2088
2089 @see GetScrollLineX(), SetScrollLineX(), SetScrollLineY()
2090 */
2091 int GetScrollLineY() const;
2092
2093 /**
2094 Returns an array of individually selected cells.
2095
2096 Notice that this array does @em not contain all the selected cells in
2097 general as it doesn't include the cells selected as part of column, row
2098 or block selection. You must use this method, GetSelectedCols(),
2099 GetSelectedRows() and GetSelectionBlockTopLeft() and
2100 GetSelectionBlockBottomRight() methods to obtain the entire selection
2101 in general.
2102
2103 Please notice this behaviour is by design and is needed in order to
2104 support grids of arbitrary size (when an entire column is selected in
2105 a grid with a million of columns, we don't want to create an array with
2106 a million of entries in this function, instead it returns an empty
2107 array and GetSelectedCols() returns an array containing one element).
2108 */
2109 wxGridCellCoordsArray GetSelectedCells() const;
2110
2111 /**
2112 Returns an array of selected columns.
2113
2114 Please notice that this method alone is not sufficient to find all the
2115 selected columns as it contains only the columns which were
2116 individually selected but not those being part of the block selection
2117 or being selected in virtue of all of their cells being selected
2118 individually, please see GetSelectedCells() for more details.
2119 */
2120 wxArrayInt GetSelectedCols() const;
2121
2122 /**
2123 Returns an array of selected rows.
2124
2125 Please notice that this method alone is not sufficient to find all the
2126 selected rows as it contains only the rows which were individually
2127 selected but not those being part of the block selection or being
2128 selected in virtue of all of their cells being selected individually,
2129 please see GetSelectedCells() for more details.
2130 */
2131 wxArrayInt GetSelectedRows() const;
2132
2133 /**
2134 Access or update the selection fore/back colours
2135 */
2136 wxColour GetSelectionBackground() const;
2137
2138 /**
2139 Returns an array of the bottom right corners of blocks of selected
2140 cells.
2141
2142 Please see GetSelectedCells() for more information about the selection
2143 representation in wxGrid.
2144
2145 @see GetSelectionBlockTopLeft()
2146 */
2147 wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
2148
2149 /**
2150 Returns an array of the top left corners of blocks of selected cells.
2151
2152 Please see GetSelectedCells() for more information about the selection
2153 representation in wxGrid.
2154
2155 @see GetSelectionBlockBottomRight()
2156 */
2157 wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
2158
2159 /**
2160 Returns the colour used for drawing the selection foreground.
2161 */
2162 wxColour GetSelectionForeground() const;
2163
2164 /**
2165 Returns the current selection mode.
2166
2167 @see SetSelectionMode().
2168 */
2169 wxGridSelectionModes GetSelectionMode() const;
2170
2171 /**
2172 Returns a base pointer to the current table object.
2173
2174 The returned pointer is still owned by the grid.
2175 */
2176 wxGridTableBase *GetTable() const;
2177
2178 //@{
2179 /**
2180 Make the given cell current and ensure it is visible.
2181
2182 This method is equivalent to calling MakeCellVisible() and
2183 SetGridCursor() and so, as with the latter, a wxEVT_GRID_SELECT_CELL
2184 event is generated by it and the selected cell doesn't change if the
2185 event is vetoed.
2186 */
2187 void GoToCell(int row, int col);
2188 void GoToCell(const wxGridCellCoords& coords);
2189 //@}
2190
2191 /**
2192 Returns @true if drawing of grid lines is turned on, @false otherwise.
2193 */
2194 bool GridLinesEnabled() const;
2195
2196 /**
2197 Hides the in-place cell edit control.
2198 */
2199 void HideCellEditControl();
2200
2201 /**
2202 Hides the column labels by calling SetColLabelSize()
2203 with a size of 0. Show labels again by calling that method with
2204 a width greater than 0.
2205 */
2206 void HideColLabels();
2207
2208 /**
2209 Hides the row labels by calling SetRowLabelSize() with a size of 0.
2210
2211 The labels can be shown again by calling SetRowLabelSize() with a width
2212 greater than 0.
2213 */
2214 void HideRowLabels();
2215
2216 /**
2217 Inserts one or more new columns into a grid with the first new column
2218 at the specified position.
2219
2220 Notice that inserting the columns in the grid requires grid table
2221 cooperation: when this method is called, grid object begins by
2222 requesting the underlying grid table to insert new columns. If this is
2223 successful the table notifies the grid and the grid updates the
2224 display. For a default grid (one where you have called
2225 wxGrid::CreateGrid) this process is automatic. If you are using a
2226 custom grid table (specified with wxGrid::SetTable) then you must
2227 override wxGridTableBase::InsertCols() in your derived table class.
2228
2229 @param pos
2230 The position which the first newly inserted column will have.
2231 @param numCols
2232 The number of columns to insert.
2233 @param updateLabels
2234 Currently not used.
2235 @return
2236 @true if the columns were successfully inserted, @false if an error
2237 occurred (most likely the table couldn't be updated).
2238 */
2239 bool InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true);
2240
2241 /**
2242 Inserts one or more new rows into a grid with the first new row at the
2243 specified position.
2244
2245 Notice that you must implement wxGridTableBase::InsertRows() if you use
2246 a grid with a custom table, please see InsertCols() for more
2247 information.
2248
2249 @param pos
2250 The position which the first newly inserted row will have.
2251 @param numRows
2252 The number of rows to insert.
2253 @param updateLabels
2254 Currently not used.
2255 @return
2256 @true if the rows were successfully inserted, @false if an error
2257 occurred (most likely the table couldn't be updated).
2258 */
2259 bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true);
2260
2261 /**
2262 Returns @true if the in-place edit control is currently enabled.
2263 */
2264 bool IsCellEditControlEnabled() const;
2265
2266 /**
2267 Returns @true if the current cell is read-only.
2268
2269 @see SetReadOnly(), IsReadOnly()
2270 */
2271 bool IsCurrentCellReadOnly() const;
2272
2273 /**
2274 Returns @false if the whole grid has been set as read-only or @true
2275 otherwise.
2276
2277 See EnableEditing() for more information about controlling the editing
2278 status of grid cells.
2279 */
2280 bool IsEditable() const;
2281
2282 //@{
2283 /**
2284 Is this cell currently selected?
2285 */
2286 bool IsInSelection(int row, int col) const;
2287 bool IsInSelection(const wxGridCellCoords& coords) const;
2288 //@}
2289
2290 /**
2291 Returns @true if the cell at the specified location can't be edited.
2292
2293 @see SetReadOnly(), IsCurrentCellReadOnly()
2294 */
2295 bool IsReadOnly(int row, int col) const;
2296
2297 /**
2298 Returns @true if there are currently any selected cells, rows, columns
2299 or blocks.
2300 */
2301 bool IsSelection() const;
2302
2303 //@{
2304 /**
2305 Returns @true if a cell is either wholly or at least partially visible
2306 in the grid window.
2307
2308 By default, the cell must be entirely visible for this function to
2309 return true but if @a wholeCellVisible is @false, the function returns
2310 @true even if the cell is only partially visible.
2311 */
2312 bool IsVisible(int row, int col, bool wholeCellVisible = true) const;
2313 bool IsVisible(const wxGridCellCoords& coords,
2314 bool wholeCellVisible = true) const;
2315 //@}
2316
2317 //@{
2318 /**
2319 Brings the specified cell into the visible grid cell area with minimal
2320 scrolling.
2321
2322 Does nothing if the cell is already visible.
2323 */
2324 void MakeCellVisible(int row, int col);
2325 void MakeCellVisible(const wxGridCellCoords& coords);
2326 //@}
2327
2328 /**
2329 Moves the grid cursor down by one row.
2330
2331 If a block of cells was previously selected it will expand if the
2332 argument is @true or be cleared if the argument is @false.
2333 */
2334 bool MoveCursorDown(bool expandSelection);
2335
2336 /**
2337 Moves the grid cursor down in the current column such that it skips to
2338 the beginning or end of a block of non-empty cells.
2339
2340 If a block of cells was previously selected it will expand if the
2341 argument is @true or be cleared if the argument is @false.
2342 */
2343 bool MoveCursorDownBlock(bool expandSelection);
2344
2345 /**
2346 Moves the grid cursor left by one column.
2347
2348 If a block of cells was previously selected it will expand if the
2349 argument is @true or be cleared if the argument is @false.
2350 */
2351 bool MoveCursorLeft(bool expandSelection);
2352
2353 /**
2354 Moves the grid cursor left in the current row such that it skips to the
2355 beginning or end of a block of non-empty cells.
2356
2357 If a block of cells was previously selected it will expand if the
2358 argument is @true or be cleared if the argument is @false.
2359 */
2360 bool MoveCursorLeftBlock(bool expandSelection);
2361
2362 /**
2363 Moves the grid cursor right by one column.
2364
2365 If a block of cells was previously selected it will expand if the
2366 argument is @true or be cleared if the argument is @false.
2367 */
2368 bool MoveCursorRight(bool expandSelection);
2369
2370 /**
2371 Moves the grid cursor right in the current row such that it skips to
2372 the beginning or end of a block of non-empty cells.
2373
2374 If a block of cells was previously selected it will expand if the
2375 argument is @true or be cleared if the argument is @false.
2376 */
2377 bool MoveCursorRightBlock(bool expandSelection);
2378
2379 /**
2380 Moves the grid cursor up by one row.
2381
2382 If a block of cells was previously selected it will expand if the
2383 argument is @true or be cleared if the argument is @false.
2384 */
2385 bool MoveCursorUp(bool expandSelection);
2386
2387 /**
2388 Moves the grid cursor up in the current column such that it skips to
2389 the beginning or end of a block of non-empty cells.
2390
2391 If a block of cells was previously selected it will expand if the
2392 argument is @true or be cleared if the argument is @false.
2393 */
2394 bool MoveCursorUpBlock(bool expandSelection);
2395
2396 /**
2397 Moves the grid cursor down by some number of rows so that the previous
2398 bottom visible row becomes the top visible row.
2399 */
2400 bool MovePageDown();
2401
2402 /**
2403 Moves the grid cursor up by some number of rows so that the previous
2404 top visible row becomes the bottom visible row.
2405 */
2406 bool MovePageUp();
2407
2408 /**
2409 Register a new data type.
2410
2411 The data types allow to naturally associate specific renderers and
2412 editors to the cells containing values of the given type. For example,
2413 the grid automatically registers a data type with the name @c
2414 wxGRID_VALUE_STRING which uses wxGridCellStringRenderer and
2415 wxGridCellTextEditor as its renderer and editor respectively -- this is
2416 the data type used by all the cells of the default wxGridStringTable,
2417 so this renderer and editor are used by default for all grid cells.
2418
2419 However if a custom table returns @c wxGRID_VALUE_BOOL from its
2420 wxGridTableBase::GetTypeName() method, then wxGridCellBoolRenderer and
2421 wxGridCellBoolEditor are used for it because the grid also registers a
2422 boolean data type with this name.
2423
2424 And as this mechanism is completely generic, you may register your own
2425 data types using your own custom renderers and editors. Just remember
2426 that the table must identify a cell as being of the given type for them
2427 to be used for this cell.
2428
2429 @param typeName
2430 Name of the new type. May be any string, but if the type name is
2431 the same as the name of an already registered type, including one
2432 of the standard ones (which are @c wxGRID_VALUE_STRING, @c
2433 wxGRID_VALUE_BOOL, @c wxGRID_VALUE_NUMBER, @c wxGRID_VALUE_FLOAT
2434 and @c wxGRID_VALUE_CHOICE), then the new registration information
2435 replaces the previously used renderer and editor.
2436 @param renderer
2437 The renderer to use for the cells of this type. Its ownership is
2438 taken by the grid, i.e. it will call DecRef() on this pointer when
2439 it doesn't need it any longer.
2440 @param editor
2441 The editor to use for the cells of this type. Its ownership is also
2442 taken by the grid.
2443 */
2444 void RegisterDataType(const wxString& typeName,
2445 wxGridCellRenderer* renderer,
2446 wxGridCellEditor* editor);
2447
2448 /**
2449 Sets the value of the current grid cell to the current in-place edit
2450 control value.
2451
2452 This is called automatically when the grid cursor moves from the
2453 current cell to a new cell. It is also a good idea to call this
2454 function when closing a grid since any edits to the final cell location
2455 will not be saved otherwise.
2456 */
2457 void SaveEditControlValue();
2458
2459 /**
2460 Selects all cells in the grid.
2461 */
2462 void SelectAll();
2463
2464 //@{
2465 /**
2466 Selects a rectangular block of cells.
2467
2468 If @a addToSelected is @false then any existing selection will be
2469 deselected; if @true the column will be added to the existing
2470 selection.
2471 */
2472 void SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
2473 bool addToSelected = false);
2474 void SelectBlock(const wxGridCellCoords& topLeft,
2475 const wxGridCellCoords& bottomRight,
2476 bool addToSelected = false);
2477 //@}
2478
2479 /**
2480 Selects the specified column.
2481
2482 If @a addToSelected is @false then any existing selection will be
2483 deselected; if @true the column will be added to the existing
2484 selection.
2485
2486 This method won't select anything if the current selection mode is
2487 wxGridSelectRows.
2488 */
2489 void SelectCol(int col, bool addToSelected = false);
2490
2491 /**
2492 Selects the specified row.
2493
2494 If @a addToSelected is @false then any existing selection will be
2495 deselected; if @true the row will be added to the existing selection.
2496
2497 This method won't select anything if the current selection mode is
2498 wxGridSelectColumns.
2499 */
2500 void SelectRow(int row, bool addToSelected = false);
2501
2502 //@{
2503 /**
2504 Sets the horizontal and vertical alignment for grid cell text at the
2505 specified location.
2506
2507 Horizontal alignment should be one of @c wxALIGN_LEFT, @c
2508 wxALIGN_CENTRE or @c wxALIGN_RIGHT.
2509
2510 Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
2511 or @c wxALIGN_BOTTOM.
2512 */
2513 void SetCellAlignment(int row, int col, int horiz, int vert);
2514 void SetCellAlignment(int align, int row, int col);
2515 //@}
2516
2517 //@{
2518 /**
2519 Set the background colour for the given cell or all cells by default.
2520 */
2521 void SetCellBackgroundColour(int row, int col, const wxColour& colour);
2522 //@}
2523
2524 /**
2525 Sets the editor for the grid cell at the specified location.
2526
2527 The grid will take ownership of the pointer.
2528
2529 See wxGridCellEditor and the @ref overview_grid "wxGrid overview"
2530 for more information about cell editors and renderers.
2531 */
2532 void SetCellEditor(int row, int col, wxGridCellEditor* editor);
2533
2534 /**
2535 Sets the font for text in the grid cell at the specified location.
2536 */
2537 void SetCellFont(int row, int col, const wxFont& font);
2538
2539 /**
2540 Sets the renderer for the grid cell at the specified location.
2541
2542 The grid will take ownership of the pointer.
2543
2544 See wxGridCellRenderer and the @ref overview_grid "wxGrid overview"
2545 for more information about cell editors and renderers.
2546 */
2547 void SetCellRenderer(int row, int col, wxGridCellRenderer* renderer);
2548
2549 //@{
2550 /**
2551 Sets the text colour for the given cell or all cells by default.
2552 */
2553 void SetCellTextColour(int row, int col, const wxColour& colour);
2554 void SetCellTextColour(const wxColour& val, int row, int col);
2555 void SetCellTextColour(const wxColour& colour);
2556 //@}
2557
2558 //@{
2559 /**
2560 Sets the string value for the cell at the specified location.
2561
2562 For simple applications where a grid object automatically uses a
2563 default grid table of string values you use this function together with
2564 GetCellValue() to access cell values. For more complex applications
2565 where you have derived your own grid table class that contains various
2566 data types (e.g. numeric, boolean or user-defined custom types) then
2567 you only use this function for those cells that contain string values.
2568 The last form is for backward compatibility only.
2569
2570 See wxGridTableBase::CanSetValueAs and the @ref overview_grid
2571 "wxGrid overview" for more information.
2572 */
2573 void SetCellValue(int row, int col, const wxString& s);
2574 void SetCellValue(const wxGridCellCoords& coords, const wxString& s);
2575 void SetCellValue(const wxString& val, int row, int col);
2576 //@}
2577
2578 /**
2579 Sets the cell attributes for all cells in the specified column.
2580
2581 For more information about controlling grid cell attributes see the
2582 wxGridCellAttr cell attribute class and the @ref overview_grid "wxGrid overview".
2583 */
2584 void SetColAttr(int col, wxGridCellAttr* attr);
2585
2586 /**
2587 Sets the specified column to display boolean values.
2588
2589 @see SetColFormatCustom()
2590 */
2591 void SetColFormatBool(int col);
2592
2593 /**
2594 Sets the specified column to display data in a custom format.
2595
2596 This method provides an alternative to defining a custom grid table
2597 which would return @a typeName from its GetTypeName() method for the
2598 cells in this column: while it doesn't really change the type of the
2599 cells in this column, it does associate the renderer and editor used
2600 for the cells of the specified type with them.
2601
2602 See the @ref overview_grid "wxGrid overview" for more
2603 information on working with custom data types.
2604 */
2605 void SetColFormatCustom(int col, const wxString& typeName);
2606
2607 /**
2608 Sets the specified column to display floating point values with the
2609 given width and precision.
2610
2611 @see SetColFormatCustom()
2612 */
2613 void SetColFormatFloat(int col, int width = -1, int precision = -1);
2614
2615 /**
2616 Sets the specified column to display integer values.
2617
2618 @see SetColFormatCustom()
2619 */
2620 void SetColFormatNumber(int col);
2621
2622 /**
2623 Sets the horizontal and vertical alignment of column label text.
2624
2625 Horizontal alignment should be one of @c wxALIGN_LEFT, @c
2626 wxALIGN_CENTRE or @c wxALIGN_RIGHT.
2627 Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
2628 or @c wxALIGN_BOTTOM.
2629 */
2630 void SetColLabelAlignment(int horiz, int vert);
2631
2632 /**
2633 Sets the height of the column labels.
2634
2635 If @a height equals to @c wxGRID_AUTOSIZE then height is calculated
2636 automatically so that no label is truncated. Note that this could be
2637 slow for a large table.
2638 */
2639 void SetColLabelSize(int height);
2640
2641 /**
2642 Set the value for the given column label.
2643
2644 If you are using a custom grid table you must override
2645 wxGridTableBase::SetColLabelValue for this to have any effect.
2646 */
2647 void SetColLabelValue(int col, const wxString& value);
2648
2649 /**
2650 Sets the minimal width to which the user can resize columns.
2651
2652 @see GetColMinimalAcceptableWidth()
2653 */
2654 void SetColMinimalAcceptableWidth(int width);
2655
2656 /**
2657 Sets the minimal width for the specified column.
2658
2659 It is usually best to call this method during grid creation as calling
2660 it later will not resize the column to the given minimal width even if
2661 it is currently narrower than it.
2662
2663 @a width must be greater than the minimal acceptable column width as
2664 returned by GetColMinimalAcceptableWidth().
2665 */
2666 void SetColMinimalWidth(int col, int width);
2667
2668 /**
2669 Sets the position of the specified column.
2670 */
2671 void SetColPos(int colID, int newPos);
2672
2673 /**
2674 Sets the width of the specified column.
2675
2676 Notice that this function does not refresh the grid, you need to call
2677 ForceRefresh() to make the changes take effect immediately.
2678
2679 @param col
2680 The column index.
2681 @param width
2682 The new column width in pixels or a negative value to fit the
2683 column width to its label width.
2684 */
2685 void SetColSize(int col, int width);
2686
2687 /**
2688 Sets the default horizontal and vertical alignment for grid cell text.
2689
2690 Horizontal alignment should be one of @c wxALIGN_LEFT, @c
2691 wxALIGN_CENTRE or @c wxALIGN_RIGHT.
2692 Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
2693 or @c wxALIGN_BOTTOM.
2694 */
2695 void SetDefaultCellAlignment(int horiz, int vert);
2696
2697 /**
2698 Sets the default background colour for grid cells.
2699 */
2700 void SetDefaultCellBackgroundColour(const wxColour& colour);
2701
2702 /**
2703 Sets the default font to be used for grid cell text.
2704 */
2705 void SetDefaultCellFont(const wxFont& font);
2706
2707 /**
2708 Sets the current default colour for grid cell text.
2709 */
2710 void SetDefaultCellTextColour(const wxColour& colour);
2711
2712 /**
2713 Sets the default width for columns in the grid.
2714
2715 This will only affect columns subsequently added to the grid unless
2716 @a resizeExistingCols is @true.
2717
2718 If @a width is less than GetColMinimalAcceptableWidth(), then the
2719 minimal acceptable width is used instead of it.
2720 */
2721 void SetDefaultColSize(int width, bool resizeExistingCols = false);
2722
2723 /**
2724 Sets the default editor for grid cells.
2725
2726 The grid will take ownership of the pointer.
2727
2728 See wxGridCellEditor and the @ref overview_grid "wxGrid overview"
2729 for more information about cell editors and renderers.
2730 */
2731 void SetDefaultEditor(wxGridCellEditor* editor);
2732
2733 /**
2734 Sets the default renderer for grid cells.
2735
2736 The grid will take ownership of the pointer.
2737
2738 See wxGridCellRenderer and the @ref overview_grid "wxGrid overview"
2739 for more information about cell editors and renderers.
2740 */
2741 void SetDefaultRenderer(wxGridCellRenderer* renderer);
2742
2743 /**
2744 Sets the default height for rows in the grid.
2745
2746 This will only affect rows subsequently added to the grid unless
2747 @a resizeExistingRows is @true.
2748
2749 If @a height is less than GetRowMinimalAcceptableHeight(), then the
2750 minimal acceptable heihgt is used instead of it.
2751 */
2752 void SetDefaultRowSize(int height, bool resizeExistingRows = false);
2753
2754 //@{
2755 /**
2756 Set the grid cursor to the specified cell.
2757
2758 The grid cursor indicates the current cell and can be moved by the user
2759 using the arrow keys or the mouse.
2760
2761 Calling this function generates a wxEVT_GRID_SELECT_CELL event and if
2762 the event handler vetoes this event, the cursor is not moved.
2763
2764 This function doesn't make the target call visible, use GoToCell() to
2765 do this.
2766 */
2767 void SetGridCursor(int row, int col);
2768 void SetGridCursor(const wxGridCellCoords& coords);
2769 //@}
2770
2771 /**
2772 Sets the colour used to draw grid lines.
2773 */
2774 void SetGridLineColour(const wxColour& colour);
2775
2776 /**
2777 Sets the background colour for row and column labels.
2778 */
2779 void SetLabelBackgroundColour(const wxColour& colour);
2780
2781 /**
2782 Sets the font for row and column labels.
2783 */
2784 void SetLabelFont(const wxFont& font);
2785
2786 /**
2787 Sets the colour for row and column label text.
2788 */
2789 void SetLabelTextColour(const wxColour& colour);
2790
2791 /**
2792 Sets the extra margins used around the grid area.
2793
2794 A grid may occupy more space than needed for its data display and
2795 this function allows to set how big this extra space is
2796 */
2797 void SetMargins(int extraWidth, int extraHeight);
2798
2799 /**
2800 Makes the cell at the specified location read-only or editable.
2801
2802 @see IsReadOnly()
2803 */
2804 void SetReadOnly(int row, int col, bool isReadOnly = true);
2805
2806 /**
2807 Sets the cell attributes for all cells in the specified row.
2808
2809 The grid takes ownership of the attribute pointer.
2810
2811 See the wxGridCellAttr class for more information about controlling
2812 cell attributes.
2813 */
2814 void SetRowAttr(int row, wxGridCellAttr* attr);
2815
2816 /**
2817 Sets the horizontal and vertical alignment of row label text.
2818
2819 Horizontal alignment should be one of @c wxALIGN_LEFT, @c
2820 wxALIGN_CENTRE or @c wxALIGN_RIGHT.
2821 Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
2822 or @c wxALIGN_BOTTOM.
2823 */
2824 void SetRowLabelAlignment(int horiz, int vert);
2825
2826 /**
2827 Sets the width of the row labels.
2828
2829 If @a width equals @c wxGRID_AUTOSIZE then width is calculated
2830 automatically so that no label is truncated. Note that this could be
2831 slow for a large table.
2832 */
2833 void SetRowLabelSize(int width);
2834
2835 /**
2836 Sets the value for the given row label.
2837
2838 If you are using a derived grid table you must override
2839 wxGridTableBase::SetRowLabelValue for this to have any effect.
2840 */
2841 void SetRowLabelValue(int row, const wxString& value);
2842
2843 /**
2844 Sets the minimal row height used by default.
2845
2846 See SetColMinimalAcceptableWidth() for more information.
2847 */
2848 void SetRowMinimalAcceptableHeight(int height);
2849
2850 /**
2851 Sets the minimal height for the specified row.
2852
2853 See SetColMinimalWidth() for more information.
2854 */
2855 void SetRowMinimalHeight(int row, int height);
2856
2857 /**
2858 Sets the height of the specified row.
2859
2860 See SetColSize() for more information.
2861 */
2862 void SetRowSize(int row, int height);
2863
2864 /**
2865 Sets the number of pixels per horizontal scroll increment.
2866
2867 The default is 15.
2868
2869 @see GetScrollLineX(), GetScrollLineY(), SetScrollLineY()
2870 */
2871 void SetScrollLineX(int x);
2872
2873 /**
2874 Sets the number of pixels per vertical scroll increment.
2875
2876 The default is 15.
2877
2878 @see GetScrollLineX(), GetScrollLineY(), SetScrollLineX()
2879 */
2880 void SetScrollLineY(int y);
2881
2882 /**
2883 Set the colour to be used for drawing the selection background.
2884 */
2885 void SetSelectionBackground(const wxColour& c);
2886
2887 /**
2888 Set the colour to be used for drawing the selection foreground.
2889 */
2890 void SetSelectionForeground(const wxColour& c);
2891
2892 /**
2893 Set the selection behaviour of the grid.
2894
2895 The existing selection is converted to conform to the new mode if
2896 possible and discarded otherwise (e.g. any individual selected cells
2897 are deselected if the new mode allows only the selection of the entire
2898 rows or columns).
2899 */
2900 void SetSelectionMode(wxGridSelectionModes selmode);
2901
2902 /**
2903 Passes a pointer to a custom grid table to be used by the grid.
2904
2905 This should be called after the grid constructor and before using the
2906 grid object. If @a takeOwnership is set to @true then the table will be
2907 deleted by the wxGrid destructor.
2908
2909 Use this function instead of CreateGrid() when your application
2910 involves complex or non-string data or data sets that are too large to
2911 fit wholly in memory.
2912 */
2913 bool SetTable(wxGridTableBase* table,
2914 bool takeOwnership = false,
2915 wxGridSelectionModes selmode = wxGridSelectCells);
2916
2917 /**
2918 Call this in order to make the column labels use a native look by using
2919 wxRenderer::DrawHeaderButton internally.
2920
2921 There is no equivalent method for drawing row columns as there is not
2922 native look for that. This option is useful when using wxGrid for
2923 displaying tables and not as a spread-sheet.
2924 */
2925 void SetUseNativeColLabels(bool native = true);
2926
2927 /**
2928 Displays the in-place cell edit control for the current cell.
2929 */
2930 void ShowCellEditControl();
2931
2932 /**
2933 Returns the column at the given pixel position.
2934
2935 @param x
2936 The x position to evaluate.
2937 @param clipToMinMax
2938 If @true, rather than returning wxNOT_FOUND, it returns either the
2939 first or last column depending on whether x is too far to the left
2940 or right respectively.
2941 @return
2942 The column index or wxNOT_FOUND.
2943 */
2944 int XToCol(int x, bool clipToMinMax = false) const;
2945
2946 /**
2947 Returns the column whose right hand edge is close to the given logical
2948 x position.
2949
2950 If no column edge is near to this position @c wxNOT_FOUND is returned.
2951 */
2952 int XToEdgeOfCol(int x) const;
2953
2954 //@{
2955 /**
2956 Translates logical pixel coordinates to the grid cell coordinates.
2957
2958 Notice that this function expects logical coordinates on input so if
2959 you use this function in a mouse event handler you need to translate
2960 the mouse position, which is expressed in device coordinates, to
2961 logical ones.
2962
2963 @see XToCol(), YToRow()
2964 */
2965
2966 // XYToCell(int, int, wxGridCellCoords&) overload is intentionally
2967 // undocumented, using it is ugly and non-const reference parameters are
2968 // not used in wxWidgets API
2969
2970 wxGridCellCoords XYToCell(int x, int y) const;
2971 wxGridCellCoords XYToCell(const wxPoint& pos) const;
2972
2973 //@}
2974
2975 /**
2976 Returns the row whose bottom edge is close to the given logical y
2977 position.
2978
2979 If no row edge is near to this position @c wxNOT_FOUND is returned.
2980 */
2981 int YToEdgeOfRow(int y) const;
2982
2983 /**
2984 Returns the grid row that corresponds to the logical y coordinate.
2985
2986 Returns @c wxNOT_FOUND if there is no row at the y position.
2987 */
2988 int YToRow(int y, bool clipToMinMax = false) const;
2989
2990 protected:
2991 /**
2992 Returns @true if this grid has support for cell attributes.
2993
2994 The grid supports attributes if it has the associated table which, in
2995 turn, has attributes support, i.e. wxGridTableBase::CanHaveAttributes()
2996 returns @true.
2997 */
2998 bool CanHaveAttributes() const;
2999
3000 /**
3001 Get the minimal width of the given column/row.
3002
3003 The value returned by this function may be different than that returned
3004 by GetColMinimalAcceptableWidth() if SetColMinimalWidth() had been
3005 called for this column.
3006 */
3007 int GetColMinimalWidth(int col) const;
3008
3009 /**
3010 Returns the coordinate of the right border specified column.
3011 */
3012 int GetColRight(int col) const;
3013
3014 /**
3015 Returns the coordinate of the left border specified column.
3016 */
3017 int GetColLeft(int col) const;
3018
3019 /**
3020 Returns the minimal size for the given column.
3021
3022 The value returned by this function may be different than that returned
3023 by GetRowMinimalAcceptableHeight() if SetRowMinimalHeight() had been
3024 called for this row.
3025 */
3026 int GetRowMinimalHeight(int col) const;
3027 };
3028
3029
3030
3031 /**
3032 @class wxGridCellBoolEditor
3033
3034 The editor for boolean data.
3035
3036 @library{wxadv}
3037 @category{grid}
3038
3039 @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellNumberEditor,
3040 wxGridCellTextEditor, wxGridCellChoiceEditor
3041 */
3042 class wxGridCellBoolEditor : public wxGridCellEditor
3043 {
3044 public:
3045 /**
3046 Default constructor.
3047 */
3048 wxGridCellBoolEditor();
3049
3050 /**
3051 Returns @true if the given @a value is equal to the string representation of
3052 the truth value we currently use (see
3053 wxGridCellBoolEditor::UseStringValues).
3054 */
3055 static bool IsTrueValue(const wxString& value);
3056
3057 /**
3058 , wxString&@e valueFalse = _T(""))
3059 This method allows to customize the values returned by GetValue() method for
3060 the cell using this editor. By default, the default values of the arguments are
3061 used, i.e. @c "1" is returned if the cell is checked and an empty string
3062 otherwise, using this method allows to change this.
3063 */
3064 static void UseStringValues() const;
3065 };
3066
3067
3068
3069 /**
3070 @class wxGridUpdateLocker
3071
3072 This small class can be used to prevent wxGrid from redrawing
3073 during its lifetime by calling wxGrid::BeginBatch
3074 in its constructor and wxGrid::EndBatch in its
3075 destructor. It is typically used in a function performing several operations
3076 with a grid which would otherwise result in flicker. For example:
3077
3078 @code
3079 void MyFrame::Foo()
3080 {
3081 m_grid = new wxGrid(this, ...);
3082
3083 wxGridUpdateLocker noUpdates(m_grid);
3084 m_grid-AppendColumn();
3085 ... many other operations with m_grid...
3086 m_grid-AppendRow();
3087
3088 // destructor called, grid refreshed
3089 }
3090 @endcode
3091
3092 Using this class is easier and safer than calling
3093 wxGrid::BeginBatch and wxGrid::EndBatch
3094 because you don't risk not to call the latter (due to an exception for example).
3095
3096 @library{wxadv}
3097 @category{grid}
3098 */
3099 class wxGridUpdateLocker
3100 {
3101 public:
3102 /**
3103 Creates an object preventing the updates of the specified @e grid. The
3104 parameter could be @NULL in which case nothing is done. If @a grid is
3105 non-@NULL then the grid must exist for longer than wxGridUpdateLocker object
3106 itself.
3107 The default constructor could be followed by a call to
3108 Create() to set the
3109 grid object later.
3110 */
3111 wxGridUpdateLocker(wxGrid* grid = NULL);
3112
3113 /**
3114 Destructor reenables updates for the grid this object is associated with.
3115 */
3116 ~wxGridUpdateLocker();
3117
3118 /**
3119 This method can be called if the object had been constructed using the default
3120 constructor. It must not be called more than once.
3121 */
3122 void Create(wxGrid* grid);
3123 };
3124