]> git.saurik.com Git - wxWidgets.git/blame - interface/dataview.h
Added wxRichTextCtrl superscript and subscript support (Knut Petter Lehre).
[wxWidgets.git] / interface / dataview.h
CommitLineData
23324ae1
FM
1/////////////////////////////////////////////////////////////////////////////
2// Name: dataview.h
e54c96f1 3// Purpose: interface of wxDataViewIconText
23324ae1
FM
4// Author: wxWidgets team
5// RCS-ID: $Id$
6// Licence: wxWindows license
7/////////////////////////////////////////////////////////////////////////////
8
9/**
10 @class wxDataViewIconText
11 @wxheader{dataview.h}
7c913512
FM
12
13 wxDataViewIconText is used by
23324ae1
FM
14 wxDataViewIconTextRenderer
15 for data transfer. This class can be converted to a from
16 a wxVariant.
7c913512 17
23324ae1
FM
18 @library{wxbase}
19 @category{FIXME}
20*/
21class wxDataViewIconText : public wxObject
22{
23public:
24 //@{
25 /**
26 Constructor.
27 */
28 wxDataViewIconText(const wxString& text = wxEmptyString,
29 const wxIcon& icon = wxNullIcon);
7c913512 30 wxDataViewIconText(const wxDataViewIconText& other);
23324ae1
FM
31 //@}
32
33 /**
34 Gets the icon.
35 */
328f5751 36 const wxIcon GetIcon() const;
23324ae1
FM
37
38 /**
39 Gets the text.
40 */
328f5751 41 wxString GetText() const;
23324ae1
FM
42
43 /**
44 Set the icon.
45 */
46 void SetIcon(const wxIcon& icon);
47
48 /**
49 Set the text.
50 */
51 void SetText(const wxString& text);
52};
53
54
e54c96f1 55
23324ae1
FM
56/**
57 @class wxDataViewEvent
58 @wxheader{dataview.h}
7c913512 59
23324ae1 60 wxDataViewEvent - the event class for the wxDataViewCtrl notifications
7c913512 61
23324ae1
FM
62 @library{wxadv}
63 @category{FIXME}
64*/
65class wxDataViewEvent : public wxNotifyEvent
66{
67public:
68 //@{
69 /**
3c4f71cc 70
23324ae1 71 */
4cc4bfaf 72 wxDataViewEvent(wxEventType commandType = wxEVT_NULL,
23324ae1 73 int winid = 0);
7c913512 74 wxDataViewEvent(const wxDataViewEvent& event);
23324ae1
FM
75 //@}
76
77 /**
78 Used to clone the event.
79 */
328f5751 80 wxEvent* Clone() const;
23324ae1
FM
81
82 /**
83 Returns the position of the column in the control or -1
84 if no column field was set by the event emitter.
85 */
328f5751 86 int GetColumn() const;
23324ae1
FM
87
88 /**
89 Returns a pointer to the wxDataViewColumn from which
90 the event was emitted or @NULL.
91 */
92 wxDataViewColumn* GetDataViewColumn();
93
94 /**
95 Returns the wxDataViewModel associated with the event.
96 */
328f5751 97 wxDataViewModel* GetModel() const;
23324ae1
FM
98
99 /**
100 Returns a the position of a context menu event in screen coordinates.
101 */
328f5751 102 wxPoint GetPosition() const;
23324ae1
FM
103
104 /**
105 Returns a reference to a value.
106 */
328f5751 107 const wxVariant GetValue() const;
23324ae1
FM
108
109 /**
3c4f71cc 110
23324ae1
FM
111 */
112 void SetColumn(int col);
113
114 /**
115 For wxEVT_DATAVIEW_COLUMN_HEADER_CLICKED only.
116 */
117 void SetDataViewColumn(wxDataViewColumn* col);
118
119 /**
3c4f71cc 120
23324ae1
FM
121 */
122 void SetModel(wxDataViewModel* model);
123
124 /**
3c4f71cc 125
23324ae1
FM
126 */
127 void SetValue(const wxVariant& value);
128};
23324ae1
FM
129/**
130 @class wxDataViewModel
131 @wxheader{dataview.h}
7c913512 132
23324ae1 133 wxDataViewModel is the base class for all data model to be
7c913512 134 displayed by a wxDataViewCtrl.
23324ae1
FM
135 All other models derive from it and must implement its
136 pure virtual functions in order to define a complete
7c913512 137 data model. In detail, you need to override
23324ae1
FM
138 wxDataViewModel::IsContainer,
139 wxDataViewModel::GetParent,
140 wxDataViewModel::GetChildren,
141 wxDataViewModel::GetColumnCount,
142 wxDataViewModel::GetColumnType and
143 wxDataViewModel::GetValue in order to
7c913512 144 define the data model which acts as an interface between
23324ae1
FM
145 your actual data and the wxDataViewCtrl. Since you will
146 usually also allow the wxDataViewCtrl to change your data
147 through its graphical interface, you will also have to override
148 wxDataViewModel::SetValue which the
149 wxDataViewCtrl will call when a change to some data has been
150 commited.
7c913512 151
23324ae1
FM
152 wxDataViewModel (as indeed the entire wxDataViewCtrl
153 code) is using wxVariant to store data and
154 its type in a generic way. wxVariant can be extended to contain
155 almost any data without changes to the original class.
7c913512 156
23324ae1
FM
157 The data that is presented through this data model is expected
158 to change at run-time. You need to inform the data model when
159 a change happened. Depending on what happened you need to call
7c913512 160 one of the following methods:
23324ae1
FM
161 wxDataViewModel::ValueChanged,
162 wxDataViewModel::ItemAdded,
163 wxDataViewModel::ItemDeleted,
164 wxDataViewModel::ItemChanged,
165 wxDataViewModel::Cleared. There are
166 plural forms for notification of addition, change
7c913512 167 or removal of several item at once. See
23324ae1
FM
168 wxDataViewModel::ItemsAdded,
169 wxDataViewModel::ItemsDeleted,
170 wxDataViewModel::ItemsChanged.
7c913512 171
23324ae1
FM
172 Note that wxDataViewModel does not define the position or
173 index of any item in the control because different controls
174 might display the same data differently. wxDataViewModel does
175 provide a wxDataViewModel::Compare method
176 which the wxDataViewCtrl may use to sort the data either
177 in conjunction with a column header or without (see
178 wxDataViewModel::HasDefaultCompare).
7c913512
FM
179
180 This class maintains a list of
23324ae1
FM
181 wxDataViewModelNotifier
182 which link this class to the specific implementations on the
7c913512 183 supported platforms so that e.g. calling
23324ae1 184 wxDataViewModel::ValueChanged
7c913512 185 on this model will just call
23324ae1 186 wxDataViewModelNotifier::ValueChanged
7c913512
FM
187 for each notifier that has been added. You can also add
188 your own notifier in order to get informed about any changes
23324ae1 189 to the data in the list model.
7c913512 190
23324ae1 191 Currently wxWidgets provides the following models apart
7c913512 192 from the base model:
23324ae1 193 wxDataViewIndexListModel,
e39de702 194 wxDataViewVirtualListModel,
23324ae1 195 wxDataViewTreeStore.
7c913512
FM
196
197 Note that wxDataViewModel is reference counted, derives from
23324ae1
FM
198 wxObjectRefData and cannot be deleted
199 directly as it can be shared by several wxDataViewCtrls. This
200 implies that you need to decrease the reference count after
201 associating the model with a control like this:
7c913512 202
23324ae1
FM
203 @code
204 wxDataViewCtrl *musicCtrl = new wxDataViewCtrl( this, ID_MUSIC_CTRL );
205 wxDataViewModel *musicModel = new MyMusicModel;
206 m_musicCtrl-AssociateModel( musicModel );
207 musicModel-DecRef(); // avoid memory leak !!
208 // add columns now
209 @endcode
7c913512
FM
210
211
23324ae1
FM
212 @library{wxadv}
213 @category{FIXME}
214*/
215class wxDataViewModel : public wxObjectRefData
216{
217public:
218 /**
219 Constructor.
220 */
221 wxDataViewModel();
222
223 /**
224 Destructor. This should not be called directly. Use DecRef() instead.
225 */
226 ~wxDataViewModel();
227
228 /**
229 Adds a wxDataViewModelNotifier
230 to the model.
231 */
232 void AddNotifier(wxDataViewModelNotifier* notifier);
233
234 /**
235 Called to inform the model that all data has been cleared. The
236 control will reread the data from the model again.
237 */
238 virtual bool Cleared();
239
240 /**
241 The compare function to be used by control. The default compare function
242 sorts by container and other items separately and in ascending order.
243 Override this for a different sorting behaviour.
23324ae1
FM
244 See also HasDefaultCompare().
245 */
246 virtual int Compare(const wxDataViewItem& item1,
247 const wxDataViewItem& item2,
248 unsigned int column,
249 bool ascending);
250
251 /**
252 Oberride this to indicate that the item has special font attributes.
7c913512 253 This only affects the
e54c96f1 254 wxDataViewTextRendererText() renderer.
23324ae1
FM
255 See also wxDataViewItemAttr.
256 */
257 bool GetAttr(const wxDataViewItem& item, unsigned int col,
258 wxDataViewItemAttr& attr);
259
260 /**
261 Override this so the control can query the child items of
262 an item. Returns the number of items.
263 */
264 virtual unsigned int GetChildren(const wxDataViewItem& item,
328f5751 265 wxDataViewItemArray& children) const;
23324ae1
FM
266
267 /**
268 Override this to indicate the number of columns in the model.
269 */
328f5751 270 virtual unsigned int GetColumnCount() const;
23324ae1
FM
271
272 /**
273 Override this to indicate what type of data is stored in the
274 column specified by @e col. This should return a string
275 indicating the type of data as reported by wxVariant.
276 */
328f5751 277 virtual wxString GetColumnType(unsigned int col) const;
23324ae1
FM
278
279 /**
280 Override this to indicate which wxDataViewItem representing the parent
4cc4bfaf 281 of @a item or an invalid wxDataViewItem if the the root item is
23324ae1
FM
282 the parent item.
283 */
328f5751 284 virtual wxDataViewItem GetParent(const wxDataViewItem& item) const;
23324ae1
FM
285
286 /**
287 Override this to indicate the value of @e item
288 A wxVariant is used to store the data.
289 */
290 virtual void GetValue(wxVariant& variant,
291 const wxDataViewItem& item,
328f5751 292 unsigned int col) const;
23324ae1
FM
293
294 /**
295 Override this method to indicate if a container item merely
296 acts as a headline (or for categorisation) or if it also
7c913512 297 acts a normal item with entries for futher columns. By
23324ae1
FM
298 default returns @e @false.
299 */
328f5751 300 virtual bool HasContainerColumns(const wxDataViewItem& item) const;
23324ae1
FM
301
302 /**
303 Override this to indicate that the model provides a default compare
304 function that the control should use if no wxDataViewColumn has been
305 chosen for sorting. Usually, the user clicks on a column header for
306 sorting, the data will be sorted alphanumerically. If any other
307 order (e.g. by index or order of appearance) is required, then this
308 should be used. See also wxDataViewIndexListModel
309 for a model which makes use of this.
310 */
328f5751 311 virtual bool HasDefaultCompare() const;
23324ae1
FM
312
313 /**
4cc4bfaf 314 Override this to indicate of @a item is a container, i.e. if
23324ae1
FM
315 it can have child items.
316 */
328f5751 317 virtual bool IsContainer(const wxDataViewItem& item) const;
23324ae1
FM
318
319 /**
320 Call this to inform the model that an item has been added
321 to the data.
322 */
323 virtual bool ItemAdded(const wxDataViewItem& parent,
324 const wxDataViewItem& item);
325
326 /**
327 Call this to inform the model that an item has changed.
23324ae1
FM
328 This will eventually emit a wxEVT_DATAVIEW_ITEM_VALUE_CHANGED
329 event (in which the column fields will not be set) to the user.
330 */
331 virtual bool ItemChanged(const wxDataViewItem& item);
332
333 /**
334 Call this to inform the model that an item has been deleted from the data.
335 */
336 virtual bool ItemDeleted(const wxDataViewItem& parent,
337 const wxDataViewItem& item);
338
339 /**
340 Call this to inform the model that several items have been added
341 to the data.
342 */
343 virtual bool ItemsAdded(const wxDataViewItem& parent,
344 const wxDataViewItemArray& items);
345
346 /**
347 Call this to inform the model that several items have changed.
23324ae1
FM
348 This will eventually emit wxEVT_DATAVIEW_ITEM_VALUE_CHANGED
349 events (in which the column fields will not be set) to the user.
350 */
351 virtual bool ItemsChanged(const wxDataViewItemArray& items);
352
353 /**
354 Call this to inform the model that several items have been deleted.
355 */
356 virtual bool ItemsDeleted(const wxDataViewItem& parent,
357 const wxDataViewItemArray& items);
358
359 /**
4cc4bfaf 360 Remove the @a notifier from the list of notifiers.
23324ae1
FM
361 */
362 void RemoveNotifier(wxDataViewModelNotifier* notifier);
363
364 /**
365 Call this to initiate a resort after the sort function has
366 been changed.
367 */
368 virtual void Resort();
369
370 /**
371 This gets called in order to set a value in the data model.
372 The most common scenario is that the wxDataViewCtrl calls
373 this method after the user changed some data in the view.
374 Afterwards ValueChanged()
375 has to be called!
376 */
377 virtual bool SetValue(const wxVariant& variant,
378 const wxDataViewItem& item,
379 unsigned int col);
380
381 /**
382 Call this to inform this model that a value in the model has
383 been changed. This is also called from wxDataViewCtrl's
7c913512 384 internal editing code, e.g. when editing a text field
23324ae1 385 in the control.
23324ae1
FM
386 This will eventually emit a wxEVT_DATAVIEW_ITEM_VALUE_CHANGED
387 event to the user.
388 */
389 virtual bool ValueChanged(const wxDataViewItem& item,
390 unsigned int col);
391};
392
393
e54c96f1 394
e54c96f1 395
e39de702
RR
396/**
397 @class wxDataViewIndexListModel
398 @wxheader{dataview.h}
399
400 wxDataViewIndexListModel is a specialized data model which lets
401 you address an item by its position (row) rather than its
402 wxDataViewItem (which you can obtain from this class).
403 This model also provides its own wxDataViewIndexListModel::Compare
404 method which sorts the model's data by the index.
405
406 This model is not a virtual model since the control stores
407 each wxDataViewItem. Use wxDataViewVirtualListModel if you
408 need to display millions of items or have other reason to
409 use a virtual control.
410
411 @library{wxbase}
412 @category{FIXME}
413*/
414class wxDataViewIndexListModel : public wxDataViewModel
415{
416public:
417 /**
418 Constructor.
419 */
420 wxDataViewIndexListModel(unsigned int initial_size = 0);
421
422 /**
423 Destructor.
424 */
425 ~wxDataViewIndexListModel();
426
427 /**
428 Compare method that sorts the items by their index.
429 */
430 int Compare(const wxDataViewItem& item1,
431 const wxDataViewItem& item2,
432 unsigned int column, bool ascending);
433
434 /**
435 Oberride this to indicate that the row has special font attributes.
436 This only affects the
437 wxDataViewTextRendererText() renderer.
438 See also wxDataViewItemAttr.
439 */
440 bool GetAttr(unsigned int row, unsigned int col,
441 wxDataViewItemAttr& attr);
442
443 /**
444 Returns the wxDataViewItem at the given @e row.
445 */
446 wxDataViewItem GetItem(unsigned int row) const;
447
448 /**
449 Returns the position of given @e item.
450 */
451 unsigned int GetRow(const wxDataViewItem& item) const;
452
453 /**
454 Override this to allow getting values from the model.
455 */
456 void GetValue(wxVariant& variant, unsigned int row,
457 unsigned int col) const;
458
459 /**
460 Call this after if the data has to be read again from
461 the model. This is useful after major changes when
462 calling the methods below (possibly thousands of times)
463 doesn't make sense.
464 */
465 void Reset(unsigned int new_size);
466
467 /**
468 Call this after a row has been appended to the model.
469 */
470 void RowAppended();
471
472 /**
473 Call this after a row has been changed.
474 */
475 void RowChanged(unsigned int row);
476
477 /**
478 Call this after a row has been deleted.
479 */
480 void RowDeleted(unsigned int row);
481
482 /**
483 Call this after a row has been inserted at the given position.
484 */
485 void RowInserted(unsigned int before);
486
487 /**
488 Call this after a row has been prepended to the model.
489 */
490 void RowPrepended();
491
492 /**
493 Call this after a value has been changed.
494 */
495 void RowValueChanged(unsigned int row, unsigned int col);
496
497 /**
498 Call this after rows have been deleted. The array will internally
499 get copied and sorted in descending order so that the rows with
500 the highest position will be deleted first.
501 */
502 void RowsDeleted(const wxArrayInt& rows);
503
504 /**
505 Called in order to set a value in the model.
506 */
507 bool SetValue(const wxVariant& variant, unsigned int row,
508 unsigned int col);
509};
510
511
512
513/**
514 @class wxDataViewVirtualListModel
515 @wxheader{dataview.h}
516
517 wxDataViewVirtualListModel is a specialized data model which lets
518 you address an item by its position (row) rather than its
519 wxDataViewItem and as such offers the exact same interface as
520 wxDataViewIndexListModel. The important difference is that under
521 platforms other than OS X, using this model will result in a
522 truely virtual control able to handle millions of items as the
523 control doesn't store any item (a feature not supported by the
524 Carbon API under OS X).
525
526 @see wxDataViewIndexListModel for the API.
527
528 @library{wxbase}
529 @category{FIXME}
530*/
531class wxDataViewVirtualListModel : public wxDataViewModel
532{
533public:
534 /**
535 Constructor.
536 */
537 wxDataViewVirtualListModel(unsigned int initial_size = 0);
538}
539
540
541
542
543
23324ae1
FM
544/**
545 @class wxDataViewItemAttr
546 @wxheader{dataview.h}
7c913512 547
23324ae1 548 This class is used to indicate to a wxDataViewCtrl
e54c96f1 549 that a certain Item() has extra font attributes
7c913512 550 for its renderer. For this, it is required to override
23324ae1 551 wxDataViewModel::GetAttr.
7c913512
FM
552
553 Attributes are currently only supported by
e54c96f1 554 wxDataViewTextRendererText().
7c913512 555
23324ae1
FM
556 @library{wxadv}
557 @category{FIXME}
558*/
7c913512 559class wxDataViewItemAttr
23324ae1
FM
560{
561public:
562 /**
563 Constructor.
564 */
565 wxDataViewItemAttr();
566
567 /**
568 Call this to indicate that the item shall be displayed in bold text.
569 */
570 void SetBold(bool set);
571
572 /**
573 Call this to indicate that the item shall be displayed with
574 that colour.
575 */
576 void SetColour(const wxColour& colour);
577
578 /**
579 Call this to indicate that the item shall be displayed in italic text.
580 */
581 void SetItalic(bool set);
582};
583
584
e54c96f1 585
23324ae1
FM
586/**
587 @class wxDataViewItem
588 @wxheader{dataview.h}
7c913512 589
23324ae1
FM
590 wxDataViewItem is a small opaque class that represents an
591 item in a wxDataViewCtrl in a
592 persistent way, i.e. indepent of the position of the
593 item in the control or changes to its contents. It must
594 hold a unique ID of type @e void* in its only field
7c913512
FM
595 and can be converted to a from it.
596
597 If the ID is @e @NULL the wxDataViewItem is invalid and
23324ae1
FM
598 wxDataViewItem::IsOk will return @e @false
599 which used in many places in the API of wxDataViewCtrl
600 to indicate that e.g. no item was found. An ID of @NULL
601 is also used to indicate the invisible root. Examples
602 for this are
603 wxDataViewModel::GetParent and
604 wxDataViewModel::GetChildren.
7c913512 605
23324ae1
FM
606 @library{wxadv}
607 @category{FIXME}
608*/
7c913512 609class wxDataViewItem
23324ae1
FM
610{
611public:
612 //@{
613 /**
3c4f71cc 614
23324ae1 615 */
4cc4bfaf 616 wxDataViewItem(void* id = NULL);
7c913512 617 wxDataViewItem(const wxDataViewItem& item);
23324ae1
FM
618 //@}
619
620 /**
621 Returns the ID.
622 */
328f5751 623 void* GetID() const;
23324ae1
FM
624
625 /**
626 Returns @true if the ID is not @e @NULL.
627 */
328f5751 628 bool IsOk() const;
23324ae1
FM
629};
630
631
e54c96f1 632
23324ae1
FM
633/**
634 @class wxDataViewCtrl
635 @wxheader{dataview.h}
7c913512 636
23324ae1
FM
637 wxDataViewCtrl is a control to display data either
638 in a tree like fashion or in a tabular form or both.
639 If you only need to display a simple tree structure
640 with an API more like the older wxTreeCtrl class,
641 then the specialized wxDataViewTreeCtrl
642 can be used.
7c913512 643
23324ae1
FM
644 A wxDataViewItem is used
645 to represent a (visible) item in the control.
7c913512
FM
646
647 Unlike wxListCtrl wxDataViewCtrl doesn't
23324ae1 648 get its data from the user through virtual functions or by
7c913512 649 setting it directly. Instead you need to write your own
23324ae1
FM
650 wxDataViewModel and associate
651 it with this control. Then you need to add a number of
652 wxDataViewColumn to this control to
653 define what each column shall display. Each wxDataViewColumn
7c913512 654 in turn owns 1 instance of a
23324ae1
FM
655 wxDataViewRenderer to render its
656 cells. A number of standard renderers for rendering text, dates,
657 images, toggle, a progress bar etc. are provided. Additionally,
7c913512 658 the user can write custom renderes deriving from
23324ae1
FM
659 wxDataViewCustomRenderer
660 for displaying anything.
7c913512 661
23324ae1
FM
662 All data transfer from the control to the model and the user
663 code is done through wxVariant which can
7c913512 664 be extended to support more data formats as necessary.
23324ae1
FM
665 Accordingly, all type information uses the strings returned
666 from wxVariant::GetType.
7c913512 667
23324ae1 668 @beginStyleTable
8c6791e4 669 @style{wxDV_SINGLE}
23324ae1 670 Single selection mode. This is the default.
8c6791e4 671 @style{wxDV_MULTIPLE}
23324ae1 672 Multiple selection mode.
8c6791e4 673 @style{wxDV_ROW_LINES}
23324ae1 674 Use alternating colours for rows if supported by platform and theme.
8c6791e4 675 @style{wxDV_HORIZ_RULES}
23324ae1 676 Display fine rules between row if supported.
8c6791e4 677 @style{wxDV_VERT_RULES}
23324ae1
FM
678 Display fine rules between columns is supported.
679 @endStyleTable
7c913512 680
23324ae1
FM
681 @library{wxadv}
682 @category{ctrl}
683 @appearance{dataviewctrl.png}
684*/
685class wxDataViewCtrl : public wxControl
686{
687public:
688 //@{
689 /**
690 Constructor. Calls Create().
691 */
692 wxDataViewCtrl();
7c913512
FM
693 wxDataViewCtrl(wxWindow* parent, wxWindowID id,
694 const wxPoint& pos = wxDefaultPosition,
695 const wxSize& size = wxDefaultSize,
696 long style = 0,
697 const wxValidator& validator = wxDefaultValidator);
23324ae1
FM
698 //@}
699
700 /**
701 Destructor.
702 */
703 ~wxDataViewCtrl();
704
e39de702
RR
705 /**
706 Add a wxDataViewColumn to the control. Returns
707 @e @true on success.
708 Note that there is a number of short cut methods which implicitly create
709 a wxDataViewColumn and a wxDataViewRenderer for it (see below).
710 */
711 virtual bool AppendColumn(wxDataViewColumn* col);
712
23324ae1
FM
713 //@{
714 /**
715 Appends a column for rendering a bitmap. Returns the wxDataViewColumn
716 created in the function or @NULL on failure.
717 */
718 wxDataViewColumn* AppendBitmapColumn(const wxString& label,
719 unsigned int model_column,
720 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
721 int width = -1,
722 wxAlignment align = wxALIGN_CENTER,
723 int flags = wxDATAVIEW_COL_RESIZABLE);
7c913512
FM
724 wxDataViewColumn* AppendBitmapColumn(const wxBitmap& label,
725 unsigned int model_column,
726 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
727 int width = -1,
728 wxAlignment align = wxALIGN_CENTER,
729 int flags = wxDATAVIEW_COL_RESIZABLE);
23324ae1
FM
730 //@}
731
23324ae1
FM
732 //@{
733 /**
734 Appends a column for rendering a date. Returns the wxDataViewColumn
735 created in the function or @NULL on failure.
e39de702
RR
736
737 NB: The @e align parameter is applied to both the column header and
738 the column renderer.
23324ae1
FM
739 */
740 wxDataViewColumn* AppendDateColumn(const wxString& label,
741 unsigned int model_column,
742 wxDataViewCellMode mode = wxDATAVIEW_CELL_ACTIVATABLE,
743 int width = -1,
744 wxAlignment align = wxALIGN_CENTER,
745 int flags = wxDATAVIEW_COL_RESIZABLE);
7c913512
FM
746 wxDataViewColumn* AppendDateColumn(const wxBitmap& label,
747 unsigned int model_column,
748 wxDataViewCellMode mode = wxDATAVIEW_CELL_ACTIVATABLE,
749 int width = -1,
750 wxAlignment align = wxALIGN_CENTER,
751 int flags = wxDATAVIEW_COL_RESIZABLE);
23324ae1
FM
752 //@}
753
754 //@{
755 /**
756 Appends a column for rendering text with an icon. Returns the wxDataViewColumn
e39de702
RR
757 created in the function or @NULL on failure. This method uses the
758 wxDataViewIconTextRenderer class.
759
760 NB: The @e align parameter is applied to both the column header and
761 the column renderer.
23324ae1
FM
762 */
763 wxDataViewColumn* AppendIconTextColumn(const wxString& label,
764 unsigned int model_column,
765 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
766 int width = -1,
767 wxAlignment align = wxALIGN_LEFT,
768 int flags = wxDATAVIEW_COL_RESIZABLE);
7c913512
FM
769 wxDataViewColumn* AppendIconTextColumn(const wxBitmap& label,
770 unsigned int model_column,
771 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
772 int width = -1,
773 wxAlignment align = wxALIGN_LEFT,
774 int flags = wxDATAVIEW_COL_RESIZABLE);
23324ae1
FM
775 //@}
776
777 //@{
778 /**
779 Appends a column for rendering a progress indicator. Returns the
e39de702
RR
780 wxDataViewColumn created in the function or @NULL on failure.
781
782 NB: The @e align parameter is applied to both the column header and
783 the column renderer.
23324ae1
FM
784 */
785 wxDataViewColumn* AppendProgressColumn(const wxString& label,
786 unsigned int model_column,
787 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
788 int width = 80,
789 wxAlignment align = wxALIGN_CENTER,
790 int flags = wxDATAVIEW_COL_RESIZABLE);
7c913512
FM
791 wxDataViewColumn* AppendProgressColumn(const wxBitmap& label,
792 unsigned int model_column,
793 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
794 int width = 80,
795 wxAlignment align = wxALIGN_CENTER,
796 int flags = wxDATAVIEW_COL_RESIZABLE);
23324ae1
FM
797 //@}
798
799 //@{
800 /**
801 Appends a column for rendering text. Returns the wxDataViewColumn
802 created in the function or @NULL on failure.
e39de702
RR
803
804 NB: The @e align parameter is applied to both the column header and
805 the column renderer.
23324ae1
FM
806 */
807 wxDataViewColumn* AppendTextColumn(const wxString& label,
808 unsigned int model_column,
809 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
810 int width = -1,
811 wxAlignment align = wxALIGN_LEFT,
812 int flags = wxDATAVIEW_COL_RESIZABLE);
7c913512
FM
813 wxDataViewColumn* AppendTextColumn(const wxBitmap& label,
814 unsigned int model_column,
815 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
816 int width = -1,
817 wxAlignment align = wxALIGN_LEFT,
818 int flags = wxDATAVIEW_COL_RESIZABLE);
23324ae1
FM
819 //@}
820
821 //@{
822 /**
823 Appends a column for rendering a toggle. Returns the wxDataViewColumn
824 created in the function or @NULL on failure.
e39de702
RR
825
826 NB: The @e align parameter is applied to both the column header and
827 the column renderer.
23324ae1
FM
828 */
829 wxDataViewColumn* AppendToggleColumn(const wxString& label,
830 unsigned int model_column,
831 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
832 int width = 30,
833 wxAlignment align = wxALIGN_CENTER,
834 int flags = wxDATAVIEW_COL_RESIZABLE);
7c913512
FM
835 wxDataViewColumn* AppendToggleColumn(const wxBitmap& label,
836 unsigned int model_column,
837 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
838 int width = 30,
839 wxAlignment align = wxALIGN_CENTER,
840 int flags = wxDATAVIEW_COL_RESIZABLE);
23324ae1
FM
841 //@}
842
843 /**
e39de702
RR
844 Associates a wxDataViewModel with the control. This increases the reference
845 count of the model by 1.
23324ae1
FM
846 */
847 virtual bool AssociateModel(wxDataViewModel* model);
848
849 /**
850 Removes all columns.
851 */
852 virtual bool ClearColumns();
853
854 /**
855 Unselects all rows.
856 */
857 void ClearSelection();
858
859 /**
860 Collapses the item.
861 */
4cc4bfaf 862 void Collapse(const wxDataViewItem& item);
23324ae1
FM
863
864 /**
865 Create the control. Useful for two step creation.
866 */
867 bool Create(wxWindow* parent, wxWindowID id,
868 const wxPoint& pos = wxDefaultPosition,
869 const wxSize& size = wxDefaultSize,
870 long style = 0,
871 const wxValidator& validator = wxDefaultValidator);
872
873 /**
874 Deletes given column.
875 */
876 virtual bool DeleteColumn(const wxDataViewColumn* column);
877
878 /**
879 Call this to ensure that the given item is visible.
880 */
4cc4bfaf
FM
881 void EnsureVisible(const wxDataViewItem& item,
882 const wxDataViewColumn* column = NULL);
23324ae1
FM
883
884 /**
885 Expands the item.
886 */
4cc4bfaf 887 void Expand(const wxDataViewItem& item);
23324ae1
FM
888
889 /**
4cc4bfaf 890 Returns pointer to the column. @a pos refers to the
23324ae1
FM
891 position in the control which may change after reordering
892 columns by the user.
893 */
328f5751 894 virtual wxDataViewColumn* GetColumn(unsigned int pos) const;
23324ae1
FM
895
896 /**
897 Returns the number of columns.
898 */
328f5751 899 virtual unsigned int GetColumnCount() const;
23324ae1
FM
900
901 /**
902 Returns the position of the column or -1 if not found in the control.
903 */
328f5751 904 virtual int GetColumnPosition(const wxDataViewColumn* column) const;
23324ae1
FM
905
906 /**
907 Returns column containing the expanders.
908 */
328f5751 909 wxDataViewColumn* GetExpanderColumn() const;
23324ae1
FM
910
911 /**
912 Returns indentation.
913 */
328f5751 914 int GetIndent() const;
23324ae1
FM
915
916 /**
917 Returns item rect.
918 */
919 wxRect GetItemRect(const wxDataViewItem& item,
328f5751 920 const wxDataViewColumn* col = NULL) const;
23324ae1
FM
921
922 /**
923 Returns pointer to the data model associated with the
924 control (if any).
925 */
328f5751 926 virtual wxDataViewModel* GetModel() const;
23324ae1
FM
927
928 /**
929 Returns first selected item or an invalid item if none is selected.
930 */
328f5751 931 wxDataViewItem GetSelection() const;
23324ae1
FM
932
933 /**
4cc4bfaf 934 Fills @a sel with currently selected items and returns
23324ae1
FM
935 their number.
936 */
328f5751 937 int GetSelections(wxDataViewItemArray& sel) const;
23324ae1
FM
938
939 /**
940 Returns the wxDataViewColumn currently responsible for sorting
941 or @NULL if none has been selected.
942 */
328f5751 943 virtual wxDataViewColumn* GetSortingColumn() const;
23324ae1
FM
944
945 /**
946 Hittest.
947 */
948 void HitTest(const wxPoint& point, wxDataViewItem& item,
328f5751 949 wxDataViewColumn*& col) const;
23324ae1
FM
950
951 /**
952 Return @true if the item is selected.
953 */
328f5751 954 bool IsSelected(const wxDataViewItem& item) const;
23324ae1
FM
955
956 /**
957 Select the given item.
958 */
4cc4bfaf 959 void Select(const wxDataViewItem& item);
23324ae1
FM
960
961 /**
962 Select all items.
963 */
964 void SelectAll();
965
966 /**
967 Set which column shall contain the tree-like expanders.
968 */
4cc4bfaf 969 void SetExpanderColumn(wxDataViewColumn* col);
23324ae1
FM
970
971 /**
972 Sets the indendation.
973 */
974 void SetIndent(int indent);
975
976 /**
977 Sets the selection to the array of wxDataViewItems.
978 */
4cc4bfaf 979 void SetSelections(const wxDataViewItemArray& sel);
23324ae1
FM
980
981 /**
982 Unselect the given item.
983 */
4cc4bfaf 984 void Unselect(const wxDataViewItem& item);
23324ae1
FM
985
986 /**
987 Unselect all item. This method only has effect if multiple
988 selections are allowed.
989 */
990 void UnselectAll();
991};
992
993
e54c96f1 994
23324ae1
FM
995/**
996 @class wxDataViewModelNotifier
997 @wxheader{dataview.h}
7c913512 998
23324ae1
FM
999 A wxDataViewModelNotifier instance is owned by a
1000 wxDataViewModel
7c913512 1001 and mirrors its notification interface. See
23324ae1
FM
1002 the documentation of that class for further
1003 information.
7c913512 1004
23324ae1
FM
1005 @library{wxbase}
1006 @category{FIXME}
1007*/
7c913512 1008class wxDataViewModelNotifier
23324ae1
FM
1009{
1010public:
1011 /**
1012 Constructor.
1013 */
1014 wxDataViewModelNotifier();
1015
1016 /**
1017 Destructor.
1018 */
1019 ~wxDataViewModelNotifier();
1020
1021 /**
1022 Called by owning model.
1023 */
1024 bool Cleared();
1025
1026 /**
1027 Get owning wxDataViewModel.
1028 */
e51bf699 1029 wxDataViewModel* GetOwner() const;
23324ae1
FM
1030
1031 /**
1032 Called by owning model.
1033 */
1034 bool ItemAdded(const wxDataViewItem& parent,
1035 const wxDataViewItem& item);
1036
1037 /**
1038 Called by owning model.
1039 */
1040 bool ItemChanged(const wxDataViewItem& item);
1041
1042 /**
1043 Called by owning model.
1044 */
1045 bool ItemDeleted(const wxDataViewItem& parent,
1046 const wxDataViewItem& item);
1047
1048 /**
1049 Called by owning model.
1050 */
1051 bool ItemsAdded(const wxDataViewItem& parent,
1052 const wxDataViewItemArray& items);
1053
1054 /**
1055 Called by owning model.
1056 */
1057 bool ItemsChanged(const wxDataViewItemArray& items);
1058
1059 /**
1060 Called by owning model.
1061 */
1062 bool ItemsDeleted(const wxDataViewItem& parent,
1063 const wxDataViewItemArray& items);
1064
1065 /**
1066 Called by owning model.
1067 */
1068 void Resort();
1069
1070 /**
1071 Set owner of this notifier. Used internally.
1072 */
1073 void SetOwner(wxDataViewModel* owner);
1074
1075 /**
1076 Called by owning model.
1077 */
1078 bool ValueChanged(const wxDataViewItem& item, unsigned int col);
1079};
1080
1081
e54c96f1 1082
23324ae1
FM
1083/**
1084 @class wxDataViewRenderer
1085 @wxheader{dataview.h}
7c913512 1086
5b99d5d8
RR
1087 This class is used by wxDataViewCtrl to render the individual cells.
1088 One instance of a renderer class is owned by a wxDataViewColumn. There
1089 is a number of ready-to-use renderers provided:
23324ae1
FM
1090 wxDataViewTextRenderer,
1091 wxDataViewTextRendererAttr,
1092 wxDataViewIconTextRenderer,
1093 wxDataViewToggleRenderer,
1094 wxDataViewProgressRenderer,
1095 wxDataViewBitmapRenderer,
1096 wxDataViewDateRenderer.
1097 wxDataViewSpinRenderer.
7c913512 1098
23324ae1
FM
1099 Additionally, the user can write own renderers by deriving from
1100 wxDataViewCustomRenderer.
7c913512 1101
23324ae1
FM
1102 The @e wxDataViewCellMode flag controls, what actions
1103 the cell data allows. @e wxDATAVIEW_CELL_ACTIVATABLE
1104 indicates that the user can double click the cell and
1105 something will happen (e.g. a window for editing a date
1106 will pop up). @e wxDATAVIEW_CELL_EDITABLE indicates
1107 that the user can edit the data in-place, i.e. an control
1108 will show up after a slow click on the cell. This behaviour
7c913512 1109 is best known from changing the filename in most file
23324ae1 1110 managers etc.
7c913512
FM
1111
1112
23324ae1
FM
1113 @code
1114 enum wxDataViewCellMode
1115 {
1116 wxDATAVIEW_CELL_INERT,
1117 wxDATAVIEW_CELL_ACTIVATABLE,
1118 wxDATAVIEW_CELL_EDITABLE
1119 };
1120 @endcode
7c913512 1121
23324ae1
FM
1122 The @e wxDataViewCellRenderState flag controls how the
1123 the renderer should display its contents in a cell:
7c913512 1124
23324ae1
FM
1125 @code
1126 enum wxDataViewCellRenderState
1127 {
1128 wxDATAVIEW_CELL_SELECTED = 1,
1129 wxDATAVIEW_CELL_PRELIT = 2,
1130 wxDATAVIEW_CELL_INSENSITIVE = 4,
1131 wxDATAVIEW_CELL_FOCUSED = 8
1132 };
1133 @endcode
7c913512
FM
1134
1135
23324ae1
FM
1136 @library{wxadv}
1137 @category{FIXME}
1138*/
1139class wxDataViewRenderer : public wxObject
1140{
1141public:
1142 /**
5b99d5d8 1143 Constructor.
23324ae1
FM
1144 */
1145 wxDataViewRenderer(const wxString& varianttype,
1146 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
f2b7492a 1147 int align = wxDVR_DEFAULT_ALIGNMENT );
23324ae1 1148
20c36737 1149 /**
f2b7492a 1150 Returns the alignment. See SetAlignment()
20c36737
RR
1151 */
1152 virtual int GetAlignment() const;
1153
23324ae1
FM
1154 /**
1155 Returns the cell mode.
1156 */
1157 virtual wxDataViewCellMode GetMode();
1158
1159 /**
1160 Returns pointer to the owning wxDataViewColumn.
1161 */
e51bf699 1162 virtual wxDataViewColumn* GetOwner() const;
23324ae1
FM
1163
1164 /**
1165 This methods retrieves the value from the renderer in order to
1166 transfer the value back to the data model. Returns @e @false
1167 on failure.
1168 */
1169 virtual bool GetValue(wxVariant& value);
1170
1171 /**
1172 Returns a string with the type of the wxVariant
1173 supported by this renderer.
1174 */
1175 virtual wxString GetVariantType();
1176
20c36737 1177 /**
f2b7492a
RR
1178 Sets the alignment of the renderer's content. The default value
1179 of wxDVR_DEFAULT_ALIGMENT indicates that the content should
1180 have the same alignment as the column header. The method is
1181 not implemented under OS X and the renderer always aligns its
1182 contents as the column header on that platform. The other platforms
1183 support both vertical and horizontal alignment.
20c36737
RR
1184 */
1185 virtual void SetAlignment( int align );
23324ae1
FM
1186 /**
1187 Sets the owning wxDataViewColumn. This
1188 is usually called from within wxDataViewColumn.
1189 */
1190 virtual void SetOwner(wxDataViewColumn* owner);
1191
1192 /**
1193 Set the value of the renderer (and thus its cell) to @e value.
1194 The internal code will then render this cell with this data.
1195 */
1196 virtual bool SetValue(const wxVariant& value);
1197
1198 /**
1199 Before data is committed to the data model, it is passed to this
1200 method where it can be checked for validity. This can also be
1201 used for checking a valid range or limiting the user input in
1202 a certain aspect (e.g. max number of characters or only alphanumeric
1203 input, ASCII only etc.). Return @e @false if the value is
1204 not valid.
23324ae1
FM
1205 Please note that due to implementation limitations, this validation
1206 is done after the editing control already is destroyed and the
1207 editing process finished.
1208 */
1209 virtual bool Validate(wxVariant& value);
1210};
1211
1212
e54c96f1 1213
23324ae1
FM
1214/**
1215 @class wxDataViewTextRenderer
1216 @wxheader{dataview.h}
7c913512 1217
23324ae1
FM
1218 wxDataViewTextRenderer is used for rendering text. It supports
1219 in-place editing if desired.
7c913512 1220
23324ae1
FM
1221 @library{wxadv}
1222 @category{FIXME}
1223*/
1224class wxDataViewTextRenderer : public wxDataViewRenderer
1225{
1226public:
1227 /**
3c4f71cc 1228
23324ae1
FM
1229 */
1230 wxDataViewTextRenderer(const wxString& varianttype = "string",
05303ccd
RR
1231 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
1232 int align = wxDVR_DEFAULT_ALIGNMENT );
23324ae1
FM
1233};
1234
1235
e54c96f1 1236
f2b7492a
RR
1237/**
1238 @class wxDataViewIconTextRenderer
1239 @wxheader{dataview.h}
1240
1241 The wxDataViewIconTextRenderer class is used to display text with
1242 a small icon next to it as it is typically done in a file manager.
1243 This classes uses the wxDataViewIconText
1244 helper class to store its data. wxDataViewIonText can be converted
1245 to a from a wxVariant using the left shift
1246 operator.
1247
1248 @library{wxadv}
1249 @category{FIXME}
1250*/
1251class wxDataViewIconTextRenderer : public wxDataViewRenderer
1252{
1253public:
1254 /**
1255
1256 */
1257 wxDataViewIconTextRenderer(const wxString& varianttype = "wxDataViewIconText",
1258 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
1259 int align = wxDVR_DEFAULT_ALIGNMENT );
1260};
1261
1262
1263
1264
1265
23324ae1
FM
1266/**
1267 @class wxDataViewProgressRenderer
1268 @wxheader{dataview.h}
7c913512 1269
23324ae1 1270 wxDataViewProgressRenderer
7c913512 1271
23324ae1
FM
1272 @library{wxadv}
1273 @category{FIXME}
1274*/
1275class wxDataViewProgressRenderer : public wxDataViewRenderer
1276{
1277public:
1278 /**
3c4f71cc 1279
23324ae1
FM
1280 */
1281 wxDataViewProgressRenderer(const wxString& label = wxEmptyString,
1282 const wxString& varianttype = "long",
05303ccd
RR
1283 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
1284 int align = wxDVR_DEFAULT_ALIGNMENT );
23324ae1
FM
1285};
1286
1287
e54c96f1 1288
23324ae1
FM
1289/**
1290 @class wxDataViewSpinRenderer
1291 @wxheader{dataview.h}
7c913512 1292
23324ae1
FM
1293 This is a specialized renderer for rendering integer values. It
1294 supports modifying the values in-place by using a wxSpinCtrl.
1295 The renderer only support variants of type @e long.
7c913512 1296
23324ae1
FM
1297 @library{wxbase}
1298 @category{FIXME}
1299*/
1300class wxDataViewSpinRenderer : public wxDataViewCustomRenderer
1301{
1302public:
1303 /**
4cc4bfaf 1304 Constructor. @a min and @a max indicate the minimum und
23324ae1
FM
1305 maximum values of for the wxSpinCtrl.
1306 */
1307 wxDataViewSpinRenderer(int min, int max,
1308 wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
05303ccd 1309 int align = wxDVR_DEFAULT_ALIGNMENT);
23324ae1
FM
1310};
1311
1312
e54c96f1 1313
23324ae1
FM
1314/**
1315 @class wxDataViewToggleRenderer
1316 @wxheader{dataview.h}
7c913512 1317
23324ae1 1318 wxDataViewToggleRenderer
7c913512 1319
23324ae1
FM
1320 @library{wxadv}
1321 @category{FIXME}
1322*/
1323class wxDataViewToggleRenderer : public wxDataViewRenderer
1324{
1325public:
1326 /**
3c4f71cc 1327
23324ae1
FM
1328 */
1329 wxDataViewToggleRenderer(const wxString& varianttype = "bool",
1330 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT);
1331};
1332
1333
e54c96f1 1334
23324ae1 1335/**
5b99d5d8 1336 @class wxDataViewDateRenderer
23324ae1 1337 @wxheader{dataview.h}
7c913512 1338
5b99d5d8 1339 wxDataViewDateRenderer
7c913512 1340
5b99d5d8
RR
1341 @library{wxadv}
1342 @category{FIXME}
23324ae1 1343*/
5b99d5d8 1344class wxDataViewDateRenderer : public wxDataViewRenderer
23324ae1
FM
1345{
1346public:
23324ae1 1347 /**
3c4f71cc 1348
23324ae1 1349 */
5b99d5d8
RR
1350 wxDataViewDateRenderer(const wxString& varianttype = "datetime",
1351 wxDataViewCellMode mode = wxDATAVIEW_CELL_ACTIVATABLE);
1352};
23324ae1 1353
3c4f71cc 1354
23324ae1 1355
5b99d5d8
RR
1356/**
1357 @class wxDataViewTextRendererAttr
1358 @wxheader{dataview.h}
23324ae1 1359
5b99d5d8
RR
1360 The same as wxDataViewTextRenderer but with
1361 support for font attributes. Font attributes are currently only supported
1362 under GTK+ and MSW.
23324ae1 1363
5b99d5d8
RR
1364 See also wxDataViewModel::GetAttr and
1365 wxDataViewItemAttr.
23324ae1 1366
5b99d5d8
RR
1367 @library{wxadv}
1368 @category{FIXME}
1369*/
1370class wxDataViewTextRendererAttr : public wxDataViewTextRenderer
1371{
1372public:
23324ae1 1373 /**
23324ae1 1374
23324ae1 1375 */
5b99d5d8
RR
1376 wxDataViewTextRendererAttr(const wxString& varianttype = "string",
1377 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
1378 int align = wxDVR_DEFAULT_ALIGNMENT);
1379};
23324ae1 1380
23324ae1 1381
5b99d5d8
RR
1382/**
1383 @class wxDataViewCustomRenderer
1384 @wxheader{dataview.h}
23324ae1 1385
5b99d5d8
RR
1386 You need to derive a new class from wxDataViewCustomRenderer in
1387 order to write a new renderer. You need to override at least
1388 wxDataViewRenderer::SetValue,
1389 wxDataViewRenderer::GetValue,
1390 wxDataViewCustomRenderer::GetSize
1391 and wxDataViewCustomRenderer::Render.
23324ae1 1392
5b99d5d8
RR
1393 If you want your renderer to support in-place editing then you
1394 also need to override
1395 wxDataViewCustomRenderer::HasEditorCtrl,
1396 wxDataViewCustomRenderer::CreateEditorCtrl
1397 and wxDataViewCustomRenderer::GetValueFromEditorCtrl.
1398 Note that a special event handler will be pushed onto that
1399 editor control which handles ENTER and focus out events
1400 in order to end the editing.
23324ae1 1401
5b99d5d8
RR
1402 @library{wxadv}
1403 @category{FIXME}
1404*/
1405class wxDataViewCustomRenderer : public wxDataViewRenderer
1406{
1407public:
23324ae1 1408 /**
5b99d5d8 1409 Constructor.
23324ae1 1410 */
5b99d5d8
RR
1411 wxDataViewCustomRenderer(const wxString& varianttype = "string",
1412 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
1413 int align = wxDVR_DEFAULT_ALIGNMENT );
23324ae1
FM
1414
1415 /**
5b99d5d8 1416 Destructor.
23324ae1 1417 */
5b99d5d8 1418 ~wxDataViewCustomRenderer();
23324ae1 1419
23324ae1 1420 /**
5b99d5d8
RR
1421 Override this to react to double clicks or ENTER. This method will
1422 only be called in wxDATAVIEW_CELL_ACTIVATABLE mode.
23324ae1 1423 */
5b99d5d8
RR
1424 virtual bool Activate( wxRect cell,
1425 wxDataViewModel* model,
1426 const wxDataViewItem & item,
1427 unsigned int col );
23324ae1
FM
1428
1429 /**
5b99d5d8
RR
1430 Override this to create the actual editor control once editing
1431 is about to start. @a parent is the parent of the editor
1432 control, @a labelRect indicates the position and
1433 size of the editor control and @a value is its initial value:
23324ae1 1434 */
5b99d5d8
RR
1435 virtual wxControl* CreateEditorCtrl(wxWindow* parent,
1436 wxRect labelRect,
1437 const wxVariant& value);
23324ae1
FM
1438
1439 /**
5b99d5d8 1440 Create DC on request. Internal.
23324ae1 1441 */
5b99d5d8 1442 virtual wxDC* GetDC();
23324ae1
FM
1443
1444 /**
5b99d5d8 1445 Return size required to show content.
23324ae1 1446 */
5b99d5d8 1447 virtual wxSize GetSize();
23324ae1
FM
1448
1449 /**
5b99d5d8
RR
1450 Overrride this so that the renderer can get the value
1451 from the editor control (pointed to by @e editor):
23324ae1 1452 */
5b99d5d8
RR
1453 virtual bool GetValueFromEditorCtrl(wxControl* editor,
1454 wxVariant& value);
23324ae1
FM
1455
1456 /**
5b99d5d8
RR
1457 Override this and make it return @e @true in order to
1458 indicate that this renderer supports in-place editing.
23324ae1 1459 */
5b99d5d8 1460 virtual bool HasEditorCtrl();
23324ae1
FM
1461
1462 /**
5b99d5d8
RR
1463 Overrride this to react to a left click. This method will
1464 only be called in wxDATAVIEW_CELL_ACTIVATABLE mode.
23324ae1 1465 */
5b99d5d8
RR
1466 virtual bool LeftClick( wxPoint cursor,
1467 wxRect cell,
1468 wxDataViewModel * model,
1469 const wxDataViewItem & item,
1470 unsigned int col );
23324ae1
FM
1471
1472 /**
5b99d5d8
RR
1473 Override this to render the cell. Before this is called,
1474 wxDataViewRenderer::SetValue was called
1475 so that this instance knows what to render.
23324ae1 1476 */
5b99d5d8 1477 virtual bool Render(wxRect cell, wxDC* dc, int state);
23324ae1
FM
1478
1479 /**
5b99d5d8
RR
1480 This method should be called from within Render()
1481 whenever you need to render simple text. This will ensure that the
1482 correct colour, font and vertical alignment will be chosen so the
1483 text will look the same as text drawn by native renderers.
23324ae1 1484 */
5b99d5d8
RR
1485 bool RenderText(const wxString& text, int xoffset, wxRect cell,
1486 wxDC* dc, int state);
23324ae1
FM
1487
1488 /**
5b99d5d8
RR
1489 Overrride this to start a drag operation. Not yet
1490 supported
23324ae1 1491 */
5b99d5d8
RR
1492 virtual bool StartDrag(wxPoint cursor, wxRect cell,
1493 wxDataViewModel* model,
1494 const wxDataViewItem & item,
1495 unsigned int col);
23324ae1
FM
1496};
1497
1498
e54c96f1 1499
23324ae1 1500/**
5b99d5d8 1501 @class wxDataViewBitmapRenderer
23324ae1 1502 @wxheader{dataview.h}
7c913512 1503
5b99d5d8 1504 wxDataViewBitmapRenderer
7c913512 1505
23324ae1
FM
1506 @library{wxadv}
1507 @category{FIXME}
1508*/
5b99d5d8 1509class wxDataViewBitmapRenderer : public wxDataViewRenderer
23324ae1
FM
1510{
1511public:
1512 /**
23324ae1 1513
23324ae1 1514 */
5b99d5d8
RR
1515 wxDataViewBitmapRenderer(const wxString& varianttype = "wxBitmap",
1516 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
1517 int align = wxDVR_DEFAULT_ALIGNMENT,
1518};
1519
23324ae1 1520
23324ae1 1521
23324ae1 1522
5b99d5d8
RR
1523/**
1524 @class wxDataViewColumn
1525 @wxheader{dataview.h}
1526
1527 This class represents a column in a wxDataViewCtrl.
1528 One wxDataViewColumn is bound to one column in the data model,
1529 to which the wxDataViewCtrl has been associated.
1530
1531 An instance of wxDataViewRenderer is used by
1532 this class to render its data.
1533
1534 @library{wxadv}
1535 @category{FIXME}
1536*/
1537class wxDataViewColumn : public wxObject
1538{
1539public:
1540 //@{
23324ae1 1541 /**
5b99d5d8 1542 Constructors.
23324ae1 1543 */
5b99d5d8
RR
1544 wxDataViewColumn(const wxString& title,
1545 wxDataViewRenderer* renderer,
1546 unsigned int model_column,
1547 int width = wxDVC_DEFAULT_WIDTH,
1548 wxAlignment align = wxALIGN_CENTRE,
1549 int flags = wxDATAVIEW_COL_RESIZABLE);
1550 wxDataViewColumn(const wxBitmap& bitmap,
1551 wxDataViewRenderer* renderer,
1552 unsigned int model_column,
1553 int width = wxDVC_DEFAULT_WIDTH,
1554 wxAlignment align = wxALIGN_CENTRE,
1555 int flags = wxDATAVIEW_COL_RESIZABLE);
1556 //@}
23324ae1
FM
1557
1558 /**
5b99d5d8 1559 Destructor.
23324ae1 1560 */
5b99d5d8 1561 ~wxDataViewColumn();
23324ae1
FM
1562
1563 /**
5b99d5d8 1564 Returns the bitmap in the header of the column, if any.
23324ae1 1565 */
5b99d5d8 1566 const wxBitmap GetBitmap();
23324ae1
FM
1567
1568 /**
5b99d5d8
RR
1569 Returns the index of the column of the model, which this
1570 wxDataViewColumn is displaying.
23324ae1 1571 */
5b99d5d8 1572 unsigned int GetModelColumn();
23324ae1
FM
1573
1574 /**
5b99d5d8 1575 Returns the owning wxDataViewCtrl.
23324ae1 1576 */
e51bf699 1577 wxDataViewCtrl* GetOwner() const;
23324ae1
FM
1578
1579 /**
5b99d5d8
RR
1580 Returns the renderer of this wxDataViewColumn.
1581 See also wxDataViewRenderer.
23324ae1 1582 */
5b99d5d8 1583 wxDataViewRenderer* GetRenderer();
23324ae1
FM
1584
1585 /**
5b99d5d8 1586 Returns @true if the column is reorderable.
23324ae1 1587 */
5b99d5d8 1588 bool GetReorderable();
23324ae1
FM
1589
1590 /**
5b99d5d8
RR
1591 Returns @true if the column is sortable.
1592 See SetSortable()
23324ae1 1593 */
5b99d5d8 1594 bool GetSortable();
23324ae1
FM
1595
1596 /**
5b99d5d8 1597 Returns the width of the column.
23324ae1 1598 */
5b99d5d8 1599 int GetWidth();
23324ae1
FM
1600
1601 /**
5b99d5d8
RR
1602 Returns @true, if the sort order is ascending.
1603 See also SetSortOrder()
23324ae1 1604 */
5b99d5d8 1605 bool IsSortOrderAscending();
23324ae1
FM
1606
1607 /**
5b99d5d8 1608 Set the alignment of the column header.
23324ae1 1609 */
5b99d5d8 1610 void SetAlignment(wxAlignment align);
23324ae1
FM
1611
1612 /**
5b99d5d8 1613 Set the bitmap of the column header.
23324ae1 1614 */
5b99d5d8 1615 void SetBitmap(const wxBitmap& bitmap);
23324ae1
FM
1616
1617 /**
5b99d5d8
RR
1618 Indicate wether the column can be reordered by the
1619 user using the mouse. This is typically implemented
1620 visually by dragging the header button around.
23324ae1 1621 */
5b99d5d8 1622 void SetReorderable(bool reorderable);
23324ae1
FM
1623
1624 /**
5b99d5d8
RR
1625 Indicate the sort order if the implementation of the
1626 wxDataViewCtrl supports it, most commonly by showing
1627 a little arrow.
23324ae1 1628 */
5b99d5d8 1629 void SetSortOrder(bool ascending);
23324ae1
FM
1630
1631 /**
5b99d5d8
RR
1632 Indicate that the column is sortable. This does
1633 not show any sorting indicate yet, but it does
1634 make the column header clickable. Call
1635 SetSortOrder()
1636 afterwards to actually make the sort indicator appear.
1637 If @a sortable is @false, the column header is
1638 no longer clickable and the sort indicator (little
1639 arrow) will disappear.
23324ae1 1640 */
5b99d5d8 1641 void SetSortable(bool sortable);
23324ae1
FM
1642
1643 /**
5b99d5d8 1644 Set the title of the column header to @e title.
23324ae1 1645 */
5b99d5d8 1646 void SetTitle(const wxString& title);
23324ae1
FM
1647};
1648
1649
e54c96f1 1650
23324ae1 1651/**
5b99d5d8 1652 @class wxDataViewTreeCtrl
23324ae1 1653 @wxheader{dataview.h}
7c913512 1654
5b99d5d8
RR
1655 This class is a wxDataViewCtrl which internally
1656 uses a wxDataViewTreeStore and forwards
1657 most of its API to that class. Additionally, it uses a wxImageList
1658 to store a list of icons. The main purpose of this class is to look
1659 like a wxTreeCtrl to make a transition from it
1660 to the wxDataViewCtrl class simpler.
7c913512 1661
5b99d5d8
RR
1662 @library{wxbase}
1663 @category{ctrl}
1664 @appearance{dataviewtreectrl.png}
23324ae1 1665*/
5b99d5d8 1666class wxDataViewTreeCtrl : public wxDataViewCtrl
23324ae1
FM
1667{
1668public:
5b99d5d8 1669 //@{
23324ae1 1670 /**
5b99d5d8
RR
1671 Constructor. Calls Create().
1672 */
1673 wxDataViewTreeCtrl();
1674 wxDataViewTreeCtrl(wxWindow* parent, wxWindowID id,
1675 const wxPoint& pos = wxDefaultPosition,
1676 const wxSize& size = wxDefaultSize,
1677 long style = wxDV_NO_HEADER,
1678 const wxValidator& validator = wxDefaultValidator);
1679 //@}
3c4f71cc 1680
5b99d5d8
RR
1681 /**
1682 Destructor. Deletes the image list if any.
23324ae1 1683 */
5b99d5d8 1684 ~wxDataViewTreeCtrl();
23324ae1 1685
5b99d5d8 1686 /**
23324ae1 1687
5b99d5d8
RR
1688 */
1689 wxDataViewItem AppendContainer(const wxDataViewItem& parent,
1690 const wxString& text,
1691 int icon = -1,
1692 int expanded = -1,
1693 wxClientData* data = NULL);
e54c96f1 1694
5b99d5d8 1695 /**
7c913512 1696
5b99d5d8
RR
1697 */
1698 wxDataViewItem AppendItem(const wxDataViewItem& parent,
1699 const wxString& text,
1700 int icon = -1,
1701 wxClientData* data = NULL);
7c913512 1702
5b99d5d8
RR
1703 /**
1704 Creates the control and a wxDataViewTreeStore as
1705 its internal model.
1706 */
1707 bool Create(wxWindow* parent, wxWindowID id,
1708 const wxPoint& pos = wxDefaultPosition,
1709 const wxSize& size = wxDefaultSize,
1710 long style = wxDV_NO_HEADER,
1711 const wxValidator& validator = wxDefaultValidator);
1712
1713 /**
1714 Calls the identical method from wxDataViewTreeStore.
1715 */
1716 void DeleteAllItems();
7c913512 1717
23324ae1 1718 /**
5b99d5d8
RR
1719 Calls the identical method from wxDataViewTreeStore.
1720 */
1721 void DeleteChildren(const wxDataViewItem& item);
3c4f71cc 1722
5b99d5d8
RR
1723 /**
1724 Calls the identical method from wxDataViewTreeStore.
23324ae1 1725 */
5b99d5d8 1726 void DeleteItem(const wxDataViewItem& item);
23324ae1 1727
5b99d5d8
RR
1728 /**
1729 Calls the identical method from wxDataViewTreeStore.
1730 */
1731 int GetChildCount(const wxDataViewItem& parent) const;
23324ae1 1732
5b99d5d8
RR
1733 /**
1734 Returns the image list.
1735 */
1736 wxImageList* GetImageList();
05303ccd 1737
5b99d5d8
RR
1738 /**
1739 Calls the identical method from wxDataViewTreeStore.
1740 */
1741 wxClientData* GetItemData(const wxDataViewItem& item) const;
05303ccd 1742
5b99d5d8
RR
1743 /**
1744 Calls the identical method from wxDataViewTreeStore.
1745 */
1746 const wxIcon GetItemExpandedIcon(const wxDataViewItem& item) const;
05303ccd 1747
05303ccd 1748 /**
5b99d5d8 1749 Calls the identical method from wxDataViewTreeStore.
05303ccd 1750 */
5b99d5d8 1751 const wxIcon GetItemIcon(const wxDataViewItem& item) const;
05303ccd
RR
1752
1753 /**
5b99d5d8 1754 Calls the identical method from wxDataViewTreeStore.
05303ccd 1755 */
5b99d5d8
RR
1756 wxString GetItemText(const wxDataViewItem& item) const;
1757
1758 /**
1759 Calls the identical method from wxDataViewTreeStore.
1760 */
1761 wxDataViewItem GetNthChild(const wxDataViewItem& parent,
1762 unsigned int pos) const;
05303ccd 1763
5b99d5d8 1764 //@{
05303ccd 1765 /**
5b99d5d8 1766 Returns the store.
05303ccd 1767 */
5b99d5d8
RR
1768 wxDataViewTreeStore* GetStore() const;
1769 const wxDataViewTreeStore* GetStore() const;
1770 //@}
05303ccd
RR
1771
1772 /**
5b99d5d8
RR
1773 Calls the same method from wxDataViewTreeStore but uess
1774 and index position in the image list instead of a wxIcon.
05303ccd 1775 */
5b99d5d8
RR
1776 wxDataViewItem InsertContainer(const wxDataViewItem& parent,
1777 const wxDataViewItem& previous,
1778 const wxString& text,
1779 int icon = -1,
1780 int expanded = -1,
1781 wxClientData* data = NULL);
05303ccd
RR
1782
1783 /**
5b99d5d8
RR
1784 Calls the same method from wxDataViewTreeStore but uess
1785 and index position in the image list instead of a wxIcon.
05303ccd 1786 */
5b99d5d8
RR
1787 wxDataViewItem InsertItem(const wxDataViewItem& parent,
1788 const wxDataViewItem& previous,
1789 const wxString& text,
1790 int icon = -1,
1791 wxClientData* data = NULL);
05303ccd
RR
1792
1793 /**
5b99d5d8
RR
1794 Calls the same method from wxDataViewTreeStore but uess
1795 and index position in the image list instead of a wxIcon.
05303ccd 1796 */
5b99d5d8
RR
1797 wxDataViewItem PrependContainer(const wxDataViewItem& parent,
1798 const wxString& text,
1799 int icon = -1,
1800 int expanded = -1,
1801 wxClientData* data = NULL);
05303ccd
RR
1802
1803 /**
5b99d5d8
RR
1804 Calls the same method from wxDataViewTreeStore but uess
1805 and index position in the image list instead of a wxIcon.
05303ccd 1806 */
5b99d5d8
RR
1807 wxDataViewItem PrependItem(const wxDataViewItem& parent,
1808 const wxString& text,
1809 int icon = -1,
1810 wxClientData* data = NULL);
05303ccd
RR
1811
1812 /**
5b99d5d8 1813 Sets the image list.
05303ccd 1814 */
5b99d5d8 1815 void SetImageList(wxImageList* imagelist);
05303ccd
RR
1816
1817 /**
5b99d5d8 1818 Calls the identical method from wxDataViewTreeStore.
05303ccd 1819 */
5b99d5d8 1820 void SetItemData(const wxDataViewItem& item, wxClientData* data);
05303ccd
RR
1821
1822 /**
5b99d5d8 1823 Calls the identical method from wxDataViewTreeStore.
05303ccd 1824 */
5b99d5d8
RR
1825 void SetItemExpandedIcon(const wxDataViewItem& item,
1826 const wxIcon& icon);
05303ccd
RR
1827
1828 /**
5b99d5d8 1829 Calls the identical method from wxDataViewTreeStore.
05303ccd 1830 */
5b99d5d8 1831 void SetItemIcon(const wxDataViewItem& item, const wxIcon& icon);
05303ccd
RR
1832
1833 /**
5b99d5d8 1834 Calls the identical method from wxDataViewTreeStore.
05303ccd 1835 */
5b99d5d8
RR
1836 void SetItemText(const wxDataViewItem& item,
1837 const wxString& text);
05303ccd
RR
1838};
1839
1840
1841
1842/**
5b99d5d8 1843 @class wxDataViewTreeStore
05303ccd
RR
1844 @wxheader{dataview.h}
1845
5b99d5d8
RR
1846 wxDataViewTreeStore is a specialised wxDataViewModel
1847 for displaying simple trees very much like wxTreeCtrl
1848 does and it offers a similar API. This class actually stores the entire
1849 tree (therefore its name) and implements all virtual methods from the base
1850 class so it can be used directly without having to derive any class from it.
1851 This comes at the price of much reduced flexibility.
05303ccd
RR
1852
1853 @library{wxadv}
1854 @category{FIXME}
1855*/
5b99d5d8 1856class wxDataViewTreeStore : public wxDataViewModel
05303ccd
RR
1857{
1858public:
1859 /**
5b99d5d8 1860 Constructor. Creates the invisible root node internally.
05303ccd 1861 */
5b99d5d8 1862 wxDataViewTreeStore();
e54c96f1 1863
5b99d5d8
RR
1864 /**
1865 Destructor.
1866 */
1867 ~wxDataViewTreeStore();
7c913512 1868
5b99d5d8
RR
1869 /**
1870 Append a container.
1871 */
1872 wxDataViewItem AppendContainer(const wxDataViewItem& parent,
1873 const wxString& text,
1874 const wxIcon& icon = wxNullIcon,
1875 const wxIcon& expanded = wxNullIcon,
1876 wxClientData* data = NULL);
7c913512 1877
5b99d5d8
RR
1878 /**
1879 Append an item.
1880 */
1881 wxDataViewItem AppendItem(const wxDataViewItem& parent,
1882 const wxString& text,
1883 const wxIcon& icon = wxNullIcon,
1884 wxClientData* data = NULL);
7c913512 1885
23324ae1 1886 /**
5b99d5d8 1887 Delete all item in the model.
23324ae1 1888 */
5b99d5d8 1889 void DeleteAllItems();
23324ae1
FM
1890
1891 /**
5b99d5d8 1892 Delete all children of the item, but not the item itself.
23324ae1 1893 */
5b99d5d8 1894 void DeleteChildren(const wxDataViewItem& item);
23324ae1
FM
1895
1896 /**
5b99d5d8 1897 Delete this item.
23324ae1 1898 */
5b99d5d8 1899 void DeleteItem(const wxDataViewItem& item);
23324ae1
FM
1900
1901 /**
5b99d5d8 1902 Return the number of children of item.
23324ae1 1903 */
5b99d5d8 1904 int GetChildCount(const wxDataViewItem& parent) const;
23324ae1
FM
1905
1906 /**
5b99d5d8 1907 Returns the client data asoociated with the item.
23324ae1 1908 */
5b99d5d8 1909 wxClientData* GetItemData(const wxDataViewItem& item) const;
23324ae1
FM
1910
1911 /**
5b99d5d8 1912 Returns the icon to display in expanded containers.
23324ae1 1913 */
5b99d5d8 1914 const wxIcon GetItemExpandedIcon(const wxDataViewItem& item) const;
23324ae1
FM
1915
1916 /**
5b99d5d8 1917 Returns the icon of the item.
23324ae1 1918 */
5b99d5d8 1919 const wxIcon GetItemIcon(const wxDataViewItem& item) const;
23324ae1
FM
1920
1921 /**
5b99d5d8 1922 Returns the text of the item.
23324ae1 1923 */
5b99d5d8 1924 wxString GetItemText(const wxDataViewItem& item) const;
23324ae1
FM
1925
1926 /**
5b99d5d8 1927 Returns the nth child item of item.
23324ae1 1928 */
5b99d5d8
RR
1929 wxDataViewItem GetNthChild(const wxDataViewItem& parent,
1930 unsigned int pos) const;
23324ae1
FM
1931
1932 /**
5b99d5d8 1933 Inserts a container after @e previous.
23324ae1 1934 */
5b99d5d8
RR
1935 wxDataViewItem InsertContainer(const wxDataViewItem& parent,
1936 const wxDataViewItem& previous,
1937 const wxString& text,
1938 const wxIcon& icon = wxNullIcon,
1939 const wxIcon& expanded = wxNullIcon,
1940 wxClientData* data = NULL);
23324ae1
FM
1941
1942 /**
5b99d5d8 1943 Inserts an item after @e previous.
23324ae1 1944 */
5b99d5d8
RR
1945 wxDataViewItem InsertItem(const wxDataViewItem& parent,
1946 const wxDataViewItem& previous,
1947 const wxString& text,
1948 const wxIcon& icon = wxNullIcon,
1949 wxClientData* data = NULL);
23324ae1
FM
1950
1951 /**
5b99d5d8 1952 Inserts a container before the first child item or @e parent.
23324ae1 1953 */
5b99d5d8
RR
1954 wxDataViewItem PrependContainer(const wxDataViewItem& parent,
1955 const wxString& text,
1956 const wxIcon& icon = wxNullIcon,
1957 const wxIcon& expanded = wxNullIcon,
1958 wxClientData* data = NULL);
23324ae1
FM
1959
1960 /**
5b99d5d8 1961 Inserts an item before the first child item or @e parent.
23324ae1 1962 */
5b99d5d8
RR
1963 wxDataViewItem PrependItem(const wxDataViewItem& parent,
1964 const wxString& text,
1965 const wxIcon& icon = wxNullIcon,
1966 wxClientData* data = NULL);
23324ae1
FM
1967
1968 /**
5b99d5d8 1969 Sets the client data associated with the item.
23324ae1 1970 */
5b99d5d8 1971 void SetItemData(const wxDataViewItem& item, wxClientData* data);
23324ae1
FM
1972
1973 /**
5b99d5d8 1974 Sets the expanded icon for the item.
23324ae1 1975 */
5b99d5d8
RR
1976 void SetItemExpandedIcon(const wxDataViewItem& item,
1977 const wxIcon& icon);
23324ae1
FM
1978
1979 /**
5b99d5d8 1980 Sets the icon for the item.
23324ae1 1981 */
5b99d5d8 1982 void SetItemIcon(const wxDataViewItem& item, const wxIcon& icon);
23324ae1 1983};
e54c96f1 1984
5b99d5d8
RR
1985
1986