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 %module gizmos
  14
  15
  16 %{
  17 #include "wxPython.h"
  18 #include <wx/gizmos/dynamicsash.h>
  19 #include <wx/gizmos/editlbox.h>
  20 #include <wx/gizmos/splittree.h>
  21 #include <wx/gizmos/ledctrl.h>
  22 #include <wx/listctrl.h>
  23 %}
  24
  25 //---------------------------------------------------------------------------
  26
  27 %include typemaps.i
  28 %include my_typemaps.i
  29
  30 %extern wx.i
  31 %extern windows.i
  32 %extern _defs.i
  33 %extern events.i
  34 %extern controls.i
  35
  36
  37 //----------------------------------------------------------------------
  38
  39 %{
  40     // Put some wx default wxChar* values into wxStrings.
  41     static const wxString wxPyDynamicSashNameStr(wxT("dynamicSashWindow"));
  42     static const wxString wxPyEditableListBoxNameStr(wxT("editableListBox"));
  43 %}
  44
  45 ///----------------------------------------------------------------------
  46
  47 enum {
  48     wxEVT_DYNAMIC_SASH_SPLIT,
  49     wxEVT_DYNAMIC_SASH_UNIFY,
  50
  51     wxDS_MANAGE_SCROLLBARS,
  52     wxDS_DRAG_CORNER,
  53 };
  54
  55
  56 /*
  57     wxDynamicSashSplitEvents are sent to your view by wxDynamicSashWindow
  58     whenever your view is being split by the user.  It is your
  59     responsibility to handle this event by creating a new view window as
  60     a child of the wxDynamicSashWindow.  wxDynamicSashWindow will
  61     automatically reparent it to the proper place in its window hierarchy.
  62 */
  63 class wxDynamicSashSplitEvent : public wxCommandEvent {
  64 public:
  65     wxDynamicSashSplitEvent(wxObject *target);
  66 };
  67
  68
  69 /*
  70     wxDynamicSashUnifyEvents are sent to your view by wxDynamicSashWindow
  71     whenever the sash which splits your view and its sibling is being
  72     reunified such that your view is expanding to replace its sibling.
  73     You needn't do anything with this event if you are allowing
  74     wxDynamicSashWindow to manage your view's scrollbars, but it is useful
  75     if you are managing the scrollbars yourself so that you can keep
  76     the scrollbars' event handlers connected to your view's event handler
  77     class.
  78 */
  79 class wxDynamicSashUnifyEvent : public wxCommandEvent {
  80 public:
  81     wxDynamicSashUnifyEvent(wxObject *target);
  82 };
  83
  84
  85
  86 /*
  87
  88     wxDynamicSashWindow
  89
  90     wxDynamicSashWindow widgets manages the way other widgets are viewed.
  91     When a wxDynamicSashWindow is first shown, it will contain one child
  92     view, a viewport for that child, and a pair of scrollbars to allow the
  93     user to navigate the child view area.  Next to each scrollbar is a small
  94     tab.  By clicking on either tab and dragging to the appropriate spot, a
  95     user can split the view area into two smaller views separated by a
  96     draggable sash.  Later, when the user wishes to reunify the two subviews,
  97     the user simply drags the sash to the side of the window.
  98     wxDynamicSashWindow will automatically reparent the appropriate child
  99     view back up the window hierarchy, and the wxDynamicSashWindow will have
 100     only one child view once again.
 101
 102     As an application developer, you will simply create a wxDynamicSashWindow
 103     using either the Create() function or the more complex constructor
 104     provided below, and then create a view window whose parent is the
 105     wxDynamicSashWindow.  The child should respond to
 106     wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
 107     constructing a new view window whose parent is also the
 108     wxDynamicSashWindow.  That's it!  Now your users can dynamically split
 109     and reunify the view you provided.
 110
 111     If you wish to handle the scrollbar events for your view, rather than
 112     allowing wxDynamicSashWindow to do it for you, things are a bit more
 113     complex.  (You might want to handle scrollbar events yourself, if,
 114     for instance, you wish to scroll a subwindow of the view you add to
 115     your wxDynamicSashWindow object, rather than scrolling the whole view.)
 116     In this case, you will need to construct your wxDynamicSashWindow without
 117     the wxDS_MANAGE_SCROLLBARS style and  you will need to use the
 118     GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
 119     controls and call SetEventHanler() on them to redirect the scrolling
 120     events whenever your window is reparented by wxDyanmicSashWindow.
 121     You will need to set the scrollbars' event handler at three times:
 122
 123         *  When your view is created
 124         *  When your view receives a wxDynamicSashSplitEvent
 125         *  When your view receives a wxDynamicSashUnifyEvent
 126
 127     See the dynsash_switch sample application for an example which does this.
 128
 129 */
 130
 131 class wxDynamicSashWindow : public wxWindow {
 132 public:
 133     wxDynamicSashWindow(wxWindow *parent, wxWindowID id,
 134                         const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
 135                         long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
 136                         const wxString& name = wxPyDynamicSashNameStr);
 137     %name(wxPreDynamicSashWindow)wxDynamicSashWindow();
 138
 139     bool Create(wxWindow *parent, wxWindowID id,
 140                 const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
 141                 long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
 142                 const wxString& name = wxPyDynamicSashNameStr);
 143
 144     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 145     %pragma(python) addtomethod = "wxPreDynamicSashWindow:val._setOORInfo(val)"
 146
 147     wxScrollBar *GetHScrollBar(const wxWindow *child) const;
 148     wxScrollBar *GetVScrollBar(const wxWindow *child) const;
 149 };
 150
 151
 152
 153 //----------------------------------------------------------------------
 154 // Python functions to act like the event macros
 155
 156 %pragma(python) code = "
 157 def EVT_DYNAMIC_SASH_SPLIT(win, id, func):
 158     win.Connect(id, -1, wxEVT_DYNAMIC_SASH_SPLIT, func)
 159
 160 def EVT_DYNAMIC_SASH_UNIFY(win, id, func):
 161     win.Connect(id, -1, wxEVT_DYNAMIC_SASH_UNIFY, func)
 162 "
 163
 164 //----------------------------------------------------------------------
 165 //----------------------------------------------------------------------
 166
 167 enum {
 168     wxEL_ALLOW_NEW,
 169     wxEL_ALLOW_EDIT,
 170     wxEL_ALLOW_DELETE,
 171 };
 172
 173 // This class provides a composite control that lets the
 174 // user easily enter list of strings
 175 class wxEditableListBox : public wxPanel
 176 {
 177 public:
 178     wxEditableListBox(wxWindow *parent, wxWindowID id,
 179                       const wxString& label,
 180                       const wxPoint& pos = wxDefaultPosition,
 181                       const wxSize& size = wxDefaultSize,
 182                       long style = wxEL_ALLOW_NEW | wxEL_ALLOW_EDIT | wxEL_ALLOW_DELETE,
 183                       const wxString& name = wxPyEditableListBoxNameStr);
 184
 185     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 186
 187     void SetStrings(const wxArrayString& strings);
 188
 189     //void GetStrings(wxArrayString& strings);
 190     %addmethods {
 191         PyObject* GetStrings() {
 192             wxArrayString strings;
 193             self->GetStrings(strings);
 194             return wxArrayString2PyList_helper(strings);
 195         }
 196     }
 197
 198     wxListCtrl* GetListCtrl()       { return m_listCtrl; }
 199     wxBitmapButton* GetDelButton()  { return m_bDel; }
 200     wxBitmapButton* GetNewButton()  { return m_bNew; }
 201     wxBitmapButton* GetUpButton()   { return m_bUp; }
 202     wxBitmapButton* GetDownButton() { return m_bDown; }
 203     wxBitmapButton* GetEditButton() { return m_bEdit; }
 204 };
 205
 206
 207
 208 //----------------------------------------------------------------------
 209
 210
 211 /*
 212  * wxRemotelyScrolledTreeCtrl
 213  *
 214  * This tree control disables its vertical scrollbar and catches scroll
 215  * events passed by a scrolled window higher in the hierarchy.
 216  * It also updates the scrolled window vertical scrollbar as appropriate.
 217  */
 218
 219 %{
 220     typedef wxTreeCtrl wxPyTreeCtrl;
 221 %}
 222
 223 class wxRemotelyScrolledTreeCtrl: public wxPyTreeCtrl
 224 {
 225 public:
 226     wxRemotelyScrolledTreeCtrl(wxWindow* parent, wxWindowID id,
 227                                const wxPoint& pos = wxDefaultPosition,
 228                                const wxSize& size = wxDefaultSize,
 229                                long style = wxTR_HAS_BUTTONS);
 230     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 231
 232
 233     void HideVScrollbar();
 234
 235     // Adjust the containing wxScrolledWindow's scrollbars appropriately
 236     void AdjustRemoteScrollbars();
 237
 238     // Find the scrolled window that contains this control
 239     wxScrolledWindow* GetScrolledWindow() const;
 240
 241     // Scroll to the given line (in scroll units where each unit is
 242     // the height of an item)
 243     void ScrollToLine(int posHoriz, int posVert);
 244
 245     // The companion window is one which will get notified when certain
 246     // events happen such as node expansion
 247     void SetCompanionWindow(wxWindow* companion);
 248     wxWindow* GetCompanionWindow() const;
 249 };
 250
 251
 252
 253 /*
 254  * wxTreeCompanionWindow
 255  *
 256  * A window displaying values associated with tree control items.
 257  */
 258
 259 %{
 260 class wxPyTreeCompanionWindow: public wxTreeCompanionWindow
 261 {
 262 public:
 263     wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
 264                             const wxPoint& pos = wxDefaultPosition,
 265                             const wxSize& size = wxDefaultSize,
 266                             long style = 0)
 267         : wxTreeCompanionWindow(parent, id, pos, size, style) {}
 268
 269
 270     virtual void DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect) {
 271         bool found;
 272         wxPyBeginBlockThreads();
 273         if ((found = wxPyCBH_findCallback(m_myInst, "DrawItem"))) {
 274             PyObject* dcobj = wxPyMake_wxObject(&dc);
 275             PyObject* idobj = wxPyConstructObject((void*)&id, wxT("wxTreeItemId"), FALSE);
 276             PyObject* recobj= wxPyConstructObject((void*)&rect, wxT("wxRect"), FALSE);
 277             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", dcobj, idobj, recobj));
 278             Py_DECREF(dcobj);
 279             Py_DECREF(idobj);
 280             Py_DECREF(recobj);
 281         }
 282         wxPyEndBlockThreads();
 283         if (! found)
 284             wxTreeCompanionWindow::DrawItem(dc, id, rect);
 285     }
 286
 287     PYPRIVATE;
 288 };
 289 %}
 290
 291
 292 %name(wxTreeCompanionWindow) class wxPyTreeCompanionWindow: public wxWindow
 293 {
 294 public:
 295     wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
 296                             const wxPoint& pos = wxDefaultPosition,
 297                             const wxSize& size = wxDefaultSize,
 298                             long style = 0);
 299     void _setCallbackInfo(PyObject* self, PyObject* _class);
 300     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxTreeCompanionWindow)"
 301     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 302
 303     wxRemotelyScrolledTreeCtrl* GetTreeCtrl() const;
 304     void SetTreeCtrl(wxRemotelyScrolledTreeCtrl* treeCtrl);
 305 };
 306
 307
 308
 309 /*
 310  * wxThinSplitterWindow
 311  *
 312  * Implements a splitter with a less obvious sash
 313  * than the usual one.
 314  */
 315
 316 class wxThinSplitterWindow: public wxSplitterWindow
 317 {
 318 public:
 319     wxThinSplitterWindow(wxWindow* parent, wxWindowID id = -1,
 320                          const wxPoint& pos = wxDefaultPosition,
 321                          const wxSize& size = wxDefaultSize,
 322                          long style = wxSP_3D | wxCLIP_CHILDREN);
 323     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 324
 325 };
 326
 327
 328 /*
 329  * wxSplitterScrolledWindow
 330  *
 331  * This scrolled window is aware of the fact that one of its
 332  * children is a splitter window. It passes on its scroll events
 333  * (after some processing) to both splitter children for them
 334  * scroll appropriately.
 335  */
 336
 337 class wxSplitterScrolledWindow: public wxScrolledWindow
 338 {
 339 public:
 340     wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id = -1,
 341                              const wxPoint& pos = wxDefaultPosition,
 342                              const wxSize& size = wxDefaultSize,
 343                              long style = 0);
 344     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 345 };
 346
 347
 348 //----------------------------------------------------------------------
 349 //----------------------------------------------------------------------
 350
 351
 352 enum wxLEDValueAlign
 353 {
 354     wxLED_ALIGN_LEFT,
 355     wxLED_ALIGN_RIGHT,
 356     wxLED_ALIGN_CENTER,
 357
 358     wxLED_ALIGN_MASK,
 359
 360     wxLED_DRAW_FADED,
 361 };
 362
 363
 364 class wxLEDNumberCtrl : public wxControl
 365 {
 366 public:
 367     // Constructors.
 368     wxLEDNumberCtrl(wxWindow *parent, wxWindowID id = -1,
 369                     const wxPoint& pos = wxDefaultPosition,
 370                     const wxSize& size = wxDefaultSize,
 371                     long style =  wxLED_ALIGN_LEFT | wxLED_DRAW_FADED);
 372     %name(wxPreLEDNumberCtrl) wxLEDNumberCtrl();
 373
 374     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 375     %pragma(python) addtomethod = "wxPreLEDNumberCtrl:val._setOORInfo(val)"
 376
 377     // Create functions.
 378     bool Create(wxWindow *parent, wxWindowID id = -1,
 379                     const wxPoint& pos = wxDefaultPosition,
 380                     const wxSize& size = wxDefaultSize,
 381                     long style = wxLED_ALIGN_LEFT | wxLED_DRAW_FADED);
 382
 383     wxLEDValueAlign GetAlignment() const { return m_Alignment; }
 384     bool GetDrawFaded() const { return m_DrawFaded; }
 385     const wxString &GetValue() const { return m_Value; }
 386
 387     void SetAlignment(wxLEDValueAlign Alignment, bool Redraw = true);
 388     void SetDrawFaded(bool DrawFaded, bool Redraw = true);
 389     void SetValue(const wxString &Value, bool Redraw = true);
 390
 391 };
 392
 393 //----------------------------------------------------------------------
 394 //----------------------------------------------------------------------
 395
 396 %init %{
 397
 398     wxClassInfo::CleanUpClasses();
 399     wxClassInfo::InitializeClasses();
 400
 401     wxPyPtrTypeMap_Add("wxTreeCompanionWindow", "wxPyTreeCompanionWindow");
 402 %}
 403
 404
 405 %pragma(python) include="_gizmoextras.py";
 406
 407 //----------------------------------------------------------------------
 408 //----------------------------------------------------------------------
 409
 410
 411
 412
 413
 414