utils/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/dynarray.h>
  20 #include <wx/statline.h>
  21
  22 #ifdef __WXMSW__
  23 #if wxUSE_OWNER_DRAWN
  24 #include <wx/checklst.h>
  25 #endif
  26 #endif
  27
  28 #ifdef __WXGTK__
  29 #include <wx/checklst.h>
  30 #endif
  31
  32 %}
  33
  34 //----------------------------------------------------------------------
  35
  36 %include typemaps.i
  37 %include my_typemaps.i
  38
  39 // Import some definitions of other classes, etc.
  40 %import _defs.i
  41 %import misc.i
  42 %import windows.i
  43 %import gdi.i
  44 %import events.i
  45
  46 %pragma(python) code = "import wx"
  47
  48 //----------------------------------------------------------------------
  49
  50 %{
  51 wxValidator wxPyDefaultValidator;       // Non-const default because of SWIG
  52 %}
  53
  54 //----------------------------------------------------------------------
  55
  56 class wxControl : public wxWindow {
  57 public:
  58 #ifdef __WXMSW__
  59     void Command(wxCommandEvent& event);
  60 #endif
  61     wxString GetLabel();
  62     void SetLabel(const wxString& label);
  63 };
  64
  65 //----------------------------------------------------------------------
  66
  67 class wxButton : public wxControl {
  68 public:
  69     wxButton(wxWindow* parent, wxWindowID id, const wxString& label,
  70              const wxPoint& pos = wxPyDefaultPosition,
  71              const wxSize& size = wxPyDefaultSize,
  72              long style = 0,
  73              const wxValidator& validator = wxPyDefaultValidator,
  74              char* name = "button");
  75
  76     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
  77
  78     void SetDefault();
  79 };
  80
  81 //----------------------------------------------------------------------
  82
  83 class wxBitmapButton : public wxButton {
  84 public:
  85     wxBitmapButton(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
  86                    const wxPoint& pos = wxPyDefaultPosition,
  87                    const wxSize& size = wxPyDefaultSize,
  88                    long style = wxBU_AUTODRAW,
  89                    const wxValidator& validator = wxPyDefaultValidator,
  90                    char* name = "button");
  91
  92     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
  93
  94     wxBitmap& GetBitmapLabel();
  95     wxBitmap& GetBitmapDisabled();
  96     wxBitmap& GetBitmapFocus();
  97     wxBitmap& GetBitmapSelected();
  98     void SetBitmapDisabled(const wxBitmap& bitmap);
  99     void SetBitmapFocus(const wxBitmap& bitmap);
 100     void SetBitmapSelected(const wxBitmap& bitmap);
 101     void SetBitmapLabel(const wxBitmap& bitmap);
 102
 103 };
 104
 105 //----------------------------------------------------------------------
 106
 107 class wxCheckBox : public wxControl {
 108 public:
 109     wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
 110                const wxPoint& pos = wxPyDefaultPosition,
 111                const wxSize& size = wxPyDefaultSize,
 112                long style = 0,
 113                const wxValidator& val = wxPyDefaultValidator,
 114                char* name = "checkBox");
 115
 116     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 117
 118     bool GetValue();
 119     void SetValue(const bool state);
 120 };
 121
 122 //----------------------------------------------------------------------
 123
 124 class wxChoice : public wxControl {
 125 public:
 126     wxChoice(wxWindow *parent, wxWindowID id,
 127              const wxPoint& pos = wxPyDefaultPosition,
 128              const wxSize& size = wxPyDefaultSize,
 129              int LCOUNT=0, wxString* LIST=NULL,
 130              long style = 0,
 131              const wxValidator& validator = wxPyDefaultValidator,
 132              char* name = "choice");
 133
 134     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 135
 136     void Append(const wxString& item);
 137     void Clear();
 138     int FindString(const wxString& string);
 139     int GetColumns();
 140     int GetSelection();
 141     wxString GetString(const int n);
 142     wxString GetStringSelection();
 143     int Number();
 144     void SetColumns(const int n = 1);
 145     void SetSelection(const int n);
 146     void SetStringSelection(const wxString& string);
 147 };
 148
 149 //----------------------------------------------------------------------
 150
 151 class wxComboBox : public wxChoice {
 152 public:
 153     wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
 154                const wxPoint& pos = wxPyDefaultPosition,
 155                const wxSize& size = wxPyDefaultSize,
 156                int LCOUNT=0, wxString* LIST=NULL,
 157                long style = 0,
 158                const wxValidator& validator = wxPyDefaultValidator,
 159                char* name = "comboBox");
 160
 161     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 162
 163     void Append(const wxString& item);
 164     // TODO: void Append(const wxString& item, char* clientData);
 165     void Clear();
 166     void Copy();
 167     void Cut();
 168     void Delete(int n);
 169     // NotMember??:    void Deselect(int n);
 170     int FindString(const wxString& string);
 171     // TODO: char* GetClientData(const int n);
 172     long GetInsertionPoint();
 173     long GetLastPosition();
 174     int GetSelection();
 175     wxString GetString(int n);
 176     wxString GetStringSelection();
 177     wxString GetValue();
 178     int Number();
 179     void Paste();
 180     void Replace(long from, long to, const wxString& text);
 181     void Remove(long from, long to);
 182     // TODO:    void SetClientData(const int n, char* data);
 183     void SetInsertionPoint(long pos);
 184     void SetInsertionPointEnd();
 185     void SetSelection(int n);
 186     %name(SetMark)void SetSelection(long from, long to);
 187     void SetValue(const wxString& text);
 188 };
 189
 190 //----------------------------------------------------------------------
 191
 192 class wxGauge : public wxControl {
 193 public:
 194     wxGauge(wxWindow* parent, wxWindowID id, int range,
 195             const wxPoint& pos = wxPyDefaultPosition,
 196             const wxSize& size = wxPyDefaultSize,
 197             long style = wxGA_HORIZONTAL,
 198             const wxValidator& validator = wxPyDefaultValidator,
 199             char* name = "gauge");
 200
 201     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 202
 203     int GetBezelFace();
 204     int GetRange();
 205     int GetShadowWidth();
 206     int GetValue();
 207     void SetBezelFace(int width);
 208     void SetRange(int range);
 209     void SetShadowWidth(int width);
 210     void SetValue(int pos);
 211 };
 212
 213 //----------------------------------------------------------------------
 214
 215 class wxStaticBox : public wxControl {
 216 public:
 217     wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
 218                 const wxPoint& pos = wxPyDefaultPosition,
 219                 const wxSize& size = wxPyDefaultSize,
 220                 long style = 0,
 221                 char* name = "staticBox");
 222 };
 223
 224
 225 //----------------------------------------------------------------------
 226
 227
 228 class wxStaticLine : public wxControl {
 229 public:
 230     wxStaticLine( wxWindow *parent, wxWindowID id,
 231                   const wxPoint &pos = wxPyDefaultPosition,
 232                   const wxSize &size = wxPyDefaultSize,
 233                   long style = wxLI_HORIZONTAL,
 234                   const char* name = "staticLine" );
 235 };
 236
 237
 238 //----------------------------------------------------------------------
 239
 240 class wxStaticText : public wxControl {
 241 public:
 242     wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
 243                  const wxPoint& pos = wxPyDefaultPosition,
 244                  const wxSize& size = wxPyDefaultSize,
 245                  long style = 0,
 246                  char* name = "staticText");
 247
 248     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 249
 250     wxString GetLabel();
 251     void SetLabel(const wxString& label);
 252 };
 253
 254 //----------------------------------------------------------------------
 255
 256 class wxListBox : public wxControl {
 257 public:
 258     wxListBox(wxWindow* parent, wxWindowID id,
 259               const wxPoint& pos = wxPyDefaultPosition,
 260               const wxSize& size = wxPyDefaultSize,
 261               int LCOUNT, wxString* LIST = NULL,
 262               long style = 0,
 263               const wxValidator& validator = wxPyDefaultValidator,
 264               char* name = "listBox");
 265
 266     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 267
 268     void Append(const wxString& item);
 269     // TODO:    void Append(const wxString& item, char* clientData);
 270     void Clear();
 271     void Delete(int n);
 272     void Deselect(int n);
 273     int FindString(const wxString& string);
 274     // TODO:    char* GetClientData(const int n);
 275     int GetSelection();
 276
 277     // int GetSelections(int **selections);
 278     %addmethods {
 279       PyObject* GetSelections() {
 280           wxArrayInt lst;
 281           self->GetSelections(lst);
 282           PyObject *tup = PyTuple_New(lst.GetCount());
 283           for(int i=0; i<lst.GetCount(); i++) {
 284               PyTuple_SetItem(tup, i, PyInt_FromLong(lst[i]));
 285           }
 286           return tup;
 287       }
 288     }
 289
 290     wxString GetString(int n);
 291     wxString GetStringSelection();
 292     int Number();
 293     bool Selected(const int n);
 294     void Set(int LCOUNT, wxString* LIST);
 295     // TODO:    void SetClientData(const int n, char* data);
 296     void SetFirstItem(int n);
 297     %name(SetFirstItemStr)void SetFirstItem(const wxString& string);
 298     void SetSelection(int n, bool select = TRUE);
 299     void SetString(int n, const wxString& string);
 300     void SetStringSelection(const wxString& string, bool select = TRUE);
 301 };
 302
 303
 304 //----------------------------------------------------------------------
 305
 306 class wxCheckListBox : public wxListBox {
 307 public:
 308     wxCheckListBox(wxWindow *parent, wxWindowID id,
 309                    const wxPoint& pos = wxPyDefaultPosition,
 310                    const wxSize& size = wxPyDefaultSize,
 311                    int LCOUNT = 0,
 312                    wxString* LIST = NULL,
 313                    long style = 0,
 314                    const wxValidator& validator = wxPyDefaultValidator,
 315                    char* name = "listBox");
 316
 317     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 318
 319     bool  IsChecked(int uiIndex);
 320     void  Check(int uiIndex, bool bCheck = TRUE);
 321
 322     int GetItemHeight();
 323 };
 324
 325 //----------------------------------------------------------------------
 326
 327 class wxTextCtrl : public wxControl {
 328 public:
 329     wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
 330                const wxPoint& pos = wxPyDefaultPosition,
 331                const wxSize& size = wxPyDefaultSize,
 332                long style = 0,
 333                const wxValidator& validator = wxPyDefaultValidator,
 334                char* name = "text");
 335
 336     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 337
 338     void Clear();
 339     void Copy();
 340     void Cut();
 341     void DiscardEdits();
 342     long GetInsertionPoint();
 343     long GetLastPosition();
 344     int GetLineLength(long lineNo);
 345     wxString GetLineText(long lineNo);
 346     int GetNumberOfLines();
 347     wxString GetValue();
 348     bool IsModified();
 349     bool LoadFile(const wxString& filename);
 350     void Paste();
 351     void PositionToXY(long pos, long *OUTPUT, long *OUTPUT);
 352     void Remove(long from, long to);
 353     void Replace(long from, long to, const wxString& value);
 354     bool SaveFile(const wxString& filename);
 355     void SetEditable(bool editable);
 356     void SetInsertionPoint(long pos);
 357     void SetInsertionPointEnd();
 358     void SetSelection(long from, long to);
 359     void SetValue(const wxString& value);
 360     void ShowPosition(long pos);
 361     void WriteText(const wxString& text);
 362     void AppendText(const wxString& text);
 363     long XYToPosition(long x, long y);
 364
 365     bool CanCopy();
 366     bool CanCut();
 367     bool CanPaste();
 368     bool CanRedo();
 369     bool CanUndo();
 370     void GetSelection(long* OUTPUT, long* OUTPUT);
 371     bool IsEditable();
 372 };
 373
 374 //----------------------------------------------------------------------
 375
 376 class wxScrollBar : public wxControl {
 377 public:
 378     wxScrollBar(wxWindow* parent, wxWindowID id = -1,
 379                 const wxPoint& pos = wxPyDefaultPosition,
 380                 const wxSize& size = wxPyDefaultSize,
 381                 long style = wxSB_HORIZONTAL,
 382                 const wxValidator& validator = wxPyDefaultValidator,
 383                 char* name = "scrollBar");
 384
 385     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 386
 387     int GetRange();
 388     int GetPageSize();
 389     int GetThumbPosition();
 390     int GetThumbSize();
 391     void SetThumbPosition(int viewStart);
 392     void SetScrollbar(int position, int thumbSize,
 393                       int range,    int pageSize,
 394                       bool refresh = TRUE);
 395 };
 396
 397 //----------------------------------------------------------------------
 398
 399 class wxSpinButton : public wxControl {
 400 public:
 401     wxSpinButton(wxWindow* parent, wxWindowID id = -1,
 402                  const wxPoint& pos = wxPyDefaultPosition,
 403                  const wxSize& size = wxPyDefaultSize,
 404                  long style = wxSP_HORIZONTAL,
 405                  char* name = "spinButton");
 406
 407     int GetMax();
 408     int GetMin();
 409     int GetValue();
 410     void SetRange(int min, int max);
 411     void SetValue(int value);
 412 };
 413
 414 //----------------------------------------------------------------------
 415
 416 class wxStaticBitmap : public wxControl {
 417 public:
 418     wxStaticBitmap(wxWindow* parent, wxWindowID id,
 419                    const wxBitmap& bitmap,
 420                    const wxPoint& pos = wxPyDefaultPosition,
 421                    const wxSize& size = wxPyDefaultSize,
 422                    long style = 0,
 423                    char* name = "staticBitmap");
 424
 425     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 426
 427     const wxBitmap& GetBitmap();
 428     void SetBitmap(const wxBitmap& bitmap);
 429     void SetIcon(const wxIcon& icon);
 430 };
 431
 432 //----------------------------------------------------------------------
 433
 434 class wxRadioBox : public wxControl {
 435 public:
 436     wxRadioBox(wxWindow* parent, wxWindowID id,
 437                const wxString& label,
 438                const wxPoint& point = wxPyDefaultPosition,
 439                const wxSize& size = wxPyDefaultSize,
 440                int LCOUNT = 0, wxString* LIST = NULL,
 441                int majorDimension = 0,
 442                long style = wxRA_HORIZONTAL,
 443                const wxValidator& validator = wxPyDefaultValidator,
 444                char* name = "radioBox");
 445
 446     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 447
 448     void Enable(bool enable);
 449     %name(EnableItem)void Enable(int n, bool enable);
 450     int FindString(const wxString& string);
 451
 452 //***    wxString GetLabel();
 453 //***    void SetLabel(const wxString& label);
 454
 455     %name(GetItemLabel)wxString GetLabel(int n);
 456     int GetSelection();
 457     wxString GetString(int n);
 458     wxString GetStringSelection();
 459     int Number();
 460     %name(SetItemLabel)void SetLabel(int n, const wxString& label);
 461     void SetSelection(int n);
 462     void SetStringSelection(const wxString& string);
 463     void Show(bool show);
 464     %name(ShowItem)void Show(int item, bool show);
 465 };
 466
 467 //----------------------------------------------------------------------
 468
 469 class wxRadioButton : public wxControl {
 470 public:
 471     wxRadioButton(wxWindow* parent, wxWindowID id,
 472                   const wxString& label,
 473                   const wxPoint& pos = wxPyDefaultPosition,
 474                   const wxSize& size = wxPyDefaultSize,
 475                   long style = 0,
 476                   const wxValidator& validator = wxPyDefaultValidator,
 477                   char* name = "radioButton");
 478
 479     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 480
 481     bool GetValue();
 482     void SetValue(bool value);
 483 };
 484
 485 //----------------------------------------------------------------------
 486
 487 class wxSlider : public wxControl {
 488 public:
 489     wxSlider(wxWindow* parent, wxWindowID id,
 490              int value, int minValue, int maxValue,
 491              const wxPoint& point = wxPyDefaultPosition,
 492              const wxSize& size = wxPyDefaultSize,
 493              long style = wxSL_HORIZONTAL,
 494              const wxValidator& validator = wxPyDefaultValidator,
 495              char* name = "slider");
 496
 497     %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
 498
 499     void ClearSel();
 500     void ClearTicks();
 501     int GetLineSize();
 502     int GetMax();
 503     int GetMin();
 504     int GetPageSize();
 505     int GetSelEnd();
 506     int GetSelStart();
 507     int GetThumbLength();
 508     int GetTickFreq();
 509     int GetValue();
 510     void SetRange(int minValue, int maxValue);
 511     void SetTickFreq(int n, int pos);
 512     void SetLineSize(int lineSize);
 513     void SetPageSize(int pageSize);
 514     void SetSelection(int startPos, int endPos);
 515     void SetThumbLength(int len);
 516     void SetTick(int tickPos);
 517     void SetValue(int value);
 518 };
 519
 520
 521 //----------------------------------------------------------------------
 522
 523
 524 /////////////////////////////////////////////////////////////////////////////
 525 //
 526 // $Log$
 527 // Revision 1.17  1999/08/18 07:41:28  RD
 528 // Using a new version of SWIG
 529 //
 530 // A few minor fixes
 531 //
 532 // Revision 1.16  1999/07/31 07:54:35  RD
 533 //
 534 // wxPython 2.1b1:
 535 //
 536 //      Added the missing wxWindow.GetUpdateRegion() method.
 537 //
 538 //      Made a new change in SWIG (update your patches everybody) that
 539 //      provides a fix for global shadow objects that get an exception in
 540 //      their __del__ when their extension module has already been deleted.
 541 //      It was only a 1 line change in .../SWIG/Modules/pycpp.cxx at about
 542 //      line 496 if you want to do it by hand.
 543 //
 544 //      It is now possible to run through MainLoop more than once in any one
 545 //      process.  The cleanup that used to happen as MainLoop completed (and
 546 //      prevented it from running again) has been delayed until the wxc module
 547 //      is being unloaded by Python.
 548 //
 549 //      wxWindow.PopupMenu() now takes a wxPoint instead of  x,y.  Added
 550 //      wxWindow.PopupMenuXY to be consistent with some other methods.
 551 //
 552 //      Added wxGrid.SetEditInPlace and wxGrid.GetEditInPlace.
 553 //
 554 //      You can now provide your own app.MainLoop method.  See
 555 //      wxPython/demo/demoMainLoop.py for an example and some explaination.
 556 //
 557 //      Got the in-place-edit for the wxTreeCtrl fixed and added some demo
 558 //      code to show how to use it.
 559 //
 560 //      Put the wxIcon constructor back in for GTK as it now has one that
 561 //      matches MSW's.
 562 //
 563 //      Added wxGrid.GetCells
 564 //
 565 //      Added wxSystemSettings static methods as functions with names like
 566 //      wxSystemSettings_GetSystemColour.
 567 //
 568 //      Removed wxPyMenu since using menu callbacks have been depreciated in
 569 //      wxWindows.  Use wxMenu and events instead.
 570 //
 571 //      Added alternate wxBitmap constructor (for MSW only) as
 572 //            wxBitmapFromData(data, type, width, height, depth = 1)
 573 //
 574 //      Added a helper function named wxPyTypeCast that can convert shadow
 575 //      objects of one type into shadow objects of another type.  (Like doing
 576 //      a down-cast.)  See the implementation in wx.py for some docs.
 577 //
 578 // Revision 1.15  1999/06/22 17:45:18  RD
 579 //
 580 // wxPython 2.1b1:  Very minor changes needed for wxGTK
 581 //
 582 // Revision 1.14  1999/06/22 07:03:02  RD
 583 //
 584 // wxPython 2.1b1 for wxMSW  (wxGTK coming soon)
 585 // Lots of changes, see the README.txt for details...
 586 //
 587 // Revision 1.13  1999/04/30 21:13:43  RD
 588 //
 589 // wxPython 2.0b9, first phase (win32)
 590 // Added gobs of stuff, see wxPython/README.txt for details
 591 //
 592 // Revision 1.12  1999/04/30 03:29:18  RD
 593 //
 594 // wxPython 2.0b9, first phase (win32)
 595 // Added gobs of stuff, see wxPython/README.txt for details
 596 //
 597 // Revision 1.11.4.1  1999/03/27 23:29:14  RD
 598 //
 599 // wxPython 2.0b8
 600 //     Python thread support
 601 //     various minor additions
 602 //     various minor fixes
 603 //
 604 // Revision 1.11  1999/02/25 07:08:30  RD
 605 //
 606 // wxPython version 2.0b5
 607 //
 608 // Revision 1.10  1998/12/17 17:52:19  RD
 609 //
 610 // wxPython 0.5.2
 611 // Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
 612 // versions are much closer now!
 613 //
 614 // Revision 1.9  1998/12/17 14:07:29  RR
 615 //
 616 //   Removed minor differences between wxMSW and wxGTK
 617 //
 618 // Revision 1.8  1998/12/15 20:41:15  RD
 619 // Changed the import semantics from "from wxPython import *" to "from
 620 // wxPython.wx import *"  This is for people who are worried about
 621 // namespace pollution, they can use "from wxPython import wx" and then
 622 // prefix all the wxPython identifiers with "wx."
 623 //
 624 // Added wxTaskbarIcon for wxMSW.
 625 //
 626 // Made the events work for wxGrid.
 627 //
 628 // Added wxConfig.
 629 //
 630 // Added wxMiniFrame for wxGTK, (untested.)
 631 //
 632 // Changed many of the args and return values that were pointers to gdi
 633 // objects to references to reflect changes in the wxWindows API.
 634 //
 635 // Other assorted fixes and additions.
 636 //
 637 // Revision 1.7  1998/11/16 00:00:53  RD
 638 // Generic treectrl for wxPython/GTK compiles...
 639 //
 640 // Revision 1.6  1998/11/15 23:03:43  RD
 641 // Removing some ifdef's for wxGTK
 642 //
 643 // Revision 1.5  1998/10/07 07:34:32  RD
 644 // Version 0.4.1 for wxGTK
 645 //
 646 // Revision 1.4  1998/10/02 06:40:35  RD
 647 //
 648 // Version 0.4 of wxPython for MSW.
 649 //
 650 // Revision 1.3  1998/08/18 19:48:14  RD
 651 // more wxGTK compatibility things.
 652 //
 653 // It builds now but there are serious runtime problems...
 654 //
 655 // Revision 1.2  1998/08/15 07:36:28  RD
 656 // - Moved the header in the .i files out of the code that gets put into
 657 // the .cpp files.  It caused CVS conflicts because of the RCS ID being
 658 // different each time.
 659 //
 660 // - A few minor fixes.
 661 //
 662 // Revision 1.1  1998/08/09 08:25:49  RD
 663 // Initial version
 664 //
 665 //
 666