interface/wx/grid.h

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