interface/wx/grid.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        grid.h
   3 // Purpose:     interface of wxGrid and related classes
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows license
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 /**
  10     @class wxGridCellRenderer
  11
  12     This class is responsible for actually drawing the cell in the grid. You
  13     may pass it to the wxGridCellAttr (below) to change the format of one given
  14     cell or to wxGrid::SetDefaultRenderer() to change the view of all cells.
  15     This is an abstract class, and you will normally use one of the predefined
  16     derived classes or derive your own class from it.
  17
  18     @library{wxadv}
  19     @category{grid}
  20
  21     @see wxGridCellAutoWrapStringRenderer, wxGridCellBoolRenderer,
  22          wxGridCellDateTimeRenderer, wxGridCellEnumRenderer,
  23          wxGridCellFloatRenderer, wxGridCellNumberRenderer,
  24          wxGridCellStringRenderer
  25 */
  26 class wxGridCellRenderer
  27 {
  28 public:
  29     /**
  30         This function must be implemented in derived classes to return a copy
  31         of itself.
  32     */
  33     virtual wxGridCellRenderer* Clone() const = 0;
  34
  35     /**
  36         Draw the given cell on the provided DC inside the given rectangle using
  37         the style specified by the attribute and the default or selected state
  38         corresponding to the isSelected value.
  39
  40         This pure virtual function has a default implementation which will
  41         prepare the DC using the given attribute: it will draw the rectangle
  42         with the background colour from attr and set the text colour and font.
  43     */
  44     virtual void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
  45                       const wxRect& rect, int row, int col,
  46                       bool isSelected) = 0;
  47
  48     /**
  49         Get the preferred size of the cell for its contents.
  50     */
  51     virtual wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
  52                                int row, int col) = 0;
  53 };
  54
  55 /**
  56     @class wxGridCellAutoWrapStringRenderer
  57
  58     This class may be used to format string data in a cell. The too
  59     long lines are wrapped to be shown entirely at word boundaries.
  60
  61     @library{wxadv}
  62     @category{grid}
  63
  64     @see wxGridCellRenderer, wxGridCellBoolRenderer,
  65          wxGridCellDateTimeRenderer, wxGridCellEnumRenderer,
  66          wxGridCellFloatRenderer, wxGridCellNumberRenderer,
  67          wxGridCellStringRenderer
  68 */
  69
  70 class wxGridCellAutoWrapStringRenderer : public wxGridCellStringRenderer
  71 {
  72 public:
  73     /**
  74         Default constructor.
  75     */
  76     wxGridCellAutoWrapStringRenderer();
  77 };
  78
  79
  80 /**
  81     @class wxGridCellBoolRenderer
  82
  83     This class may be used to format boolean data in a cell.
  84
  85     @library{wxadv}
  86     @category{grid}
  87
  88     @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
  89          wxGridCellDateTimeRenderer, wxGridCellEnumRenderer,
  90          wxGridCellFloatRenderer, wxGridCellNumberRenderer,
  91          wxGridCellStringRenderer
  92 */
  93 class wxGridCellBoolRenderer : public wxGridCellRenderer
  94 {
  95 public:
  96     /**
  97         Default constructor.
  98     */
  99     wxGridCellBoolRenderer();
 100 };
 101
 102 /**
 103     @class wxGridCellDateTimeRenderer
 104
 105     This class may be used to format a date/time data in a cell.
 106     The class wxDateTime is used internally to display the local date/time
 107     or to parse the string date entered in the cell thanks to the defined format.
 108
 109     @library{wxadv}
 110     @category{grid}
 111
 112     @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
 113          wxGridCellBoolRenderer, wxGridCellEnumRenderer,
 114          wxGridCellFloatRenderer, wxGridCellNumberRenderer,
 115          wxGridCellStringRenderer
 116 */
 117 class wxGridCellDateTimeRenderer : public wxGridCellStringRenderer
 118 {
 119 public:
 120     /**
 121         Date/time renderer constructor.
 122
 123         @param outformat
 124             strptime()-like format string used the parse the output date/time.
 125         @param informat
 126             strptime()-like format string used to parse the string entered in the cell.
 127     */
 128     wxGridCellDateTimeRenderer(const wxString& outformat = wxDefaultDateTimeFormat,
 129                                const wxString& informat = wxDefaultDateTimeFormat);
 130
 131
 132     /**
 133         Sets the strptime()-like format string which will be used to parse
 134         the date/time.
 135
 136         @param params
 137             strptime()-like format string used to parse the date/time.
 138     */
 139     virtual void SetParameters(const wxString& params);
 140 };
 141
 142 /**
 143     @class wxGridCellEnumRenderer
 144
 145     This class may be used to render in a cell a number as a textual
 146     equivalent.
 147
 148     The corresponding text strings are specified as comma-separated items in
 149     the string passed to this renderer ctor or SetParameters() method. For
 150     example, if this string is @c "John,Fred,Bob" the cell will be rendered as
 151     "John", "Fred" or "Bob" if its contents is 0, 1 or 2 respectively.
 152
 153     @library{wxadv}
 154     @category{grid}
 155
 156     @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
 157          wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
 158          wxGridCellFloatRenderer, wxGridCellNumberRenderer,
 159          wxGridCellStringRenderer
 160 */
 161 class wxGridCellEnumRenderer : public wxGridCellStringRenderer
 162 {
 163 public:
 164     /**
 165         Enum renderer ctor.
 166
 167         @param choices
 168             Comma separated string parameters "item1[,item2[...,itemN]]".
 169     */
 170     wxGridCellEnumRenderer( const wxString& choices = wxEmptyString );
 171
 172     /**
 173         Sets the comma separated string content of the enum.
 174
 175         @param params
 176             Comma separated string parameters "item1[,item2[...,itemN]]".
 177     */
 178     virtual void SetParameters(const wxString& params);
 179 };
 180
 181 /**
 182     @class wxGridCellFloatRenderer
 183
 184     This class may be used to format floating point data in a cell.
 185
 186     @library{wxadv}
 187     @category{grid}
 188
 189     @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
 190          wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
 191          wxGridCellEnumRenderer, wxGridCellNumberRenderer,
 192          wxGridCellStringRenderer
 193 */
 194 class wxGridCellFloatRenderer : public wxGridCellStringRenderer
 195 {
 196 public:
 197     /**
 198         Float cell renderer ctor.
 199
 200         @param width
 201             Minimum number of characters to be shown.
 202         @param precision
 203             Number of digits after the decimal dot.
 204     */
 205     wxGridCellFloatRenderer(int width = -1, int precision = -1);
 206
 207     /**
 208         Returns the precision.
 209     */
 210     int GetPrecision() const;
 211
 212     /**
 213         Returns the width.
 214     */
 215     int GetWidth() const;
 216
 217     /**
 218         Parameters string format is "width[,precision]".
 219     */
 220     virtual void SetParameters(const wxString& params);
 221
 222     /**
 223         Sets the precision.
 224     */
 225     void SetPrecision(int precision);
 226
 227     /**
 228         Sets the width.
 229     */
 230     void SetWidth(int width);
 231 };
 232
 233 /**
 234     @class wxGridCellNumberRenderer
 235
 236     This class may be used to format integer data in a cell.
 237
 238     @library{wxadv}
 239     @category{grid}
 240
 241     @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
 242          wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
 243          wxGridCellEnumRenderer, wxGridCellFloatRenderer,
 244          wxGridCellStringRenderer
 245 */
 246 class wxGridCellNumberRenderer : public wxGridCellStringRenderer
 247 {
 248 public:
 249     /**
 250         Default constructor.
 251     */
 252     wxGridCellNumberRenderer();
 253 };
 254
 255 /**
 256     @class wxGridCellStringRenderer
 257
 258     This class may be used to format string data in a cell; it is the default
 259     for string cells.
 260
 261     @library{wxadv}
 262     @category{grid}
 263
 264     @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
 265          wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
 266          wxGridCellEnumRenderer, wxGridCellFloatRenderer,
 267          wxGridCellNumberRenderer
 268 */
 269 class wxGridCellStringRenderer : public wxGridCellRenderer
 270 {
 271 public:
 272     /**
 273         Default constructor.
 274     */
 275     wxGridCellStringRenderer();
 276 };
 277
 278
 279 /**
 280     @class wxGridCellEditor
 281
 282     This class is responsible for providing and manipulating the in-place edit
 283     controls for the grid.  Instances of wxGridCellEditor (actually, instances
 284     of derived classes since it is an abstract class) can be associated with
 285     the cell attributes for individual cells, rows, columns, or even for the
 286     entire grid.
 287
 288     @library{wxadv}
 289     @category{grid}
 290
 291     @see wxGridCellAutoWrapStringEditor, wxGridCellBoolEditor,
 292          wxGridCellChoiceEditor, wxGridCellEnumEditor,
 293          wxGridCellFloatEditor, wxGridCellNumberEditor,
 294          wxGridCellTextEditor
 295 */
 296 class wxGridCellEditor
 297 {
 298 public:
 299     /**
 300         Default constructor.
 301     */
 302     wxGridCellEditor();
 303
 304     /**
 305         Fetch the value from the table and prepare the edit control to begin
 306         editing.
 307
 308         This function should save the original value of the grid cell at the
 309         given @a row and @a col and show the control allowing the user to
 310         change it.
 311
 312         @see EndEdit()
 313     */
 314     virtual void BeginEdit(int row, int col, wxGrid* grid) = 0;
 315
 316     /**
 317         Create a new object which is the copy of this one.
 318     */
 319     virtual wxGridCellEditor* Clone() const = 0;
 320
 321     /**
 322         Creates the actual edit control.
 323     */
 324     virtual void Create(wxWindow* parent, wxWindowID id,
 325                         wxEvtHandler* evtHandler) = 0;
 326
 327     /**
 328         Final cleanup.
 329     */
 330     virtual void Destroy();
 331
 332     /**
 333         End editing the cell.
 334
 335         This function must check if the current value of the editing control is
 336         valid and different from the original value (available as @a oldval in
 337         its string form and possibly saved internally using its real type by
 338         BeginEdit()). If it isn't, it just returns @false, otherwise it must do
 339         the following:
 340             # Save the new value internally so that ApplyEdit() could apply it.
 341             # Fill @a newval (which is never @NULL) with the string
 342             representation of the new value.
 343             # Return @true
 344
 345         Notice that it must @em not modify the grid as the change could still
 346         be vetoed.
 347
 348         If the user-defined wxEVT_GRID_CELL_CHANGING event handler doesn't veto
 349         this change, ApplyEdit() will be called next.
 350     */
 351     virtual bool EndEdit(int row, int col, const wxGrid* grid,
 352                          const wxString& oldval, wxString* newval) = 0;
 353
 354     /**
 355         Effectively save the changes in the grid.
 356
 357         This function should save the value of the control in the grid. It is
 358         called only after EndEdit() returns @true.
 359      */
 360     virtual void ApplyEdit(int row, int col, wxGrid* grid) = 0;
 361
 362     /**
 363         Some types of controls on some platforms may need some help with the
 364         Return key.
 365     */
 366     virtual void HandleReturn(wxKeyEvent& event);
 367
 368     /**
 369         Returns @true if the edit control has been created.
 370     */
 371     bool IsCreated();
 372
 373     /**
 374         Draws the part of the cell not occupied by the control: the base class
 375         version just fills it with background colour from the attribute.
 376     */
 377     virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr* attr);
 378
 379     /**
 380         Reset the value in the control back to its starting value.
 381     */
 382     virtual void Reset() = 0;
 383
 384     /**
 385         Size and position the edit control.
 386     */
 387     virtual void SetSize(const wxRect& rect);
 388
 389     /**
 390         Show or hide the edit control, use the specified attributes to set
 391         colours/fonts for it.
 392     */
 393     virtual void Show(bool show, wxGridCellAttr* attr = NULL);
 394
 395     /**
 396         If the editor is enabled by clicking on the cell, this method will be
 397         called.
 398     */
 399     virtual void StartingClick();
 400
 401     /**
 402         If the editor is enabled by pressing keys on the grid, this will be
 403         called to let the editor do something about that first key if desired.
 404     */
 405     virtual void StartingKey(wxKeyEvent& event);
 406
 407 protected:
 408
 409     /**
 410         The destructor is private because only DecRef() can delete us.
 411     */
 412     virtual ~wxGridCellEditor();
 413 };
 414
 415 /**
 416     @class wxGridCellAutoWrapStringEditor
 417
 418     Grid cell editor for wrappable string/text data.
 419
 420     @library{wxadv}
 421     @category{grid}
 422
 423     @see wxGridCellEditor, wxGridCellBoolEditor, wxGridCellChoiceEditor,
 424          wxGridCellEnumEditor, wxGridCellFloatEditor,
 425          wxGridCellNumberEditor, wxGridCellTextEditor
 426 */
 427 class wxGridCellAutoWrapStringEditor : public wxGridCellTextEditor
 428 {
 429 public:
 430     wxGridCellAutoWrapStringEditor();
 431 };
 432
 433 /**
 434     @class wxGridCellBoolEditor
 435
 436     Grid cell editor for boolean data.
 437
 438     @library{wxadv}
 439     @category{grid}
 440
 441     @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
 442          wxGridCellChoiceEditor, wxGridCellEnumEditor,
 443          wxGridCellFloatEditor, wxGridCellNumberEditor,
 444          wxGridCellTextEditor
 445 */
 446 class wxGridCellBoolEditor : public wxGridCellEditor
 447 {
 448 public:
 449     /**
 450         Default constructor.
 451     */
 452     wxGridCellBoolEditor();
 453
 454     /**
 455         Returns @true if the given @a value is equal to the string
 456         representation of the truth value we currently use (see
 457         UseStringValues()).
 458     */
 459     static bool IsTrueValue(const wxString& value);
 460
 461     /**
 462         This method allows you to customize the values returned by GetValue()
 463         for the cell using this editor. By default, the default values of the
 464         arguments are used, i.e. @c "1" is returned if the cell is checked and
 465         an empty string otherwise.
 466     */
 467     static void UseStringValues(const wxString& valueTrue = "1",
 468                                 const wxString& valueFalse = wxEmptyString);
 469 };
 470
 471 /**
 472     @class wxGridCellChoiceEditor
 473
 474     Grid cell editor for string data providing the user a choice from a list of
 475     strings.
 476
 477     @library{wxadv}
 478     @category{grid}
 479
 480     @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
 481          wxGridCellBoolEditor, wxGridCellEnumEditor,
 482          wxGridCellFloatEditor, wxGridCellNumberEditor,
 483          wxGridCellTextEditor
 484 */
 485 class wxGridCellChoiceEditor : public wxGridCellEditor
 486 {
 487 public:
 488     /**
 489         Choice cell renderer ctor.
 490
 491         @param count
 492             Number of strings from which the user can choose.
 493         @param choices
 494             An array of strings from which the user can choose.
 495         @param allowOthers
 496             If allowOthers is @true, the user can type a string not in choices
 497             array.
 498     */
 499     //@{
 500     wxGridCellChoiceEditor(size_t count = 0,
 501                            const wxString choices[] = NULL,
 502                            bool allowOthers = false);
 503     wxGridCellChoiceEditor(const wxArrayString& choices,
 504                            bool allowOthers = false);
 505     //@}
 506
 507     /**
 508         Parameters string format is "item1[,item2[...,itemN]]"
 509     */
 510     virtual void SetParameters(const wxString& params);
 511 };
 512
 513 /**
 514     @class wxGridCellEnumEditor
 515
 516     Grid cell editor which displays an enum number as a textual equivalent
 517     (eg. data in cell is 0,1,2 ... n the cell could be displayed as
 518     "John","Fred"..."Bob" in the combo choice box).
 519
 520     @library{wxadv}
 521     @category{grid}
 522
 523     @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
 524          wxGridCellBoolEditor, wxGridCellChoiceEditor,
 525          wxGridCellTextEditor, wxGridCellFloatEditor,
 526          wxGridCellNumberEditor
 527 */
 528 class wxGridCellEnumEditor : public wxGridCellChoiceEditor
 529 {
 530 public:
 531     /**
 532         Enum cell editor ctor.
 533
 534         @param choices
 535             Comma separated choice parameters "item1[,item2[...,itemN]]".
 536     */
 537     wxGridCellEnumEditor( const wxString& choices = wxEmptyString );
 538 };
 539
 540 /**
 541     @class wxGridCellTextEditor
 542
 543     Grid cell editor for string/text data.
 544
 545     @library{wxadv}
 546     @category{grid}
 547
 548     @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
 549          wxGridCellBoolEditor, wxGridCellChoiceEditor,
 550          wxGridCellEnumEditor, wxGridCellFloatEditor,
 551          wxGridCellNumberEditor
 552 */
 553 class wxGridCellTextEditor : public wxGridCellEditor
 554 {
 555 public:
 556     /**
 557         Default constructor.
 558     */
 559     wxGridCellTextEditor();
 560
 561     /**
 562         The parameters string format is "n" where n is a number representing
 563         the maximum width.
 564     */
 565     virtual void SetParameters(const wxString& params);
 566 };
 567
 568 /**
 569     @class wxGridCellFloatEditor
 570
 571     The editor for floating point numbers data.
 572
 573     @library{wxadv}
 574     @category{grid}
 575
 576     @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
 577          wxGridCellBoolEditor, wxGridCellChoiceEditor,
 578          wxGridCellEnumEditor, wxGridCellNumberEditor,
 579          wxGridCellTextEditor
 580 */
 581 class wxGridCellFloatEditor : public wxGridCellTextEditor
 582 {
 583 public:
 584     /**
 585         Float cell editor ctor.
 586
 587         @param width
 588             Minimum number of characters to be shown.
 589         @param precision
 590             Number of digits after the decimal dot.
 591     */
 592     wxGridCellFloatEditor(int width = -1, int precision = -1);
 593
 594     /**
 595         Parameters string format is "width,precision"
 596     */
 597     virtual void SetParameters(const wxString& params);
 598 };
 599
 600 /**
 601     @class wxGridCellNumberEditor
 602
 603     Grid cell editor for numeric integer data.
 604
 605     @library{wxadv}
 606     @category{grid}
 607
 608     @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
 609          wxGridCellBoolEditor, wxGridCellChoiceEditor,
 610          wxGridCellEnumEditor, wxGridCellFloatEditor,
 611          wxGridCellTextEditor
 612 */
 613 class wxGridCellNumberEditor : public wxGridCellTextEditor
 614 {
 615 public:
 616     /**
 617         Allows you to specify the range for acceptable data. Values equal to
 618         -1 for both @a min and @a max indicate that no range checking should be
 619         done.
 620     */
 621     wxGridCellNumberEditor(int min = -1, int max = -1);
 622
 623
 624     /**
 625         Parameters string format is "min,max".
 626     */
 627     virtual void SetParameters(const wxString& params);
 628
 629 protected:
 630
 631     /**
 632         If the return value is @true, the editor uses a wxSpinCtrl to get user
 633         input, otherwise it uses a wxTextCtrl.
 634     */
 635     bool HasRange() const;
 636
 637     /**
 638         String representation of the value.
 639     */
 640     wxString GetString() const;
 641 };
 642
 643
 644
 645 /**
 646     @class wxGridCellAttr
 647
 648     This class can be used to alter the cells' appearance in the grid by
 649     changing their attributes from the defaults. An object of this class may be
 650     returned by wxGridTableBase::GetAttr().
 651
 652     @library{wxadv}
 653     @category{grid}
 654 */
 655 class wxGridCellAttr
 656 {
 657 public:
 658     /**
 659         Kind of the attribute to retrieve.
 660
 661         @see wxGridCellAttrProvider::GetAttr(), wxGridTableBase::GetAttr()
 662      */
 663     enum wxAttrKind
 664     {
 665         /// Return the combined effective attribute for the cell.
 666         Any,
 667
 668         /// Return the attribute explicitly set for this cell.
 669         Cell,
 670
 671         /// Return the attribute set for this cells row.
 672         Row,
 673
 674         /// Return the attribute set for this cells column.
 675         Col
 676     };
 677
 678     /**
 679         Default constructor.
 680     */
 681     wxGridCellAttr(wxGridCellAttr* attrDefault = NULL);
 682     /**
 683         Constructor specifying some of the often used attributes.
 684     */
 685     wxGridCellAttr(const wxColour& colText, const wxColour& colBack,
 686                    const wxFont& font, int hAlign, int vAlign);
 687
 688     /**
 689         Creates a new copy of this object.
 690     */
 691     wxGridCellAttr* Clone() const;
 692
 693     /**
 694         This class is reference counted: it is created with ref count of 1, so
 695         calling DecRef() once will delete it. Calling IncRef() allows to lock
 696         it until the matching DecRef() is called.
 697     */
 698     void DecRef();
 699
 700     /**
 701         Get the alignment to use for the cell with the given attribute.
 702
 703         If this attribute doesn't specify any alignment, the default attribute
 704         alignment is used (which can be changed using
 705         wxGrid::SetDefaultCellAlignment() but is left and top by default).
 706
 707         Notice that @a hAlign and @a vAlign values are always overwritten by
 708         this function, use GetNonDefaultAlignment() if this is not desirable.
 709
 710         @param hAlign
 711             Horizontal alignment is returned here if this argument is non-@NULL.
 712             It is one of wxALIGN_LEFT, wxALIGN_CENTRE or wxALIGN_RIGHT.
 713         @param vAlign
 714             Vertical alignment is returned here if this argument is non-@NULL.
 715             It is one of wxALIGN_TOP, wxALIGN_CENTRE or wxALIGN_BOTTOM.
 716     */
 717     void GetAlignment(int* hAlign, int* vAlign) const;
 718
 719     /**
 720         Returns the background colour.
 721     */
 722     const wxColour& GetBackgroundColour() const;
 723
 724     /**
 725         Returns the cell editor.
 726     */
 727     wxGridCellEditor* GetEditor(const wxGrid* grid, int row, int col) const;
 728
 729     /**
 730         Returns the font.
 731     */
 732     const wxFont& GetFont() const;
 733
 734     /**
 735         Get the alignment defined by this attribute.
 736
 737         Unlike GetAlignment() this function only modifies @a hAlign and @a
 738         vAlign if this attribute does define a non-default alignment. This
 739         means that they must be initialized before calling this function and
 740         that their values will be preserved unchanged if they are different
 741         from wxALIGN_INVALID.
 742
 743         For example, the following fragment can be used to use the cell
 744         alignment if one is defined but right-align its contents by default
 745         (instead of left-aligning it by default) while still using the default
 746         vertical alignment:
 747         @code
 748             int hAlign = wxALIGN_RIGHT,
 749                 vAlign = wxALIGN_INVALID;
 750             attr.GetNonDefaultAlignment(&hAlign, &vAlign);
 751         @endcode
 752
 753         @since 2.9.1
 754      */
 755     void GetNonDefaultAlignment(int *hAlign, int *vAlign) const;
 756
 757     /**
 758         Returns the cell renderer.
 759     */
 760     wxGridCellRenderer* GetRenderer(const wxGrid* grid, int row, int col) const;
 761
 762     /**
 763         Returns the text colour.
 764     */
 765     const wxColour& GetTextColour() const;
 766
 767     /**
 768         Returns @true if this attribute has a valid alignment set.
 769     */
 770     bool HasAlignment() const;
 771
 772     /**
 773         Returns @true if this attribute has a valid background colour set.
 774     */
 775     bool HasBackgroundColour() const;
 776
 777     /**
 778         Returns @true if this attribute has a valid cell editor set.
 779     */
 780     bool HasEditor() const;
 781
 782     /**
 783         Returns @true if this attribute has a valid font set.
 784     */
 785     bool HasFont() const;
 786
 787     /**
 788         Returns @true if this attribute has a valid cell renderer set.
 789     */
 790     bool HasRenderer() const;
 791
 792     /**
 793         Returns @true if this attribute has a valid text colour set.
 794     */
 795     bool HasTextColour() const;
 796
 797     /**
 798         This class is reference counted: it is created with ref count of 1, so
 799         calling DecRef() once will delete it. Calling IncRef() allows to lock
 800         it until the matching DecRef() is called.
 801     */
 802     void IncRef();
 803
 804     /**
 805         Returns @true if this cell is set as read-only.
 806     */
 807     bool IsReadOnly() const;
 808
 809     /**
 810         Sets the alignment. @a hAlign can be one of @c wxALIGN_LEFT,
 811         @c wxALIGN_CENTRE or @c wxALIGN_RIGHT and @a vAlign can be one of
 812         @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
 813     */
 814     void SetAlignment(int hAlign, int vAlign);
 815
 816     /**
 817         Sets the background colour.
 818     */
 819     void SetBackgroundColour(const wxColour& colBack);
 820
 821     /**
 822         @todo Needs documentation.
 823     */
 824     void SetDefAttr(wxGridCellAttr* defAttr);
 825
 826     /**
 827         Sets the editor to be used with the cells with this attribute.
 828     */
 829     void SetEditor(wxGridCellEditor* editor);
 830
 831     /**
 832         Sets the font.
 833     */
 834     void SetFont(const wxFont& font);
 835
 836     /**
 837         Sets the cell as read-only.
 838     */
 839     void SetReadOnly(bool isReadOnly = true);
 840
 841     /**
 842         Sets the renderer to be used for cells with this attribute. Takes
 843         ownership of the pointer.
 844     */
 845     void SetRenderer(wxGridCellRenderer* renderer);
 846
 847     /**
 848         Sets the text colour.
 849     */
 850     void SetTextColour(const wxColour& colText);
 851 };
 852
 853 /**
 854     Base class for corner window renderer.
 855
 856     This is the simplest of all header renderers and only has a single
 857     function.
 858
 859     @see wxGridCellAttrProvider::GetCornerRenderer()
 860
 861     @since 2.9.1
 862  */
 863 class wxGridCornerHeaderRenderer
 864 {
 865 public:
 866     /**
 867         Called by the grid to draw the corner window border.
 868
 869         This method is responsible for drawing the border inside the given @a
 870         rect and adjusting the rectangle size to correspond to the area inside
 871         the border, i.e. usually call wxRect::Deflate() to account for the
 872         border width.
 873
 874         @param grid
 875             The grid whose corner window is being drawn.
 876         @param dc
 877             The device context to use for drawing.
 878         @param rect
 879             Input/output parameter which contains the border rectangle on input
 880             and should be updated to contain the area inside the border on
 881             function return.
 882      */
 883     virtual void DrawBorder(const wxGrid& grid,
 884                             wxDC& dc,
 885                             wxRect& rect) const = 0;
 886 };
 887 /**
 888     Common base class for row and column headers renderers.
 889
 890     @see wxGridColumnHeaderRenderer, wxGridRowHeaderRenderer
 891
 892     @since 2.9.1
 893  */
 894 class wxGridHeaderLabelsRenderer : public wxGridCornerHeaderRenderer
 895 {
 896 public:
 897     /**
 898         Called by the grid to draw the specified label.
 899
 900         Notice that the base class DrawBorder() method is called before this
 901         one.
 902
 903         The default implementation uses wxGrid::GetLabelTextColour() and
 904         wxGrid::GetLabelFont() to draw the label.
 905      */
 906     virtual void DrawLabel(const wxGrid& grid,
 907                            wxDC& dc,
 908                            const wxString& value,
 909                            const wxRect& rect,
 910                            int horizAlign,
 911                            int vertAlign,
 912                            int textOrientation) const;
 913 };
 914
 915 /**
 916     Base class for row headers renderer.
 917
 918     This is the same as wxGridHeaderLabelsRenderer currently but we still use a
 919     separate class for it to distinguish it from wxGridColumnHeaderRenderer.
 920
 921     @see wxGridRowHeaderRendererDefault
 922
 923     @see wxGridCellAttrProvider::GetRowHeaderRenderer()
 924
 925     @since 2.9.1
 926  */
 927 class wxGridRowHeaderRenderer : public wxGridHeaderLabelsRenderer
 928 {
 929 };
 930
 931 /**
 932     Base class for column headers renderer.
 933
 934     This is the same as wxGridHeaderLabelsRenderer currently but we still use a
 935     separate class for it to distinguish it from wxGridRowHeaderRenderer.
 936
 937     @see wxGridColumnHeaderRendererDefault
 938
 939     @see wxGridCellAttrProvider::GetColumnHeaderRenderer()
 940
 941     @since 2.9.1
 942  */
 943 class wxGridColumnHeaderRenderer : public wxGridHeaderLabelsRenderer
 944 {
 945 };
 946
 947 /**
 948     Default row header renderer.
 949
 950     You may derive from this class if you need to only override one of its
 951     methods (i.e. either DrawLabel() or DrawBorder()) but continue to use the
 952     default implementation for the other one.
 953
 954     @see wxGridColumnHeaderRendererDefault
 955
 956     @since 2.9.1
 957  */
 958 class wxGridRowHeaderRendererDefault : public wxGridRowHeaderRenderer
 959 {
 960 public:
 961     /// Implement border drawing for the row labels.
 962     virtual void DrawBorder(const wxGrid& grid,
 963                             wxDC& dc,
 964                             wxRect& rect) const;
 965 };
 966
 967 /**
 968     Default column header renderer.
 969
 970     @see wxGridRowHeaderRendererDefault
 971
 972     @since 2.9.1
 973  */
 974 class wxGridColumnHeaderRendererDefault : public wxGridColumnHeaderRenderer
 975 {
 976 public:
 977     /// Implement border drawing for the column labels.
 978     virtual void DrawBorder(const wxGrid& grid,
 979                             wxDC& dc,
 980                             wxRect& rect) const;
 981 };
 982
 983 /**
 984     Default corner window renderer.
 985
 986     @see wxGridColumnHeaderRendererDefault, wxGridRowHeaderRendererDefault
 987
 988     @since 2.9.1
 989  */
 990 class wxGridCornerHeaderRendererDefault : public wxGridCornerHeaderRenderer
 991 {
 992 public:
 993     /// Implement border drawing for the corner window.
 994     virtual void DrawBorder(const wxGrid& grid,
 995                             wxDC& dc,
 996                             wxRect& rect) const;
 997 };
 998
 999 /**
1000     Class providing attributes to be used for the grid cells.
1001
1002     This class both defines an interface which grid cell attributes providers
1003     should implement -- and which can be implemented differently in derived
1004     classes -- and a default implementation of this interface which is often
1005     good enough to be used without modification, especially with not very large
1006     grids for which the efficiency of attributes storage hardly matters (see
1007     the discussion below).
1008
1009     An object of this class can be associated with a wxGrid using
1010     wxGridTableBase::SetAttrProvider() but it's not necessary to call it if you
1011     intend to use the default provider as it is used by wxGridTableBase by
1012     default anyhow.
1013
1014     Notice that while attributes provided by this class can be set for
1015     individual cells using SetAttr() or the entire rows or columns using
1016     SetRowAttr() and SetColAttr() they are always retrieved using GetAttr()
1017     function.
1018
1019
1020     The default implementation of this class stores the attributes passed to
1021     its SetAttr(), SetRowAttr() and SetColAttr() in a straightforward way. A
1022     derived class may use its knowledge about how the attributes are used in
1023     your program to implement it much more efficiently: for example, using a
1024     special background colour for all even-numbered rows can be implemented by
1025     simply returning the same attribute from GetAttr() if the row number is
1026     even instead of having to store N/2 row attributes where N is the total
1027     number of rows in the grid.
1028
1029     Notice that objects of this class can't be copied.
1030  */
1031 class wxGridCellAttrProvider : public wxClientDataContainer
1032 {
1033 public:
1034     /// Trivial default constructor.
1035     wxGridCellAttrProvider();
1036
1037     /// Destructor releases any attributes held by this class.
1038     virtual ~wxGridCellAttrProvider();
1039
1040     /**
1041         Get the attribute to use for the specified cell.
1042
1043         If wxGridCellAttr::Any is used as @a kind value, this function combines
1044         the attributes set for this cell using SetAttr() and those for its row
1045         or column (set with SetRowAttr() or SetColAttr() respectively), with
1046         the cell attribute having the highest precedence.
1047
1048         Notice that the caller must call DecRef() on the returned pointer if it
1049         is non-@NULL.
1050
1051         @param row
1052             The row of the cell.
1053         @param col
1054             The column of the cell.
1055         @param kind
1056             The kind of the attribute to return.
1057         @return
1058             The attribute to use which should be DecRef()'d by caller or @NULL
1059             if no attributes are defined for this cell.
1060      */
1061     virtual wxGridCellAttr *GetAttr(int row, int col,
1062                                     wxGridCellAttr::wxAttrKind kind) const;
1063
1064     /**
1065         Setting attributes.
1066
1067         All these functions take ownership of the attribute passed to them,
1068         i.e. will call DecRef() on it themselves later and so it should not be
1069         destroyed by the caller. And the attribute can be @NULL to reset a
1070         previously set value.
1071      */
1072     //@{
1073
1074     /// Set attribute for the specified cell.
1075     virtual void SetAttr(wxGridCellAttr *attr, int row, int col);
1076
1077     /// Set attribute for the specified row.
1078     virtual void SetRowAttr(wxGridCellAttr *attr, int row);
1079
1080     /// Set attribute for the specified column.
1081     virtual void SetColAttr(wxGridCellAttr *attr, int col);
1082
1083     //@}
1084
1085     /**
1086         Getting header renderers.
1087
1088         These functions return the renderers for the given row or column header
1089         label and the corner window. Unlike cell attributes, these objects are
1090         not reference counted and are never @NULL so they are returned by
1091         reference and not pointer and DecRef() shouldn't (and can't) be called
1092         for them.
1093
1094         All these functions were added in wxWidgets 2.9.1.
1095      */
1096     //@{
1097
1098     /**
1099         Return the renderer used for drawing column headers.
1100
1101         By default wxGridColumnHeaderRendererDefault is returned.
1102
1103         @see wxGrid::SetUseNativeColLabels(), wxGrid::UseNativeColHeader()
1104
1105         @since 2.9.1
1106      */
1107     virtual const wxGridColumnHeaderRenderer& GetColumnHeaderRenderer(int col);
1108
1109     /**
1110         Return the renderer used for drawing row headers.
1111
1112         By default wxGridRowHeaderRendererDefault is returned.
1113
1114         @since 2.9.1
1115      */
1116     virtual const wxGridRowHeaderRenderer& GetRowHeaderRenderer(int row);
1117
1118     /**
1119         Return the renderer used for drawing the corner window.
1120
1121         By default wxGridCornerHeaderRendererDefault is returned.
1122
1123         @since 2.9.1
1124      */
1125     virtual const wxGridCornerHeaderRenderer& GetCornerRenderer();
1126
1127     //@}
1128 };
1129
1130
1131 /**
1132     @class wxGridTableBase
1133
1134     The almost abstract base class for grid tables.
1135
1136     A grid table is responsible for storing the grid data and, indirectly, grid
1137     cell attributes. The data can be stored in the way most convenient for the
1138     application but has to be provided in string form to wxGrid. It is also
1139     possible to provide cells values in other formats if appropriate, e.g. as
1140     numbers.
1141
1142     This base class is not quite abstract as it implements a trivial strategy
1143     for storing the attributes by forwarding it to wxGridCellAttrProvider and
1144     also provides stubs for some other functions. However it does have a number
1145     of pure virtual methods which must be implemented in the derived classes.
1146
1147     @see wxGridStringTable
1148
1149     @library{wxadv}
1150     @category{grid}
1151 */
1152 class wxGridTableBase : public wxObject
1153 {
1154 public:
1155     /**
1156         Default constructor.
1157      */
1158     wxGridTableBase();
1159
1160     /**
1161         Destructor frees the attribute provider if it was created.
1162      */
1163     virtual ~wxGridTableBase();
1164
1165     /**
1166         Must be overridden to return the number of rows in the table.
1167
1168         For backwards compatibility reasons, this method is not const.
1169         Use GetRowsCount() instead of it in const methods of derived table
1170         classes.
1171      */
1172     virtual int GetNumberRows() = 0;
1173
1174     /**
1175         Must be overridden to return the number of columns in the table.
1176
1177         For backwards compatibility reasons, this method is not const.
1178         Use GetColsCount() instead of it in const methods of derived table
1179         classes,
1180      */
1181     virtual int GetNumberCols() = 0;
1182
1183     /**
1184         Return the number of rows in the table.
1185
1186         This method is not virtual and is only provided as a convenience for
1187         the derived classes which can't call GetNumberRows() without a
1188         @c const_cast from their const methods.
1189      */
1190     int GetRowsCount() const;
1191
1192     /**
1193         Return the number of columns in the table.
1194
1195         This method is not virtual and is only provided as a convenience for
1196         the derived classes which can't call GetNumberCols() without a
1197         @c const_cast from their const methods.
1198      */
1199     int GetColsCount() const;
1200
1201
1202     /**
1203         @name Table Cell Accessors
1204      */
1205     //@{
1206
1207     /**
1208         May be overridden to implement testing for empty cells.
1209
1210         This method is used by the grid to test if the given cell is not used
1211         and so whether a neighbouring cell may overflow into it. By default it
1212         only returns true if the value of the given cell, as returned by
1213         GetValue(), is empty.
1214      */
1215     virtual bool IsEmptyCell(int row, int col);
1216
1217     /**
1218         Same as IsEmptyCell() but taking wxGridCellCoords.
1219
1220         Notice that this method is not virtual, only IsEmptyCell() should be
1221         overridden.
1222      */
1223     bool IsEmpty(const wxGridCellCoords& coords);
1224
1225     /**
1226         Must be overridden to implement accessing the table values as text.
1227      */
1228     virtual wxString GetValue(int row, int col) = 0;
1229
1230     /**
1231         Must be overridden to implement setting the table values as text.
1232      */
1233     virtual void SetValue(int row, int col, const wxString& value) = 0;
1234
1235     /**
1236         Returns the type of the value in the given cell.
1237
1238         By default all cells are strings and this method returns
1239         @c wxGRID_VALUE_STRING.
1240      */
1241     virtual wxString GetTypeName(int row, int col);
1242
1243     /**
1244         Returns true if the value of the given cell can be accessed as if it
1245         were of the specified type.
1246
1247         By default the cells can only be accessed as strings. Note that a cell
1248         could be accessible in different ways, e.g. a numeric cell may return
1249         @true for @c wxGRID_VALUE_NUMBER but also for @c wxGRID_VALUE_STRING
1250         indicating that the value can be coerced to a string form.
1251      */
1252     virtual bool CanGetValueAs(int row, int col, const wxString& typeName);
1253
1254     /**
1255         Returns true if the value of the given cell can be set as if it were of
1256         the specified type.
1257
1258         @see CanGetValueAs()
1259      */
1260     virtual bool CanSetValueAs(int row, int col, const wxString& typeName);
1261
1262     /**
1263         Returns the value of the given cell as a long.
1264
1265         This should only be called if CanGetValueAs() returns @true when called
1266         with @c wxGRID_VALUE_NUMBER argument. Default implementation always
1267         return 0.
1268      */
1269     virtual long GetValueAsLong(int row, int col);
1270
1271     /**
1272         Returns the value of the given cell as a double.
1273
1274         This should only be called if CanGetValueAs() returns @true when called
1275         with @c wxGRID_VALUE_FLOAT argument. Default implementation always
1276         return 0.0.
1277      */
1278     virtual double GetValueAsDouble(int row, int col);
1279
1280     /**
1281         Returns the value of the given cell as a boolean.
1282
1283         This should only be called if CanGetValueAs() returns @true when called
1284         with @c wxGRID_VALUE_BOOL argument. Default implementation always
1285         return false.
1286      */
1287     virtual bool GetValueAsBool(int row, int col);
1288
1289     /**
1290         Returns the value of the given cell as a user-defined type.
1291
1292         This should only be called if CanGetValueAs() returns @true when called
1293         with @a typeName. Default implementation always return @NULL.
1294      */
1295     virtual void *GetValueAsCustom(int row, int col, const wxString& typeName);
1296
1297     /**
1298         Sets the value of the given cell as a long.
1299
1300         This should only be called if CanSetValueAs() returns @true when called
1301         with @c wxGRID_VALUE_NUMBER argument. Default implementation doesn't do
1302         anything.
1303      */
1304     virtual void SetValueAsLong(int row, int col, long value);
1305
1306     /**
1307         Sets the value of the given cell as a double.
1308
1309         This should only be called if CanSetValueAs() returns @true when called
1310         with @c wxGRID_VALUE_FLOAT argument. Default implementation doesn't do
1311         anything.
1312      */
1313     virtual void SetValueAsDouble(int row, int col, double value);
1314
1315     /**
1316         Sets the value of the given cell as a boolean.
1317
1318         This should only be called if CanSetValueAs() returns @true when called
1319         with @c wxGRID_VALUE_BOOL argument. Default implementation doesn't do
1320         anything.
1321      */
1322     virtual void SetValueAsBool( int row, int col, bool value );
1323
1324     /**
1325         Sets the value of the given cell as a user-defined type.
1326
1327         This should only be called if CanSetValueAs() returns @true when called
1328         with @a typeName. Default implementation doesn't do anything.
1329      */
1330     virtual void SetValueAsCustom(int row, int col, const wxString& typeName,
1331                                   void *value);
1332
1333     //@}
1334
1335
1336     /**
1337         Called by the grid when the table is associated with it.
1338
1339         The default implementation stores the pointer and returns it from its
1340         GetView() and so only makes sense if the table cannot be associated
1341         with more than one grid at a time.
1342      */
1343     virtual void SetView(wxGrid *grid);
1344
1345     /**
1346         Returns the last grid passed to SetView().
1347      */
1348     virtual wxGrid *GetView() const;
1349
1350
1351     /**
1352         @name Table Structure Modifiers
1353
1354         Notice that none of these functions are pure virtual as they don't have
1355         to be implemented if the table structure is never modified after
1356         creation, i.e. neither rows nor columns are never added or deleted but
1357         that you do need to implement them if they are called, i.e. if your
1358         code either calls them directly or uses the matching wxGrid methods, as
1359         by default they simply do nothing which is definitely inappropriate.
1360      */
1361     //@{
1362
1363     /**
1364         Clear the table contents.
1365
1366         This method is used by wxGrid::ClearGrid().
1367      */
1368     virtual void Clear();
1369
1370     /**
1371         Insert additional rows into the table.
1372
1373         @param pos
1374             The position of the first new row.
1375         @param numRows
1376             The number of rows to insert.
1377      */
1378     virtual bool InsertRows(size_t pos = 0, size_t numRows = 1);
1379
1380     /**
1381         Append additional rows at the end of the table.
1382
1383         This method is provided in addition to InsertRows() as some data models
1384         may only support appending rows to them but not inserting them at
1385         arbitrary locations. In such case you may implement this method only
1386         and leave InsertRows() unimplemented.
1387
1388         @param numRows
1389             The number of rows to add.
1390      */
1391     virtual bool AppendRows(size_t numRows = 1);
1392
1393     /**
1394         Delete rows from the table.
1395
1396         @param pos
1397             The first row to delete.
1398         @param numRows
1399             The number of rows to delete.
1400      */
1401     virtual bool DeleteRows(size_t pos = 0, size_t numRows = 1);
1402
1403     /**
1404         Exactly the same as InsertRows() but for columns.
1405      */
1406     virtual bool InsertCols(size_t pos = 0, size_t numCols = 1);
1407
1408     /**
1409         Exactly the same as AppendRows() but for columns.
1410      */
1411     virtual bool AppendCols(size_t numCols = 1);
1412
1413     /**
1414         Exactly the same as DeleteRows() but for columns.
1415      */
1416     virtual bool DeleteCols(size_t pos = 0, size_t numCols = 1);
1417
1418     //@}
1419
1420     /**
1421         @name Table Row and Column Labels
1422
1423         By default the numbers are used for labeling rows and Latin letters for
1424         labeling columns. If the table has more than 26 columns, the pairs of
1425         letters are used starting from the 27-th one and so on, i.e. the
1426         sequence of labels is A, B, ..., Z, AA, AB, ..., AZ, BA, ..., ..., ZZ,
1427         AAA, ...
1428      */
1429     //@{
1430
1431     /**
1432         Return the label of the specified row.
1433      */
1434     virtual wxString GetRowLabelValue(int row);
1435
1436     /**
1437         Return the label of the specified column.
1438      */
1439     virtual wxString GetColLabelValue(int col);
1440
1441     /**
1442         Set the given label for the specified row.
1443
1444         The default version does nothing, i.e. the label is not stored. You
1445         must override this method in your derived class if you wish
1446         wxGrid::SetRowLabelValue() to work.
1447      */
1448     virtual void SetRowLabelValue(int row, const wxString& label);
1449
1450     /**
1451         Exactly the same as SetRowLabelValue() but for columns.
1452      */
1453     virtual void SetColLabelValue(int col, const wxString& label);
1454
1455     //@}
1456
1457
1458     /**
1459         @name Attributes Management
1460
1461         By default the attributes management is delegated to
1462         wxGridCellAttrProvider class. You may override the methods in this
1463         section to handle the attributes directly if, for example, they can be
1464         computed from the cell values.
1465      */
1466     //@{
1467
1468     /**
1469         Associate this attributes provider with the table.
1470
1471         The table takes ownership of @a attrProvider pointer and will delete it
1472         when it doesn't need it any more. The pointer can be @NULL, however
1473         this won't disable attributes management in the table but will just
1474         result in a default attributes being recreated the next time any of the
1475         other functions in this section is called. To completely disable the
1476         attributes support, should this be needed, you need to override
1477         CanHaveAttributes() to return @false.
1478      */
1479     void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
1480
1481     /**
1482         Returns the attribute provider currently being used.
1483
1484         This function may return @NULL if the attribute provider hasn't been
1485         neither associated with this table by SetAttrProvider() nor created on
1486         demand by any other methods.
1487      */
1488     wxGridCellAttrProvider *GetAttrProvider() const;
1489
1490     /**
1491         Return the attribute for the given cell.
1492
1493         By default this function is simply forwarded to
1494         wxGridCellAttrProvider::GetAttr() but it may be overridden to handle
1495         attributes directly in the table.
1496      */
1497     virtual wxGridCellAttr *GetAttr(int row, int col,
1498                                     wxGridCellAttr::wxAttrKind kind);
1499
1500     /**
1501         Set attribute of the specified cell.
1502
1503         By default this function is simply forwarded to
1504         wxGridCellAttrProvider::SetAttr().
1505
1506         The table takes ownership of @a attr, i.e. will call DecRef() on it.
1507      */
1508     virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
1509
1510     /**
1511         Set attribute of the specified row.
1512
1513         By default this function is simply forwarded to
1514         wxGridCellAttrProvider::SetRowAttr().
1515
1516         The table takes ownership of @a attr, i.e. will call DecRef() on it.
1517      */
1518     virtual void SetRowAttr(wxGridCellAttr *attr, int row);
1519
1520     /**
1521         Set attribute of the specified column.
1522
1523         By default this function is simply forwarded to
1524         wxGridCellAttrProvider::SetColAttr().
1525
1526         The table takes ownership of @a attr, i.e. will call DecRef() on it.
1527      */
1528     virtual void SetColAttr(wxGridCellAttr *attr, int col);
1529
1530     //@}
1531
1532     /**
1533         Returns true if this table supports attributes or false otherwise.
1534
1535         By default, the table automatically creates a wxGridCellAttrProvider
1536         when this function is called if it had no attribute provider before and
1537         returns @true.
1538      */
1539     virtual bool CanHaveAttributes();
1540 };
1541
1542 /**
1543     @class wxGridSizesInfo
1544
1545     wxGridSizesInfo stores information about sizes of all wxGrid rows or
1546     columns.
1547
1548     It assumes that most of the rows or columns (which are both called elements
1549     here as the difference between them doesn't matter at this class level)
1550     have the default size and so stores it separately. And it uses a wxHashMap
1551     to store the sizes of all elements which have the non-default size.
1552
1553     This structure is particularly useful for serializing the sizes of all
1554     wxGrid elements at once.
1555
1556     @library{wxadv}
1557     @category{grid}
1558  */
1559 struct wxGridSizesInfo
1560 {
1561     /**
1562         Default constructor.
1563
1564         m_sizeDefault and m_customSizes must be initialized later.
1565      */
1566     wxGridSizesInfo();
1567
1568     /**
1569         Constructor.
1570
1571         This constructor is used by wxGrid::GetRowSizes() and GetColSizes()
1572         methods. User code will usually use the default constructor instead.
1573
1574         @param defSize
1575             The default element size.
1576         @param allSizes
1577             Array containing the sizes of @em all elements, including those
1578             which have the default size.
1579      */
1580     wxGridSizesInfo(int defSize, const wxArrayInt& allSizes);
1581
1582     /**
1583         Get the element size.
1584
1585         @param pos
1586             The index of the element.
1587         @return
1588             The size for this element, using m_customSizes if @a pos is in it
1589             or m_sizeDefault otherwise.
1590      */
1591     int GetSize(unsigned pos) const;
1592
1593
1594     /// Default size
1595     int m_sizeDefault;
1596
1597     /**
1598         Map with element indices as keys and their sizes as values.
1599
1600         This map only contains the elements with non-default size.
1601      */
1602     wxUnsignedToIntHashMap m_customSizes;
1603 };
1604
1605
1606 /**
1607     @class wxGrid
1608
1609     wxGrid and its related classes are used for displaying and editing tabular
1610     data. They provide a rich set of features for display, editing, and
1611     interacting with a variety of data sources. For simple applications, and to
1612     help you get started, wxGrid is the only class you need to refer to
1613     directly. It will set up default instances of the other classes and manage
1614     them for you. For more complex applications you can derive your own classes
1615     for custom grid views, grid data tables, cell editors and renderers. The
1616     @ref overview_grid has examples of simple and more complex applications,
1617     explains the relationship between the various grid classes and has a
1618     summary of the keyboard shortcuts and mouse functions provided by wxGrid.
1619
1620     A wxGridTableBase class holds the actual data to be displayed by a wxGrid
1621     class. One or more wxGrid classes may act as a view for one table class.
1622     The default table class is called wxGridStringTable and holds an array of
1623     strings. An instance of such a class is created by CreateGrid().
1624
1625     wxGridCellRenderer is the abstract base class for rendereing contents in a
1626     cell. The following renderers are predefined:
1627
1628     - wxGridCellBoolRenderer
1629     - wxGridCellFloatRenderer
1630     - wxGridCellNumberRenderer
1631     - wxGridCellStringRenderer
1632
1633     The look of a cell can be further defined using wxGridCellAttr. An object
1634     of this type may be returned by wxGridTableBase::GetAttr().
1635
1636     wxGridCellEditor is the abstract base class for editing the value of a
1637     cell. The following editors are predefined:
1638
1639     - wxGridCellBoolEditor
1640     - wxGridCellChoiceEditor
1641     - wxGridCellFloatEditor
1642     - wxGridCellNumberEditor
1643     - wxGridCellTextEditor
1644
1645     Please see wxGridEvent, wxGridSizeEvent, wxGridRangeSelectEvent, and
1646     wxGridEditorCreatedEvent for the documentation of all event types you can
1647     use with wxGrid.
1648
1649     @library{wxadv}
1650     @category{grid}
1651
1652     @see @ref overview_grid, wxGridUpdateLocker
1653 */
1654 class wxGrid : public wxScrolledWindow
1655 {
1656 public:
1657
1658     /**
1659         Different selection modes supported by the grid.
1660      */
1661     enum wxGridSelectionModes
1662     {
1663         /**
1664             The default selection mode allowing selection of the individual
1665             cells as well as of the entire rows and columns.
1666          */
1667         wxGridSelectCells,
1668
1669         /**
1670             The selection mode allowing the selection of the entire rows only.
1671
1672             The user won't be able to select any cells or columns in this mode.
1673          */
1674         wxGridSelectRows,
1675
1676         /**
1677             The selection mode allowing the selection of the entire columns only.
1678
1679             The user won't be able to select any cells or rows in this mode.
1680          */
1681         wxGridSelectColumns
1682     };
1683
1684     /**
1685         Return values for GetCellSize().
1686
1687         @since 2.9.1
1688      */
1689     enum CellSpan
1690     {
1691         /// This cell is inside a span covered by another cell.
1692         CellSpan_Inside = -1,
1693
1694         /// This is a normal, non-spanning cell.
1695         CellSpan_None = 0,
1696
1697         /// This cell spans several physical wxGrid cells.
1698         CellSpan_Main
1699     };
1700
1701     /**
1702         @name Constructors and Initialization
1703      */
1704     //@{
1705
1706     /**
1707         Default constructor.
1708
1709         You must call Create() to really create the grid window and also call
1710         CreateGrid() or SetTable() to initialize the grid contents.
1711      */
1712     wxGrid();
1713     /**
1714         Constructor creating the grid window.
1715
1716         You must call either CreateGrid() or SetTable() to initialize the grid
1717         contents before using it.
1718     */
1719     wxGrid(wxWindow* parent, wxWindowID id,
1720            const wxPoint& pos = wxDefaultPosition,
1721            const wxSize& size = wxDefaultSize,
1722            long style = wxWANTS_CHARS,
1723            const wxString& name = wxGridNameStr);
1724
1725     /**
1726         Destructor.
1727
1728         This will also destroy the associated grid table unless you passed a
1729         table object to the grid and specified that the grid should not take
1730         ownership of the table (see SetTable()).
1731     */
1732     virtual ~wxGrid();
1733
1734     /**
1735         Creates the grid window for an object initialized using the default
1736         constructor.
1737
1738         You must call either CreateGrid() or SetTable() to initialize the grid
1739         contents before using it.
1740      */
1741     bool Create(wxWindow* parent, wxWindowID id,
1742                 const wxPoint& pos = wxDefaultPosition,
1743                 const wxSize& size = wxDefaultSize,
1744                 long style = wxWANTS_CHARS,
1745                 const wxString& name = wxGridNameStr);
1746
1747     /**
1748         Creates a grid with the specified initial number of rows and columns.
1749
1750         Call this directly after the grid constructor. When you use this
1751         function wxGrid will create and manage a simple table of string values
1752         for you. All of the grid data will be stored in memory.
1753
1754         For applications with more complex data types or relationships, or for
1755         dealing with very large datasets, you should derive your own grid table
1756         class and pass a table object to the grid with SetTable().
1757     */
1758     bool CreateGrid(int numRows, int numCols,
1759                     wxGridSelectionModes selmode = wxGridSelectCells);
1760
1761     /**
1762         Passes a pointer to a custom grid table to be used by the grid.
1763
1764         This should be called after the grid constructor and before using the
1765         grid object. If @a takeOwnership is set to @true then the table will be
1766         deleted by the wxGrid destructor.
1767
1768         Use this function instead of CreateGrid() when your application
1769         involves complex or non-string data or data sets that are too large to
1770         fit wholly in memory.
1771     */
1772     bool SetTable(wxGridTableBase* table, bool takeOwnership = false,
1773                   wxGridSelectionModes selmode = wxGridSelectCells);
1774
1775     //@}
1776
1777
1778     /**
1779         @name Grid Line Formatting
1780      */
1781     //@{
1782
1783     /**
1784         Turns the drawing of grid lines on or off.
1785     */
1786     void EnableGridLines(bool enable = true);
1787
1788     /**
1789         Returns the pen used for vertical grid lines.
1790
1791         This virtual function may be overridden in derived classes in order to
1792         change the appearance of individual grid lines for the given column
1793         @a col.
1794
1795         See GetRowGridLinePen() for an example.
1796     */
1797     virtual wxPen GetColGridLinePen(int col);
1798
1799     /**
1800         Returns the pen used for grid lines.
1801
1802         This virtual function may be overridden in derived classes in order to
1803         change the appearance of grid lines. Note that currently the pen width
1804         must be 1.
1805
1806         @see GetColGridLinePen(), GetRowGridLinePen()
1807     */
1808     virtual wxPen GetDefaultGridLinePen();
1809
1810     /**
1811         Returns the colour used for grid lines.
1812
1813         @see GetDefaultGridLinePen()
1814     */
1815     wxColour GetGridLineColour() const;
1816
1817     /**
1818         Returns the pen used for horizontal grid lines.
1819
1820         This virtual function may be overridden in derived classes in order to
1821         change the appearance of individual grid line for the given @a row.
1822
1823         Example:
1824         @code
1825         // in a grid displaying music notation, use a solid black pen between
1826         // octaves (C0=row 127, C1=row 115 etc.)
1827         wxPen MidiGrid::GetRowGridLinePen(int row)
1828         {
1829             if ( row % 12 == 7 )
1830                 return wxPen(*wxBLACK, 1, wxSOLID);
1831             else
1832                 return GetDefaultGridLinePen();
1833         }
1834         @endcode
1835     */
1836     virtual wxPen GetRowGridLinePen(int row);
1837
1838     /**
1839         Returns @true if drawing of grid lines is turned on, @false otherwise.
1840     */
1841     bool GridLinesEnabled() const;
1842
1843     /**
1844         Sets the colour used to draw grid lines.
1845     */
1846     void SetGridLineColour(const wxColour& colour);
1847
1848     //@}
1849
1850
1851     /**
1852         @name Label Values and Formatting
1853      */
1854     //@{
1855
1856     /**
1857         Sets the arguments to the current column label alignment values.
1858
1859         Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
1860         or @c wxALIGN_RIGHT.
1861
1862         Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
1863         @c wxALIGN_BOTTOM.
1864     */
1865     void GetColLabelAlignment(int* horiz, int* vert) const;
1866
1867     /**
1868         Returns the orientation of the column labels (either @c wxHORIZONTAL or
1869         @c wxVERTICAL).
1870     */
1871     int GetColLabelTextOrientation() const;
1872
1873     /**
1874         Returns the specified column label.
1875
1876         The default grid table class provides column labels of the form
1877         A,B...Z,AA,AB...ZZ,AAA... If you are using a custom grid table you can
1878         override wxGridTableBase::GetColLabelValue() to provide your own
1879         labels.
1880     */
1881     wxString GetColLabelValue(int col) const;
1882
1883     /**
1884         Returns the colour used for the background of row and column labels.
1885     */
1886     wxColour GetLabelBackgroundColour() const;
1887
1888     /**
1889         Returns the font used for row and column labels.
1890     */
1891     wxFont GetLabelFont() const;
1892
1893     /**
1894         Returns the colour used for row and column label text.
1895     */
1896     wxColour GetLabelTextColour() const;
1897
1898     /**
1899         Returns the alignment used for row labels.
1900
1901         Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
1902         or @c wxALIGN_RIGHT.
1903
1904         Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
1905         @c wxALIGN_BOTTOM.
1906     */
1907     void GetRowLabelAlignment(int* horiz, int* vert) const;
1908
1909     /**
1910         Returns the specified row label.
1911
1912         The default grid table class provides numeric row labels. If you are
1913         using a custom grid table you can override
1914         wxGridTableBase::GetRowLabelValue() to provide your own labels.
1915     */
1916     wxString GetRowLabelValue(int row) const;
1917
1918     /**
1919         Hides the column labels by calling SetColLabelSize() with a size of 0.
1920         Show labels again by calling that method with a width greater than 0.
1921     */
1922     void HideColLabels();
1923
1924     /**
1925         Hides the row labels by calling SetRowLabelSize() with a size of 0.
1926
1927         The labels can be shown again by calling SetRowLabelSize() with a width
1928         greater than 0.
1929     */
1930     void HideRowLabels();
1931
1932     /**
1933         Sets the horizontal and vertical alignment of column label text.
1934
1935         Horizontal alignment should be one of @c wxALIGN_LEFT,
1936         @c wxALIGN_CENTRE or @c wxALIGN_RIGHT. Vertical alignment should be one
1937         of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
1938     */
1939     void SetColLabelAlignment(int horiz, int vert);
1940
1941     /**
1942         Sets the orientation of the column labels (either @c wxHORIZONTAL or
1943         @c wxVERTICAL).
1944     */
1945     void SetColLabelTextOrientation(int textOrientation);
1946
1947     /**
1948         Set the value for the given column label.
1949
1950         If you are using a custom grid table you must override
1951         wxGridTableBase::SetColLabelValue() for this to have any effect.
1952     */
1953     void SetColLabelValue(int col, const wxString& value);
1954
1955     /**
1956         Sets the background colour for row and column labels.
1957     */
1958     void SetLabelBackgroundColour(const wxColour& colour);
1959
1960     /**
1961         Sets the font for row and column labels.
1962     */
1963     void SetLabelFont(const wxFont& font);
1964
1965     /**
1966         Sets the colour for row and column label text.
1967     */
1968     void SetLabelTextColour(const wxColour& colour);
1969
1970     /**
1971         Sets the horizontal and vertical alignment of row label text.
1972
1973         Horizontal alignment should be one of @c wxALIGN_LEFT,
1974         @c wxALIGN_CENTRE or @c wxALIGN_RIGHT. Vertical alignment should be one
1975         of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
1976     */
1977     void SetRowLabelAlignment(int horiz, int vert);
1978
1979     /**
1980         Sets the value for the given row label.
1981
1982         If you are using a derived grid table you must override
1983         wxGridTableBase::SetRowLabelValue() for this to have any effect.
1984     */
1985     void SetRowLabelValue(int row, const wxString& value);
1986
1987     /**
1988         Call this in order to make the column labels use a native look by using
1989         wxRendererNative::DrawHeaderButton() internally.
1990
1991         There is no equivalent method for drawing row columns as there is not
1992         native look for that. This option is useful when using wxGrid for
1993         displaying tables and not as a spread-sheet.
1994
1995         @see UseNativeColHeader()
1996     */
1997     void SetUseNativeColLabels(bool native = true);
1998
1999     /**
2000         Enable the use of native header window for column labels.
2001
2002         If this function is called with @true argument, a wxHeaderCtrl is used
2003         instead to display the column labels instead of drawing them in wxGrid
2004         code itself. This has the advantage of making the grid look and feel
2005         perfectly the same as native applications (using SetUseNativeColLabels()
2006         the grid can be made to look more natively but it still doesn't feel
2007         natively, notably the column resizing and dragging still works slightly
2008         differently as it is implemented in wxWidgets itself) but results in
2009         different behaviour for column and row headers, for which there is no
2010         equivalent function, and, most importantly, is unsuitable for grids
2011         with huge numbers of columns as wxHeaderCtrl doesn't support virtual
2012         mode. Because of this, by default the grid does not use the native
2013         header control but you should call this function to enable it if you
2014         are using the grid to display tabular data and don't have thousands of
2015         columns in it.
2016
2017         Also note that currently @c wxEVT_GRID_LABEL_LEFT_DCLICK and
2018         @c wxEVT_GRID_LABEL_RIGHT_DCLICK events are not generated for the column
2019         labels if the native columns header is used (but this limitation could
2020         possibly be lifted in the future).
2021      */
2022     void UseNativeColHeader(bool native = true);
2023
2024     //@}
2025
2026
2027     /**
2028         @name Cell Formatting
2029
2030         Note that wxGridCellAttr can be used alternatively to most of these
2031         methods. See the "Attributes Management" of wxGridTableBase.
2032      */
2033     //@{
2034
2035     /**
2036         Sets the arguments to the horizontal and vertical text alignment values
2037         for the grid cell at the specified location.
2038
2039         Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
2040         or @c wxALIGN_RIGHT.
2041
2042         Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
2043         @c wxALIGN_BOTTOM.
2044     */
2045     void GetCellAlignment(int row, int col, int* horiz, int* vert) const;
2046
2047     /**
2048         Returns the background colour of the cell at the specified location.
2049     */
2050     wxColour GetCellBackgroundColour(int row, int col) const;
2051
2052     /**
2053         Returns the font for text in the grid cell at the specified location.
2054     */
2055     wxFont GetCellFont(int row, int col) const;
2056
2057     /**
2058         Returns the text colour for the grid cell at the specified location.
2059     */
2060     wxColour GetCellTextColour(int row, int col) const;
2061
2062     /**
2063         Returns the default cell alignment.
2064
2065         Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
2066         or @c wxALIGN_RIGHT.
2067
2068         Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
2069         @c wxALIGN_BOTTOM.
2070
2071         @see SetDefaultCellAlignment()
2072     */
2073     void GetDefaultCellAlignment(int* horiz, int* vert) const;
2074
2075     /**
2076         Returns the current default background colour for grid cells.
2077     */
2078     wxColour GetDefaultCellBackgroundColour() const;
2079
2080     /**
2081         Returns the current default font for grid cell text.
2082     */
2083     wxFont GetDefaultCellFont() const;
2084
2085     /**
2086         Returns the current default colour for grid cell text.
2087     */
2088     wxColour GetDefaultCellTextColour() const;
2089
2090     /**
2091         Sets the horizontal and vertical alignment for grid cell text at the
2092         specified location.
2093
2094         Horizontal alignment should be one of @c wxALIGN_LEFT,
2095         @c wxALIGN_CENTRE or @c wxALIGN_RIGHT.
2096
2097         Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
2098         or @c wxALIGN_BOTTOM.
2099     */
2100     void SetCellAlignment(int row, int col, int horiz, int vert);
2101     /**
2102         Sets the horizontal and vertical alignment for grid cell text at the
2103         specified location.
2104
2105         Horizontal alignment should be one of @c wxALIGN_LEFT,
2106         @c wxALIGN_CENTRE or @c wxALIGN_RIGHT.
2107
2108         Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
2109         or @c wxALIGN_BOTTOM.
2110     */
2111     void SetCellAlignment(int align, int row, int col);
2112
2113     /**
2114         Set the background colour for the given cell or all cells by default.
2115     */
2116     void SetCellBackgroundColour(int row, int col, const wxColour& colour);
2117
2118     /**
2119         Sets the font for text in the grid cell at the specified location.
2120     */
2121     void SetCellFont(int row, int col, const wxFont& font);
2122
2123     /**
2124         Sets the text colour for the given cell.
2125     */
2126     void SetCellTextColour(int row, int col, const wxColour& colour);
2127     /**
2128         Sets the text colour for the given cell.
2129     */
2130     void SetCellTextColour(const wxColour& val, int row, int col);
2131     /**
2132         Sets the text colour for all cells by default.
2133     */
2134     void SetCellTextColour(const wxColour& colour);
2135
2136     /**
2137         Sets the default horizontal and vertical alignment for grid cell text.
2138
2139         Horizontal alignment should be one of @c wxALIGN_LEFT,
2140         @c wxALIGN_CENTRE or @c wxALIGN_RIGHT. Vertical alignment should be one
2141         of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
2142     */
2143     void SetDefaultCellAlignment(int horiz, int vert);
2144
2145     /**
2146         Sets the default background colour for grid cells.
2147     */
2148     void SetDefaultCellBackgroundColour(const wxColour& colour);
2149
2150     /**
2151         Sets the default font to be used for grid cell text.
2152     */
2153     void SetDefaultCellFont(const wxFont& font);
2154
2155     /**
2156         Sets the current default colour for grid cell text.
2157     */
2158     void SetDefaultCellTextColour(const wxColour& colour);
2159
2160     //@}
2161
2162
2163     /**
2164         @name Cell Values, Editors, and Renderers
2165
2166         Note that wxGridCellAttr can be used alternatively to most of these
2167         methods. See the "Attributes Management" of wxGridTableBase.
2168      */
2169     //@{
2170
2171     /**
2172         Returns @true if the in-place edit control for the current grid cell
2173         can be used and @false otherwise.
2174
2175         This function always returns @false for the read-only cells.
2176     */
2177     bool CanEnableCellControl() const;
2178
2179     /**
2180         Disables in-place editing of grid cells.
2181
2182         Equivalent to calling EnableCellEditControl(@false).
2183     */
2184     void DisableCellEditControl();
2185
2186     /**
2187         Enables or disables in-place editing of grid cell data.
2188
2189         The grid will issue either a @c wxEVT_GRID_EDITOR_SHOWN or
2190         @c wxEVT_GRID_EDITOR_HIDDEN event.
2191     */
2192     void EnableCellEditControl(bool enable = true);
2193
2194     /**
2195         Makes the grid globally editable or read-only.
2196
2197         If the edit argument is @false this function sets the whole grid as
2198         read-only. If the argument is @true the grid is set to the default
2199         state where cells may be editable. In the default state you can set
2200         single grid cells and whole rows and columns to be editable or
2201         read-only via wxGridCellAttr::SetReadOnly(). For single cells you
2202         can also use the shortcut function SetReadOnly().
2203
2204         For more information about controlling grid cell attributes see the
2205         wxGridCellAttr class and the @ref overview_grid.
2206     */
2207     void EnableEditing(bool edit);
2208
2209     /**
2210         Returns a pointer to the editor for the cell at the specified location.
2211
2212         See wxGridCellEditor and the @ref overview_grid for more information
2213         about cell editors and renderers.
2214
2215         The caller must call DecRef() on the returned pointer.
2216     */
2217     wxGridCellEditor* GetCellEditor(int row, int col) const;
2218
2219     /**
2220         Returns a pointer to the renderer for the grid cell at the specified
2221         location.
2222
2223         See wxGridCellRenderer and the @ref overview_grid for more information
2224         about cell editors and renderers.
2225
2226         The caller must call DecRef() on the returned pointer.
2227     */
2228     wxGridCellRenderer* GetCellRenderer(int row, int col) const;
2229
2230     /**
2231         Returns the string contained in the cell at the specified location.
2232
2233         For simple applications where a grid object automatically uses a
2234         default grid table of string values you use this function together with
2235         SetCellValue() to access cell values. For more complex applications
2236         where you have derived your own grid table class that contains various
2237         data types (e.g. numeric, boolean or user-defined custom types) then
2238         you only use this function for those cells that contain string values.
2239
2240         See wxGridTableBase::CanGetValueAs() and the @ref overview_grid for
2241         more information.
2242     */
2243     wxString GetCellValue(int row, int col) const;
2244     /**
2245         Returns the string contained in the cell at the specified location.
2246
2247         For simple applications where a grid object automatically uses a
2248         default grid table of string values you use this function together with
2249         SetCellValue() to access cell values. For more complex applications
2250         where you have derived your own grid table class that contains various
2251         data types (e.g. numeric, boolean or user-defined custom types) then
2252         you only use this function for those cells that contain string values.
2253
2254         See wxGridTableBase::CanGetValueAs() and the @ref overview_grid for
2255         more information.
2256     */
2257     wxString GetCellValue(const wxGridCellCoords& coords) const;
2258
2259     /**
2260         Returns a pointer to the current default grid cell editor.
2261
2262         See wxGridCellEditor and the @ref overview_grid for more information
2263         about cell editors and renderers.
2264     */
2265     wxGridCellEditor* GetDefaultEditor() const;
2266
2267     /**
2268         Returns the default editor for the specified cell.
2269
2270         The base class version returns the editor appropriate for the current
2271         cell type but this method may be overridden in the derived classes to
2272         use custom editors for some cells by default.
2273
2274         Notice that the same may be achieved in a usually simpler way by
2275         associating a custom editor with the given cell or cells.
2276
2277         The caller must call DecRef() on the returned pointer.
2278     */
2279     virtual wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
2280     /**
2281         Returns the default editor for the specified cell.
2282
2283         The base class version returns the editor appropriate for the current
2284         cell type but this method may be overridden in the derived classes to
2285         use custom editors for some cells by default.
2286
2287         Notice that the same may be achieved in a usually simpler way by
2288         associating a custom editor with the given cell or cells.
2289
2290         The caller must call DecRef() on the returned pointer.
2291     */
2292     wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const;
2293
2294     /**
2295         Returns the default editor for the cells containing values of the given
2296         type.
2297
2298         The base class version returns the editor which was associated with the
2299         specified @a typeName when it was registered RegisterDataType() but
2300         this function may be overridden to return something different. This
2301         allows to override an editor used for one of the standard types.
2302
2303         The caller must call DecRef() on the returned pointer.
2304     */
2305     virtual wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
2306
2307     /**
2308         Returns a pointer to the current default grid cell renderer.
2309
2310         See wxGridCellRenderer and the @ref overview_grid for more information
2311         about cell editors and renderers.
2312
2313         The caller must call DecRef() on the returned pointer.
2314     */
2315     wxGridCellRenderer* GetDefaultRenderer() const;
2316
2317     /**
2318         Returns the default renderer for the given cell.
2319
2320         The base class version returns the renderer appropriate for the current
2321         cell type but this method may be overridden in the derived classes to
2322         use custom renderers for some cells by default.
2323
2324         The caller must call DecRef() on the returned pointer.
2325     */
2326     virtual wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
2327
2328     /**
2329         Returns the default renderer for the cell containing values of the
2330         given type.
2331
2332         @see GetDefaultEditorForType()
2333     */
2334     virtual wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
2335
2336     /**
2337         Hides the in-place cell edit control.
2338     */
2339     void HideCellEditControl();
2340
2341     /**
2342         Returns @true if the in-place edit control is currently enabled.
2343     */
2344     bool IsCellEditControlEnabled() const;
2345
2346     /**
2347         Returns @true if the current cell is read-only.
2348
2349         @see SetReadOnly(), IsReadOnly()
2350     */
2351     bool IsCurrentCellReadOnly() const;
2352
2353     /**
2354         Returns @false if the whole grid has been set as read-only or @true
2355         otherwise.
2356
2357         See EnableEditing() for more information about controlling the editing
2358         status of grid cells.
2359     */
2360     bool IsEditable() const;
2361
2362     /**
2363         Returns @true if the cell at the specified location can't be edited.
2364
2365         @see SetReadOnly(), IsCurrentCellReadOnly()
2366     */
2367     bool IsReadOnly(int row, int col) const;
2368
2369     /**
2370         Register a new data type.
2371
2372         The data types allow to naturally associate specific renderers and
2373         editors to the cells containing values of the given type. For example,
2374         the grid automatically registers a data type with the name
2375         @c wxGRID_VALUE_STRING which uses wxGridCellStringRenderer and
2376         wxGridCellTextEditor as its renderer and editor respectively -- this is
2377         the data type used by all the cells of the default wxGridStringTable,
2378         so this renderer and editor are used by default for all grid cells.
2379
2380         However if a custom table returns @c wxGRID_VALUE_BOOL from its
2381         wxGridTableBase::GetTypeName() method, then wxGridCellBoolRenderer and
2382         wxGridCellBoolEditor are used for it because the grid also registers a
2383         boolean data type with this name.
2384
2385         And as this mechanism is completely generic, you may register your own
2386         data types using your own custom renderers and editors. Just remember
2387         that the table must identify a cell as being of the given type for them
2388         to be used for this cell.
2389
2390         @param typeName
2391             Name of the new type. May be any string, but if the type name is
2392             the same as the name of an already registered type, including one
2393             of the standard ones (which are @c wxGRID_VALUE_STRING, @c
2394             wxGRID_VALUE_BOOL, @c wxGRID_VALUE_NUMBER, @c wxGRID_VALUE_FLOAT
2395             and @c wxGRID_VALUE_CHOICE), then the new registration information
2396             replaces the previously used renderer and editor.
2397         @param renderer
2398             The renderer to use for the cells of this type. Its ownership is
2399             taken by the grid, i.e. it will call DecRef() on this pointer when
2400             it doesn't need it any longer.
2401         @param editor
2402             The editor to use for the cells of this type. Its ownership is also
2403             taken by the grid.
2404     */
2405     void RegisterDataType(const wxString& typeName,
2406                           wxGridCellRenderer* renderer,
2407                           wxGridCellEditor* editor);
2408
2409     /**
2410         Sets the value of the current grid cell to the current in-place edit
2411         control value.
2412
2413         This is called automatically when the grid cursor moves from the
2414         current cell to a new cell. It is also a good idea to call this
2415         function when closing a grid since any edits to the final cell location
2416         will not be saved otherwise.
2417     */
2418     void SaveEditControlValue();
2419
2420     /**
2421         Sets the editor for the grid cell at the specified location.
2422
2423         The grid will take ownership of the pointer.
2424
2425         See wxGridCellEditor and the @ref overview_grid for more information
2426         about cell editors and renderers.
2427     */
2428     void SetCellEditor(int row, int col, wxGridCellEditor* editor);
2429
2430     /**
2431         Sets the renderer for the grid cell at the specified location.
2432
2433         The grid will take ownership of the pointer.
2434
2435         See wxGridCellRenderer and the @ref overview_grid for more information
2436         about cell editors and renderers.
2437     */
2438     void SetCellRenderer(int row, int col, wxGridCellRenderer* renderer);
2439
2440     /**
2441         Sets the string value for the cell at the specified location.
2442
2443         For simple applications where a grid object automatically uses a
2444         default grid table of string values you use this function together with
2445         GetCellValue() to access cell values. For more complex applications
2446         where you have derived your own grid table class that contains various
2447         data types (e.g. numeric, boolean or user-defined custom types) then
2448         you only use this function for those cells that contain string values.
2449
2450         See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
2451         more information.
2452     */
2453     void SetCellValue(int row, int col, const wxString& s);
2454     /**
2455         Sets the string value for the cell at the specified location.
2456
2457         For simple applications where a grid object automatically uses a
2458         default grid table of string values you use this function together with
2459         GetCellValue() to access cell values. For more complex applications
2460         where you have derived your own grid table class that contains various
2461         data types (e.g. numeric, boolean or user-defined custom types) then
2462         you only use this function for those cells that contain string values.
2463
2464         See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
2465         more information.
2466     */
2467     void SetCellValue(const wxGridCellCoords& coords, const wxString& s);
2468     /**
2469         @deprecated Please use SetCellValue(int,int,const wxString&) or
2470                     SetCellValue(const wxGridCellCoords&,const wxString&)
2471                     instead.
2472
2473         Sets the string value for the cell at the specified location.
2474
2475         For simple applications where a grid object automatically uses a
2476         default grid table of string values you use this function together with
2477         GetCellValue() to access cell values. For more complex applications
2478         where you have derived your own grid table class that contains various
2479         data types (e.g. numeric, boolean or user-defined custom types) then
2480         you only use this function for those cells that contain string values.
2481
2482         See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
2483         more information.
2484     */
2485     void SetCellValue(const wxString& val, int row, int col);
2486
2487     /**
2488         Sets the specified column to display boolean values.
2489
2490         @see SetColFormatCustom()
2491     */
2492     void SetColFormatBool(int col);
2493
2494     /**
2495         Sets the specified column to display data in a custom format.
2496
2497         This method provides an alternative to defining a custom grid table
2498         which would return @a typeName from its GetTypeName() method for the
2499         cells in this column: while it doesn't really change the type of the
2500         cells in this column, it does associate the renderer and editor used
2501         for the cells of the specified type with them.
2502
2503         See the @ref overview_grid for more information on working with custom
2504         data types.
2505     */
2506     void SetColFormatCustom(int col, const wxString& typeName);
2507
2508     /**
2509         Sets the specified column to display floating point values with the
2510         given width and precision.
2511
2512         @see SetColFormatCustom()
2513     */
2514     void SetColFormatFloat(int col, int width = -1, int precision = -1);
2515
2516     /**
2517         Sets the specified column to display integer values.
2518
2519         @see SetColFormatCustom()
2520     */
2521     void SetColFormatNumber(int col);
2522
2523     /**
2524         Sets the default editor for grid cells.
2525
2526         The grid will take ownership of the pointer.
2527
2528         See wxGridCellEditor and the @ref overview_grid for more information
2529         about cell editors and renderers.
2530     */
2531     void SetDefaultEditor(wxGridCellEditor* editor);
2532
2533     /**
2534         Sets the default renderer for grid cells.
2535
2536         The grid will take ownership of the pointer.
2537
2538         See wxGridCellRenderer and the @ref overview_grid for more information
2539         about cell editors and renderers.
2540     */
2541     void SetDefaultRenderer(wxGridCellRenderer* renderer);
2542
2543     /**
2544         Makes the cell at the specified location read-only or editable.
2545
2546         @see IsReadOnly()
2547     */
2548     void SetReadOnly(int row, int col, bool isReadOnly = true);
2549
2550     /**
2551         Displays the in-place cell edit control for the current cell.
2552     */
2553     void ShowCellEditControl();
2554
2555     //@}
2556
2557
2558     /**
2559         @name Column and Row Sizes
2560
2561         @see @ref overview_grid_resizing
2562      */
2563     //@{
2564
2565     /**
2566         Automatically sets the height and width of all rows and columns to fit
2567         their contents.
2568     */
2569     void AutoSize();
2570
2571     /**
2572         Automatically adjusts width of the column to fit its label.
2573     */
2574     void AutoSizeColLabelSize(int col);
2575
2576     /**
2577         Automatically sizes the column to fit its contents. If @a setAsMin is
2578         @true the calculated width will also be set as the minimal width for
2579         the column.
2580     */
2581     void AutoSizeColumn(int col, bool setAsMin = true);
2582
2583     /**
2584         Automatically sizes all columns to fit their contents. If @a setAsMin
2585         is @true the calculated widths will also be set as the minimal widths
2586         for the columns.
2587     */
2588     void AutoSizeColumns(bool setAsMin = true);
2589
2590     /**
2591         Automatically sizes the row to fit its contents. If @a setAsMin is
2592         @true the calculated height will also be set as the minimal height for
2593         the row.
2594     */
2595     void AutoSizeRow(int row, bool setAsMin = true);
2596
2597     /**
2598         Automatically adjusts height of the row to fit its label.
2599     */
2600     void AutoSizeRowLabelSize(int col);
2601
2602     /**
2603         Automatically sizes all rows to fit their contents. If @a setAsMin is
2604         @true the calculated heights will also be set as the minimal heights
2605         for the rows.
2606     */
2607     void AutoSizeRows(bool setAsMin = true);
2608
2609     /**
2610         Returns the current height of the column labels.
2611     */
2612     int GetColLabelSize() const;
2613
2614     /**
2615         Returns the minimal width to which a column may be resized.
2616
2617         Use SetColMinimalAcceptableWidth() to change this value globally or
2618         SetColMinimalWidth() to do it for individual columns.
2619
2620         @see GetRowMinimalAcceptableHeight()
2621     */
2622     int GetColMinimalAcceptableWidth() const;
2623
2624     /**
2625         Returns the width of the specified column.
2626     */
2627     int GetColSize(int col) const;
2628
2629     /**
2630         Returns @true if the specified column is not currently hidden.
2631      */
2632     bool IsColShown(int col) const;
2633
2634     /**
2635         Returns the default height for column labels.
2636     */
2637     int GetDefaultColLabelSize() const;
2638
2639     /**
2640         Returns the current default width for grid columns.
2641     */
2642     int GetDefaultColSize() const;
2643
2644     /**
2645         Returns the default width for the row labels.
2646     */
2647     int GetDefaultRowLabelSize() const;
2648
2649     /**
2650         Returns the current default height for grid rows.
2651     */
2652     int GetDefaultRowSize() const;
2653
2654     /**
2655         Returns the minimal size to which rows can be resized.
2656
2657         Use SetRowMinimalAcceptableHeight() to change this value globally or
2658         SetRowMinimalHeight() to do it for individual cells.
2659
2660         @see GetColMinimalAcceptableWidth()
2661     */
2662     int GetRowMinimalAcceptableHeight() const;
2663
2664     /**
2665         Returns the current width of the row labels.
2666     */
2667     int GetRowLabelSize() const;
2668
2669     /**
2670         Returns the height of the specified row.
2671     */
2672     int GetRowSize(int row) const;
2673
2674     /**
2675         Returns @true if the specified row is not currently hidden.
2676      */
2677     bool IsRowShown(int row) const;
2678
2679     /**
2680         Sets the height of the column labels.
2681
2682         If @a height equals to @c wxGRID_AUTOSIZE then height is calculated
2683         automatically so that no label is truncated. Note that this could be
2684         slow for a large table.
2685     */
2686     void SetColLabelSize(int height);
2687
2688     /**
2689         Sets the minimal @a width to which the user can resize columns.
2690
2691         @see GetColMinimalAcceptableWidth()
2692     */
2693     void SetColMinimalAcceptableWidth(int width);
2694
2695     /**
2696         Sets the minimal @a width for the specified column @a col.
2697
2698         It is usually best to call this method during grid creation as calling
2699         it later will not resize the column to the given minimal width even if
2700         it is currently narrower than it.
2701
2702         @a width must be greater than the minimal acceptable column width as
2703         returned by GetColMinimalAcceptableWidth().
2704     */
2705     void SetColMinimalWidth(int col, int width);
2706
2707     /**
2708         Sets the width of the specified column.
2709
2710         @param col
2711             The column index.
2712         @param width
2713             The new column width in pixels, 0 to hide the column or -1 to fit
2714             the column width to its label width.
2715     */
2716     void SetColSize(int col, int width);
2717
2718     /**
2719         Hides the specified column.
2720
2721         To show the column later you need to call SetColSize() with non-0
2722         width or ShowCol().
2723
2724         @param col
2725             The column index.
2726      */
2727     void HideCol(int col);
2728
2729     /**
2730         Shows the previously hidden column by resizing it to non-0 size.
2731
2732         @see HideCol(), SetColSize()
2733      */
2734     void ShowCol(int col);
2735
2736
2737     /**
2738         Sets the default width for columns in the grid.
2739
2740         This will only affect columns subsequently added to the grid unless
2741         @a resizeExistingCols is @true.
2742
2743         If @a width is less than GetColMinimalAcceptableWidth(), then the
2744         minimal acceptable width is used instead of it.
2745     */
2746     void SetDefaultColSize(int width, bool resizeExistingCols = false);
2747
2748     /**
2749         Sets the default height for rows in the grid.
2750
2751         This will only affect rows subsequently added to the grid unless
2752         @a resizeExistingRows is @true.
2753
2754         If @a height is less than GetRowMinimalAcceptableHeight(), then the
2755         minimal acceptable heihgt is used instead of it.
2756     */
2757     void SetDefaultRowSize(int height, bool resizeExistingRows = false);
2758
2759     /**
2760         Sets the width of the row labels.
2761
2762         If @a width equals @c wxGRID_AUTOSIZE then width is calculated
2763         automatically so that no label is truncated. Note that this could be
2764         slow for a large table.
2765     */
2766     void SetRowLabelSize(int width);
2767
2768     /**
2769         Sets the minimal row @a height used by default.
2770
2771         See SetColMinimalAcceptableWidth() for more information.
2772     */
2773     void SetRowMinimalAcceptableHeight(int height);
2774
2775     /**
2776         Sets the minimal @a height for the specified @a row.
2777
2778         See SetColMinimalWidth() for more information.
2779     */
2780     void SetRowMinimalHeight(int row, int height);
2781
2782     /**
2783         Sets the height of the specified row.
2784
2785         See SetColSize() for more information.
2786     */
2787     void SetRowSize(int row, int height);
2788
2789     /**
2790         Hides the specified row.
2791
2792         To show the row later you need to call SetRowSize() with non-0
2793         width or ShowRow().
2794
2795         @param col
2796             The row index.
2797      */
2798     void HideRow(int col);
2799
2800     /**
2801         Shows the previously hidden row by resizing it to non-0 size.
2802
2803         @see HideRow(), SetRowSize()
2804      */
2805     void ShowRow(int col);
2806
2807     /**
2808         Get size information for all columns at once.
2809
2810         This method is useful when the information about all column widths
2811         needs to be saved. The widths can be later restored using
2812         SetColSizes().
2813
2814         @sa wxGridSizesInfo, GetRowSizes()
2815      */
2816     wxGridSizesInfo GetColSizes() const;
2817
2818     /**
2819         Get size information for all row at once.
2820
2821         @sa wxGridSizesInfo, GetColSizes()
2822      */
2823     wxGridSizesInfo GetRowSizes() const;
2824
2825     /**
2826         Restore all columns sizes.
2827
2828         This is usually called with wxGridSizesInfo object previously returned
2829         by GetColSizes().
2830
2831         @sa SetRowSizes()
2832      */
2833     void SetColSizes(const wxGridSizesInfo& sizeInfo);
2834
2835     /**
2836         Restore all rows sizes.
2837
2838         @sa SetColSizes()
2839      */
2840     void SetRowSizes(const wxGridSizesInfo& sizeInfo);
2841
2842     /**
2843         Set the size of the cell.
2844
2845         Specifying a value of more than 1 in @a num_rows or @a num_cols will
2846         make the cell at (@a row, @a col) span the block of the specified size,
2847         covering the other cells which would be normally shown in it. Passing 1
2848         for both arguments resets the cell to normal appearance.
2849
2850         @see GetCellSize()
2851
2852         @param row
2853             The row of the cell.
2854         @param col
2855             The column of the cell.
2856         @param num_rows
2857             Number of rows to be occupied by this cell, must be >= 1.
2858         @param num_cols
2859             Number of columns to be occupied by this cell, must be >= 1.
2860      */
2861     void SetCellSize(int row, int col, int num_rows, int num_cols);
2862
2863     /**
2864         Get the size of the cell in number of cells covered by it.
2865
2866         For normal cells, the function fills both @a num_rows and @a num_cols
2867         with 1 and returns CellSpan_None. For cells which span multiple cells, i.e.
2868         for which SetCellSize() had been called, the returned values are the
2869         same ones as were passed to SetCellSize() call and the function return
2870         value is CellSpan_Main.
2871
2872         More unexpectedly, perhaps, the returned values may be @em negative for
2873         the cells which are inside a span covered by a cell occupying multiple
2874         rows or columns. They correspond to the offset of the main cell of the
2875         span from the cell passed to this functions and the function returns
2876         CellSpan_Inside value to indicate this.
2877
2878         As an example, consider a 3*3 grid with the cell (1, 1) (the one in the
2879         middle) having a span of 2 rows and 2 columns, i.e. the grid looks like
2880         @code
2881             +----+----+----+
2882             |    |    |    |
2883             +----+----+----+
2884             |    |         |
2885             +----+         |
2886             |    |         |
2887             +----+----+----+
2888         @endcode
2889         Then the function returns 2 and 2 in @a num_rows and @a num_cols for
2890         the cell (1, 1) itself and -1 and -1 for the cell (2, 2) as well as -1
2891         and 0 for the cell (2, 1).
2892
2893         @param row
2894             The row of the cell.
2895         @param col
2896             The column of the cell.
2897         @param num_rows
2898             Pointer to variable receiving the number of rows, must not be @NULL.
2899         @param num_cols
2900             Pointer to variable receiving the number of columns, must not be
2901             @NULL.
2902         @return
2903             The kind of this cell span (the return value is new in wxWidgets
2904             2.9.1, this function was void in previous wxWidgets versions).
2905      */
2906     CellSpan GetCellSize( int row, int col, int *num_rows, int *num_cols ) const;
2907
2908     /**
2909         Get the number of rows and columns allocated for this cell.
2910
2911         This overload doesn't return a CellSpan value but the values returned
2912         may still be negative, see GetCellSize(int, int, int *, int *) for
2913         details.
2914      */
2915     wxSize GetCellSize(const wxGridCellCoords& coords);
2916
2917     //@}
2918
2919
2920     /**
2921         @name User-Resizing and Dragging
2922
2923         Functions controlling various interactive mouse operations.
2924
2925         By default, columns and rows can be resized by dragging the edges of
2926         their labels (this can be disabled using DisableDragColSize() and
2927         DisableDragRowSize() methods). And if grid line dragging is enabled with
2928         EnableDragGridSize() they can also be resized by dragging the right or
2929         bottom edge of the grid cells.
2930
2931         Columns can also be moved to interactively change their order but this
2932         needs to be explicitly enabled with EnableDragColMove().
2933      */
2934     //@{
2935
2936     /**
2937         Return @true if the dragging of cells is enabled or @false otherwise.
2938     */
2939     bool CanDragCell() const;
2940
2941     /**
2942         Returns @true if columns can be moved by dragging with the mouse.
2943
2944         Columns can be moved by dragging on their labels.
2945     */
2946     bool CanDragColMove() const;
2947
2948     /**
2949         Returns @true if the given column can be resized by dragging with the
2950         mouse.
2951
2952         This function returns @true if resizing the columns interactively is
2953         globally enabled, i.e. if DisableDragColSize() hadn't been called, and
2954         if this column wasn't explicitly marked as non-resizable with
2955         DisableColResize().
2956     */
2957     bool CanDragColSize(int col) const;
2958
2959     /**
2960         Return @true if the dragging of grid lines to resize rows and columns
2961         is enabled or @false otherwise.
2962     */
2963     bool CanDragGridSize() const;
2964
2965     /**
2966         Returns @true if the given row can be resized by dragging with the
2967         mouse.
2968
2969         This is the same as CanDragColSize() but for rows.
2970     */
2971     bool CanDragRowSize(int row) const;
2972
2973     /**
2974         Disable interactive resizing of the specified column.
2975
2976         This method allows to disable resizing of an individual column in a
2977         grid where the columns are otherwise resizable (which is the case by
2978         default).
2979
2980         Notice that currently there is no way to make some columns resizable in
2981         a grid where columns can't be resized by default as there doesn't seem
2982         to be any need for this in practice. There is also no way to make the
2983         column marked as fixed using this method resizeable again because it is
2984         supposed that fixed columns are used for static parts of the grid and
2985         so should remain fixed during the entire grid lifetime.
2986
2987         Also notice that disabling interactive column resizing will not prevent
2988         the program from changing the column size.
2989
2990         @see EnableDragColSize()
2991      */
2992     void DisableColResize(int col);
2993
2994     /**
2995         Disable interactive resizing of the specified row.
2996
2997         This is the same as DisableColResize() but for rows.
2998
2999         @see EnableDragRowSize()
3000      */
3001     void DisableRowResize(int row);
3002
3003     /**
3004         Disables column moving by dragging with the mouse.
3005
3006         Equivalent to passing @false to EnableDragColMove().
3007     */
3008     void DisableDragColMove();
3009
3010     /**
3011         Disables column sizing by dragging with the mouse.
3012
3013         Equivalent to passing @false to EnableDragColSize().
3014     */
3015     void DisableDragColSize();
3016
3017     /**
3018         Disable mouse dragging of grid lines to resize rows and columns.
3019
3020         Equivalent to passing @false to EnableDragGridSize()
3021     */
3022     void DisableDragGridSize();
3023
3024     /**
3025         Disables row sizing by dragging with the mouse.
3026
3027         Equivalent to passing @false to EnableDragRowSize().
3028     */
3029     void DisableDragRowSize();
3030
3031     /**
3032         Enables or disables cell dragging with the mouse.
3033     */
3034     void EnableDragCell(bool enable = true);
3035
3036     /**
3037         Enables or disables column moving by dragging with the mouse.
3038     */
3039     void EnableDragColMove(bool enable = true);
3040
3041     /**
3042         Enables or disables column sizing by dragging with the mouse.
3043
3044         @see DisableColResize()
3045     */
3046     void EnableDragColSize(bool enable = true);
3047
3048     /**
3049         Enables or disables row and column resizing by dragging gridlines with
3050         the mouse.
3051     */
3052     void EnableDragGridSize(bool enable = true);
3053
3054     /**
3055         Enables or disables row sizing by dragging with the mouse.
3056
3057         @see DisableRowResize()
3058     */
3059     void EnableDragRowSize(bool enable = true);
3060
3061     /**
3062         Returns the column ID of the specified column position.
3063     */
3064     int GetColAt(int colPos) const;
3065
3066     /**
3067         Returns the position of the specified column.
3068     */
3069     int GetColPos(int colID) const;
3070
3071     /**
3072         Sets the position of the specified column.
3073     */
3074     void SetColPos(int colID, int newPos);
3075
3076     /**
3077         Sets the positions of all columns at once.
3078
3079         This method takes an array containing the indices of the columns in
3080         their display order, i.e. uses the same convention as
3081         wxHeaderCtrl::SetColumnsOrder().
3082     */
3083     void SetColumnsOrder(const wxArrayInt& order);
3084
3085     /**
3086         Resets the position of the columns to the default.
3087     */
3088     void ResetColPos();
3089
3090     //@}
3091
3092
3093     /**
3094         @name Cursor Movement
3095     */
3096     //@{
3097
3098     /**
3099         Returns the current grid cell column position.
3100     */
3101     int GetGridCursorCol() const;
3102
3103     /**
3104         Returns the current grid cell row position.
3105     */
3106     int GetGridCursorRow() const;
3107
3108     /**
3109         Make the given cell current and ensure it is visible.
3110
3111         This method is equivalent to calling MakeCellVisible() and
3112         SetGridCursor() and so, as with the latter, a @c wxEVT_GRID_SELECT_CELL
3113         event is generated by it and the selected cell doesn't change if the
3114         event is vetoed.
3115      */
3116     void GoToCell(int row, int col);
3117     /**
3118         Make the given cell current and ensure it is visible.
3119
3120         This method is equivalent to calling MakeCellVisible() and
3121         SetGridCursor() and so, as with the latter, a @c wxEVT_GRID_SELECT_CELL
3122         event is generated by it and the selected cell doesn't change if the
3123         event is vetoed.
3124      */
3125     void GoToCell(const wxGridCellCoords& coords);
3126
3127     /**
3128         Moves the grid cursor down by one row.
3129
3130         If a block of cells was previously selected it will expand if the
3131         argument is @true or be cleared if the argument is @false.
3132     */
3133     bool MoveCursorDown(bool expandSelection);
3134
3135     /**
3136         Moves the grid cursor down in the current column such that it skips to
3137         the beginning or end of a block of non-empty cells.
3138
3139         If a block of cells was previously selected it will expand if the
3140         argument is @true or be cleared if the argument is @false.
3141     */
3142     bool MoveCursorDownBlock(bool expandSelection);
3143
3144     /**
3145         Moves the grid cursor left by one column.
3146
3147         If a block of cells was previously selected it will expand if the
3148         argument is @true or be cleared if the argument is @false.
3149     */
3150     bool MoveCursorLeft(bool expandSelection);
3151
3152     /**
3153         Moves the grid cursor left in the current row such that it skips to the
3154         beginning or end of a block of non-empty cells.
3155
3156         If a block of cells was previously selected it will expand if the
3157         argument is @true or be cleared if the argument is @false.
3158     */
3159     bool MoveCursorLeftBlock(bool expandSelection);
3160
3161     /**
3162         Moves the grid cursor right by one column.
3163
3164         If a block of cells was previously selected it will expand if the
3165         argument is @true or be cleared if the argument is @false.
3166     */
3167     bool MoveCursorRight(bool expandSelection);
3168
3169     /**
3170         Moves the grid cursor right in the current row such that it skips to
3171         the beginning or end of a block of non-empty cells.
3172
3173         If a block of cells was previously selected it will expand if the
3174         argument is @true or be cleared if the argument is @false.
3175     */
3176     bool MoveCursorRightBlock(bool expandSelection);
3177
3178     /**
3179         Moves the grid cursor up by one row.
3180
3181         If a block of cells was previously selected it will expand if the
3182         argument is @true or be cleared if the argument is @false.
3183     */
3184     bool MoveCursorUp(bool expandSelection);
3185
3186     /**
3187         Moves the grid cursor up in the current column such that it skips to
3188         the beginning or end of a block of non-empty cells.
3189
3190         If a block of cells was previously selected it will expand if the
3191         argument is @true or be cleared if the argument is @false.
3192     */
3193     bool MoveCursorUpBlock(bool expandSelection);
3194
3195     /**
3196         Moves the grid cursor down by some number of rows so that the previous
3197         bottom visible row becomes the top visible row.
3198     */
3199     bool MovePageDown();
3200
3201     /**
3202         Moves the grid cursor up by some number of rows so that the previous
3203         top visible row becomes the bottom visible row.
3204     */
3205     bool MovePageUp();
3206
3207     /**
3208         Set the grid cursor to the specified cell.
3209
3210         The grid cursor indicates the current cell and can be moved by the user
3211         using the arrow keys or the mouse.
3212
3213         Calling this function generates a @c wxEVT_GRID_SELECT_CELL event and
3214         if the event handler vetoes this event, the cursor is not moved.
3215
3216         This function doesn't make the target call visible, use GoToCell() to
3217         do this.
3218     */
3219     void SetGridCursor(int row, int col);
3220     /**
3221         Set the grid cursor to the specified cell.
3222
3223         The grid cursor indicates the current cell and can be moved by the user
3224         using the arrow keys or the mouse.
3225
3226         Calling this function generates a @c wxEVT_GRID_SELECT_CELL event and
3227         if the event handler vetoes this event, the cursor is not moved.
3228
3229         This function doesn't make the target call visible, use GoToCell() to
3230         do this.
3231     */
3232     void SetGridCursor(const wxGridCellCoords& coords);
3233
3234     //@}
3235
3236
3237     /**
3238         @name User Selection
3239      */
3240     //@{
3241
3242     /**
3243         Deselects all cells that are currently selected.
3244     */
3245     void ClearSelection();
3246
3247     /**
3248         Returns an array of individually selected cells.
3249
3250         Notice that this array does @em not contain all the selected cells in
3251         general as it doesn't include the cells selected as part of column, row
3252         or block selection. You must use this method, GetSelectedCols(),
3253         GetSelectedRows() and GetSelectionBlockTopLeft() and
3254         GetSelectionBlockBottomRight() methods to obtain the entire selection
3255         in general.
3256
3257         Please notice this behaviour is by design and is needed in order to
3258         support grids of arbitrary size (when an entire column is selected in
3259         a grid with a million of columns, we don't want to create an array with
3260         a million of entries in this function, instead it returns an empty
3261         array and GetSelectedCols() returns an array containing one element).
3262     */
3263     wxGridCellCoordsArray GetSelectedCells() const;
3264
3265     /**
3266         Returns an array of selected columns.
3267
3268         Please notice that this method alone is not sufficient to find all the
3269         selected columns as it contains only the columns which were
3270         individually selected but not those being part of the block selection
3271         or being selected in virtue of all of their cells being selected
3272         individually, please see GetSelectedCells() for more details.
3273     */
3274     wxArrayInt GetSelectedCols() const;
3275
3276     /**
3277         Returns an array of selected rows.
3278
3279         Please notice that this method alone is not sufficient to find all the
3280         selected rows as it contains only the rows which were individually
3281         selected but not those being part of the block selection or being
3282         selected in virtue of all of their cells being selected individually,
3283         please see GetSelectedCells() for more details.
3284     */
3285     wxArrayInt GetSelectedRows() const;
3286
3287     /**
3288         Returns the colour used for drawing the selection background.
3289     */
3290     wxColour GetSelectionBackground() const;
3291
3292     /**
3293         Returns an array of the bottom right corners of blocks of selected
3294         cells.
3295
3296         Please see GetSelectedCells() for more information about the selection
3297         representation in wxGrid.
3298
3299         @see GetSelectionBlockTopLeft()
3300     */
3301     wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
3302
3303     /**
3304         Returns an array of the top left corners of blocks of selected cells.
3305
3306         Please see GetSelectedCells() for more information about the selection
3307         representation in wxGrid.
3308
3309         @see GetSelectionBlockBottomRight()
3310     */
3311     wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
3312
3313     /**
3314         Returns the colour used for drawing the selection foreground.
3315     */
3316     wxColour GetSelectionForeground() const;
3317
3318     /**
3319         Returns the current selection mode.
3320
3321         @see SetSelectionMode().
3322     */
3323     wxGridSelectionModes GetSelectionMode() const;
3324
3325     /**
3326         Returns @true if the given cell is selected.
3327     */
3328     bool IsInSelection(int row, int col) const;
3329     /**
3330         Returns @true if the given cell is selected.
3331     */
3332     bool IsInSelection(const wxGridCellCoords& coords) const;
3333
3334     /**
3335         Returns @true if there are currently any selected cells, rows, columns
3336         or blocks.
3337     */
3338     bool IsSelection() const;
3339
3340     /**
3341         Selects all cells in the grid.
3342     */
3343     void SelectAll();
3344
3345     /**
3346         Selects a rectangular block of cells.
3347
3348         If @a addToSelected is @false then any existing selection will be
3349         deselected; if @true the column will be added to the existing
3350         selection.
3351     */
3352     void SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
3353                      bool addToSelected = false);
3354     /**
3355         Selects a rectangular block of cells.
3356
3357         If @a addToSelected is @false then any existing selection will be
3358         deselected; if @true the column will be added to the existing
3359         selection.
3360     */
3361     void SelectBlock(const wxGridCellCoords& topLeft,
3362                      const wxGridCellCoords& bottomRight,
3363                      bool addToSelected = false);
3364
3365     /**
3366         Selects the specified column.
3367
3368         If @a addToSelected is @false then any existing selection will be
3369         deselected; if @true the column will be added to the existing
3370         selection.
3371
3372         This method won't select anything if the current selection mode is
3373         wxGridSelectRows.
3374     */
3375     void SelectCol(int col, bool addToSelected = false);
3376
3377     /**
3378         Selects the specified row.
3379
3380         If @a addToSelected is @false then any existing selection will be
3381         deselected; if @true the row will be added to the existing selection.
3382
3383         This method won't select anything if the current selection mode is
3384         wxGridSelectColumns.
3385     */
3386     void SelectRow(int row, bool addToSelected = false);
3387
3388     /**
3389         Set the colour to be used for drawing the selection background.
3390     */
3391     void SetSelectionBackground(const wxColour& c);
3392
3393     /**
3394         Set the colour to be used for drawing the selection foreground.
3395     */
3396     void SetSelectionForeground(const wxColour& c);
3397
3398     /**
3399         Set the selection behaviour of the grid.
3400
3401         The existing selection is converted to conform to the new mode if
3402         possible and discarded otherwise (e.g. any individual selected cells
3403         are deselected if the new mode allows only the selection of the entire
3404         rows or columns).
3405     */
3406     void SetSelectionMode(wxGridSelectionModes selmode);
3407
3408     //@}
3409
3410
3411     /**
3412         @name Scrolling
3413      */
3414     //@{
3415
3416     /**
3417         Returns the number of pixels per horizontal scroll increment.
3418
3419         The default is 15.
3420
3421         @see GetScrollLineY(), SetScrollLineX(), SetScrollLineY()
3422     */
3423     int GetScrollLineX() const;
3424
3425     /**
3426         Returns the number of pixels per vertical scroll increment.
3427
3428         The default is 15.
3429
3430         @see GetScrollLineX(), SetScrollLineX(), SetScrollLineY()
3431     */
3432     int GetScrollLineY() const;
3433
3434     /**
3435         Returns @true if a cell is either entirely or at least partially
3436         visible in the grid window.
3437
3438         By default, the cell must be entirely visible for this function to
3439         return @true but if @a wholeCellVisible is @false, the function returns
3440         @true even if the cell is only partially visible.
3441     */
3442     bool IsVisible(int row, int col, bool wholeCellVisible = true) const;
3443     /**
3444         Returns @true if a cell is either entirely or at least partially
3445         visible in the grid window.
3446
3447         By default, the cell must be entirely visible for this function to
3448         return @true but if @a wholeCellVisible is @false, the function returns
3449         @true even if the cell is only partially visible.
3450     */
3451     bool IsVisible(const wxGridCellCoords& coords,
3452                    bool wholeCellVisible = true) const;
3453
3454     /**
3455         Brings the specified cell into the visible grid cell area with minimal
3456         scrolling.
3457
3458         Does nothing if the cell is already visible.
3459     */
3460     void MakeCellVisible(int row, int col);
3461     /**
3462         Brings the specified cell into the visible grid cell area with minimal
3463         scrolling.
3464
3465         Does nothing if the cell is already visible.
3466     */
3467     void MakeCellVisible(const wxGridCellCoords& coords);
3468
3469     /**
3470         Sets the number of pixels per horizontal scroll increment.
3471
3472         The default is 15.
3473
3474         @see GetScrollLineX(), GetScrollLineY(), SetScrollLineY()
3475     */
3476     void SetScrollLineX(int x);
3477
3478     /**
3479         Sets the number of pixels per vertical scroll increment.
3480
3481         The default is 15.
3482
3483         @see GetScrollLineX(), GetScrollLineY(), SetScrollLineX()
3484     */
3485     void SetScrollLineY(int y);
3486
3487     //@}
3488
3489
3490     /**
3491         @name Cell and Device Coordinate Translation
3492      */
3493     //@{
3494
3495     /**
3496         Convert grid cell coordinates to grid window pixel coordinates.
3497
3498         This function returns the rectangle that encloses the block of cells
3499         limited by @a topLeft and @a bottomRight cell in device coords and
3500         clipped to the client size of the grid window.
3501
3502         @see CellToRect()
3503     */
3504     wxRect BlockToDeviceRect(const wxGridCellCoords& topLeft,
3505                              const wxGridCellCoords& bottomRight) const;
3506
3507     /**
3508         Return the rectangle corresponding to the grid cell's size and position
3509         in logical coordinates.
3510
3511         @see BlockToDeviceRect()
3512     */
3513     wxRect CellToRect(int row, int col) const;
3514     /**
3515         Return the rectangle corresponding to the grid cell's size and position
3516         in logical coordinates.
3517
3518         @see BlockToDeviceRect()
3519     */
3520     wxRect CellToRect(const wxGridCellCoords& coords) const;
3521
3522     /**
3523         Returns the column at the given pixel position.
3524
3525         @param x
3526             The x position to evaluate.
3527         @param clipToMinMax
3528             If @true, rather than returning @c wxNOT_FOUND, it returns either
3529             the first or last column depending on whether @a x is too far to
3530             the left or right respectively.
3531         @return
3532             The column index or @c wxNOT_FOUND.
3533     */
3534     int XToCol(int x, bool clipToMinMax = false) const;
3535
3536     /**
3537         Returns the column whose right hand edge is close to the given logical
3538         @a x position.
3539
3540         If no column edge is near to this position @c wxNOT_FOUND is returned.
3541     */
3542     int XToEdgeOfCol(int x) const;
3543
3544     /**
3545         Translates logical pixel coordinates to the grid cell coordinates.
3546
3547         Notice that this function expects logical coordinates on input so if
3548         you use this function in a mouse event handler you need to translate
3549         the mouse position, which is expressed in device coordinates, to
3550         logical ones.
3551
3552         @see XToCol(), YToRow()
3553      */
3554     wxGridCellCoords XYToCell(int x, int y) const;
3555     /**
3556         Translates logical pixel coordinates to the grid cell coordinates.
3557
3558         Notice that this function expects logical coordinates on input so if
3559         you use this function in a mouse event handler you need to translate
3560         the mouse position, which is expressed in device coordinates, to
3561         logical ones.
3562
3563         @see XToCol(), YToRow()
3564      */
3565     wxGridCellCoords XYToCell(const wxPoint& pos) const;
3566     // XYToCell(int, int, wxGridCellCoords&) overload is intentionally
3567     // undocumented, using it is ugly and non-const reference parameters are
3568     // not used in wxWidgets API
3569
3570     /**
3571         Returns the row whose bottom edge is close to the given logical @a y
3572         position.
3573
3574         If no row edge is near to this position @c wxNOT_FOUND is returned.
3575     */
3576     int YToEdgeOfRow(int y) const;
3577
3578     /**
3579         Returns the grid row that corresponds to the logical @a y coordinate.
3580
3581         Returns @c wxNOT_FOUND if there is no row at the @a y position.
3582     */
3583     int YToRow(int y, bool clipToMinMax = false) const;
3584
3585     //@}
3586
3587
3588     /**
3589         @name Miscellaneous Functions
3590      */
3591     //@{
3592
3593     /**
3594         Appends one or more new columns to the right of the grid.
3595
3596         The @a updateLabels argument is not used at present. If you are using a
3597         derived grid table class you will need to override
3598         wxGridTableBase::AppendCols(). See InsertCols() for further
3599         information.
3600
3601         @return @true on success or @false if appending columns failed.
3602     */
3603     bool AppendCols(int numCols = 1, bool updateLabels = true);
3604
3605     /**
3606         Appends one or more new rows to the bottom of the grid.
3607
3608         The @a updateLabels argument is not used at present. If you are using a
3609         derived grid table class you will need to override
3610         wxGridTableBase::AppendRows(). See InsertRows() for further
3611         information.
3612
3613         @return @true on success or @false if appending rows failed.
3614     */
3615     bool AppendRows(int numRows = 1, bool updateLabels = true);
3616
3617     /**
3618         Return @true if the horizontal grid lines stop at the last column
3619         boundary or @false if they continue to the end of the window.
3620
3621         The default is to clip grid lines.
3622
3623         @see ClipHorzGridLines(), AreVertGridLinesClipped()
3624      */
3625     bool AreHorzGridLinesClipped() const;
3626
3627     /**
3628         Return @true if the vertical grid lines stop at the last row
3629         boundary or @false if they continue to the end of the window.
3630
3631         The default is to clip grid lines.
3632
3633         @see ClipVertGridLines(), AreHorzGridLinesClipped()
3634      */
3635     bool AreVertGridLinesClipped() const;
3636
3637     /**
3638         Increments the grid's batch count.
3639
3640         When the count is greater than zero repainting of the grid is
3641         suppressed. Each call to BeginBatch must be matched by a later call to
3642         EndBatch(). Code that does a lot of grid modification can be enclosed
3643         between BeginBatch() and EndBatch() calls to avoid screen flicker. The
3644         final EndBatch() call will cause the grid to be repainted.
3645
3646         Notice that you should use wxGridUpdateLocker which ensures that there
3647         is always a matching EndBatch() call for this BeginBatch() if possible
3648         instead of calling this method directly.
3649     */
3650     void BeginBatch();
3651
3652     /**
3653         Clears all data in the underlying grid table and repaints the grid.
3654
3655         The table is not deleted by this function. If you are using a derived
3656         table class then you need to override wxGridTableBase::Clear() for this
3657         function to have any effect.
3658     */
3659     void ClearGrid();
3660
3661     /**
3662         Change whether the horizontal grid lines are clipped by the end of the
3663         last column.
3664
3665         By default the grid lines are not drawn beyond the end of the last
3666         column but after calling this function with @a clip set to @false they
3667         will be drawn across the entire grid window.
3668
3669         @see AreHorzGridLinesClipped(), ClipVertGridLines()
3670      */
3671     void ClipHorzGridLines(bool clip);
3672
3673     /**
3674         Change whether the vertical grid lines are clipped by the end of the
3675         last row.
3676
3677         By default the grid lines are not drawn beyond the end of the last
3678         row but after calling this function with @a clip set to @false they
3679         will be drawn across the entire grid window.
3680
3681         @see AreVertGridLinesClipped(), ClipHorzGridLines()
3682      */
3683     void ClipVertGridLines(bool clip);
3684
3685     /**
3686         Deletes one or more columns from a grid starting at the specified
3687         position.
3688
3689         The @a updateLabels argument is not used at present. If you are using a
3690         derived grid table class you will need to override
3691         wxGridTableBase::DeleteCols(). See InsertCols() for further
3692         information.
3693
3694         @return @true on success or @false if deleting columns failed.
3695     */
3696     bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true);
3697
3698     /**
3699         Deletes one or more rows from a grid starting at the specified
3700         position.
3701
3702         The @a updateLabels argument is not used at present. If you are using a
3703         derived grid table class you will need to override
3704         wxGridTableBase::DeleteRows(). See InsertRows() for further
3705         information.
3706
3707         @return @true on success or @false if appending rows failed.
3708     */
3709     bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true);
3710
3711     /**
3712         Decrements the grid's batch count.
3713
3714         When the count is greater than zero repainting of the grid is
3715         suppressed. Each previous call to BeginBatch() must be matched by a
3716         later call to EndBatch(). Code that does a lot of grid modification can
3717         be enclosed between BeginBatch() and EndBatch() calls to avoid screen
3718         flicker. The final EndBatch() will cause the grid to be repainted.
3719
3720         @see wxGridUpdateLocker
3721     */
3722     void EndBatch();
3723
3724     /**
3725         Overridden wxWindow method.
3726     */
3727     virtual void Fit();
3728
3729     /**
3730         Causes immediate repainting of the grid.
3731
3732         Use this instead of the usual wxWindow::Refresh().
3733     */
3734     void ForceRefresh();
3735
3736     /**
3737         Returns the number of times that BeginBatch() has been called without
3738         (yet) matching calls to EndBatch(). While the grid's batch count is
3739         greater than zero the display will not be updated.
3740     */
3741     int GetBatchCount();
3742
3743     /**
3744         Returns the total number of grid columns.
3745
3746         This is the same as the number of columns in the underlying grid table.
3747     */
3748     int GetNumberCols() const;
3749
3750     /**
3751         Returns the total number of grid rows.
3752
3753         This is the same as the number of rows in the underlying grid table.
3754     */
3755     int GetNumberRows() const;
3756
3757     /**
3758         Returns the attribute for the given cell creating one if necessary.
3759
3760         If the cell already has an attribute, it is returned. Otherwise a new
3761         attribute is created, associated with the cell and returned. In any
3762         case the caller must call DecRef() on the returned pointer.
3763
3764         This function may only be called if CanHaveAttributes() returns @true.
3765     */
3766     wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
3767
3768     /**
3769         Returns a base pointer to the current table object.
3770
3771         The returned pointer is still owned by the grid.
3772     */
3773     wxGridTableBase *GetTable() const;
3774
3775     /**
3776         Inserts one or more new columns into a grid with the first new column
3777         at the specified position.
3778
3779         Notice that inserting the columns in the grid requires grid table
3780         cooperation: when this method is called, grid object begins by
3781         requesting the underlying grid table to insert new columns. If this is
3782         successful the table notifies the grid and the grid updates the
3783         display. For a default grid (one where you have called CreateGrid())
3784         this process is automatic. If you are using a custom grid table
3785         (specified with SetTable()) then you must override
3786         wxGridTableBase::InsertCols() in your derived table class.
3787
3788         @param pos
3789             The position which the first newly inserted column will have.
3790         @param numCols
3791             The number of columns to insert.
3792         @param updateLabels
3793             Currently not used.
3794         @return
3795             @true if the columns were successfully inserted, @false if an error
3796             occurred (most likely the table couldn't be updated).
3797     */
3798     bool InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true);
3799
3800     /**
3801         Inserts one or more new rows into a grid with the first new row at the
3802         specified position.
3803
3804         Notice that you must implement wxGridTableBase::InsertRows() if you use
3805         a grid with a custom table, please see InsertCols() for more
3806         information.
3807
3808         @param pos
3809             The position which the first newly inserted row will have.
3810         @param numRows
3811             The number of rows to insert.
3812         @param updateLabels
3813             Currently not used.
3814         @return
3815             @true if the rows were successfully inserted, @false if an error
3816             occurred (most likely the table couldn't be updated).
3817     */
3818     bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true);
3819
3820     /**
3821         Sets the cell attributes for all cells in the specified column.
3822
3823         For more information about controlling grid cell attributes see the
3824         wxGridCellAttr cell attribute class and the @ref overview_grid.
3825     */
3826     void SetColAttr(int col, wxGridCellAttr* attr);
3827
3828     /**
3829         Sets the extra margins used around the grid area.
3830
3831         A grid may occupy more space than needed for its data display and
3832         this function allows to set how big this extra space is
3833     */
3834     void SetMargins(int extraWidth, int extraHeight);
3835
3836     /**
3837         Sets the cell attributes for all cells in the specified row.
3838
3839         The grid takes ownership of the attribute pointer.
3840
3841         See the wxGridCellAttr class for more information about controlling
3842         cell attributes.
3843     */
3844     void SetRowAttr(int row, wxGridCellAttr* attr);
3845
3846     //@}
3847
3848
3849     /**
3850         @name Sorting support.
3851
3852         wxGrid doesn't provide any support for sorting the data but it does
3853         generate events allowing the user code to sort it and supports
3854         displaying the sort indicator in the column used for sorting.
3855
3856         To use wxGrid sorting support you need to handle wxEVT_GRID_COL_SORT
3857         event (and not veto it) and resort the data displayed in the grid. The
3858         grid will automatically update the sorting indicator on the column
3859         which was clicked.
3860
3861         You can also call the functions in this section directly to update the
3862         sorting indicator. Once again, they don't do anything with the grid
3863         data, it remains your responsibility to actually sort it appropriately.
3864      */
3865     //@{
3866
3867     /**
3868         Return the column in which the sorting indicator is currently
3869         displayed.
3870
3871         Returns @c wxNOT_FOUND if sorting indicator is not currently displayed
3872         at all.
3873
3874         @see SetSortingColumn()
3875      */
3876     int GetSortingColumn() const;
3877
3878     /**
3879         Return @true if this column is currently used for sorting.
3880
3881         @see GetSortingColumn()
3882      */
3883     bool IsSortingBy(int col) const;
3884
3885     /**
3886         Return @true if the current sorting order is ascending or @false if it
3887         is descending.
3888
3889         It only makes sense to call this function if GetSortingColumn() returns
3890         a valid column index and not @c wxNOT_FOUND.
3891
3892         @see SetSortingColumn()
3893      */
3894     bool IsSortOrderAscending() const;
3895
3896     /**
3897         Set the column to display the sorting indicator in and its direction.
3898
3899         @param col
3900             The column to display the sorting indicator in or @c wxNOT_FOUND to
3901             remove any currently displayed sorting indicator.
3902         @param ascending
3903             If @true, display the ascending sort indicator, otherwise display
3904             the descending sort indicator.
3905
3906         @see GetSortingColumn(), IsSortOrderAscending()
3907      */
3908     void SetSortingColumn(int col, bool ascending = true);
3909
3910     /**
3911         Remove any currently shown sorting indicator.
3912
3913         This is equivalent to calling SetSortingColumn() with @c wxNOT_FOUND
3914         first argument.
3915      */
3916     void UnsetSortingColumn();
3917     //@}
3918
3919
3920     /**
3921         @name Accessors for component windows.
3922
3923         Return the various child windows of wxGrid.
3924
3925         wxGrid is an empty parent window for 4 children representing the column
3926         labels window (top), the row labels window (left), the corner window
3927         (top left) and the main grid window. It may be necessary to use these
3928         individual windows and not the wxGrid window itself if you need to
3929         handle events for them (this can be done using wxEvtHandler::Connect()
3930         or wxWindow::PushEventHandler()) or do something else requiring the use
3931         of the correct window pointer. Notice that you should not, however,
3932         change these windows (e.g. reposition them or draw over them) because
3933         they are managed by wxGrid itself.
3934      */
3935     //@{
3936
3937     /**
3938         Return the main grid window containing the grid cells.
3939
3940         This window is always shown.
3941      */
3942     wxWindow *GetGridWindow() const;
3943
3944     /**
3945         Return the row labels window.
3946
3947         This window is not shown if the row labels were hidden using
3948         HideRowLabels().
3949      */
3950     wxWindow *GetGridRowLabelWindow() const;
3951
3952     /**
3953         Return the column labels window.
3954
3955         This window is not shown if the columns labels were hidden using
3956         HideColLabels().
3957
3958         Depending on whether UseNativeColHeader() was called or not this can be
3959         either a wxHeaderCtrl or a plain wxWindow.  This function returns a valid
3960         window pointer in either case but in the former case you can also use
3961         GetGridColHeader() to access it if you need wxHeaderCtrl-specific
3962         functionality.
3963      */
3964     wxWindow *GetGridColLabelWindow() const;
3965
3966     /**
3967         Return the window in the top left grid corner.
3968
3969         This window is shown only of both columns and row labels are shown and
3970         normally doesn't contain anything. Clicking on it is handled by wxGrid
3971         however and can be used to select the entire grid.
3972      */
3973     wxWindow *GetGridCornerLabelWindow() const;
3974
3975     /**
3976         Return the header control used for column labels display.
3977
3978         This function can only be called if UseNativeColHeader() had been
3979         called.
3980      */
3981     wxHeaderCtrl *GetGridColHeader() const;
3982
3983     //@}
3984
3985 protected:
3986     /**
3987         Returns @true if this grid has support for cell attributes.
3988
3989         The grid supports attributes if it has the associated table which, in
3990         turn, has attributes support, i.e. wxGridTableBase::CanHaveAttributes()
3991         returns @true.
3992     */
3993     bool CanHaveAttributes() const;
3994
3995     /**
3996         Get the minimal width of the given column/row.
3997
3998         The value returned by this function may be different than that returned
3999         by GetColMinimalAcceptableWidth() if SetColMinimalWidth() had been
4000         called for this column.
4001     */
4002     int GetColMinimalWidth(int col) const;
4003
4004     /**
4005         Returns the coordinate of the right border specified column.
4006     */
4007     int GetColRight(int col) const;
4008
4009     /**
4010         Returns the coordinate of the left border specified column.
4011     */
4012     int GetColLeft(int col) const;
4013
4014     /**
4015         Returns the minimal size for the given column.
4016
4017         The value returned by this function may be different than that returned
4018         by GetRowMinimalAcceptableHeight() if SetRowMinimalHeight() had been
4019         called for this row.
4020     */
4021     int GetRowMinimalHeight(int col) const;
4022 };
4023
4024
4025
4026 /**
4027     @class wxGridUpdateLocker
4028
4029     This small class can be used to prevent wxGrid from redrawing during its
4030     lifetime by calling wxGrid::BeginBatch() in its constructor and
4031     wxGrid::EndBatch() in its destructor. It is typically used in a function
4032     performing several operations with a grid which would otherwise result in
4033     flicker. For example:
4034
4035     @code
4036     void MyFrame::Foo()
4037     {
4038         m_grid = new wxGrid(this, ...);
4039
4040         wxGridUpdateLocker noUpdates(m_grid);
4041         m_grid-AppendColumn();
4042         // ... many other operations with m_grid ...
4043         m_grid-AppendRow();
4044
4045         // destructor called, grid refreshed
4046     }
4047     @endcode
4048
4049     Using this class is easier and safer than calling wxGrid::BeginBatch() and
4050     wxGrid::EndBatch() because you don't risk missing the call the latter (due
4051     to an exception for example).
4052
4053     @library{wxadv}
4054     @category{grid}
4055 */
4056 class wxGridUpdateLocker
4057 {
4058 public:
4059     /**
4060         Creates an object preventing the updates of the specified @a grid. The
4061         parameter could be @NULL in which case nothing is done. If @a grid is
4062         non-@NULL then the grid must exist for longer than this
4063         wxGridUpdateLocker object itself.
4064
4065         The default constructor could be followed by a call to Create() to set
4066         the grid object later.
4067     */
4068     wxGridUpdateLocker(wxGrid* grid = NULL);
4069
4070     /**
4071         Destructor reenables updates for the grid this object is associated
4072         with.
4073     */
4074     ~wxGridUpdateLocker();
4075
4076     /**
4077         This method can be called if the object had been constructed using the
4078         default constructor. It must not be called more than once.
4079     */
4080     void Create(wxGrid* grid);
4081 };
4082
4083
4084
4085 /**
4086     @class wxGridEvent
4087
4088     This event class contains information about various grid events.
4089
4090     Notice that all grid event table macros are available in two versions:
4091     @c EVT_GRID_XXX and @c EVT_GRID_CMD_XXX. The only difference between the
4092     two is that the former doesn't allow to specify the grid window identifier
4093     and so takes a single parameter, the event handler, but is not suitable if
4094     there is more than one grid control in the window where the event table is
4095     used (as it would catch the events from all the grids). The version with @c
4096     CMD takes the id as first argument and the event handler as the second one
4097     and so can be used with multiple grids as well. Otherwise there are no
4098     difference between the two and only the versions without the id are
4099     documented below for brevity.
4100
4101     @beginEventTable{wxGridEvent}
4102     @event{EVT_GRID_CELL_CHANGING(func)}
4103         The user is about to change the data in a cell. The new cell value as
4104         string is available from GetString() event object method. This event
4105         can be vetoed if the change is not allowed.
4106         Processes a @c wxEVT_GRID_CELL_CHANGING event type.
4107     @event{EVT_GRID_CELL_CHANGED(func)}
4108         The user changed the data in a cell. The old cell value as string is
4109         available from GetString() event object method. Notice that vetoing
4110         this event still works for backwards compatibility reasons but any new
4111         code should only veto EVT_GRID_CELL_CHANGING event and not this one.
4112         Processes a @c wxEVT_GRID_CELL_CHANGED event type.
4113     @event{EVT_GRID_CELL_LEFT_CLICK(func)}
4114         The user clicked a cell with the left mouse button. Processes a
4115         @c wxEVT_GRID_CELL_LEFT_CLICK event type.
4116     @event{EVT_GRID_CELL_LEFT_DCLICK(func)}
4117         The user double-clicked a cell with the left mouse button. Processes a
4118         @c wxEVT_GRID_CELL_LEFT_DCLICK event type.
4119     @event{EVT_GRID_CELL_RIGHT_CLICK(func)}
4120         The user clicked a cell with the right mouse button. Processes a
4121         @c wxEVT_GRID_CELL_RIGHT_CLICK event type.
4122     @event{EVT_GRID_CELL_RIGHT_DCLICK(func)}
4123         The user double-clicked a cell with the right mouse button. Processes a
4124         @c wxEVT_GRID_CELL_RIGHT_DCLICK event type.
4125     @event{EVT_GRID_EDITOR_HIDDEN(func)}
4126         The editor for a cell was hidden. Processes a
4127         @c wxEVT_GRID_EDITOR_HIDDEN event type.
4128     @event{EVT_GRID_EDITOR_SHOWN(func)}
4129         The editor for a cell was shown. Processes a
4130         @c wxEVT_GRID_EDITOR_SHOWN event type.
4131     @event{EVT_GRID_LABEL_LEFT_CLICK(func)}
4132         The user clicked a label with the left mouse button. Processes a
4133         @c wxEVT_GRID_LABEL_LEFT_CLICK event type.
4134     @event{EVT_GRID_LABEL_LEFT_DCLICK(func)}
4135         The user double-clicked a label with the left mouse button. Processes a
4136         @c wxEVT_GRID_LABEL_LEFT_DCLICK event type.
4137     @event{EVT_GRID_LABEL_RIGHT_CLICK(func)}
4138         The user clicked a label with the right mouse button. Processes a
4139         @c wxEVT_GRID_LABEL_RIGHT_CLICK event type.
4140     @event{EVT_GRID_LABEL_RIGHT_DCLICK(func)}
4141         The user double-clicked a label with the right mouse button. Processes
4142         a @c wxEVT_GRID_LABEL_RIGHT_DCLICK event type.
4143     @event{EVT_GRID_SELECT_CELL(func)}
4144         The given cell was made current, either by user or by the program via a
4145         call to SetGridCursor() or GoToCell(). Processes a
4146         @c wxEVT_GRID_SELECT_CELL event type.
4147     @event{EVT_GRID_COL_MOVE(func)}
4148         The user tries to change the order of the columns in the grid by
4149         dragging the column specified by GetCol(). This event can be vetoed to
4150         either prevent the user from reordering the column change completely
4151         (but notice that if you don't want to allow it at all, you simply
4152         shouldn't call wxGrid::EnableDragColMove() in the first place), vetoed
4153         but handled in some way in the handler, e.g. by really moving the
4154         column to the new position at the associated table level, or allowed to
4155         proceed in which case wxGrid::SetColPos() is used to reorder the
4156         columns display order without affecting the use of the column indices
4157         otherwise.
4158         This event macro corresponds to @c wxEVT_GRID_COL_MOVE event type.
4159     @event{EVT_GRID_COL_SORT(func)}
4160         This event is generated when a column is clicked by the user and its
4161         name is explained by the fact that the custom reaction to a click on a
4162         column is to sort the grid contents by this column. However the grid
4163         itself has no special support for sorting and it's up to the handler of
4164         this event to update the associated table. But if the event is handled
4165         (and not vetoed) the grid supposes that the table was indeed resorted
4166         and updates the column to indicate the new sort order and refreshes
4167         itself.
4168         This event macro corresponds to @c wxEVT_GRID_COL_SORT event type.
4169     @endEventTable
4170
4171     @library{wxadv}
4172     @category{grid,events}
4173 */
4174 class wxGridEvent : public wxNotifyEvent
4175 {
4176 public:
4177     /**
4178         Default constructor.
4179     */
4180     wxGridEvent();
4181     /**
4182         Constructor for initializing all event attributes.
4183     */
4184     wxGridEvent(int id, wxEventType type, wxObject* obj,
4185                 int row = -1, int col = -1, int x = -1, int y = -1,
4186                 bool sel = true, const wxKeyboardState& kbd = wxKeyboardState());
4187
4188     /**
4189         Returns @true if the Alt key was down at the time of the event.
4190     */
4191     bool AltDown() const;
4192
4193     /**
4194         Returns @true if the Control key was down at the time of the event.
4195     */
4196     bool ControlDown() const;
4197
4198     /**
4199         Column at which the event occurred.
4200     */
4201     virtual int GetCol();
4202
4203     /**
4204         Position in pixels at which the event occurred.
4205     */
4206     wxPoint GetPosition();
4207
4208     /**
4209         Row at which the event occurred.
4210     */
4211     virtual int GetRow();
4212
4213     /**
4214         Returns @true if the Meta key was down at the time of the event.
4215     */
4216     bool MetaDown() const;
4217
4218     /**
4219         Returns @true if the user is selecting grid cells, or @false if
4220         deselecting.
4221     */
4222     bool Selecting();
4223
4224     /**
4225         Returns @true if the Shift key was down at the time of the event.
4226     */
4227     bool ShiftDown() const;
4228 };
4229
4230
4231
4232 /**
4233     @class wxGridSizeEvent
4234
4235     This event class contains information about a row/column resize event.
4236
4237     @beginEventTable{wxGridSizeEvent}
4238     @event{EVT_GRID_CMD_COL_SIZE(id, func)}
4239         The user resized a column, corresponds to @c wxEVT_GRID_COL_SIZE event
4240         type.
4241     @event{EVT_GRID_CMD_ROW_SIZE(id, func)}
4242         The user resized a row, corresponds to @c wxEVT_GRID_ROW_SIZE event
4243         type.
4244     @event{EVT_GRID_COL_SIZE(func)}
4245         Same as EVT_GRID_CMD_COL_SIZE() but uses `wxID_ANY` id.
4246     @event{EVT_GRID_ROW_SIZE(func)}
4247         Same as EVT_GRID_CMD_ROW_SIZE() but uses `wxID_ANY` id.
4248     @endEventTable
4249
4250     @library{wxadv}
4251     @category{grid,events}
4252 */
4253 class wxGridSizeEvent : public wxNotifyEvent
4254 {
4255 public:
4256     /**
4257         Default constructor.
4258     */
4259     wxGridSizeEvent();
4260     /**
4261         Constructor for initializing all event attributes.
4262     */
4263     wxGridSizeEvent(int id, wxEventType type, wxObject* obj,
4264                     int rowOrCol = -1, int x = -1, int y = -1,
4265                     const wxKeyboardState& kbd = wxKeyboardState());
4266
4267     /**
4268         Returns @true if the Alt key was down at the time of the event.
4269     */
4270     bool AltDown() const;
4271
4272     /**
4273         Returns @true if the Control key was down at the time of the event.
4274     */
4275     bool ControlDown() const;
4276
4277     /**
4278         Position in pixels at which the event occurred.
4279     */
4280     wxPoint GetPosition();
4281
4282     /**
4283         Row or column at that was resized.
4284     */
4285     int GetRowOrCol();
4286
4287     /**
4288         Returns @true if the Meta key was down at the time of the event.
4289     */
4290     bool MetaDown() const;
4291
4292     /**
4293         Returns @true if the Shift key was down at the time of the event.
4294     */
4295     bool ShiftDown() const;
4296 };
4297
4298
4299
4300 /**
4301     @class wxGridRangeSelectEvent
4302
4303     @beginEventTable{wxGridRangeSelectEvent}
4304     @event{EVT_GRID_RANGE_SELECT(func)}
4305         The user selected a group of contiguous cells. Processes a
4306         @c wxEVT_GRID_RANGE_SELECT event type.
4307     @event{EVT_GRID_CMD_RANGE_SELECT(id, func)}
4308         The user selected a group of contiguous cells; variant taking a window
4309         identifier. Processes a @c wxEVT_GRID_RANGE_SELECT event type.
4310     @endEventTable
4311
4312     @library{wxadv}
4313     @category{grid,events}
4314 */
4315 class wxGridRangeSelectEvent : public wxNotifyEvent
4316 {
4317 public:
4318     /**
4319         Default constructor.
4320     */
4321     wxGridRangeSelectEvent();
4322     /**
4323         Constructor for initializing all event attributes.
4324     */
4325     wxGridRangeSelectEvent(int id, wxEventType type,
4326                            wxObject* obj,
4327                            const wxGridCellCoords& topLeft,
4328                            const wxGridCellCoords& bottomRight,
4329                            bool sel = true, const wxKeyboardState& kbd = wxKeyboardState());
4330
4331     /**
4332         Returns @true if the Alt key was down at the time of the event.
4333     */
4334     bool AltDown() const;
4335
4336     /**
4337         Returns @true if the Control key was down at the time of the event.
4338     */
4339     bool ControlDown() const;
4340
4341     /**
4342         Top left corner of the rectangular area that was (de)selected.
4343     */
4344     wxGridCellCoords GetBottomRightCoords();
4345
4346     /**
4347         Bottom row of the rectangular area that was (de)selected.
4348     */
4349     int GetBottomRow();
4350
4351     /**
4352         Left column of the rectangular area that was (de)selected.
4353     */
4354     int GetLeftCol();
4355
4356     /**
4357         Right column of the rectangular area that was (de)selected.
4358     */
4359     int GetRightCol();
4360
4361     /**
4362         Top left corner of the rectangular area that was (de)selected.
4363     */
4364     wxGridCellCoords GetTopLeftCoords();
4365
4366     /**
4367         Top row of the rectangular area that was (de)selected.
4368     */
4369     int GetTopRow();
4370
4371     /**
4372         Returns @true if the Meta key was down at the time of the event.
4373     */
4374     bool MetaDown() const;
4375
4376     /**
4377         Returns @true if the area was selected, @false otherwise.
4378     */
4379     bool Selecting();
4380
4381     /**
4382         Returns @true if the Shift key was down at the time of the event.
4383     */
4384     bool ShiftDown() const;
4385 };
4386
4387
4388
4389 /**
4390     @class wxGridEditorCreatedEvent
4391
4392     @beginEventTable{wxGridEditorCreatedEvent}
4393     @event{EVT_GRID_EDITOR_CREATED(func)}
4394         The editor for a cell was created. Processes a
4395         @c wxEVT_GRID_EDITOR_CREATED event type.
4396     @event{EVT_GRID_CMD_EDITOR_CREATED(id, func)}
4397         The editor for a cell was created; variant taking a window identifier.
4398         Processes a @c wxEVT_GRID_EDITOR_CREATED event type.
4399     @endEventTable
4400
4401     @library{wxadv}
4402     @category{grid,events}
4403 */
4404 class wxGridEditorCreatedEvent : public wxCommandEvent
4405 {
4406 public:
4407     /**
4408         Default constructor.
4409     */
4410     wxGridEditorCreatedEvent();
4411     /**
4412         Constructor for initializing all event attributes.
4413     */
4414     wxGridEditorCreatedEvent(int id, wxEventType type, wxObject* obj,
4415                              int row, int col, wxControl* ctrl);
4416
4417     /**
4418         Returns the column at which the event occurred.
4419     */
4420     int GetCol();
4421
4422     /**
4423         Returns the edit control.
4424     */
4425     wxControl* GetControl();
4426
4427     /**
4428         Returns the row at which the event occurred.
4429     */
4430     int GetRow();
4431
4432     /**
4433         Sets the column at which the event occurred.
4434     */
4435     void SetCol(int col);
4436
4437     /**
4438         Sets the edit control.
4439     */
4440     void SetControl(wxControl* ctrl);
4441
4442     /**
4443         Sets the row at which the event occurred.
4444     */
4445     void SetRow(int row);
4446 };
4447