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(self)"
  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(self)"
 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(self)"
 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(self)"
 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(self)"
 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(self)"
 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(self)"
 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(self)"
 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(self)"
 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(self)"
 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(self)"
 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(self)"
 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     int GetItemHeight();
 494 };
 495
 496 //----------------------------------------------------------------------
 497
 498
 499 class wxTextAttr
 500 {
 501 public:
 502     // ctors
 503     wxTextAttr(const wxColour& colText = wxNullColour,
 504                const wxColour& colBack = wxNullColour,
 505                const wxFont& font = wxNullFont);
 506     ~wxTextAttr();
 507
 508     // setters
 509     void SetTextColour(const wxColour& colText);
 510     void SetBackgroundColour(const wxColour& colBack);
 511     void SetFont(const wxFont& font);
 512
 513     // accessors
 514     bool HasTextColour() const;
 515     bool HasBackgroundColour() const;
 516     bool HasFont() const;
 517
 518     const wxColour& GetTextColour() const;
 519     const wxColour& GetBackgroundColour() const;
 520     const wxFont& GetFont() const;
 521 };
 522
 523
 524
 525 class wxTextCtrl : public wxControl {
 526 public:
 527     wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
 528                const wxPoint& pos = wxDefaultPosition,
 529                const wxSize& size = wxDefaultSize,
 530                long style = 0,
 531                const wxValidator& validator = wxDefaultValidator,
 532                char* name = "text");
 533     %name(wxPreTextCtrl)wxTextCtrl();
 534
 535     bool Create(wxWindow* parent, wxWindowID id, char* value = "",
 536                const wxPoint& pos = wxDefaultPosition,
 537                const wxSize& size = wxDefaultSize,
 538                long style = 0,
 539                const wxValidator& validator = wxDefaultValidator,
 540                char* name = "text");
 541
 542     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 543     %pragma(python) addtomethod = "wxPreTextCtrl:val._setOORInfo(self)"
 544
 545     void Clear();
 546     void Copy();
 547     void Cut();
 548     void DiscardEdits();
 549     long GetInsertionPoint();
 550     long GetLastPosition();
 551     int GetLineLength(long lineNo);
 552     wxString GetLineText(long lineNo);
 553     int GetNumberOfLines();
 554     wxString GetValue();
 555     bool IsModified();
 556     bool LoadFile(const wxString& filename);
 557     void Paste();
 558     void PositionToXY(long pos, long *OUTPUT, long *OUTPUT);
 559     void Remove(long from, long to);
 560     void Replace(long from, long to, const wxString& value);
 561     bool SaveFile(const wxString& filename);
 562     void SetEditable(bool editable);
 563     void SetInsertionPoint(long pos);
 564     void SetInsertionPointEnd();
 565     void SetSelection(long from, long to);
 566     void SetValue(const wxString& value);
 567     void ShowPosition(long pos);
 568     void WriteText(const wxString& text);
 569     void AppendText(const wxString& text);
 570     long XYToPosition(long x, long y);
 571
 572     bool CanCopy();
 573     bool CanCut();
 574     bool CanPaste();
 575     bool CanRedo();
 576     bool CanUndo();
 577     void GetSelection(long* OUTPUT, long* OUTPUT);
 578     bool IsEditable();
 579     void Undo();
 580     void Redo();
 581
 582     bool SetStyle(long start, long end, const wxTextAttr& style);
 583     bool SetDefaultStyle(const wxTextAttr& style);
 584     const wxTextAttr& GetDefaultStyle() const;
 585
 586     void SetMaxLength(unsigned long len);
 587
 588     %addmethods {
 589         void write(const wxString& text) {
 590             self->AppendText(text);
 591         }
 592     }
 593 };
 594
 595 //----------------------------------------------------------------------
 596
 597 class wxScrollBar : public wxControl {
 598 public:
 599     wxScrollBar(wxWindow* parent, wxWindowID id = -1,
 600                 const wxPoint& pos = wxDefaultPosition,
 601                 const wxSize& size = wxDefaultSize,
 602                 long style = wxSB_HORIZONTAL,
 603                 const wxValidator& validator = wxDefaultValidator,
 604                 char* name = "scrollBar");
 605     %name(wxPreScrollBar)wxScrollBar();
 606
 607     bool Create(wxWindow* parent, wxWindowID id = -1,
 608                 const wxPoint& pos = wxDefaultPosition,
 609                 const wxSize& size = wxDefaultSize,
 610                 long style = wxSB_HORIZONTAL,
 611                 const wxValidator& validator = wxDefaultValidator,
 612                 char* name = "scrollBar");
 613
 614     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 615     %pragma(python) addtomethod = "wxPreScrollBar:val._setOORInfo(self)"
 616
 617     int GetRange();
 618     int GetPageSize();
 619     int GetThumbPosition();
 620     int GetThumbSize();
 621     %name(GetThumbLength) int GetThumbSize();  // to match the docs
 622     void SetThumbPosition(int viewStart);
 623     void SetScrollbar(int position, int thumbSize,
 624                       int range,    int pageSize,
 625                       bool refresh = TRUE);
 626 };
 627
 628 //----------------------------------------------------------------------
 629
 630 class wxSpinButton : public wxControl {
 631 public:
 632     wxSpinButton(wxWindow* parent, wxWindowID id = -1,
 633                  const wxPoint& pos = wxDefaultPosition,
 634                  const wxSize& size = wxDefaultSize,
 635                  long style = wxSP_HORIZONTAL,
 636                  char* name = "spinButton");
 637     %name(wxPreSpinButton)wxSpinButton();
 638
 639     bool Create(wxWindow* parent, wxWindowID id = -1,
 640                  const wxPoint& pos = wxDefaultPosition,
 641                  const wxSize& size = wxDefaultSize,
 642                  long style = wxSP_HORIZONTAL,
 643                  char* name = "spinButton");
 644
 645     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 646     %pragma(python) addtomethod = "wxPreSpinButton:val._setOORInfo(self)"
 647
 648     int GetMax();
 649     int GetMin();
 650     int GetValue();
 651     void SetRange(int min, int max);
 652     void SetValue(int value);
 653 };
 654
 655 //----------------------------------------------------------------------
 656
 657 class wxStaticBitmap : public wxControl {
 658 public:
 659     wxStaticBitmap(wxWindow* parent, wxWindowID id,
 660                    const wxBitmap& bitmap,
 661                    const wxPoint& pos = wxDefaultPosition,
 662                    const wxSize& size = wxDefaultSize,
 663                    long style = 0,
 664                    char* name = "staticBitmap");
 665     %name(wxPreStaticBitmap)wxStaticBitmap();
 666
 667     bool Create(wxWindow* parent, wxWindowID id,
 668                    const wxBitmap& bitmap,
 669                    const wxPoint& pos = wxDefaultPosition,
 670                    const wxSize& size = wxDefaultSize,
 671                    long style = 0,
 672                    char* name = "staticBitmap");
 673
 674     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 675     %pragma(python) addtomethod = "wxPreStaticBitmap:val._setOORInfo(self)"
 676
 677     const wxBitmap& GetBitmap();
 678     void SetBitmap(const wxBitmap& bitmap);
 679     void SetIcon(const wxIcon& icon);
 680 };
 681
 682 //----------------------------------------------------------------------
 683
 684 class wxRadioBox : public wxControl {
 685 public:
 686     wxRadioBox(wxWindow* parent, wxWindowID id,
 687                const wxString& label,
 688                const wxPoint& point = wxDefaultPosition,
 689                const wxSize& size = wxDefaultSize,
 690                int LCOUNT = 0, wxString* choices = NULL,
 691                int majorDimension = 0,
 692                long style = wxRA_HORIZONTAL,
 693                const wxValidator& validator = wxDefaultValidator,
 694                char* name = "radioBox");
 695     %name(wxPreRadioBox)wxRadioBox();
 696
 697     bool Create(wxWindow* parent, wxWindowID id,
 698                const wxString& label,
 699                const wxPoint& point = wxDefaultPosition,
 700                const wxSize& size = wxDefaultSize,
 701                int LCOUNT = 0, wxString* choices = NULL,
 702                int majorDimension = 0,
 703                long style = wxRA_HORIZONTAL,
 704                const wxValidator& validator = wxDefaultValidator,
 705                char* name = "radioBox");
 706
 707     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 708     %pragma(python) addtomethod = "wxPreRadioBox:val._setOORInfo(self)"
 709
 710     void Enable(bool enable);
 711     %name(EnableItem)void Enable(int n, bool enable);
 712     int FindString(const wxString& string);
 713
 714     wxString GetString(int n);
 715
 716 #ifdef __WXMSW__
 717     void SetString(int n, const wxString& label);
 718     %pragma(python) addtoclass = "
 719     GetItemLabel = GetString
 720     SetItemLabel = SetString
 721     "
 722     int GetColumnCount();
 723     int GetRowCount();
 724 #else
 725     %name(GetItemLabel)wxString GetLabel( int item );
 726     %name(SetItemLabel)void SetLabel( int item, const wxString& label );
 727 #endif
 728
 729     int GetSelection();
 730     wxString GetStringSelection();
 731     int GetCount();
 732     %pragma(python) addtoclass = "Number = GetCount"
 733
 734     void SetSelection(int n);
 735     void SetStringSelection(const wxString& string);
 736     void Show(bool show);
 737     %name(ShowItem)void Show(int item, bool show);
 738 };
 739
 740 //----------------------------------------------------------------------
 741
 742 class wxRadioButton : public wxControl {
 743 public:
 744     wxRadioButton(wxWindow* parent, wxWindowID id,
 745                   const wxString& label,
 746                   const wxPoint& pos = wxDefaultPosition,
 747                   const wxSize& size = wxDefaultSize,
 748                   long style = 0,
 749                   const wxValidator& validator = wxDefaultValidator,
 750                   char* name = "radioButton");
 751     %name(wxPreRadioButton)wxRadioButton();
 752
 753     bool Create(wxWindow* parent, wxWindowID id,
 754                   const wxString& label,
 755                   const wxPoint& pos = wxDefaultPosition,
 756                   const wxSize& size = wxDefaultSize,
 757                   long style = 0,
 758                   const wxValidator& validator = wxDefaultValidator,
 759                   char* name = "radioButton");
 760
 761     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 762     %pragma(python) addtomethod = "wxPreRadioButton:val._setOORInfo(self)"
 763
 764     bool GetValue();
 765     void SetValue(bool value);
 766 };
 767
 768 //----------------------------------------------------------------------
 769
 770 class wxSlider : public wxControl {
 771 public:
 772     wxSlider(wxWindow* parent, wxWindowID id,
 773              int value, int minValue, int maxValue,
 774              const wxPoint& point = wxDefaultPosition,
 775              const wxSize& size = wxDefaultSize,
 776              long style = wxSL_HORIZONTAL,
 777              const wxValidator& validator = wxDefaultValidator,
 778              char* name = "slider");
 779     %name(wxPreSlider)wxSlider();
 780
 781     bool Create(wxWindow* parent, wxWindowID id,
 782              int value, int minValue, int maxValue,
 783              const wxPoint& point = wxDefaultPosition,
 784              const wxSize& size = wxDefaultSize,
 785              long style = wxSL_HORIZONTAL,
 786              const wxValidator& validator = wxDefaultValidator,
 787              char* name = "slider");
 788
 789     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 790     %pragma(python) addtomethod = "wxPreSlider:val._setOORInfo(self)"
 791
 792     void ClearSel();
 793     void ClearTicks();
 794     int GetLineSize();
 795     int GetMax();
 796     int GetMin();
 797     int GetPageSize();
 798     int GetSelEnd();
 799     int GetSelStart();
 800     int GetThumbLength();
 801     int GetTickFreq();
 802     int GetValue();
 803     void SetRange(int minValue, int maxValue);
 804     void SetTickFreq(int n, int pos);
 805     void SetLineSize(int lineSize);
 806     void SetPageSize(int pageSize);
 807     void SetSelection(int startPos, int endPos);
 808     void SetThumbLength(int len);
 809     void SetTick(int tickPos);
 810     void SetValue(int value);
 811 };
 812
 813
 814 //----------------------------------------------------------------------
 815
 816 class wxSpinCtrl : public wxSpinButton {
 817 public:
 818     wxSpinCtrl(wxWindow *parent,
 819                wxWindowID id = -1,
 820                const char* value = "",
 821                const wxPoint& pos = wxDefaultPosition,
 822                const wxSize& size = wxDefaultSize,
 823                long style = wxSP_ARROW_KEYS,
 824                int min = 0, int max = 100, int initial = 0,
 825                const char* name = "wxSpinCtrl");
 826     %name(wxPreSpinCtrl)wxSpinCtrl();
 827
 828     bool Create(wxWindow *parent,
 829                wxWindowID id = -1,
 830                const char* value = "",
 831                const wxPoint& pos = wxDefaultPosition,
 832                const wxSize& size = wxDefaultSize,
 833                long style = wxSP_ARROW_KEYS,
 834                int min = 0, int max = 100, int initial = 0,
 835                const char* name = "wxSpinCtrl");
 836
 837     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 838     %pragma(python) addtomethod = "wxPreSpinCtrl:val._setOORInfo(self)"
 839
 840     int GetMax();
 841     int GetMin();
 842     int GetValue();
 843     void SetRange(int min, int max);
 844     void SetValue(int value);
 845
 846 };
 847
 848
 849 //----------------------------------------------------------------------
 850
 851 enum { wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, };
 852
 853 class wxToggleButton : public wxControl {
 854 public:
 855     wxToggleButton(wxWindow *parent,
 856                    wxWindowID id,
 857                    const wxString& label,
 858                    const wxPoint& pos = wxDefaultPosition,
 859                    const wxSize& size = wxDefaultSize,
 860                    long style = 0,
 861                    const wxValidator& validator = wxDefaultValidator,
 862                    const char* name = "toggle");
 863     %name(wxPreToggleButton)wxToggleButton();
 864
 865     bool Create(wxWindow *parent,
 866                    wxWindowID id,
 867                    const wxString& label,
 868                    const wxPoint& pos = wxDefaultPosition,
 869                    const wxSize& size = wxDefaultSize,
 870                    long style = 0,
 871                    const wxValidator& validator = wxDefaultValidator,
 872                    const char* name = "toggle");
 873
 874     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 875     %pragma(python) addtomethod = "wxPreToggleButton:val._setOORInfo(self)"
 876
 877     void SetValue(bool value);
 878     bool GetValue() const ;
 879     void SetLabel(const wxString& label);
 880
 881 };
 882
 883 //----------------------------------------------------------------------
 884 //----------------------------------------------------------------------
 885 //----------------------------------------------------------------------
 886
 887
 888