wxPython/src/controls.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        controls.i
   3 // Purpose:     Control (widget) classes for wxPython
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     6/10/98
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 %module controls
  14
  15 %{
  16 #include "helpers.h"
  17 #include <wx/slider.h>
  18 #include <wx/spinbutt.h>
  19 #include <wx/spinctrl.h>
  20 #include <wx/dynarray.h>
  21 #include <wx/statline.h>
  22 #include <wx/tglbtn.h>
  23
  24 #ifdef __WXMSW__
  25 #if wxUSE_OWNER_DRAWN
  26 #include <wx/checklst.h>
  27 #endif
  28 #endif
  29
  30 #ifdef __WXGTK__
  31 #include <wx/checklst.h>
  32 #endif
  33
  34 %}
  35
  36 //----------------------------------------------------------------------
  37
  38 %include typemaps.i
  39 %include my_typemaps.i
  40
  41 // Import some definitions of other classes, etc.
  42 %import _defs.i
  43 %import misc.i
  44 %import windows.i
  45 %import gdi.i
  46 %import events.i
  47
  48 %pragma(python) code = "import wx"
  49
  50 //----------------------------------------------------------------------
  51
  52 %readonly
  53 wxValidator wxDefaultValidator;
  54 %readwrite
  55
  56 //----------------------------------------------------------------------
  57
  58 class wxControl : public wxWindow {
  59 public:
  60     wxControl(wxWindow *parent,
  61                        wxWindowID id,
  62                        const wxPoint& pos=wxDefaultPosition,
  63                        const wxSize& size=wxDefaultSize,
  64                        long style=0,
  65                        const wxValidator& validator=wxDefaultValidator,
  66                        const char* name="control");
  67     %name(wxPreControl)wxControl();
  68
  69     bool Create(wxWindow *parent,
  70                        wxWindowID id,
  71                        const wxPoint& pos=wxDefaultPosition,
  72                        const wxSize& size=wxDefaultSize,
  73                        long style=0,
  74                        const wxValidator& validator=wxDefaultValidator,
  75                        const char* name="control");
  76
  77     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
  78     %pragma(python) addtomethod = "wxPreControl:val._setOORInfo(val)"
  79
  80     void Command(wxCommandEvent& event);
  81     wxString GetLabel();
  82     void SetLabel(const wxString& label);
  83 };
  84
  85
  86 //----------------------------------------------------------------------
  87
  88
  89 class wxControlWithItems : public wxControl {
  90 public:
  91
  92     // void Clear();  ambiguous, redefine below...
  93     void Delete(int n);
  94
  95     int GetCount();
  96     %pragma(python) addtoclass = "Number = GetCount"
  97     wxString GetString(int n);
  98     void SetString(int n, const wxString& s);
  99     int FindString(const wxString& s);
 100
 101     void Select(int n);
 102     int GetSelection();
 103
 104     wxString GetStringSelection() const;
 105
 106     //   void Append(const wxString& item);
 107     //   void Append(const wxString& item, char* clientData);
 108     //   char* GetClientData(const int n);
 109     //   void SetClientData(const int n, char* data);
 110     %addmethods {
 111         void Append(const wxString& item, PyObject* clientData=NULL) {
 112             if (clientData) {
 113                 wxPyClientData* data = new wxPyClientData(clientData);
 114                 self->Append(item, data);
 115             } else
 116                 self->Append(item);
 117         }
 118
 119         PyObject* GetClientData(int n) {
 120             wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
 121             if (data) {
 122                 Py_INCREF(data->m_obj);
 123                 return data->m_obj;
 124             } else {
 125                 Py_INCREF(Py_None);
 126                 return Py_None;
 127             }
 128         }
 129
 130         void SetClientData(int n, PyObject* clientData) {
 131             wxPyClientData* data = new wxPyClientData(clientData);
 132             self->SetClientObject(n, data);
 133         }
 134     }
 135
 136 };
 137 //----------------------------------------------------------------------
 138
 139 class wxButton : public wxControl {
 140 public:
 141     wxButton(wxWindow* parent, wxWindowID id, const wxString& label,
 142              const wxPoint& pos = wxDefaultPosition,
 143              const wxSize& size = wxDefaultSize,
 144              long style = 0,
 145              const wxValidator& validator = wxDefaultValidator,
 146              char* name = "button");
 147     %name(wxPreButton)wxButton();
 148
 149     bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
 150              const wxPoint& pos = wxDefaultPosition,
 151              const wxSize& size = wxDefaultSize,
 152              long style = 0,
 153              const wxValidator& validator = wxDefaultValidator,
 154              char* name = "button");
 155
 156     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 157     %pragma(python) addtomethod = "wxPreButton:val._setOORInfo(val)"
 158
 159     void SetDefault();
 160     void SetBackgroundColour(const wxColour& colour);
 161     void SetForegroundColour(const wxColour& colour);
 162 #ifdef __WXMSW__
 163     void SetImageLabel(const wxBitmap& bitmap);
 164     void SetImageMargins(wxCoord x, wxCoord y);
 165 #endif
 166     static wxSize GetDefaultSize();
 167 };
 168
 169 //----------------------------------------------------------------------
 170
 171 class wxBitmapButton : public wxButton {
 172 public:
 173     wxBitmapButton(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
 174                    const wxPoint& pos = wxDefaultPosition,
 175                    const wxSize& size = wxDefaultSize,
 176                    long style = wxBU_AUTODRAW,
 177                    const wxValidator& validator = wxDefaultValidator,
 178                    char* name = "button");
 179     %name(wxPreBitmapButton)wxBitmapButton();
 180
 181     bool Create(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
 182                    const wxPoint& pos = wxDefaultPosition,
 183                    const wxSize& size = wxDefaultSize,
 184                    long style = wxBU_AUTODRAW,
 185                    const wxValidator& validator = wxDefaultValidator,
 186                    char* name = "button");
 187
 188     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 189     %pragma(python) addtomethod = "wxPreBitmapButton:val._setOORInfo(val)"
 190
 191     wxBitmap& GetBitmapLabel();
 192     wxBitmap& GetBitmapDisabled();
 193     wxBitmap& GetBitmapFocus();
 194     wxBitmap& GetBitmapSelected();
 195     void SetBitmapDisabled(const wxBitmap& bitmap);
 196     void SetBitmapFocus(const wxBitmap& bitmap);
 197     void SetBitmapSelected(const wxBitmap& bitmap);
 198     void SetBitmapLabel(const wxBitmap& bitmap);
 199
 200     void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
 201     int GetMarginX() const { return m_marginX; }
 202     int GetMarginY() const { return m_marginY; }
 203 };
 204
 205 //----------------------------------------------------------------------
 206
 207 class wxCheckBox : public wxControl {
 208 public:
 209     wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
 210                const wxPoint& pos = wxDefaultPosition,
 211                const wxSize& size = wxDefaultSize,
 212                long style = 0,
 213                const wxValidator& val = wxDefaultValidator,
 214                char* name = "checkBox");
 215     %name(wxPreCheckBox)wxCheckBox();
 216
 217     bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
 218                const wxPoint& pos = wxDefaultPosition,
 219                const wxSize& size = wxDefaultSize,
 220                long style = 0,
 221                const wxValidator& val = wxDefaultValidator,
 222                char* name = "checkBox");
 223
 224     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 225     %pragma(python) addtomethod = "wxPreCheckBox:val._setOORInfo(val)"
 226
 227     bool GetValue();
 228     void SetValue(const bool state);
 229 };
 230
 231 //----------------------------------------------------------------------
 232
 233 class wxChoice : public wxControlWithItems {
 234 public:
 235     wxChoice(wxWindow *parent, wxWindowID id,
 236              const wxPoint& pos = wxDefaultPosition,
 237              const wxSize& size = wxDefaultSize,
 238              int LCOUNT=0, wxString* choices=NULL,
 239              long style = 0,
 240              const wxValidator& validator = wxDefaultValidator,
 241              char* name = "choice");
 242     %name(wxPreChoice)wxChoice();
 243
 244     bool Create(wxWindow *parent, wxWindowID id,
 245              const wxPoint& pos = wxDefaultPosition,
 246              const wxSize& size = wxDefaultSize,
 247              int LCOUNT=0, wxString* choices=NULL,
 248              long style = 0,
 249              const wxValidator& validator = wxDefaultValidator,
 250              char* name = "choice");
 251
 252     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 253     %pragma(python) addtomethod = "wxPreChoice:val._setOORInfo(val)"
 254
 255     void Clear();
 256
 257     int GetColumns();
 258     void SetColumns(const int n = 1);
 259     void SetSelection(const int n);
 260     void SetStringSelection(const wxString& string);
 261     void SetString(int n, const wxString& s);
 262
 263     %pragma(python) addtoclass = "
 264     Select = SetSelection
 265     "
 266 };
 267
 268 //----------------------------------------------------------------------
 269
 270 class wxComboBox : public wxChoice {
 271 public:
 272     wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
 273                const wxPoint& pos = wxDefaultPosition,
 274                const wxSize& size = wxDefaultSize,
 275                int LCOUNT=0, wxString* choices=NULL,
 276                long style = 0,
 277                const wxValidator& validator = wxDefaultValidator,
 278                char* name = "comboBox");
 279     %name(wxPreComboBox)wxComboBox();
 280
 281     bool Create(wxWindow* parent, wxWindowID id, char* value = "",
 282                const wxPoint& pos = wxDefaultPosition,
 283                const wxSize& size = wxDefaultSize,
 284                int LCOUNT=0, wxString* choices=NULL,
 285                long style = 0,
 286                const wxValidator& validator = wxDefaultValidator,
 287                char* name = "comboBox");
 288
 289     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 290     %pragma(python) addtomethod = "wxPreComboBox:val._setOORInfo(val)"
 291
 292     void Copy();
 293     void Cut();
 294     long GetInsertionPoint();
 295     long GetLastPosition();
 296     wxString GetValue();
 297     void Paste();
 298     void Replace(long from, long to, const wxString& text);
 299     void Remove(long from, long to);
 300     void SetInsertionPoint(long pos);
 301     void SetInsertionPointEnd();
 302     void SetSelection(int n);
 303     %name(SetMark)void SetSelection(long from, long to);
 304     void SetValue(const wxString& text);
 305     void SetEditable(bool editable);
 306 };
 307
 308 //----------------------------------------------------------------------
 309
 310 class wxGauge : public wxControl {
 311 public:
 312     wxGauge(wxWindow* parent, wxWindowID id, int range,
 313             const wxPoint& pos = wxDefaultPosition,
 314             const wxSize& size = wxDefaultSize,
 315             long style = wxGA_HORIZONTAL,
 316             const wxValidator& validator = wxDefaultValidator,
 317             char* name = "gauge");
 318     %name(wxPreGauge)wxGauge();
 319
 320     bool Create(wxWindow* parent, wxWindowID id, int range,
 321             const wxPoint& pos = wxDefaultPosition,
 322             const wxSize& size = wxDefaultSize,
 323             long style = wxGA_HORIZONTAL,
 324             const wxValidator& validator = wxDefaultValidator,
 325             char* name = "gauge");
 326
 327     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 328     %pragma(python) addtomethod = "wxPreGauge:val._setOORInfo(val)"
 329
 330     int GetBezelFace();
 331     int GetRange();
 332     int GetShadowWidth();
 333     int GetValue();
 334     void SetBezelFace(int width);
 335     void SetRange(int range);
 336     void SetShadowWidth(int width);
 337     void SetValue(int pos);
 338 };
 339
 340 //----------------------------------------------------------------------
 341
 342 class wxStaticBox : public wxControl {
 343 public:
 344     wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
 345                 const wxPoint& pos = wxDefaultPosition,
 346                 const wxSize& size = wxDefaultSize,
 347                 long style = 0,
 348                 char* name = "staticBox");
 349     %name(wxPreStaticBox)wxStaticBox();
 350
 351     bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
 352                 const wxPoint& pos = wxDefaultPosition,
 353                 const wxSize& size = wxDefaultSize,
 354                 long style = 0,
 355                 char* name = "staticBox");
 356
 357     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 358     %pragma(python) addtomethod = "wxPreStaticBox:val._setOORInfo(val)"
 359 };
 360
 361
 362 //----------------------------------------------------------------------
 363
 364
 365 class wxStaticLine : public wxControl {
 366 public:
 367     wxStaticLine( wxWindow *parent, wxWindowID id,
 368                   const wxPoint &pos = wxDefaultPosition,
 369                   const wxSize &size = wxDefaultSize,
 370                   long style = wxLI_HORIZONTAL,
 371                   const char* name = "staticLine" );
 372     %name(wxPreStaticLine)wxStaticLine();
 373
 374     bool Create( wxWindow *parent, wxWindowID id,
 375                   const wxPoint &pos = wxDefaultPosition,
 376                   const wxSize &size = wxDefaultSize,
 377                   long style = wxLI_HORIZONTAL,
 378                   const char* name = "staticLine" );
 379
 380     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 381     %pragma(python) addtomethod = "wxPreStaticLine:val._setOORInfo(val)"
 382 };
 383
 384
 385 //----------------------------------------------------------------------
 386
 387 class wxStaticText : public wxControl {
 388 public:
 389     wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
 390                  const wxPoint& pos = wxDefaultPosition,
 391                  const wxSize& size = wxDefaultSize,
 392                  long style = 0,
 393                  char* name = "staticText");
 394     %name(wxPreStaticText)wxStaticText();
 395
 396     bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
 397                  const wxPoint& pos = wxDefaultPosition,
 398                  const wxSize& size = wxDefaultSize,
 399                  long style = 0,
 400                  char* name = "staticText");
 401
 402     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 403     %pragma(python) addtomethod = "wxPreStaticText:val._setOORInfo(val)"
 404
 405     wxString GetLabel();
 406     void SetLabel(const wxString& label);
 407 };
 408
 409 //----------------------------------------------------------------------
 410
 411 class wxListBox : public wxControlWithItems {
 412 public:
 413     wxListBox(wxWindow* parent, wxWindowID id,
 414               const wxPoint& pos = wxDefaultPosition,
 415               const wxSize& size = wxDefaultSize,
 416               int LCOUNT, wxString* choices = NULL,
 417               long style = 0,
 418               const wxValidator& validator = wxDefaultValidator,
 419               char* name = "listBox");
 420     %name(wxPreListBox)wxListBox();
 421
 422     bool Create(wxWindow* parent, wxWindowID id,
 423               const wxPoint& pos = wxDefaultPosition,
 424               const wxSize& size = wxDefaultSize,
 425               int LCOUNT, wxString* choices = NULL,
 426               long style = 0,
 427               const wxValidator& validator = wxDefaultValidator,
 428               char* name = "listBox");
 429
 430     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 431     %pragma(python) addtomethod = "wxPreListBox:val._setOORInfo(val)"
 432
 433     void Clear();
 434     void Deselect(int n);
 435
 436     // int GetSelections(int **selections);
 437     %addmethods {
 438       PyObject* GetSelections() {
 439           wxArrayInt lst;
 440           self->GetSelections(lst);
 441           PyObject *tup = PyTuple_New(lst.GetCount());
 442           for(size_t i=0; i<lst.GetCount(); i++) {
 443               PyTuple_SetItem(tup, i, PyInt_FromLong(lst[i]));
 444           }
 445           return tup;
 446       }
 447     }
 448
 449
 450     void InsertItems(int LCOUNT, wxString* choices, int pos);
 451
 452     bool IsSelected(const int n);
 453     bool Selected(const int n);
 454     void Set(int LCOUNT, wxString* choices);
 455     void SetFirstItem(int n);
 456     %name(SetFirstItemStr)void SetFirstItem(const wxString& string);
 457     void SetSelection(int n, bool select = TRUE);
 458     void SetString(int n, const wxString& string);
 459     void SetStringSelection(const wxString& string, bool select = TRUE);
 460 };
 461
 462
 463 //----------------------------------------------------------------------
 464
 465 class wxCheckListBox : public wxListBox {
 466 public:
 467     wxCheckListBox(wxWindow *parent, wxWindowID id,
 468                    const wxPoint& pos = wxDefaultPosition,
 469                    const wxSize& size = wxDefaultSize,
 470                    int LCOUNT = 0,
 471                    wxString* choices = NULL,
 472                    long style = 0,
 473                    const wxValidator& validator = wxDefaultValidator,
 474                    char* name = "listBox");
 475     %name(wxPreCheckListBox)wxCheckListBox();
 476
 477     bool Create(wxWindow *parent, wxWindowID id,
 478                    const wxPoint& pos = wxDefaultPosition,
 479                    const wxSize& size = wxDefaultSize,
 480                    int LCOUNT = 0,
 481                    wxString* choices = NULL,
 482                    long style = 0,
 483                    const wxValidator& validator = wxDefaultValidator,
 484                    char* name = "listBox");
 485
 486     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 487     %pragma(python) addtomethod = "wxPreCheckListBox:val._setOORInfo(val)"
 488
 489     bool  IsChecked(int uiIndex);
 490     void  Check(int uiIndex, int bCheck = TRUE);
 491     void InsertItems(int LCOUNT, wxString* choices, int pos);
 492
 493 #ifndef __WXMAC__
 494     int GetItemHeight();
 495 #endif
 496 };
 497
 498 //----------------------------------------------------------------------
 499
 500
 501 class wxTextAttr
 502 {
 503 public:
 504     // ctors
 505     wxTextAttr(const wxColour& colText = wxNullColour,
 506                const wxColour& colBack = wxNullColour,
 507                const wxFont& font = wxNullFont);
 508     ~wxTextAttr();
 509
 510     // setters
 511     void SetTextColour(const wxColour& colText);
 512     void SetBackgroundColour(const wxColour& colBack);
 513     void SetFont(const wxFont& font);
 514
 515     // accessors
 516     bool HasTextColour() const;
 517     bool HasBackgroundColour() const;
 518     bool HasFont() const;
 519
 520     const wxColour& GetTextColour() const;
 521     const wxColour& GetBackgroundColour() const;
 522     const wxFont& GetFont() const;
 523
 524     // returns false if we have any attributes set, true otherwise
 525     bool IsDefault();
 526 };
 527
 528
 529
 530 class wxTextCtrl : public wxControl {
 531 public:
 532     wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
 533                const wxPoint& pos = wxDefaultPosition,
 534                const wxSize& size = wxDefaultSize,
 535                long style = 0,
 536                const wxValidator& validator = wxDefaultValidator,
 537                char* name = "text");
 538     %name(wxPreTextCtrl)wxTextCtrl();
 539
 540     bool Create(wxWindow* parent, wxWindowID id, char* value = "",
 541                const wxPoint& pos = wxDefaultPosition,
 542                const wxSize& size = wxDefaultSize,
 543                long style = 0,
 544                const wxValidator& validator = wxDefaultValidator,
 545                char* name = "text");
 546
 547     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 548     %pragma(python) addtomethod = "wxPreTextCtrl:val._setOORInfo(val)"
 549
 550
 551     wxString GetValue() const;
 552     void SetValue(const wxString& value);
 553
 554     int GetLineLength(long lineNo) const;
 555     wxString GetLineText(long lineNo) const;
 556     int GetNumberOfLines() const;
 557
 558     bool IsModified() const;
 559     bool IsEditable() const;
 560
 561     // If the return values from and to are the same, there is no selection.
 562     void GetSelection(long* OUTPUT, long* OUTPUT) const;
 563     wxString GetStringSelection();
 564
 565     void Clear();
 566     void Replace(long from, long to, const wxString& value);
 567     void Remove(long from, long to);
 568
 569     // load/save the controls contents from/to the file
 570     bool LoadFile(const wxString& file);
 571     bool SaveFile(const wxString& file = wxEmptyString);
 572
 573     // clears the dirty flag
 574     void DiscardEdits();
 575
 576     // set the max number of characters which may be entered in a single line
 577     // text control
 578     void SetMaxLength(unsigned long len);
 579
 580     // writing text inserts it at the current position, appending always
 581     // inserts it at the end
 582     void WriteText(const wxString& text);
 583     void AppendText(const wxString& text);
 584
 585     // text control under some platforms supports the text styles: these
 586     // methods allow to apply the given text style to the given selection or to
 587     // set/get the style which will be used for all appended text
 588     bool SetStyle(long start, long end, const wxTextAttr& style);
 589     bool SetDefaultStyle(const wxTextAttr& style);
 590     const wxTextAttr& GetDefaultStyle() const;
 591
 592     // translate between the position (which is just an index in the text ctrl
 593     // considering all its contents as a single strings) and (x, y) coordinates
 594     // which represent column and line.
 595     long XYToPosition(long x, long y) const;
 596     bool PositionToXY(long pos, long *OUTPUT, long *OUTPUT) const;
 597
 598     void ShowPosition(long pos);
 599
 600     // Clipboard operations
 601     void Copy();
 602     void Cut();
 603     void Paste();
 604
 605     bool CanCopy() const;
 606     bool CanCut() const;
 607     bool CanPaste() const;
 608
 609     // Undo/redo
 610     void Undo();
 611     void Redo();
 612
 613     bool CanUndo() const;
 614     bool CanRedo() const;
 615
 616     // Insertion point
 617     void SetInsertionPoint(long pos);
 618     void SetInsertionPointEnd();
 619     long GetInsertionPoint() const;
 620     long GetLastPosition() const;
 621
 622     void SetSelection(long from, long to);
 623     void SelectAll();
 624     void SetEditable(bool editable);
 625
 626     %addmethods {
 627         void write(const wxString& text) {
 628             self->AppendText(text);
 629         }
 630     }
 631 };
 632
 633 //----------------------------------------------------------------------
 634
 635 class wxScrollBar : public wxControl {
 636 public:
 637     wxScrollBar(wxWindow* parent, wxWindowID id = -1,
 638                 const wxPoint& pos = wxDefaultPosition,
 639                 const wxSize& size = wxDefaultSize,
 640                 long style = wxSB_HORIZONTAL,
 641                 const wxValidator& validator = wxDefaultValidator,
 642                 char* name = "scrollBar");
 643     %name(wxPreScrollBar)wxScrollBar();
 644
 645     bool Create(wxWindow* parent, wxWindowID id = -1,
 646                 const wxPoint& pos = wxDefaultPosition,
 647                 const wxSize& size = wxDefaultSize,
 648                 long style = wxSB_HORIZONTAL,
 649                 const wxValidator& validator = wxDefaultValidator,
 650                 char* name = "scrollBar");
 651
 652     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 653     %pragma(python) addtomethod = "wxPreScrollBar:val._setOORInfo(val)"
 654
 655     int GetRange();
 656     int GetPageSize();
 657     int GetThumbPosition();
 658     int GetThumbSize();
 659     %name(GetThumbLength) int GetThumbSize();  // to match the docs
 660     void SetThumbPosition(int viewStart);
 661     void SetScrollbar(int position, int thumbSize,
 662                       int range,    int pageSize,
 663                       bool refresh = TRUE);
 664 };
 665
 666 //----------------------------------------------------------------------
 667
 668 class wxSpinButton : public wxControl {
 669 public:
 670     wxSpinButton(wxWindow* parent, wxWindowID id = -1,
 671                  const wxPoint& pos = wxDefaultPosition,
 672                  const wxSize& size = wxDefaultSize,
 673                  long style = wxSP_HORIZONTAL,
 674                  char* name = "spinButton");
 675     %name(wxPreSpinButton)wxSpinButton();
 676
 677     bool Create(wxWindow* parent, wxWindowID id = -1,
 678                  const wxPoint& pos = wxDefaultPosition,
 679                  const wxSize& size = wxDefaultSize,
 680                  long style = wxSP_HORIZONTAL,
 681                  char* name = "spinButton");
 682
 683     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 684     %pragma(python) addtomethod = "wxPreSpinButton:val._setOORInfo(val)"
 685
 686     int GetMax();
 687     int GetMin();
 688     int GetValue();
 689     void SetRange(int min, int max);
 690     void SetValue(int value);
 691 };
 692
 693 //----------------------------------------------------------------------
 694
 695 class wxStaticBitmap : public wxControl {
 696 public:
 697     wxStaticBitmap(wxWindow* parent, wxWindowID id,
 698                    const wxBitmap& bitmap,
 699                    const wxPoint& pos = wxDefaultPosition,
 700                    const wxSize& size = wxDefaultSize,
 701                    long style = 0,
 702                    char* name = "staticBitmap");
 703     %name(wxPreStaticBitmap)wxStaticBitmap();
 704
 705     bool Create(wxWindow* parent, wxWindowID id,
 706                    const wxBitmap& bitmap,
 707                    const wxPoint& pos = wxDefaultPosition,
 708                    const wxSize& size = wxDefaultSize,
 709                    long style = 0,
 710                    char* name = "staticBitmap");
 711
 712     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 713     %pragma(python) addtomethod = "wxPreStaticBitmap:val._setOORInfo(val)"
 714
 715     const wxBitmap& GetBitmap();
 716     void SetBitmap(const wxBitmap& bitmap);
 717     void SetIcon(const wxIcon& icon);
 718 };
 719
 720 //----------------------------------------------------------------------
 721
 722 class wxRadioBox : public wxControl {
 723 public:
 724     wxRadioBox(wxWindow* parent, wxWindowID id,
 725                const wxString& label,
 726                const wxPoint& point = wxDefaultPosition,
 727                const wxSize& size = wxDefaultSize,
 728                int LCOUNT = 0, wxString* choices = NULL,
 729                int majorDimension = 0,
 730                long style = wxRA_HORIZONTAL,
 731                const wxValidator& validator = wxDefaultValidator,
 732                char* name = "radioBox");
 733     %name(wxPreRadioBox)wxRadioBox();
 734
 735     bool Create(wxWindow* parent, wxWindowID id,
 736                const wxString& label,
 737                const wxPoint& point = wxDefaultPosition,
 738                const wxSize& size = wxDefaultSize,
 739                int LCOUNT = 0, wxString* choices = NULL,
 740                int majorDimension = 0,
 741                long style = wxRA_HORIZONTAL,
 742                const wxValidator& validator = wxDefaultValidator,
 743                char* name = "radioBox");
 744
 745     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 746     %pragma(python) addtomethod = "wxPreRadioBox:val._setOORInfo(val)"
 747
 748     void Enable(bool enable);
 749     %name(EnableItem)void Enable(int n, bool enable);
 750     int FindString(const wxString& string);
 751
 752     wxString GetString(int n);
 753
 754 #ifdef __WXGTK__
 755     %name(GetItemLabel)wxString GetLabel( int item );
 756     %name(SetItemLabel)void SetLabel( int item, const wxString& label );
 757 #else
 758     void SetString(int n, const wxString& label);
 759     %pragma(python) addtoclass = "
 760     GetItemLabel = GetString
 761     SetItemLabel = SetString
 762     "
 763     int GetColumnCount();
 764     int GetRowCount();
 765 #endif
 766
 767     int GetSelection();
 768     wxString GetStringSelection();
 769     int GetCount();
 770     %pragma(python) addtoclass = "Number = GetCount"
 771
 772     void SetSelection(int n);
 773     void SetStringSelection(const wxString& string);
 774     void Show(bool show);
 775     %name(ShowItem)void Show(int item, bool show);
 776 };
 777
 778 //----------------------------------------------------------------------
 779
 780 class wxRadioButton : public wxControl {
 781 public:
 782     wxRadioButton(wxWindow* parent, wxWindowID id,
 783                   const wxString& label,
 784                   const wxPoint& pos = wxDefaultPosition,
 785                   const wxSize& size = wxDefaultSize,
 786                   long style = 0,
 787                   const wxValidator& validator = wxDefaultValidator,
 788                   char* name = "radioButton");
 789     %name(wxPreRadioButton)wxRadioButton();
 790
 791     bool Create(wxWindow* parent, wxWindowID id,
 792                   const wxString& label,
 793                   const wxPoint& pos = wxDefaultPosition,
 794                   const wxSize& size = wxDefaultSize,
 795                   long style = 0,
 796                   const wxValidator& validator = wxDefaultValidator,
 797                   char* name = "radioButton");
 798
 799     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 800     %pragma(python) addtomethod = "wxPreRadioButton:val._setOORInfo(val)"
 801
 802     bool GetValue();
 803     void SetValue(bool value);
 804 };
 805
 806 //----------------------------------------------------------------------
 807
 808 class wxSlider : public wxControl {
 809 public:
 810     wxSlider(wxWindow* parent, wxWindowID id,
 811              int value, int minValue, int maxValue,
 812              const wxPoint& point = wxDefaultPosition,
 813              const wxSize& size = wxDefaultSize,
 814              long style = wxSL_HORIZONTAL,
 815              const wxValidator& validator = wxDefaultValidator,
 816              char* name = "slider");
 817     %name(wxPreSlider)wxSlider();
 818
 819     bool Create(wxWindow* parent, wxWindowID id,
 820              int value, int minValue, int maxValue,
 821              const wxPoint& point = wxDefaultPosition,
 822              const wxSize& size = wxDefaultSize,
 823              long style = wxSL_HORIZONTAL,
 824              const wxValidator& validator = wxDefaultValidator,
 825              char* name = "slider");
 826
 827     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 828     %pragma(python) addtomethod = "wxPreSlider:val._setOORInfo(val)"
 829
 830     void ClearSel();
 831     void ClearTicks();
 832     int GetLineSize();
 833     int GetMax();
 834     int GetMin();
 835     int GetPageSize();
 836     int GetSelEnd();
 837     int GetSelStart();
 838     int GetThumbLength();
 839     int GetTickFreq();
 840     int GetValue();
 841     void SetRange(int minValue, int maxValue);
 842     void SetTickFreq(int n, int pos);
 843     void SetLineSize(int lineSize);
 844     void SetPageSize(int pageSize);
 845     void SetSelection(int startPos, int endPos);
 846     void SetThumbLength(int len);
 847     void SetTick(int tickPos);
 848     void SetValue(int value);
 849 };
 850
 851
 852 //----------------------------------------------------------------------
 853
 854 class wxSpinCtrl : public wxSpinButton {
 855 public:
 856     wxSpinCtrl(wxWindow *parent,
 857                wxWindowID id = -1,
 858                const char* value = "",
 859                const wxPoint& pos = wxDefaultPosition,
 860                const wxSize& size = wxDefaultSize,
 861                long style = wxSP_ARROW_KEYS,
 862                int min = 0, int max = 100, int initial = 0,
 863                const char* name = "wxSpinCtrl");
 864     %name(wxPreSpinCtrl)wxSpinCtrl();
 865
 866     bool Create(wxWindow *parent,
 867                wxWindowID id = -1,
 868                const char* value = "",
 869                const wxPoint& pos = wxDefaultPosition,
 870                const wxSize& size = wxDefaultSize,
 871                long style = wxSP_ARROW_KEYS,
 872                int min = 0, int max = 100, int initial = 0,
 873                const char* name = "wxSpinCtrl");
 874
 875     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 876     %pragma(python) addtomethod = "wxPreSpinCtrl:val._setOORInfo(val)"
 877
 878     int GetMax();
 879     int GetMin();
 880     int GetValue();
 881     void SetRange(int min, int max);
 882     void SetValue(int value);
 883
 884 };
 885
 886
 887 //----------------------------------------------------------------------
 888
 889 #ifndef __WXMAC__
 890 enum { wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, };
 891
 892 class wxToggleButton : public wxControl {
 893 public:
 894     wxToggleButton(wxWindow *parent,
 895                    wxWindowID id,
 896                    const wxString& label,
 897                    const wxPoint& pos = wxDefaultPosition,
 898                    const wxSize& size = wxDefaultSize,
 899                    long style = 0,
 900                    const wxValidator& validator = wxDefaultValidator,
 901                    const char* name = "toggle");
 902     %name(wxPreToggleButton)wxToggleButton();
 903
 904     bool Create(wxWindow *parent,
 905                    wxWindowID id,
 906                    const wxString& label,
 907                    const wxPoint& pos = wxDefaultPosition,
 908                    const wxSize& size = wxDefaultSize,
 909                    long style = 0,
 910                    const wxValidator& validator = wxDefaultValidator,
 911                    const char* name = "toggle");
 912
 913     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 914     %pragma(python) addtomethod = "wxPreToggleButton:val._setOORInfo(val)"
 915
 916     void SetValue(bool value);
 917     bool GetValue() const ;
 918     void SetLabel(const wxString& label);
 919
 920 };
 921
 922 #endif
 923 //----------------------------------------------------------------------
 924 //----------------------------------------------------------------------
 925 //----------------------------------------------------------------------
 926
 927
 928