wxPython/src/aui.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        aui.i
   3 // Purpose:     Wrappers for the wxAUI classes.
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     5-July-2006
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2006 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 %define DOCSTRING
  14 "The wx.aui moduleis an Advanced User Interface library that aims to
  15 implement \"cutting-edge\" interface usability and design features so
  16 developers can quickly and easily create beautiful and usable
  17 application interfaces.
  18
  19 **Vision and Design Principles**
  20
  21 wx.aui attempts to encapsulate the following aspects of the user
  22 interface:
  23
  24   * Frame Management: Frame management provides the means to open,
  25     move and hide common controls that are needed to interact with the
  26     document, and allow these configurations to be saved into
  27     different perspectives and loaded at a later time.
  28
  29   * Toolbars: Toolbars are a specialized subset of the frame
  30     management system and should behave similarly to other docked
  31     components. However, they also require additional functionality,
  32     such as \"spring-loaded\" rebar support, \"chevron\" buttons and
  33     end-user customizability.
  34
  35   * Modeless Controls: Modeless controls expose a tool palette or set
  36     of options that float above the application content while allowing
  37     it to be accessed. Usually accessed by the toolbar, these controls
  38     disappear when an option is selected, but may also be \"torn off\"
  39     the toolbar into a floating frame of their own.
  40
  41   * Look and Feel: Look and feel encompasses the way controls are
  42     drawn, both when shown statically as well as when they are being
  43     moved. This aspect of user interface design incorporates \"special
  44     effects\" such as transparent window dragging as well as frame
  45     animation.
  46
  47 **PyAUI adheres to the following principles**
  48
  49   - Use native floating frames to obtain a native look and feel for
  50     all platforms;
  51
  52   - Use existing wxPython code where possible, such as sizer
  53     implementation for frame management;
  54
  55   - Use standard wxPython coding conventions.
  56
  57
  58 **Usage**
  59
  60 The following example shows a simple implementation that utilizes
  61 `wx.aui.FrameManager` to manage three text controls in a frame window::
  62
  63     import wx
  64     import wx.aui
  65
  66     class MyFrame(wx.Frame):
  67
  68         def __init__(self, parent, id=-1, title='wx.aui Test',
  69                      size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
  70             wx.Frame.__init__(self, parent, id, title, pos, size, style)
  71
  72             self._mgr = wx.aui.FrameManager(self)
  73
  74             # create several text controls
  75             text1 = wx.TextCtrl(self, -1, 'Pane 1 - sample text',
  76                                 wx.DefaultPosition, wx.Size(200,150),
  77                                 wx.NO_BORDER | wx.TE_MULTILINE)
  78
  79             text2 = wx.TextCtrl(self, -1, 'Pane 2 - sample text',
  80                                 wx.DefaultPosition, wx.Size(200,150),
  81                                 wx.NO_BORDER | wx.TE_MULTILINE)
  82
  83             text3 = wx.TextCtrl(self, -1, 'Main content window',
  84                                 wx.DefaultPosition, wx.Size(200,150),
  85                                 wx.NO_BORDER | wx.TE_MULTILINE)
  86
  87             # add the panes to the manager
  88             self._mgr.AddPane(text1, wx.LEFT, 'Pane Number One')
  89             self._mgr.AddPane(text2, wx.BOTTOM, 'Pane Number Two')
  90             self._mgr.AddPane(text3, wx.CENTER)
  91
  92             # tell the manager to 'commit' all the changes just made
  93             self._mgr.Update()
  94
  95             self.Bind(wx.EVT_CLOSE, self.OnClose)
  96
  97
  98         def OnClose(self, event):
  99             # deinitialize the frame manager
 100             self._mgr.UnInit()
 101             # delete the frame
 102             self.Destroy()
 103
 104
 105     app = wx.App()
 106     frame = MyFrame(None)
 107     frame.Show()
 108     app.MainLoop()
 109 "
 110 %enddef
 111
 112
 113
 114 %module(package="wx", docstring=DOCSTRING) aui
 115
 116 %{
 117 #include "wx/wxPython/wxPython.h"
 118 #include "wx/wxPython/pyclasses.h"
 119 #include <wx/aui/aui.h>
 120 %}
 121
 122 //---------------------------------------------------------------------------
 123
 124 %import core.i
 125 %import windows.i
 126
 127 %pythoncode { wx = _core }
 128 %pythoncode { __docfilter__ = wx.__DocFilter(globals()) }
 129
 130
 131 %include _aui_docstrings.i
 132
 133 //---------------------------------------------------------------------------
 134
 135
 136 #define wxUSE_AUI 1
 137 #define WXDLLIMPEXP_AUI
 138 #define unsigned
 139 #define wxDEPRECATED(decl)
 140
 141
 142 // We'll skip making wrappers for these, they have overloads that take a
 143 // wxSize or wxPoint
 144 %ignore wxPaneInfo::MaxSize(int x, int y);
 145 %ignore wxPaneInfo::MinSize(int x, int y);
 146 %ignore wxPaneInfo::BestSize(int x, int y);
 147 %ignore wxPaneInfo::FloatingPosition(int x, int y);
 148 %ignore wxPaneInfo::FloatingSize(int x, int y);
 149
 150 // But for these we will do the overloading (see %pythoncode below) so let's
 151 // rename the C++ versions
 152 %rename(_GetPaneByWidget) wxFrameManager::GetPane(wxWindow* window);
 153 %rename(_GetPaneByName)   wxFrameManager::GetPane(const wxString& name);
 154
 155 %rename(_AddPane1) wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info);
 156 %rename(_AddPane2) wxFrameManager::AddPane(wxWindow* window, int direction = wxLEFT,
 157                                            const wxString& caption = wxEmptyString);
 158
 159 %rename(AddPaneAtPos) wxFrameManager::AddPane(wxWindow* window,
 160                                               const wxPaneInfo& pane_info,
 161                                               const wxPoint& drop_pos);
 162
 163 // A typemap for the return value of wxFrameManager::GetAllPanes
 164 %typemap(out) wxPaneInfoArray& {
 165     $result = PyList_New(0);
 166     for (size_t i=0; i < $1->GetCount(); i++) {
 167         PyObject* pane_obj = SWIG_NewPointerObj((void*)(&$1->Item(i)), SWIGTYPE_p_wxPaneInfo, 0);
 168         PyList_Append($result, pane_obj);
 169     }
 170 }
 171
 172
 173 %nokwargs wxAuiTabContainer::SetActivePage;
 174
 175 %pythonAppend wxAuiTabCtrl::wxAuiTabCtrl "self._setOORInfo(self)";
 176
 177 %pythonAppend wxAuiMultiNotebook::wxAuiMultiNotebook    "self._setOORInfo(self)";
 178 %pythonAppend wxAuiMultiNotebook::wxAuiMultiNotebook()  "self._setOORInfo(self)";
 179 %ignore wxAuiMultiNotebook::~wxAuiMultiNotebook;
 180 %rename(PreAuiMultiNotebook) wxAuiMultiNotebook::wxAuiMultiNotebook();
 181
 182 //---------------------------------------------------------------------------
 183 // Get all our defs from the REAL header files.
 184 %include framemanager.h
 185 %include dockart.h
 186 %include floatpane.h
 187 %include auibook.h
 188
 189 //---------------------------------------------------------------------------
 190 // Methods to inject into the FrameManager class that will sort out calls to
 191 // the overloaded versions of GetPane and AddPane
 192
 193 %extend wxFrameManager {
 194     %pythoncode {
 195     def GetPane(self, item):
 196         """
 197         GetPane(self, window_or_info item) -> PaneInfo
 198
 199         GetPane is used to search for a `PaneInfo` object either by
 200         widget reference or by pane name, which acts as a unique id
 201         for a window pane. The returned `PaneInfo` object may then be
 202         modified to change a pane's look, state or position. After one
 203         or more modifications to the `PaneInfo`, `FrameManager.Update`
 204         should be called to realize the changes to the user interface.
 205
 206         If the lookup failed (meaning the pane could not be found in
 207         the manager) GetPane returns an empty `PaneInfo`, a condition
 208         which can be checked by calling `PaneInfo.IsOk`.
 209         """
 210         if isinstance(item, wx.Window):
 211             return self._GetPaneByWidget(item)
 212         else:
 213             return self._GetPaneByName(item)
 214
 215     def AddPane(self, window, info=None, caption=None):
 216         """
 217         AddPane(self, window, info=None, caption=None) -> bool
 218
 219         AddPane tells the frame manager to start managing a child
 220         window. There are two versions of this function. The first
 221         verison accepts a `PaneInfo` object for the ``info`` parameter
 222         and allows the full spectrum of pane parameter
 223         possibilities. (Say that 3 times fast!)
 224
 225         The second version is used for simpler user interfaces which
 226         do not require as much configuration.  In this case the
 227         ``info`` parameter specifies the direction property of the
 228         pane info, and defaults to ``wx.LEFT``.  The pane caption may
 229         also be specified as an extra parameter in this form.
 230         """
 231         if type(info) == PaneInfo:
 232             return self._AddPane1(window, info)
 233         else:
 234             # This Is AddPane2
 235             if info is None:
 236                 info = wx.LEFT
 237             if caption is None:
 238                 caption = ""
 239             return self._AddPane2(window, info, caption)
 240     }
 241
 242     // For backwards compatibility
 243     %pythoncode {
 244          SetFrame = wx._deprecated(SetManagedWindow,
 245                                    "SetFrame is deprecated, use `SetManagedWindow` instead.")
 246          GetFrame = wx._deprecated(GetManagedWindow,
 247                                    "GetFrame is deprecated, use `GetManagedWindow` instead.")
 248     }
 249 }
 250
 251 %extend wxDockInfo {
 252     ~wxDockInfo() {}
 253 }
 254
 255 %extend wxDockUIPart {
 256     wxDockUIPart() {}
 257     ~wxDockUIPart() {}
 258 }
 259
 260 %extend wxPaneButton {
 261     wxPaneButton() {}
 262     ~wxPaneButton() {}
 263 }
 264
 265 //---------------------------------------------------------------------------
 266
 267 %{
 268 // A wxDocArt class that knows how to forward virtuals to Python methods
 269 class wxPyDockArt :  public wxDefaultDockArt
 270 {
 271     wxPyDockArt() : wxDefaultDockArt() {}
 272
 273     DEC_PYCALLBACK_INT_INT(GetMetric);
 274     DEC_PYCALLBACK_VOID_INTINT(SetMetric);
 275     DEC_PYCALLBACK__INTFONT(SetFont);
 276     DEC_PYCALLBACK_FONT_INT(GetFont);
 277     DEC_PYCALLBACK_COLOUR_INT(GetColour);
 278     DEC_PYCALLBACK__INTCOLOUR(SetColour);
 279
 280     virtual void DrawSash(wxDC& dc,
 281                           wxWindow* window,
 282                           int orientation,
 283                           const wxRect& rect)
 284     {
 285         bool found;
 286         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 287         if ((found = wxPyCBH_findCallback(m_myInst, "DrawSash"))) {
 288             PyObject* odc = wxPyMake_wxObject(&dc, false);
 289             PyObject* owin = wxPyMake_wxObject(window, false);
 290             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 291             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiO)",
 292                                                          odc, owin, orientation, orect));
 293             Py_DECREF(odc);
 294             Py_DECREF(orect);
 295         }
 296         wxPyEndBlockThreads(blocked);
 297         if (! found)
 298             wxDefaultDockArt::DrawSash(dc, window, orientation, rect);
 299     }
 300
 301     virtual void DrawBackground(wxDC& dc,
 302                           wxWindow* window,
 303                           int orientation,
 304                           const wxRect& rect)
 305     {
 306         bool found;
 307         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 308         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBackground"))) {
 309             PyObject* odc = wxPyMake_wxObject(&dc, false);
 310             PyObject* owin = wxPyMake_wxObject(window, false);
 311             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 312             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiO)",
 313                                                          odc, owin, orientation, orect));
 314             Py_DECREF(odc);
 315             Py_DECREF(orect);
 316         }
 317         wxPyEndBlockThreads(blocked);
 318         if (! found)
 319             wxDefaultDockArt::DrawBackground(dc, window, orientation, rect);
 320     }
 321
 322     virtual void DrawCaption(wxDC& dc,
 323                           wxWindow* window,
 324                           const wxString& text,
 325                           const wxRect& rect,
 326                           wxPaneInfo& pane)
 327     {
 328         bool found;
 329         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 330         if ((found = wxPyCBH_findCallback(m_myInst, "DrawCaption"))) {
 331             PyObject* odc = wxPyMake_wxObject(&dc, false);
 332             PyObject* owin = wxPyMake_wxObject(window, false);
 333             PyObject* otext = wx2PyString(text);
 334             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 335             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 336             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOO)",
 337                                                          odc, owin, otext, orect, opane));
 338             Py_DECREF(odc);
 339             Py_DECREF(otext);
 340             Py_DECREF(orect);
 341             Py_DECREF(opane);
 342        }
 343         wxPyEndBlockThreads(blocked);
 344         if (! found)
 345             wxDefaultDockArt::DrawCaption(dc, window, text, rect, pane);
 346     }
 347
 348     virtual void DrawGripper(wxDC& dc,
 349                           wxWindow* window,
 350                           const wxRect& rect,
 351                           wxPaneInfo& pane)
 352     {
 353         bool found;
 354         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 355         if ((found = wxPyCBH_findCallback(m_myInst, "DrawGripper"))) {
 356             PyObject* odc = wxPyMake_wxObject(&dc, false);
 357             PyObject* owin = wxPyMake_wxObject(window, false);
 358             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 359             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 360             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOO)", odc, owin, orect, opane));
 361             Py_DECREF(odc);
 362             Py_DECREF(orect);
 363             Py_DECREF(opane);
 364         }
 365         wxPyEndBlockThreads(blocked);
 366         if (! found)
 367             wxDefaultDockArt::DrawGripper(dc, window, rect, pane);
 368     }
 369
 370     virtual void DrawBorder(wxDC& dc,
 371                           wxWindow* window,
 372                           const wxRect& rect,
 373                           wxPaneInfo& pane)
 374     {
 375         bool found;
 376         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 377         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBorder"))) {
 378             PyObject* odc = wxPyMake_wxObject(&dc, false);
 379             PyObject* owin = wxPyMake_wxObject(window, false);
 380             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 381             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 382             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
 383             Py_DECREF(odc);
 384             Py_DECREF(orect);
 385             Py_DECREF(opane);
 386        }
 387         wxPyEndBlockThreads(blocked);
 388         if (! found)
 389             wxDefaultDockArt::DrawBorder(dc, window, rect, pane);
 390     }
 391
 392     virtual void DrawPaneButton(wxDC& dc,
 393                           wxWindow* window,
 394                           int button,
 395                           int button_state,
 396                           const wxRect& rect,
 397                           wxPaneInfo& pane)
 398     {
 399         bool found;
 400         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 401         if ((found = wxPyCBH_findCallback(m_myInst, "DrawPaneButton"))) {
 402             PyObject* odc = wxPyMake_wxObject(&dc, false);
 403             PyObject* owin = wxPyMake_wxObject(window, false);
 404             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 405             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 406             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiIOO)",
 407                                                          odc, owin, button, button_state,
 408                                                          orect, opane));
 409             Py_DECREF(odc);
 410             Py_DECREF(orect);
 411             Py_DECREF(opane);
 412         }
 413         wxPyEndBlockThreads(blocked);
 414         if (! found)
 415             wxDefaultDockArt::DrawPaneButton(dc, window, button, button_state, rect, pane);
 416     }
 417
 418     PYPRIVATE;
 419
 420 };
 421
 422 IMP_PYCALLBACK_INT_INT(wxPyDockArt, wxDefaultDockArt, GetMetric);
 423 IMP_PYCALLBACK_VOID_INTINT(wxPyDockArt, wxDefaultDockArt, SetMetric);
 424 IMP_PYCALLBACK__INTFONT(wxPyDockArt, wxDefaultDockArt, SetFont);
 425 IMP_PYCALLBACK_FONT_INT(wxPyDockArt, wxDefaultDockArt, GetFont);
 426 IMP_PYCALLBACK_COLOUR_INT(wxPyDockArt, wxDefaultDockArt, GetColour);
 427 IMP_PYCALLBACK__INTCOLOUR(wxPyDockArt, wxDefaultDockArt, SetColour);
 428
 429 %}
 430
 431
 432 DocStr(wxPyDockArt,
 433 "This version of the `DockArt` class has been instrumented to be
 434 subclassable in Python and to reflect all calls to the C++ base class
 435 methods to the Python methods implemented in the derived class.", "");
 436
 437 class wxPyDockArt :  public wxDefaultDockArt
 438 {
 439     %pythonAppend wxPyDockArt     "self._setCallbackInfo(self, PyDockArt)"
 440     PyDocArt();
 441
 442 };
 443
 444
 445 //---------------------------------------------------------------------------
 446
 447 %extend wxAuiMultiNotebook {
 448     %property(PageCount, GetPageCount, doc="See `GetPageCount`");
 449     %property(Selection, GetSelection, SetSelection, doc="See `GetSelection` and `SetSelection`");
 450 }
 451
 452
 453 %extend wxAuiNotebookEvent {
 454     %property(OldSelection, GetOldSelection, SetOldSelection, doc="See `GetOldSelection` and `SetOldSelection`");
 455     %property(Selection, GetSelection, SetSelection, doc="See `GetSelection` and `SetSelection`");
 456 }
 457
 458
 459 %extend wxAuiTabContainer {
 460     %property(ActivePage, GetActivePage, SetActivePage, doc="See `GetActivePage` and `SetActivePage`");
 461     %property(PageCount, GetPageCount, doc="See `GetPageCount`");
 462     %property(Pages, GetPages, doc="See `GetPages`");
 463 }
 464
 465
 466 %extend wxFrameManager {
 467     %property(AllPanes, GetAllPanes, doc="See `GetAllPanes`");
 468     %property(ArtProvider, GetArtProvider, SetArtProvider, doc="See `GetArtProvider` and `SetArtProvider`");
 469     %property(Flags, GetFlags, SetFlags, doc="See `GetFlags` and `SetFlags`");
 470     %property(ManagedWindow, GetManagedWindow, SetManagedWindow, doc="See `GetManagedWindow` and `SetManagedWindow`");
 471 }
 472
 473
 474 %extend wxFrameManagerEvent {
 475     %property(Button, GetButton, SetButton, doc="See `GetButton` and `SetButton`");
 476     %property(DC, GetDC, SetDC, doc="See `GetDC` and `SetDC`");
 477     %property(Pane, GetPane, SetPane, doc="See `GetPane` and `SetPane`");
 478 }
 479
 480
 481 //---------------------------------------------------------------------------
 482
 483 #undef wxUSE_AUI
 484 #undef WXDLLIMPEXP_AUI
 485
 486 //---------------------------------------------------------------------------
 487