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 //---------------------------------------------------------------------------
 252
 253 %{
 254 // A wxDocArt class that knows how to forward virtuals to Python methods
 255 class wxPyDockArt :  public wxDefaultDockArt
 256 {
 257     wxPyDockArt() : wxDefaultDockArt() {}
 258
 259     DEC_PYCALLBACK_INT_INT(GetMetric);
 260     DEC_PYCALLBACK_VOID_INTINT(SetMetric);
 261     DEC_PYCALLBACK__INTFONT(SetFont);
 262     DEC_PYCALLBACK_FONT_INT(GetFont);
 263     DEC_PYCALLBACK_COLOUR_INT(GetColour);
 264     DEC_PYCALLBACK__INTCOLOUR(SetColour);
 265
 266     virtual void DrawSash(wxDC& dc,
 267                           wxWindow* window,
 268                           int orientation,
 269                           const wxRect& rect)
 270     {
 271         bool found;
 272         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 273         if ((found = wxPyCBH_findCallback(m_myInst, "DrawSash"))) {
 274             PyObject* odc = wxPyMake_wxObject(&dc, false);
 275             PyObject* owin = wxPyMake_wxObject(window, false);
 276             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 277             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiO)",
 278                                                          odc, owin, orientation, orect));
 279             Py_DECREF(odc);
 280             Py_DECREF(orect);
 281         }
 282         wxPyEndBlockThreads(blocked);
 283         if (! found)
 284             wxDefaultDockArt::DrawSash(dc, window, orientation, rect);
 285     }
 286
 287     virtual void DrawBackground(wxDC& dc,
 288                           wxWindow* window,
 289                           int orientation,
 290                           const wxRect& rect)
 291     {
 292         bool found;
 293         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 294         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBackground"))) {
 295             PyObject* odc = wxPyMake_wxObject(&dc, false);
 296             PyObject* owin = wxPyMake_wxObject(window, false);
 297             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 298             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiO)",
 299                                                          odc, owin, orientation, orect));
 300             Py_DECREF(odc);
 301             Py_DECREF(orect);
 302         }
 303         wxPyEndBlockThreads(blocked);
 304         if (! found)
 305             wxDefaultDockArt::DrawBackground(dc, window, orientation, rect);
 306     }
 307
 308     virtual void DrawCaption(wxDC& dc,
 309                           wxWindow* window,
 310                           const wxString& text,
 311                           const wxRect& rect,
 312                           wxPaneInfo& pane)
 313     {
 314         bool found;
 315         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 316         if ((found = wxPyCBH_findCallback(m_myInst, "DrawCaption"))) {
 317             PyObject* odc = wxPyMake_wxObject(&dc, false);
 318             PyObject* owin = wxPyMake_wxObject(window, false);
 319             PyObject* otext = wx2PyString(text);
 320             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 321             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 322             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOO)",
 323                                                          odc, owin, otext, orect, opane));
 324             Py_DECREF(odc);
 325             Py_DECREF(otext);
 326             Py_DECREF(orect);
 327             Py_DECREF(opane);
 328        }
 329         wxPyEndBlockThreads(blocked);
 330         if (! found)
 331             wxDefaultDockArt::DrawCaption(dc, window, text, rect, pane);
 332     }
 333
 334     virtual void DrawGripper(wxDC& dc,
 335                           wxWindow* window,
 336                           const wxRect& rect,
 337                           wxPaneInfo& pane)
 338     {
 339         bool found;
 340         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 341         if ((found = wxPyCBH_findCallback(m_myInst, "DrawGripper"))) {
 342             PyObject* odc = wxPyMake_wxObject(&dc, false);
 343             PyObject* owin = wxPyMake_wxObject(window, false);
 344             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 345             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 346             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOO)", odc, owin, orect, opane));
 347             Py_DECREF(odc);
 348             Py_DECREF(orect);
 349             Py_DECREF(opane);
 350         }
 351         wxPyEndBlockThreads(blocked);
 352         if (! found)
 353             wxDefaultDockArt::DrawGripper(dc, window, rect, pane);
 354     }
 355
 356     virtual void DrawBorder(wxDC& dc,
 357                           wxWindow* window,
 358                           const wxRect& rect,
 359                           wxPaneInfo& pane)
 360     {
 361         bool found;
 362         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 363         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBorder"))) {
 364             PyObject* odc = wxPyMake_wxObject(&dc, false);
 365             PyObject* owin = wxPyMake_wxObject(window, false);
 366             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 367             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 368             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
 369             Py_DECREF(odc);
 370             Py_DECREF(orect);
 371             Py_DECREF(opane);
 372        }
 373         wxPyEndBlockThreads(blocked);
 374         if (! found)
 375             wxDefaultDockArt::DrawBorder(dc, window, rect, pane);
 376     }
 377
 378     virtual void DrawPaneButton(wxDC& dc,
 379                           wxWindow* window,
 380                           int button,
 381                           int button_state,
 382                           const wxRect& rect,
 383                           wxPaneInfo& pane)
 384     {
 385         bool found;
 386         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 387         if ((found = wxPyCBH_findCallback(m_myInst, "DrawPaneButton"))) {
 388             PyObject* odc = wxPyMake_wxObject(&dc, false);
 389             PyObject* owin = wxPyMake_wxObject(window, false);
 390             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 391             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 392             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiIOO)",
 393                                                          odc, owin, button, button_state,
 394                                                          orect, opane));
 395             Py_DECREF(odc);
 396             Py_DECREF(orect);
 397             Py_DECREF(opane);
 398         }
 399         wxPyEndBlockThreads(blocked);
 400         if (! found)
 401             wxDefaultDockArt::DrawPaneButton(dc, window, button, button_state, rect, pane);
 402     }
 403
 404     PYPRIVATE;
 405
 406 };
 407
 408 IMP_PYCALLBACK_INT_INT(wxPyDockArt, wxDefaultDockArt, GetMetric);
 409 IMP_PYCALLBACK_VOID_INTINT(wxPyDockArt, wxDefaultDockArt, SetMetric);
 410 IMP_PYCALLBACK__INTFONT(wxPyDockArt, wxDefaultDockArt, SetFont);
 411 IMP_PYCALLBACK_FONT_INT(wxPyDockArt, wxDefaultDockArt, GetFont);
 412 IMP_PYCALLBACK_COLOUR_INT(wxPyDockArt, wxDefaultDockArt, GetColour);
 413 IMP_PYCALLBACK__INTCOLOUR(wxPyDockArt, wxDefaultDockArt, SetColour);
 414
 415 %}
 416
 417
 418 DocStr(wxPyDockArt,
 419 "This version of the `DockArt` class has been instrumented to be
 420 subclassable in Python and to reflect all calls to the C++ base class
 421 methods to the Python methods implemented in the derived class.", "");
 422
 423 class wxPyDockArt :  public wxDefaultDockArt
 424 {
 425     %pythonAppend wxPyDockArt     "self._setCallbackInfo(self, PyDockArt)"
 426     PyDocArt();
 427
 428 };
 429
 430
 431 //---------------------------------------------------------------------------
 432
 433 %extend wxAuiMultiNotebook {
 434     %property(PageCount, GetPageCount, doc="See `GetPageCount`");
 435     %property(Selection, GetSelection, SetSelection, doc="See `GetSelection` and `SetSelection`");
 436 }
 437
 438
 439 %extend wxAuiNotebookEvent {
 440     %property(OldSelection, GetOldSelection, SetOldSelection, doc="See `GetOldSelection` and `SetOldSelection`");
 441     %property(Selection, GetSelection, SetSelection, doc="See `GetSelection` and `SetSelection`");
 442 }
 443
 444
 445 %extend wxAuiTabContainer {
 446     %property(ActivePage, GetActivePage, SetActivePage, doc="See `GetActivePage` and `SetActivePage`");
 447     %property(PageCount, GetPageCount, doc="See `GetPageCount`");
 448     %property(Pages, GetPages, doc="See `GetPages`");
 449 }
 450
 451
 452 %extend wxFrameManager {
 453     %property(AllPanes, GetAllPanes, doc="See `GetAllPanes`");
 454     %property(ArtProvider, GetArtProvider, SetArtProvider, doc="See `GetArtProvider` and `SetArtProvider`");
 455     %property(Flags, GetFlags, SetFlags, doc="See `GetFlags` and `SetFlags`");
 456     %property(ManagedWindow, GetManagedWindow, SetManagedWindow, doc="See `GetManagedWindow` and `SetManagedWindow`");
 457 }
 458
 459
 460 %extend wxFrameManagerEvent {
 461     %property(Button, GetButton, SetButton, doc="See `GetButton` and `SetButton`");
 462     %property(DC, GetDC, SetDC, doc="See `GetDC` and `SetDC`");
 463     %property(Pane, GetPane, SetPane, doc="See `GetPane` and `SetPane`");
 464 }
 465
 466
 467 //---------------------------------------------------------------------------
 468
 469 #undef wxUSE_AUI
 470 #undef WXDLLIMPEXP_AUI
 471
 472 //---------------------------------------------------------------------------
 473