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/toggbutt.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
  68     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
  69
  70     void Command(wxCommandEvent& event);
  71     wxString GetLabel();
  72     void SetLabel(const wxString& label);
  73 };
  74
  75
  76 //----------------------------------------------------------------------
  77
  78 class wxButton : public wxControl {
  79 public:
  80     wxButton(wxWindow* parent, wxWindowID id, const wxString& label,
  81              const wxPoint& pos = wxDefaultPosition,
  82              const wxSize& size = wxDefaultSize,
  83              long style = 0,
  84              const wxValidator& validator = wxDefaultValidator,
  85              char* name = "button");
  86
  87     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
  88
  89     void SetDefault();
  90     void SetBackgroundColour(const wxColour& colour);
  91     void SetForegroundColour(const wxColour& colour);
  92 };
  93
  94
  95 %inline %{
  96     wxSize wxButton_GetDefaultSize() {
  97         return wxButton::GetDefaultSize();
  98     }
  99 %}
 100
 101 //----------------------------------------------------------------------
 102
 103 class wxBitmapButton : public wxButton {
 104 public:
 105     wxBitmapButton(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
 106                    const wxPoint& pos = wxDefaultPosition,
 107                    const wxSize& size = wxDefaultSize,
 108                    long style = wxBU_AUTODRAW,
 109                    const wxValidator& validator = wxDefaultValidator,
 110                    char* name = "button");
 111
 112     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 113
 114     wxBitmap& GetBitmapLabel();
 115     wxBitmap& GetBitmapDisabled();
 116     wxBitmap& GetBitmapFocus();
 117     wxBitmap& GetBitmapSelected();
 118     void SetBitmapDisabled(const wxBitmap& bitmap);
 119     void SetBitmapFocus(const wxBitmap& bitmap);
 120     void SetBitmapSelected(const wxBitmap& bitmap);
 121     void SetBitmapLabel(const wxBitmap& bitmap);
 122
 123     void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
 124     int GetMarginX() const { return m_marginX; }
 125     int GetMarginY() const { return m_marginY; }
 126 };
 127
 128 //----------------------------------------------------------------------
 129
 130 //  class wxToggleButton : public wxControl {
 131 //  public:
 132 //      wxToggleButton(wxWindow *parent, wxWindowID id, const wxString& label,
 133 //                     const wxPoint& pos = wxDefaultPosition,
 134 //                     const wxSize& size = wxDefaultSize, long style = 0,
 135 //                     const wxValidator& validator = wxDefaultValidator,
 136 //                     const char* name = "toggle");
 137 //      void SetValue(bool value);
 138 //      bool GetValue() const ;
 139 //      void SetLabel(const wxString& label);
 140 //  };
 141
 142 //  class wxBitmapToggleButton : public wxToggleButton {
 143 //  public:
 144 //      wxBitmapToggleButton(wxWindow *parent, wxWindowID id, const wxBitmap *label,
 145 //                           const wxPoint& pos = wxDefaultPosition,
 146 //                           const wxSize& size = wxDefaultSize, long style = 0,
 147 //                           const wxValidator& validator = wxDefaultValidator,
 148 //                           const char *name = "toggle");
 149 //      void SetLabel(const wxBitmap& bitmap);
 150 //  };
 151
 152
 153 //----------------------------------------------------------------------
 154
 155 class wxCheckBox : public wxControl {
 156 public:
 157     wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
 158                const wxPoint& pos = wxDefaultPosition,
 159                const wxSize& size = wxDefaultSize,
 160                long style = 0,
 161                const wxValidator& val = wxDefaultValidator,
 162                char* name = "checkBox");
 163
 164     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 165
 166     bool GetValue();
 167     void SetValue(const bool state);
 168 };
 169
 170 //----------------------------------------------------------------------
 171
 172 class wxChoice : public wxControl {
 173 public:
 174     wxChoice(wxWindow *parent, wxWindowID id,
 175              const wxPoint& pos = wxDefaultPosition,
 176              const wxSize& size = wxDefaultSize,
 177              int LCOUNT=0, wxString* choices=NULL,
 178              long style = 0,
 179              const wxValidator& validator = wxDefaultValidator,
 180              char* name = "choice");
 181
 182     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 183
 184     void Append(const wxString& item);
 185     void Clear();
 186     int FindString(const wxString& string);
 187     int GetColumns();
 188     int GetSelection();
 189     wxString GetString(const int n);
 190     wxString GetStringSelection();
 191     int Number();
 192     void SetColumns(const int n = 1);
 193     void SetSelection(const int n);
 194     void SetStringSelection(const wxString& string);
 195 };
 196
 197 //----------------------------------------------------------------------
 198
 199 class wxComboBox : public wxChoice {
 200 public:
 201     wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
 202                const wxPoint& pos = wxDefaultPosition,
 203                const wxSize& size = wxDefaultSize,
 204                int LCOUNT=0, wxString* choices=NULL,
 205                long style = 0,
 206                const wxValidator& validator = wxDefaultValidator,
 207                char* name = "comboBox");
 208
 209     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 210
 211     void Append(const wxString& item);
 212     // TODO: void Append(const wxString& item, char* clientData);
 213     void Clear();
 214     void Copy();
 215     void Cut();
 216     void Delete(int n);
 217     // NotMember??:    void Deselect(int n);
 218     int FindString(const wxString& string);
 219     // TODO: char* GetClientData(const int n);
 220     long GetInsertionPoint();
 221     long GetLastPosition();
 222     int GetSelection();
 223     wxString GetString(int n);
 224     wxString GetStringSelection();
 225     wxString GetValue();
 226     int Number();
 227     void Paste();
 228     void Replace(long from, long to, const wxString& text);
 229     void Remove(long from, long to);
 230     // TODO:    void SetClientData(const int n, char* data);
 231     void SetInsertionPoint(long pos);
 232     void SetInsertionPointEnd();
 233     void SetSelection(int n);
 234     %name(SetMark)void SetSelection(long from, long to);
 235     void SetValue(const wxString& text);
 236 };
 237
 238 //----------------------------------------------------------------------
 239
 240 class wxGauge : public wxControl {
 241 public:
 242     wxGauge(wxWindow* parent, wxWindowID id, int range,
 243             const wxPoint& pos = wxDefaultPosition,
 244             const wxSize& size = wxDefaultSize,
 245             long style = wxGA_HORIZONTAL,
 246             const wxValidator& validator = wxDefaultValidator,
 247             char* name = "gauge");
 248
 249     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 250
 251     int GetBezelFace();
 252     int GetRange();
 253     int GetShadowWidth();
 254     int GetValue();
 255     void SetBezelFace(int width);
 256     void SetRange(int range);
 257     void SetShadowWidth(int width);
 258     void SetValue(int pos);
 259 };
 260
 261 //----------------------------------------------------------------------
 262
 263 class wxStaticBox : public wxControl {
 264 public:
 265     wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
 266                 const wxPoint& pos = wxDefaultPosition,
 267                 const wxSize& size = wxDefaultSize,
 268                 long style = 0,
 269                 char* name = "staticBox");
 270 };
 271
 272
 273 //----------------------------------------------------------------------
 274
 275
 276 class wxStaticLine : public wxControl {
 277 public:
 278     wxStaticLine( wxWindow *parent, wxWindowID id,
 279                   const wxPoint &pos = wxDefaultPosition,
 280                   const wxSize &size = wxDefaultSize,
 281                   long style = wxLI_HORIZONTAL,
 282                   const char* name = "staticLine" );
 283 };
 284
 285
 286 //----------------------------------------------------------------------
 287
 288 class wxStaticText : public wxControl {
 289 public:
 290     wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
 291                  const wxPoint& pos = wxDefaultPosition,
 292                  const wxSize& size = wxDefaultSize,
 293                  long style = 0,
 294                  char* name = "staticText");
 295
 296     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 297
 298     wxString GetLabel();
 299     void SetLabel(const wxString& label);
 300 };
 301
 302 //----------------------------------------------------------------------
 303
 304 class wxListBox : public wxControl {
 305 public:
 306     wxListBox(wxWindow* parent, wxWindowID id,
 307               const wxPoint& pos = wxDefaultPosition,
 308               const wxSize& size = wxDefaultSize,
 309               int LCOUNT, wxString* choices = NULL,
 310               long style = 0,
 311               const wxValidator& validator = wxDefaultValidator,
 312               char* name = "listBox");
 313
 314     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 315
 316     void Append(const wxString& item);
 317     // TODO:    void Append(const wxString& item, char* clientData);
 318     void Clear();
 319     void Delete(int n);
 320     void Deselect(int n);
 321     int FindString(const wxString& string);
 322     // TODO:    char* GetClientData(const int n);
 323     int GetSelection();
 324
 325     // int GetSelections(int **selections);
 326     %addmethods {
 327       PyObject* GetSelections() {
 328           wxArrayInt lst;
 329           self->GetSelections(lst);
 330           PyObject *tup = PyTuple_New(lst.GetCount());
 331           for(size_t i=0; i<lst.GetCount(); i++) {
 332               PyTuple_SetItem(tup, i, PyInt_FromLong(lst[i]));
 333           }
 334           return tup;
 335       }
 336     }
 337
 338     void InsertItems(int LCOUNT, wxString* choices, int pos);
 339
 340     wxString GetString(int n);
 341     wxString GetStringSelection();
 342     int Number();
 343     bool Selected(const int n);
 344     void Set(int LCOUNT, wxString* choices);
 345     // TODO:    void SetClientData(const int n, char* data);
 346     void SetFirstItem(int n);
 347     %name(SetFirstItemStr)void SetFirstItem(const wxString& string);
 348     void SetSelection(int n, bool select = TRUE);
 349     void SetString(int n, const wxString& string);
 350     void SetStringSelection(const wxString& string, bool select = TRUE);
 351 };
 352
 353
 354 //----------------------------------------------------------------------
 355
 356 class wxCheckListBox : public wxListBox {
 357 public:
 358     wxCheckListBox(wxWindow *parent, wxWindowID id,
 359                    const wxPoint& pos = wxDefaultPosition,
 360                    const wxSize& size = wxDefaultSize,
 361                    int LCOUNT = 0,
 362                    wxString* choices = NULL,
 363                    long style = 0,
 364                    const wxValidator& validator = wxDefaultValidator,
 365                    char* name = "listBox");
 366
 367     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 368
 369     bool  IsChecked(int uiIndex);
 370     void  Check(int uiIndex, int bCheck = TRUE);
 371     void InsertItems(int LCOUNT, wxString* choices, int pos);
 372
 373     int GetItemHeight();
 374 };
 375
 376 //----------------------------------------------------------------------
 377
 378 class wxTextCtrl : public wxControl {
 379 public:
 380     wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
 381                const wxPoint& pos = wxDefaultPosition,
 382                const wxSize& size = wxDefaultSize,
 383                long style = 0,
 384                const wxValidator& validator = wxDefaultValidator,
 385                char* name = "text");
 386
 387     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 388
 389     void Clear();
 390     void Copy();
 391     void Cut();
 392     void DiscardEdits();
 393     long GetInsertionPoint();
 394     long GetLastPosition();
 395     int GetLineLength(long lineNo);
 396     wxString GetLineText(long lineNo);
 397     int GetNumberOfLines();
 398     wxString GetValue();
 399     bool IsModified();
 400     bool LoadFile(const wxString& filename);
 401     void Paste();
 402     void PositionToXY(long pos, long *OUTPUT, long *OUTPUT);
 403     void Remove(long from, long to);
 404     void Replace(long from, long to, const wxString& value);
 405     bool SaveFile(const wxString& filename);
 406     void SetEditable(bool editable);
 407     void SetInsertionPoint(long pos);
 408     void SetInsertionPointEnd();
 409     void SetSelection(long from, long to);
 410     void SetValue(const wxString& value);
 411     void ShowPosition(long pos);
 412     void WriteText(const wxString& text);
 413     void AppendText(const wxString& text);
 414     long XYToPosition(long x, long y);
 415
 416     bool CanCopy();
 417     bool CanCut();
 418     bool CanPaste();
 419     bool CanRedo();
 420     bool CanUndo();
 421     void GetSelection(long* OUTPUT, long* OUTPUT);
 422     bool IsEditable();
 423     void Undo();
 424     void Redo();
 425
 426     %addmethods {
 427         void write(const wxString& text) {
 428             self->AppendText(text + '\n');
 429         }
 430     }
 431 };
 432
 433 //----------------------------------------------------------------------
 434
 435 class wxScrollBar : public wxControl {
 436 public:
 437     wxScrollBar(wxWindow* parent, wxWindowID id = -1,
 438                 const wxPoint& pos = wxDefaultPosition,
 439                 const wxSize& size = wxDefaultSize,
 440                 long style = wxSB_HORIZONTAL,
 441                 const wxValidator& validator = wxDefaultValidator,
 442                 char* name = "scrollBar");
 443
 444     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 445
 446     int GetRange();
 447     int GetPageSize();
 448     int GetThumbPosition();
 449     int GetThumbSize();
 450     %name(GetThumbLength) int GetThumbSize();  // to match the docs
 451     void SetThumbPosition(int viewStart);
 452     void SetScrollbar(int position, int thumbSize,
 453                       int range,    int pageSize,
 454                       bool refresh = TRUE);
 455 };
 456
 457 //----------------------------------------------------------------------
 458
 459 class wxSpinButton : public wxControl {
 460 public:
 461     wxSpinButton(wxWindow* parent, wxWindowID id = -1,
 462                  const wxPoint& pos = wxDefaultPosition,
 463                  const wxSize& size = wxDefaultSize,
 464                  long style = wxSP_HORIZONTAL,
 465                  char* name = "spinButton");
 466
 467     int GetMax();
 468     int GetMin();
 469     int GetValue();
 470     void SetRange(int min, int max);
 471     void SetValue(int value);
 472 };
 473
 474 //----------------------------------------------------------------------
 475
 476 class wxStaticBitmap : public wxControl {
 477 public:
 478     wxStaticBitmap(wxWindow* parent, wxWindowID id,
 479                    const wxBitmap& bitmap,
 480                    const wxPoint& pos = wxDefaultPosition,
 481                    const wxSize& size = wxDefaultSize,
 482                    long style = 0,
 483                    char* name = "staticBitmap");
 484
 485     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 486
 487     const wxBitmap& GetBitmap();
 488     void SetBitmap(const wxBitmap& bitmap);
 489     void SetIcon(const wxIcon& icon);
 490 };
 491
 492 //----------------------------------------------------------------------
 493
 494 class wxRadioBox : public wxControl {
 495 public:
 496     wxRadioBox(wxWindow* parent, wxWindowID id,
 497                const wxString& label,
 498                const wxPoint& point = wxDefaultPosition,
 499                const wxSize& size = wxDefaultSize,
 500                int LCOUNT = 0, wxString* choices = NULL,
 501                int majorDimension = 0,
 502                long style = wxRA_HORIZONTAL,
 503                const wxValidator& validator = wxDefaultValidator,
 504                char* name = "radioBox");
 505
 506     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 507
 508     void Enable(bool enable);
 509     %name(EnableItem)void Enable(int n, bool enable);
 510     int FindString(const wxString& string);
 511
 512 //***    wxString GetLabel();
 513 //***    void SetLabel(const wxString& label);
 514
 515     %name(GetItemLabel)wxString GetLabel(int n);
 516     int GetSelection();
 517     wxString GetString(int n);
 518     wxString GetStringSelection();
 519     int Number();
 520     %name(SetItemLabel)void SetLabel(int n, const wxString& label);
 521     void SetSelection(int n);
 522     void SetStringSelection(const wxString& string);
 523     void Show(bool show);
 524     %name(ShowItem)void Show(int item, bool show);
 525 };
 526
 527 //----------------------------------------------------------------------
 528
 529 class wxRadioButton : public wxControl {
 530 public:
 531     wxRadioButton(wxWindow* parent, wxWindowID id,
 532                   const wxString& label,
 533                   const wxPoint& pos = wxDefaultPosition,
 534                   const wxSize& size = wxDefaultSize,
 535                   long style = 0,
 536                   const wxValidator& validator = wxDefaultValidator,
 537                   char* name = "radioButton");
 538
 539     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 540
 541     bool GetValue();
 542     void SetValue(bool value);
 543 };
 544
 545 //----------------------------------------------------------------------
 546
 547 class wxSlider : public wxControl {
 548 public:
 549     wxSlider(wxWindow* parent, wxWindowID id,
 550              int value, int minValue, int maxValue,
 551              const wxPoint& point = wxDefaultPosition,
 552              const wxSize& size = wxDefaultSize,
 553              long style = wxSL_HORIZONTAL,
 554              const wxValidator& validator = wxDefaultValidator,
 555              char* name = "slider");
 556
 557     %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
 558
 559     void ClearSel();
 560     void ClearTicks();
 561     int GetLineSize();
 562     int GetMax();
 563     int GetMin();
 564     int GetPageSize();
 565     int GetSelEnd();
 566     int GetSelStart();
 567     int GetThumbLength();
 568     int GetTickFreq();
 569     int GetValue();
 570     void SetRange(int minValue, int maxValue);
 571     void SetTickFreq(int n, int pos);
 572     void SetLineSize(int lineSize);
 573     void SetPageSize(int pageSize);
 574     void SetSelection(int startPos, int endPos);
 575     void SetThumbLength(int len);
 576     void SetTick(int tickPos);
 577     void SetValue(int value);
 578 };
 579
 580
 581 //----------------------------------------------------------------------
 582
 583 class wxSpinCtrl : public wxSpinButton {
 584 public:
 585     wxSpinCtrl(wxWindow *parent,
 586                wxWindowID id = -1,
 587                const char* value = "",
 588                const wxPoint& pos = wxDefaultPosition,
 589                const wxSize& size = wxDefaultSize,
 590                long style = wxSP_ARROW_KEYS,
 591                int min = 0, int max = 100, int initial = 0,
 592                const char* name = "wxSpinCtrl");
 593
 594
 595     int GetMax();
 596     int GetMin();
 597     int GetValue();
 598     void SetRange(int min, int max);
 599     void SetValue(int value);
 600
 601 };
 602
 603
 604 //----------------------------------------------------------------------
 605
 606
 607