wxPython/contrib/gizmos/gizmos.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gizmos.i
   3 // Purpose:     Wrappers for the "gizmo" classes in wx/contrib
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     23-Nov-2001
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2001 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 %define DOCSTRING
  14 "Various *gizmo* classes: `DynamicSashWindow`, `EditableListBox`,
  15 `LEDNumberCtrl`, `TreeListCtrl`, etc."
  16 %enddef
  17
  18 %module(package="wx", docstring=DOCSTRING) gizmos
  19
  20
  21 %{
  22 #include "wx/wxPython/wxPython.h"
  23 #include "wx/wxPython/pyclasses.h"
  24
  25 #include <wx/gizmos/dynamicsash.h>
  26 #include <wx/gizmos/editlbox.h>
  27 #include <wx/gizmos/splittree.h>
  28 #include <wx/gizmos/ledctrl.h>
  29 #include <wx/gizmos/statpict.h>
  30
  31 #include <wx/listctrl.h>
  32 #include <wx/treectrl.h>
  33 #include <wx/imaglist.h>
  34
  35 %}
  36
  37 //---------------------------------------------------------------------------
  38
  39 %import windows.i
  40 %import controls.i
  41 %pythoncode { import wx }
  42 %pythoncode { __docfilter__ = wx._core.__DocFilter(globals()) }
  43
  44
  45 MAKE_CONST_WXSTRING2(DynamicSashNameStr,     wxT("dynamicSashWindow"));
  46 MAKE_CONST_WXSTRING2(EditableListBoxNameStr, wxT("editableListBox"));
  47 MAKE_CONST_WXSTRING(StaticPictureNameStr);
  48
  49 MAKE_CONST_WXSTRING_NOSWIG(EmptyString);
  50
  51 //---------------------------------------------------------------------------
  52
  53 enum {
  54     wxDS_MANAGE_SCROLLBARS,
  55     wxDS_DRAG_CORNER,
  56 };
  57
  58 %constant wxEventType wxEVT_DYNAMIC_SASH_SPLIT;
  59 %constant wxEventType wxEVT_DYNAMIC_SASH_UNIFY;
  60
  61
  62 /*
  63     wxDynamicSashSplitEvents are sent to your view by wxDynamicSashWindow
  64     whenever your view is being split by the user.  It is your
  65     responsibility to handle this event by creating a new view window as
  66     a child of the wxDynamicSashWindow.  wxDynamicSashWindow will
  67     automatically reparent it to the proper place in its window hierarchy.
  68 */
  69 class wxDynamicSashSplitEvent : public wxCommandEvent {
  70 public:
  71     wxDynamicSashSplitEvent(wxObject *target);
  72 };
  73
  74
  75 /*
  76     wxDynamicSashUnifyEvents are sent to your view by wxDynamicSashWindow
  77     whenever the sash which splits your view and its sibling is being
  78     reunified such that your view is expanding to replace its sibling.
  79     You needn't do anything with this event if you are allowing
  80     wxDynamicSashWindow to manage your view's scrollbars, but it is useful
  81     if you are managing the scrollbars yourself so that you can keep
  82     the scrollbars' event handlers connected to your view's event handler
  83     class.
  84 */
  85 class wxDynamicSashUnifyEvent : public wxCommandEvent {
  86 public:
  87     wxDynamicSashUnifyEvent(wxObject *target);
  88 };
  89
  90
  91
  92 /*
  93
  94     wxDynamicSashWindow
  95
  96     wxDynamicSashWindow widgets manages the way other widgets are viewed.
  97     When a wxDynamicSashWindow is first shown, it will contain one child
  98     view, a viewport for that child, and a pair of scrollbars to allow the
  99     user to navigate the child view area.  Next to each scrollbar is a small
 100     tab.  By clicking on either tab and dragging to the appropriate spot, a
 101     user can split the view area into two smaller views separated by a
 102     draggable sash.  Later, when the user wishes to reunify the two subviews,
 103     the user simply drags the sash to the side of the window.
 104     wxDynamicSashWindow will automatically reparent the appropriate child
 105     view back up the window hierarchy, and the wxDynamicSashWindow will have
 106     only one child view once again.
 107
 108     As an application developer, you will simply create a wxDynamicSashWindow
 109     using either the Create() function or the more complex constructor
 110     provided below, and then create a view window whose parent is the
 111     wxDynamicSashWindow.  The child should respond to
 112     wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
 113     constructing a new view window whose parent is also the
 114     wxDynamicSashWindow.  That's it!  Now your users can dynamically split
 115     and reunify the view you provided.
 116
 117     If you wish to handle the scrollbar events for your view, rather than
 118     allowing wxDynamicSashWindow to do it for you, things are a bit more
 119     complex.  (You might want to handle scrollbar events yourself, if,
 120     for instance, you wish to scroll a subwindow of the view you add to
 121     your wxDynamicSashWindow object, rather than scrolling the whole view.)
 122     In this case, you will need to construct your wxDynamicSashWindow without
 123     the wxDS_MANAGE_SCROLLBARS style and  you will need to use the
 124     GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
 125     controls and call SetEventHanler() on them to redirect the scrolling
 126     events whenever your window is reparented by wxDyanmicSashWindow.
 127     You will need to set the scrollbars' event handler at three times:
 128
 129         *  When your view is created
 130         *  When your view receives a wxDynamicSashSplitEvent
 131         *  When your view receives a wxDynamicSashUnifyEvent
 132
 133     See the dynsash_switch sample application for an example which does this.
 134
 135 */
 136
 137 MustHaveApp(wxDynamicSashWindow);
 138
 139 class wxDynamicSashWindow : public wxWindow {
 140 public:
 141     %pythonAppend wxDynamicSashWindow         "self._setOORInfo(self)"
 142     %pythonAppend wxDynamicSashWindow()       ""
 143
 144     wxDynamicSashWindow(wxWindow *parent, wxWindowID id=-1,
 145                         const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
 146                         long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
 147                         const wxString& name = wxPyDynamicSashNameStr);
 148     %RenameCtor(PreDynamicSashWindow, wxDynamicSashWindow());
 149
 150     bool Create(wxWindow *parent, wxWindowID id=-1,
 151                 const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
 152                 long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
 153                 const wxString& name = wxPyDynamicSashNameStr);
 154
 155     wxScrollBar *GetHScrollBar(const wxWindow *child) const;
 156     wxScrollBar *GetVScrollBar(const wxWindow *child) const;
 157 };
 158
 159
 160
 161 %pythoncode {
 162 EVT_DYNAMIC_SASH_SPLIT = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_SPLIT, 1 )
 163 EVT_DYNAMIC_SASH_UNIFY = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_UNIFY, 1 )
 164 }
 165
 166 //---------------------------------------------------------------------------
 167 //---------------------------------------------------------------------------
 168
 169 enum {
 170     wxEL_ALLOW_NEW,
 171     wxEL_ALLOW_EDIT,
 172     wxEL_ALLOW_DELETE,
 173 };
 174
 175 // This class provides a composite control that lets the
 176 // user easily enter list of strings
 177 MustHaveApp(wxEditableListBox);
 178 class wxEditableListBox : public wxPanel
 179 {
 180 public:
 181     %pythonAppend wxEditableListBox         "self._setOORInfo(self)"
 182     %pythonAppend wxEditableListBox()       ""
 183
 184     wxEditableListBox(wxWindow *parent, wxWindowID id=-1,
 185                       const wxString& label = wxPyEmptyString,
 186                       const wxPoint& pos = wxDefaultPosition,
 187                       const wxSize& size = wxDefaultSize,
 188                       long style = wxEL_ALLOW_NEW | wxEL_ALLOW_EDIT | wxEL_ALLOW_DELETE,
 189                       const wxString& name = wxPyEditableListBoxNameStr);
 190
 191
 192     void SetStrings(const wxArrayString& strings);
 193
 194     //void GetStrings(wxArrayString& strings);
 195     %extend {
 196         PyObject* GetStrings() {
 197             wxArrayString strings;
 198             self->GetStrings(strings);
 199             return wxArrayString2PyList_helper(strings);
 200         }
 201     }
 202
 203     wxPyListCtrl* GetListCtrl();
 204     wxBitmapButton* GetDelButton();
 205     wxBitmapButton* GetNewButton();
 206     wxBitmapButton* GetUpButton();
 207     wxBitmapButton* GetDownButton();
 208     wxBitmapButton* GetEditButton();
 209 };
 210
 211
 212
 213 //---------------------------------------------------------------------------
 214
 215
 216 /*
 217  * wxRemotelyScrolledTreeCtrl
 218  *
 219  * This tree control disables its vertical scrollbar and catches scroll
 220  * events passed by a scrolled window higher in the hierarchy.
 221  * It also updates the scrolled window vertical scrollbar as appropriate.
 222  */
 223
 224 %{
 225     typedef wxTreeCtrl wxPyTreeCtrl;
 226 %}
 227
 228 MustHaveApp(wxRemotelyScrolledTreeCtrl);
 229
 230 class wxRemotelyScrolledTreeCtrl: public wxPyTreeCtrl
 231 {
 232 public:
 233     %pythonAppend wxRemotelyScrolledTreeCtrl         "self._setOORInfo(self)"
 234     %pythonAppend wxRemotelyScrolledTreeCtrl()       ""
 235
 236     wxRemotelyScrolledTreeCtrl(wxWindow* parent, wxWindowID id,
 237                                const wxPoint& pos = wxDefaultPosition,
 238                                const wxSize& size = wxDefaultSize,
 239                                long style = wxTR_HAS_BUTTONS);
 240
 241
 242     void HideVScrollbar();
 243
 244     // Adjust the containing wxScrolledWindow's scrollbars appropriately
 245     void AdjustRemoteScrollbars();
 246
 247     // Find the scrolled window that contains this control
 248     wxScrolledWindow* GetScrolledWindow() const;
 249
 250     // Scroll to the given line (in scroll units where each unit is
 251     // the height of an item)
 252     void ScrollToLine(int posHoriz, int posVert);
 253
 254     // The companion window is one which will get notified when certain
 255     // events happen such as node expansion
 256     void SetCompanionWindow(wxWindow* companion);
 257     wxWindow* GetCompanionWindow() const;
 258 };
 259
 260
 261
 262 /*
 263  * wxTreeCompanionWindow
 264  *
 265  * A window displaying values associated with tree control items.
 266  */
 267
 268 %{
 269 class wxPyTreeCompanionWindow: public wxTreeCompanionWindow
 270 {
 271 public:
 272     wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
 273                             const wxPoint& pos = wxDefaultPosition,
 274                             const wxSize& size = wxDefaultSize,
 275                             long style = 0)
 276         : wxTreeCompanionWindow(parent, id, pos, size, style) {}
 277
 278
 279     virtual void DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect) {
 280         bool found;
 281         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 282         if ((found = wxPyCBH_findCallback(m_myInst, "DrawItem"))) {
 283             PyObject* dcobj = wxPyMake_wxObject(&dc,false);
 284             PyObject* idobj = wxPyConstructObject((void*)&id, wxT("wxTreeItemId"), false);
 285             PyObject* recobj= wxPyConstructObject((void*)&rect, wxT("wxRect"), false);
 286             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", dcobj, idobj, recobj));
 287             Py_DECREF(dcobj);
 288             Py_DECREF(idobj);
 289             Py_DECREF(recobj);
 290         }
 291         wxPyEndBlockThreads(blocked);
 292         if (! found)
 293             wxTreeCompanionWindow::DrawItem(dc, id, rect);
 294     }
 295
 296     PYPRIVATE;
 297 };
 298 %}
 299
 300
 301 MustHaveApp(wxPyTreeCompanionWindow);
 302
 303 %rename(TreeCompanionWindow) wxPyTreeCompanionWindow;
 304 class wxPyTreeCompanionWindow: public wxWindow
 305 {
 306 public:
 307     %pythonAppend wxPyTreeCompanionWindow         "self._setOORInfo(self);self._setCallbackInfo(self, TreeCompanionWindow)"
 308     %pythonAppend wxPyTreeCompanionWindow()       ""
 309
 310     wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
 311                             const wxPoint& pos = wxDefaultPosition,
 312                             const wxSize& size = wxDefaultSize,
 313                             long style = 0);
 314     void _setCallbackInfo(PyObject* self, PyObject* _class);
 315
 316     wxRemotelyScrolledTreeCtrl* GetTreeCtrl() const;
 317     void SetTreeCtrl(wxRemotelyScrolledTreeCtrl* treeCtrl);
 318 };
 319
 320
 321
 322 /*
 323  * wxThinSplitterWindow
 324  *
 325  * Implements a splitter with a less obvious sash
 326  * than the usual one.
 327  */
 328
 329 MustHaveApp(wxThinSplitterWindow);
 330
 331 class wxThinSplitterWindow: public wxSplitterWindow
 332 {
 333 public:
 334     %pythonAppend wxThinSplitterWindow         "self._setOORInfo(self)"
 335     %pythonAppend wxThinSplitterWindow()       ""
 336
 337     wxThinSplitterWindow(wxWindow* parent, wxWindowID id = -1,
 338                          const wxPoint& pos = wxDefaultPosition,
 339                          const wxSize& size = wxDefaultSize,
 340                          long style = wxSP_3D | wxCLIP_CHILDREN);
 341 };
 342
 343
 344
 345 /*
 346  * wxSplitterScrolledWindow
 347  *
 348  * This scrolled window is aware of the fact that one of its
 349  * children is a splitter window. It passes on its scroll events
 350  * (after some processing) to both splitter children for them
 351  * scroll appropriately.
 352  */
 353
 354 MustHaveApp(wxSplitterScrolledWindow);
 355
 356 class wxSplitterScrolledWindow: public wxScrolledWindow
 357 {
 358 public:
 359     %pythonAppend wxSplitterScrolledWindow         "self._setOORInfo(self)"
 360     %pythonAppend wxSplitterScrolledWindow()       ""
 361
 362     wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id = -1,
 363                              const wxPoint& pos = wxDefaultPosition,
 364                              const wxSize& size = wxDefaultSize,
 365                              long style = 0);
 366 };
 367
 368
 369 //---------------------------------------------------------------------------
 370 //---------------------------------------------------------------------------
 371
 372
 373 enum wxLEDValueAlign
 374 {
 375     wxLED_ALIGN_LEFT,
 376     wxLED_ALIGN_RIGHT,
 377     wxLED_ALIGN_CENTER,
 378
 379     wxLED_ALIGN_MASK,
 380
 381     wxLED_DRAW_FADED,
 382 };
 383
 384
 385 MustHaveApp(wxLEDNumberCtrl);
 386
 387 class wxLEDNumberCtrl : public wxControl
 388 {
 389 public:
 390     %pythonAppend wxLEDNumberCtrl         "self._setOORInfo(self)"
 391     %pythonAppend wxLEDNumberCtrl()       ""
 392
 393     wxLEDNumberCtrl(wxWindow *parent, wxWindowID id = -1,
 394                     const wxPoint& pos = wxDefaultPosition,
 395                     const wxSize& size = wxDefaultSize,
 396                     long style =  wxLED_ALIGN_LEFT | wxLED_DRAW_FADED);
 397     %RenameCtor(PreLEDNumberCtrl,  wxLEDNumberCtrl());
 398
 399     bool Create(wxWindow *parent, wxWindowID id = -1,
 400                     const wxPoint& pos = wxDefaultPosition,
 401                     const wxSize& size = wxDefaultSize,
 402                     long style = wxLED_ALIGN_LEFT | wxLED_DRAW_FADED);
 403
 404     wxLEDValueAlign GetAlignment() const;
 405     bool GetDrawFaded() const;
 406     const wxString &GetValue() const;
 407
 408     void SetAlignment(wxLEDValueAlign Alignment, bool Redraw = true);
 409     void SetDrawFaded(bool DrawFaded, bool Redraw = true);
 410     void SetValue(const wxString &Value, bool Redraw = true);
 411
 412 };
 413
 414
 415
 416 //----------------------------------------------------------------------
 417
 418 %include _treelist.i
 419
 420 //----------------------------------------------------------------------
 421
 422 enum
 423 {
 424     wxSCALE_HORIZONTAL,
 425     wxSCALE_VERTICAL,
 426     wxSCALE_UNIFORM,
 427     wxSCALE_CUSTOM
 428 };
 429
 430 MustHaveApp(wxStaticPicture);
 431
 432 class wxStaticPicture : public wxControl
 433 {
 434 public:
 435     %pythonAppend wxStaticPicture         "self._setOORInfo(self)"
 436     %pythonAppend wxStaticPicture()       ""
 437
 438     wxStaticPicture( wxWindow* parent, wxWindowID id=-1,
 439                      const wxBitmap& label=wxNullBitmap,
 440                      const wxPoint& pos = wxDefaultPosition,
 441                      const wxSize& size = wxDefaultSize,
 442                      long style = 0,
 443                      const wxString& name = wxPyStaticPictureNameStr );
 444
 445     %RenameCtor(PreStaticPicture, wxStaticPicture());
 446
 447     bool Create( wxWindow* parent, wxWindowID id=-1,
 448                  const wxBitmap& label=wxNullBitmap,
 449                  const wxPoint& pos = wxDefaultPosition,
 450                  const wxSize& size = wxDefaultSize,
 451                  long style = 0,
 452                  const wxString& name = wxPyStaticPictureNameStr );
 453
 454     void SetBitmap( const wxBitmap& bmp );
 455     wxBitmap GetBitmap() const;
 456     void SetIcon( const wxIcon& icon );
 457     wxIcon GetIcon() const;
 458
 459     void SetAlignment( int align );
 460     int GetAlignment() const;
 461
 462     void SetScale( int scale );
 463     int GetScale() const;
 464
 465     void SetCustomScale( float sx, float sy );
 466     void GetCustomScale( float* OUTPUT, float* OUTPUT ) const;
 467
 468 };
 469
 470
 471 //----------------------------------------------------------------------
 472 //----------------------------------------------------------------------
 473
 474 %init %{
 475     wxPyPtrTypeMap_Add("wxTreeCompanionWindow", "wxPyTreeCompanionWindow");
 476 %}
 477
 478 //----------------------------------------------------------------------
 479 //----------------------------------------------------------------------
 480