| 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 | |