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 lcass 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                           int orientation,
 268                           const wxRect& rect)
 269     {
 270         bool found;
 271         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 272         if ((found = wxPyCBH_findCallback(m_myInst, "DrawSash"))) {
 273             PyObject* odc = wxPyMake_wxObject(&dc, false);
 274             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 275             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)",
 276                                                          odc, orientation, orect));
 277             Py_DECREF(odc);
 278             Py_DECREF(orect);
 279         }
 280         wxPyEndBlockThreads(blocked);
 281         if (! found)
 282             wxDefaultDockArt::DrawSash(dc, orientation, rect);
 283     }
 284
 285     virtual void DrawBackground(wxDC& dc,
 286                           int orientation,
 287                           const wxRect& rect)
 288     {
 289         bool found;
 290         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 291         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBackground"))) {
 292             PyObject* odc = wxPyMake_wxObject(&dc, false);
 293             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 294             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)",
 295                                                          odc, orientation, orect));
 296             Py_DECREF(odc);
 297             Py_DECREF(orect);
 298         }
 299         wxPyEndBlockThreads(blocked);
 300         if (! found)
 301             wxDefaultDockArt::DrawBackground(dc, orientation, rect);
 302     }
 303
 304     virtual void DrawCaption(wxDC& dc,
 305                           const wxString& text,
 306                           const wxRect& rect,
 307                           wxPaneInfo& pane)
 308     {
 309         bool found;
 310         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 311         if ((found = wxPyCBH_findCallback(m_myInst, "DrawCaption"))) {
 312             PyObject* odc = wxPyMake_wxObject(&dc, false);
 313             PyObject* otext = wx2PyString(text);
 314             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 315             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 316             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOO)",
 317                                                          odc, otext, orect, opane));
 318             Py_DECREF(odc);
 319             Py_DECREF(otext);
 320             Py_DECREF(orect);
 321             Py_DECREF(opane);
 322        }
 323         wxPyEndBlockThreads(blocked);
 324         if (! found)
 325             wxDefaultDockArt::DrawCaption(dc, text, rect, pane);
 326     }
 327
 328     virtual void DrawGripper(wxDC& dc,
 329                           const wxRect& rect,
 330                           wxPaneInfo& pane)
 331     {
 332         bool found;
 333         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 334         if ((found = wxPyCBH_findCallback(m_myInst, "DrawGripper"))) {
 335             PyObject* odc = wxPyMake_wxObject(&dc, false);
 336             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 337             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 338             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
 339             Py_DECREF(odc);
 340             Py_DECREF(orect);
 341             Py_DECREF(opane);
 342         }
 343         wxPyEndBlockThreads(blocked);
 344         if (! found)
 345             wxDefaultDockArt::DrawGripper(dc, rect, pane);
 346     }
 347
 348     virtual void DrawBorder(wxDC& dc,
 349                           const wxRect& rect,
 350                           wxPaneInfo& pane)
 351     {
 352         bool found;
 353         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 354         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBorder"))) {
 355             PyObject* odc = wxPyMake_wxObject(&dc, false);
 356             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 357             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 358             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
 359             Py_DECREF(odc);
 360             Py_DECREF(orect);
 361             Py_DECREF(opane);
 362        }
 363         wxPyEndBlockThreads(blocked);
 364         if (! found)
 365             wxDefaultDockArt::DrawBorder(dc, rect, pane);
 366     }
 367
 368     virtual void DrawPaneButton(wxDC& dc,
 369                           int button,
 370                           int button_state,
 371                           const wxRect& rect,
 372                           wxPaneInfo& pane)
 373     {
 374         bool found;
 375         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 376         if ((found = wxPyCBH_findCallback(m_myInst, "DrawPaneButton"))) {
 377             PyObject* odc = wxPyMake_wxObject(&dc, false);
 378             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 379             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
 380             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiIOO)",
 381                                                          odc, button, button_state,
 382                                                          orect, opane));
 383             Py_DECREF(odc);
 384             Py_DECREF(orect);
 385             Py_DECREF(opane);
 386         }
 387         wxPyEndBlockThreads(blocked);
 388         if (! found)
 389             wxDefaultDockArt::DrawPaneButton(dc, button, button_state, rect, pane);
 390     }
 391
 392     PYPRIVATE;
 393
 394 };
 395
 396 IMP_PYCALLBACK_INT_INT(wxPyDockArt, wxDefaultDockArt, GetMetric);
 397 IMP_PYCALLBACK_VOID_INTINT(wxPyDockArt, wxDefaultDockArt, SetMetric);
 398 IMP_PYCALLBACK__INTFONT(wxPyDockArt, wxDefaultDockArt, SetFont);
 399 IMP_PYCALLBACK_FONT_INT(wxPyDockArt, wxDefaultDockArt, GetFont);
 400 IMP_PYCALLBACK_COLOUR_INT(wxPyDockArt, wxDefaultDockArt, GetColour);
 401 IMP_PYCALLBACK__INTCOLOUR(wxPyDockArt, wxDefaultDockArt, SetColour);
 402
 403 %}
 404
 405
 406 DocStr(wxPyDockArt,
 407 "This version of the `DockArt` class has been instrumented to be
 408 subclassable in Python and to reflect all calls to the C++ base class
 409 methods to the Python methods implemented in the derived class.", "");
 410
 411 class wxPyDockArt :  public wxDefaultDockArt
 412 {
 413     %pythonAppend wxPyDockArt     "self._setCallbackInfo(self, PyDockArt)"
 414     PyDocArt();
 415
 416 };
 417
 418
 419
 420 #undef wxUSE_AUI
 421 #undef WXDLLIMPEXP_AUI
 422
 423 //---------------------------------------------------------------------------
 424