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
 564     void Clear();
 565     void Replace(long from, long to, const wxString& value);
 566     void Remove(long from, long to);
 567
 568     // load/save the controls contents from/to the file
 569     bool LoadFile(const wxString& file);
 570     bool SaveFile(const wxString& file = wxEmptyString);
 571
 572     // clears the dirty flag
 573     void DiscardEdits();
 574
 575     // set the max number of characters which may be entered in a single line
 576     // text control
 577     void SetMaxLength(unsigned long len);
 578
 579     // writing text inserts it at the current position, appending always
 580     // inserts it at the end
 581     void WriteText(const wxString& text);
 582     void AppendText(const wxString& text);
 583
 584     // text control under some platforms supports the text styles: these
 585     // methods allow to apply the given text style to the given selection or to
 586     // set/get the style which will be used for all appended text
 587     bool SetStyle(long start, long end, const wxTextAttr& style);
 588     bool SetDefaultStyle(const wxTextAttr& style);
 589     const wxTextAttr& GetDefaultStyle() const;
 590
 591     // translate between the position (which is just an index in the text ctrl
 592     // considering all its contents as a single strings) and (x, y) coordinates
 593     // which represent column and line.
 594     long XYToPosition(long x, long y) const;
 595     bool PositionToXY(long pos, long *OUTPUT, long *OUTPUT) const;
 596
 597     void ShowPosition(long pos);
 598
 599     // Clipboard operations
 600     void Copy();
 601     void Cut();
 602     void Paste();
 603
 604     bool CanCopy() const;
 605     bool CanCut() const;
 606     bool CanPaste() const;
 607
 608     // Undo/redo
 609     void Undo();
 610     void Redo();
 611
 612     bool CanUndo() const;
 613     bool CanRedo() const;
 614
 615     // Insertion point
 616     void SetInsertionPoint(long pos);
 617     void SetInsertionPointEnd();
 618     long GetInsertionPoint() const;
 619     long GetLastPosition() const;
 620
 621     void SetSelection(long from, long to);
 622     void SelectAll();
 623     void SetEditable(bool editable);
 624
 625     %addmethods {
 626         void write(const wxString& text) {
 627             self->AppendText(text);
 628         }
 629     }
 630 };
 631
 632 //----------------------------------------------------------------------
 633
 634 class wxScrollBar : public wxControl {
 635 public:
 636     wxScrollBar(wxWindow* parent, wxWindowID id = -1,
 637                 const wxPoint& pos = wxDefaultPosition,
 638                 const wxSize& size = wxDefaultSize,
 639                 long style = wxSB_HORIZONTAL,
 640                 const wxValidator& validator = wxDefaultValidator,
 641                 char* name = "scrollBar");
 642     %name(wxPreScrollBar)wxScrollBar();
 643
 644     bool Create(wxWindow* parent, wxWindowID id = -1,
 645                 const wxPoint& pos = wxDefaultPosition,
 646                 const wxSize& size = wxDefaultSize,
 647                 long style = wxSB_HORIZONTAL,
 648                 const wxValidator& validator = wxDefaultValidator,
 649                 char* name = "scrollBar");
 650
 651     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 652     %pragma(python) addtomethod = "wxPreScrollBar:val._setOORInfo(val)"
 653
 654     int GetRange();
 655     int GetPageSize();
 656     int GetThumbPosition();
 657     int GetThumbSize();
 658     %name(GetThumbLength) int GetThumbSize();  // to match the docs
 659     void SetThumbPosition(int viewStart);
 660     void SetScrollbar(int position, int thumbSize,
 661                       int range,    int pageSize,
 662                       bool refresh = TRUE);
 663 };
 664
 665 //----------------------------------------------------------------------
 666
 667 class wxSpinButton : public wxControl {
 668 public:
 669     wxSpinButton(wxWindow* parent, wxWindowID id = -1,
 670                  const wxPoint& pos = wxDefaultPosition,
 671                  const wxSize& size = wxDefaultSize,
 672                  long style = wxSP_HORIZONTAL,
 673                  char* name = "spinButton");
 674     %name(wxPreSpinButton)wxSpinButton();
 675
 676     bool Create(wxWindow* parent, wxWindowID id = -1,
 677                  const wxPoint& pos = wxDefaultPosition,
 678                  const wxSize& size = wxDefaultSize,
 679                  long style = wxSP_HORIZONTAL,
 680                  char* name = "spinButton");
 681
 682     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 683     %pragma(python) addtomethod = "wxPreSpinButton:val._setOORInfo(val)"
 684
 685     int GetMax();
 686     int GetMin();
 687     int GetValue();
 688     void SetRange(int min, int max);
 689     void SetValue(int value);
 690 };
 691
 692 //----------------------------------------------------------------------
 693
 694 class wxStaticBitmap : public wxControl {
 695 public:
 696     wxStaticBitmap(wxWindow* parent, wxWindowID id,
 697                    const wxBitmap& bitmap,
 698                    const wxPoint& pos = wxDefaultPosition,
 699                    const wxSize& size = wxDefaultSize,
 700                    long style = 0,
 701                    char* name = "staticBitmap");
 702     %name(wxPreStaticBitmap)wxStaticBitmap();
 703
 704     bool Create(wxWindow* parent, wxWindowID id,
 705                    const wxBitmap& bitmap,
 706                    const wxPoint& pos = wxDefaultPosition,
 707                    const wxSize& size = wxDefaultSize,
 708                    long style = 0,
 709                    char* name = "staticBitmap");
 710
 711     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 712     %pragma(python) addtomethod = "wxPreStaticBitmap:val._setOORInfo(val)"
 713
 714     const wxBitmap& GetBitmap();
 715     void SetBitmap(const wxBitmap& bitmap);
 716     void SetIcon(const wxIcon& icon);
 717 };
 718
 719 //----------------------------------------------------------------------
 720
 721 class wxRadioBox : public wxControl {
 722 public:
 723     wxRadioBox(wxWindow* parent, wxWindowID id,
 724                const wxString& label,
 725                const wxPoint& point = wxDefaultPosition,
 726                const wxSize& size = wxDefaultSize,
 727                int LCOUNT = 0, wxString* choices = NULL,
 728                int majorDimension = 0,
 729                long style = wxRA_HORIZONTAL,
 730                const wxValidator& validator = wxDefaultValidator,
 731                char* name = "radioBox");
 732     %name(wxPreRadioBox)wxRadioBox();
 733
 734     bool Create(wxWindow* parent, wxWindowID id,
 735                const wxString& label,
 736                const wxPoint& point = wxDefaultPosition,
 737                const wxSize& size = wxDefaultSize,
 738                int LCOUNT = 0, wxString* choices = NULL,
 739                int majorDimension = 0,
 740                long style = wxRA_HORIZONTAL,
 741                const wxValidator& validator = wxDefaultValidator,
 742                char* name = "radioBox");
 743
 744     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 745     %pragma(python) addtomethod = "wxPreRadioBox:val._setOORInfo(val)"
 746
 747     void Enable(bool enable);
 748     %name(EnableItem)void Enable(int n, bool enable);
 749     int FindString(const wxString& string);
 750
 751     wxString GetString(int n);
 752
 753 #ifdef __WXGTK__
 754     %name(GetItemLabel)wxString GetLabel( int item );
 755     %name(SetItemLabel)void SetLabel( int item, const wxString& label );
 756 #else
 757     void SetString(int n, const wxString& label);
 758     %pragma(python) addtoclass = "
 759     GetItemLabel = GetString
 760     SetItemLabel = SetString
 761     "
 762     int GetColumnCount();
 763     int GetRowCount();
 764 #endif
 765
 766     int GetSelection();
 767     wxString GetStringSelection();
 768     int GetCount();
 769     %pragma(python) addtoclass = "Number = GetCount"
 770
 771     void SetSelection(int n);
 772     void SetStringSelection(const wxString& string);
 773     void Show(bool show);
 774     %name(ShowItem)void Show(int item, bool show);
 775 };
 776
 777 //----------------------------------------------------------------------
 778
 779 class wxRadioButton : public wxControl {
 780 public:
 781     wxRadioButton(wxWindow* parent, wxWindowID id,
 782                   const wxString& label,
 783                   const wxPoint& pos = wxDefaultPosition,
 784                   const wxSize& size = wxDefaultSize,
 785                   long style = 0,
 786                   const wxValidator& validator = wxDefaultValidator,
 787                   char* name = "radioButton");
 788     %name(wxPreRadioButton)wxRadioButton();
 789
 790     bool Create(wxWindow* parent, wxWindowID id,
 791                   const wxString& label,
 792                   const wxPoint& pos = wxDefaultPosition,
 793                   const wxSize& size = wxDefaultSize,
 794                   long style = 0,
 795                   const wxValidator& validator = wxDefaultValidator,
 796                   char* name = "radioButton");
 797
 798     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 799     %pragma(python) addtomethod = "wxPreRadioButton:val._setOORInfo(val)"
 800
 801     bool GetValue();
 802     void SetValue(bool value);
 803 };
 804
 805 //----------------------------------------------------------------------
 806
 807 class wxSlider : public wxControl {
 808 public:
 809     wxSlider(wxWindow* parent, wxWindowID id,
 810              int value, int minValue, int maxValue,
 811              const wxPoint& point = wxDefaultPosition,
 812              const wxSize& size = wxDefaultSize,
 813              long style = wxSL_HORIZONTAL,
 814              const wxValidator& validator = wxDefaultValidator,
 815              char* name = "slider");
 816     %name(wxPreSlider)wxSlider();
 817
 818     bool Create(wxWindow* parent, wxWindowID id,
 819              int value, int minValue, int maxValue,
 820              const wxPoint& point = wxDefaultPosition,
 821              const wxSize& size = wxDefaultSize,
 822              long style = wxSL_HORIZONTAL,
 823              const wxValidator& validator = wxDefaultValidator,
 824              char* name = "slider");
 825
 826     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 827     %pragma(python) addtomethod = "wxPreSlider:val._setOORInfo(val)"
 828
 829     void ClearSel();
 830     void ClearTicks();
 831     int GetLineSize();
 832     int GetMax();
 833     int GetMin();
 834     int GetPageSize();
 835     int GetSelEnd();
 836     int GetSelStart();
 837     int GetThumbLength();
 838     int GetTickFreq();
 839     int GetValue();
 840     void SetRange(int minValue, int maxValue);
 841     void SetTickFreq(int n, int pos);
 842     void SetLineSize(int lineSize);
 843     void SetPageSize(int pageSize);
 844     void SetSelection(int startPos, int endPos);
 845     void SetThumbLength(int len);
 846     void SetTick(int tickPos);
 847     void SetValue(int value);
 848 };
 849
 850
 851 //----------------------------------------------------------------------
 852
 853 class wxSpinCtrl : public wxSpinButton {
 854 public:
 855     wxSpinCtrl(wxWindow *parent,
 856                wxWindowID id = -1,
 857                const char* value = "",
 858                const wxPoint& pos = wxDefaultPosition,
 859                const wxSize& size = wxDefaultSize,
 860                long style = wxSP_ARROW_KEYS,
 861                int min = 0, int max = 100, int initial = 0,
 862                const char* name = "wxSpinCtrl");
 863     %name(wxPreSpinCtrl)wxSpinCtrl();
 864
 865     bool Create(wxWindow *parent,
 866                wxWindowID id = -1,
 867                const char* value = "",
 868                const wxPoint& pos = wxDefaultPosition,
 869                const wxSize& size = wxDefaultSize,
 870                long style = wxSP_ARROW_KEYS,
 871                int min = 0, int max = 100, int initial = 0,
 872                const char* name = "wxSpinCtrl");
 873
 874     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 875     %pragma(python) addtomethod = "wxPreSpinCtrl:val._setOORInfo(val)"
 876
 877     int GetMax();
 878     int GetMin();
 879     int GetValue();
 880     void SetRange(int min, int max);
 881     void SetValue(int value);
 882
 883 };
 884
 885
 886 //----------------------------------------------------------------------
 887
 888 #ifndef __WXMAC__
 889 enum { wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, };
 890
 891 class wxToggleButton : public wxControl {
 892 public:
 893     wxToggleButton(wxWindow *parent,
 894                    wxWindowID id,
 895                    const wxString& label,
 896                    const wxPoint& pos = wxDefaultPosition,
 897                    const wxSize& size = wxDefaultSize,
 898                    long style = 0,
 899                    const wxValidator& validator = wxDefaultValidator,
 900                    const char* name = "toggle");
 901     %name(wxPreToggleButton)wxToggleButton();
 902
 903     bool Create(wxWindow *parent,
 904                    wxWindowID id,
 905                    const wxString& label,
 906                    const wxPoint& pos = wxDefaultPosition,
 907                    const wxSize& size = wxDefaultSize,
 908                    long style = 0,
 909                    const wxValidator& validator = wxDefaultValidator,
 910                    const char* name = "toggle");
 911
 912     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 913     %pragma(python) addtomethod = "wxPreToggleButton:val._setOORInfo(val)"
 914
 915     void SetValue(bool value);
 916     bool GetValue() const ;
 917     void SetLabel(const wxString& label);
 918
 919 };
 920
 921 #endif
 922 //----------------------------------------------------------------------
 923 //----------------------------------------------------------------------
 924 //----------------------------------------------------------------------
 925
 926
 927