interface/wx/dataview.h

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