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 **wx.aui 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.AuiManager(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 // Preprocessor stuff so SWIG doesn't get confused when %include-ing
 136 // the aui .h files.
 137 %ignore wxUSE_AUI;
 138 %ignore wxUSE_MENUS;
 139 %ignore wxABI_VERSION;
 140 #define wxUSE_AUI 1
 141 #define wxUSE_MENUS 1
 142 #define wxABI_VERSION 99999
 143
 144 #define WXDLLIMPEXP_AUI
 145 #define unsigned
 146 #define wxDEPRECATED(decl)
 147 #define DECLARE_EVENT_TABLE()
 148 #define DECLARE_DYNAMIC_CLASS(foo)
 149
 150
 151
 152 // We'll skip making wrappers for these, they have overloads that take a
 153 // wxSize or wxPoint
 154 %ignore wxAuiPaneInfo::MaxSize(int x, int y);
 155 %ignore wxAuiPaneInfo::MinSize(int x, int y);
 156 %ignore wxAuiPaneInfo::BestSize(int x, int y);
 157 %ignore wxAuiPaneInfo::FloatingPosition(int x, int y);
 158 %ignore wxAuiPaneInfo::FloatingSize(int x, int y);
 159
 160 // But for these we will do the overloading (see %pythoncode below) so let's
 161 // rename the C++ versions
 162 %rename(_GetPaneByWidget) wxAuiManager::GetPane(wxWindow* window);
 163 %rename(_GetPaneByName)   wxAuiManager::GetPane(const wxString& name);
 164
 165 %rename(_AddPane1) wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info);
 166 %rename(_AddPane2) wxAuiManager::AddPane(wxWindow* window, int direction = wxLEFT,
 167                                          const wxString& caption = wxEmptyString);
 168
 169 %rename(AddPaneAtPos) wxAuiManager::AddPane(wxWindow* window,
 170                                             const wxPaneInfo& pane_info,
 171                                             const wxPoint& drop_pos);
 172
 173 // A typemap for the return value of wxFrameManager::GetAllPanes
 174 %typemap(out) wxAuiPaneInfoArray& {
 175     $result = PyList_New(0);
 176     for (size_t i=0; i < $1->GetCount(); i++) {
 177         PyObject* pane_obj = SWIG_NewPointerObj((void*)(&$1->Item(i)), SWIGTYPE_p_wxAuiPaneInfo, 0);
 178         PyList_Append($result, pane_obj);
 179     }
 180 }
 181
 182
 183 %nokwargs wxAuiTabContainer::SetActivePage;
 184
 185 %pythonAppend wxAuiTabCtrl::wxAuiTabCtrl "self._setOORInfo(self)";
 186
 187 %pythonAppend wxAuiNotebook::wxAuiNotebook    "self._setOORInfo(self)";
 188 %pythonAppend wxAuiNotebook::wxAuiNotebook()  "val._setOORInfo(val)";
 189 %ignore wxAuiiNotebook::~wxAuiNotebook;
 190 %rename(PreAuiNotebook) wxAuiNotebook::wxAuiNotebook();
 191
 192 // Link error...
 193 %ignore wxAuiDefaultTabArt::SetWindow;
 194
 195 // ignore this overload
 196 %ignore wxAuiTabContainer::GetPage(size_t idx) const;
 197
 198
 199
 200 %pythonAppend wxAuiMDIParentFrame::wxAuiMDIParentFrame    "self._setOORInfo(self)";
 201 %pythonAppend wxAuiMDIParentFrame::wxAuiMDIParentFrame()  "val._setOORInfo(val)";
 202 %ignore wxAuiMDIParentFrame::~wxAuiMDIParentFrame;
 203 %rename(PreAuiMDIParentFrame) wxAuiMDIParentFrame::wxAuiMDIParentFrame();
 204
 205 // Ignore these for now because they need a typemap for the return value, see below.
 206 %ignore wxAuiMDIParentFrame::GetNotebook;
 207 %ignore wxAuiMDIParentFrame::GetActiveChild;
 208 %ignore wxAuiMDIParentFrame::GetClientWindow;
 209
 210 %pythonAppend wxAuiMDIChildFrame::wxAuiMDIChildFrame    "self._setOORInfo(self)";
 211 %pythonAppend wxAuiMDIChildFrame::wxAuiMDIChildFrame()  "val._setOORInfo(val)";
 212 %ignore wxAuiMDIChildFrame::~wxAuiMDIChildFrame;
 213 %rename(PreAuiMDIChildFrame) wxAuiMDIChildFrame::wxAuiMDIChildFrame();
 214
 215 %pythonAppend wxAuiMDIClientWindow::wxAuiMDIClientWindow    "self._setOORInfo(self)";
 216 %pythonAppend wxAuiMDIClientWindow::wxAuiMDIClientWindow()  "val._setOORInfo(val)";
 217 %ignore wxAuiMDIClientWindow::~wxAuiMDIClientWindow;
 218 %rename(PreAuiMDIClientWindow) wxAuiMDIClientWindow::wxAuiMDIClientWindow();
 219
 220
 221 %typemap(out) wxEvtHandler*             { $result = wxPyMake_wxObject($1, $owner); }
 222
 223 //---------------------------------------------------------------------------
 224 // Get all our defs from the REAL header files.
 225
 226 #define wxColor wxColour  // fix problem in dockart.h
 227
 228 %include framemanager.h
 229 %include dockart.h
 230 %include floatpane.h
 231 %include auibook.h
 232 %include tabmdi.h
 233
 234 #undef wxColor
 235
 236 //---------------------------------------------------------------------------
 237 // Methods to inject into the FrameManager class that will sort out calls to
 238 // the overloaded versions of GetPane and AddPane
 239
 240 %extend wxAuiManager {
 241     %pythoncode {
 242     def GetPane(self, item):
 243         """
 244         GetPane(self, window_or_info item) -> PaneInfo
 245
 246         GetPane is used to search for a `PaneInfo` object either by
 247         widget reference or by pane name, which acts as a unique id
 248         for a window pane. The returned `PaneInfo` object may then be
 249         modified to change a pane's look, state or position. After one
 250         or more modifications to the `PaneInfo`, `FrameManager.Update`
 251         should be called to realize the changes to the user interface.
 252
 253         If the lookup failed (meaning the pane could not be found in
 254         the manager) GetPane returns an empty `PaneInfo`, a condition
 255         which can be checked by calling `PaneInfo.IsOk`.
 256         """
 257         if isinstance(item, wx.Window):
 258             return self._GetPaneByWidget(item)
 259         else:
 260             return self._GetPaneByName(item)
 261
 262     def AddPane(self, window, info=None, caption=None):
 263         """
 264         AddPane(self, window, info=None, caption=None) -> bool
 265
 266         AddPane tells the frame manager to start managing a child
 267         window. There are two versions of this function. The first
 268         verison accepts a `PaneInfo` object for the ``info`` parameter
 269         and allows the full spectrum of pane parameter
 270         possibilities. (Say that 3 times fast!)
 271
 272         The second version is used for simpler user interfaces which
 273         do not require as much configuration.  In this case the
 274         ``info`` parameter specifies the direction property of the
 275         pane info, and defaults to ``wx.LEFT``.  The pane caption may
 276         also be specified as an extra parameter in this form.
 277         """
 278         if type(info) == AuiPaneInfo:
 279             return self._AddPane1(window, info)
 280         else:
 281             # This Is AddPane2
 282             if info is None:
 283                 info = wx.LEFT
 284             if caption is None:
 285                 caption = ""
 286             return self._AddPane2(window, info, caption)
 287     }
 288
 289     // For backwards compatibility
 290     %pythoncode {
 291          SetFrame = wx._deprecated(SetManagedWindow,
 292                                    "SetFrame is deprecated, use `SetManagedWindow` instead.")
 293          GetFrame = wx._deprecated(GetManagedWindow,
 294                                    "GetFrame is deprecated, use `GetManagedWindow` instead.")
 295     }
 296 }
 297
 298 %extend wxAuiDockInfo {
 299     ~wxAuiDockInfo() {}
 300 }
 301
 302 %extend wxAuiDockUIPart {
 303     ~wxAuiDockUIPart() {}
 304 }
 305
 306 %extend wxAuiPaneButton {
 307     ~wxAuiPaneButton() {}
 308 }
 309
 310 %extend wxAuiMDIParentFrame {
 311     %typemap(out) wxAuiNotebook*          { $result = wxPyMake_wxObject($1, $owner); }
 312     %typemap(out) wxAuiMDIChildFrame*     { $result = wxPyMake_wxObject($1, $owner); }
 313     %typemap(out) wxAuiMDIClientWindow*   { $result = wxPyMake_wxObject($1, $owner); }
 314
 315     %rename(GetNotebook) _GetNotebook;
 316     %rename(GetActiveChild) _GetActiveChild;
 317     %rename(GetClientWindow) _GetClientWindow;
 318
 319     wxAuiNotebook* _GetNotebook() const
 320     {
 321         return self->GetNotebook();
 322     }
 323
 324     wxAuiMDIChildFrame* _GetActiveChild() const
 325     {
 326         return self->GetActiveChild();
 327     }
 328
 329     wxAuiMDIClientWindow* _GetClientWindow() const
 330     {
 331         return self->GetClientWindow();
 332     }
 333
 334     %typemap(out) wxAuiNotebook*;
 335     %typemap(out) wxAuiMDIChildFrame*;
 336     %typemap(out) wxAuiMDIClientWindow*;
 337 }
 338
 339
 340 //---------------------------------------------------------------------------
 341
 342 %{
 343 // A wxDocArt class that knows how to forward virtuals to Python methods
 344 class wxPyAuiDockArt :  public wxAuiDefaultDockArt
 345 {
 346 public:
 347     wxPyAuiDockArt() : wxAuiDefaultDockArt() {}
 348
 349     DEC_PYCALLBACK_INT_INT(GetMetric);
 350     DEC_PYCALLBACK_VOID_INTINT(SetMetric);
 351     DEC_PYCALLBACK__INTFONT(SetFont);
 352     DEC_PYCALLBACK_FONT_INT(GetFont);
 353     DEC_PYCALLBACK_COLOUR_INT(GetColour);
 354     DEC_PYCALLBACK__INTCOLOUR(SetColour);
 355
 356     virtual void DrawSash(wxDC& dc,
 357                           wxWindow* window,
 358                           int orientation,
 359                           const wxRect& rect)
 360     {
 361         bool found;
 362         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 363         if ((found = wxPyCBH_findCallback(m_myInst, "DrawSash"))) {
 364             PyObject* odc = wxPyMake_wxObject(&dc, false);
 365             PyObject* owin = wxPyMake_wxObject(window, false);
 366             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 367             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiO)",
 368                                                          odc, owin, orientation, orect));
 369             Py_DECREF(odc);
 370             Py_DECREF(owin);
 371             Py_DECREF(orect);
 372         }
 373         wxPyEndBlockThreads(blocked);
 374         if (! found)
 375             wxAuiDefaultDockArt::DrawSash(dc, window, orientation, rect);
 376     }
 377
 378     virtual void DrawBackground(wxDC& dc,
 379                           wxWindow* window,
 380                           int orientation,
 381                           const wxRect& rect)
 382     {
 383         bool found;
 384         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 385         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBackground"))) {
 386             PyObject* odc = wxPyMake_wxObject(&dc, false);
 387             PyObject* owin = wxPyMake_wxObject(window, false);
 388             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 389             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiO)",
 390                                                          odc, owin, orientation, orect));
 391             Py_DECREF(odc);
 392             Py_DECREF(owin);
 393             Py_DECREF(orect);
 394         }
 395         wxPyEndBlockThreads(blocked);
 396         if (! found)
 397             wxAuiDefaultDockArt::DrawBackground(dc, window, orientation, rect);
 398     }
 399
 400     virtual void DrawCaption(wxDC& dc,
 401                           wxWindow* window,
 402                           const wxString& text,
 403                           const wxRect& rect,
 404                           wxAuiPaneInfo& pane)
 405     {
 406         bool found;
 407         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 408         if ((found = wxPyCBH_findCallback(m_myInst, "DrawCaption"))) {
 409             PyObject* odc = wxPyMake_wxObject(&dc, false);
 410             PyObject* owin = wxPyMake_wxObject(window, false);
 411             PyObject* otext = wx2PyString(text);
 412             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 413             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiPaneInfo"), 0);
 414             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOO)",
 415                                                          odc, owin, otext, orect, opane));
 416             Py_DECREF(odc);
 417             Py_DECREF(owin);
 418             Py_DECREF(otext);
 419             Py_DECREF(orect);
 420             Py_DECREF(opane);
 421        }
 422         wxPyEndBlockThreads(blocked);
 423         if (! found)
 424             wxAuiDefaultDockArt::DrawCaption(dc, window, text, rect, pane);
 425     }
 426
 427     virtual void DrawGripper(wxDC& dc,
 428                           wxWindow* window,
 429                           const wxRect& rect,
 430                           wxAuiPaneInfo& pane)
 431     {
 432         bool found;
 433         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 434         if ((found = wxPyCBH_findCallback(m_myInst, "DrawGripper"))) {
 435             PyObject* odc = wxPyMake_wxObject(&dc, false);
 436             PyObject* owin = wxPyMake_wxObject(window, false);
 437             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 438             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiPaneInfo"), 0);
 439             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOO)", odc, owin, orect, opane));
 440             Py_DECREF(odc);
 441             Py_DECREF(orect);
 442             Py_DECREF(opane);
 443         }
 444         wxPyEndBlockThreads(blocked);
 445         if (! found)
 446             wxAuiDefaultDockArt::DrawGripper(dc, window, rect, pane);
 447     }
 448
 449     virtual void DrawBorder(wxDC& dc,
 450                           wxWindow* window,
 451                           const wxRect& rect,
 452                           wxAuiPaneInfo& pane)
 453     {
 454         bool found;
 455         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 456         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBorder"))) {
 457             PyObject* odc = wxPyMake_wxObject(&dc, false);
 458             PyObject* owin = wxPyMake_wxObject(window, false);
 459             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 460             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiPaneInfo"), 0);
 461             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
 462             Py_DECREF(odc);
 463             Py_DECREF(owin);
 464             Py_DECREF(orect);
 465             Py_DECREF(opane);
 466        }
 467         wxPyEndBlockThreads(blocked);
 468         if (! found)
 469             wxAuiDefaultDockArt::DrawBorder(dc, window, rect, pane);
 470     }
 471
 472     virtual void DrawPaneButton(wxDC& dc,
 473                           wxWindow* window,
 474                           int button,
 475                           int button_state,
 476                           const wxRect& rect,
 477                           wxAuiPaneInfo& pane)
 478     {
 479         bool found;
 480         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 481         if ((found = wxPyCBH_findCallback(m_myInst, "DrawPaneButton"))) {
 482             PyObject* odc = wxPyMake_wxObject(&dc, false);
 483             PyObject* owin = wxPyMake_wxObject(window, false);
 484             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 485             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiPaneInfo"), 0);
 486             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiIOO)",
 487                                                          odc, owin, button, button_state,
 488                                                          orect, opane));
 489             Py_DECREF(odc);
 490             Py_DECREF(owin);
 491             Py_DECREF(orect);
 492             Py_DECREF(opane);
 493         }
 494         wxPyEndBlockThreads(blocked);
 495         if (! found)
 496             wxAuiDefaultDockArt::DrawPaneButton(dc, window, button, button_state, rect, pane);
 497     }
 498
 499     PYPRIVATE;
 500
 501 };
 502
 503 IMP_PYCALLBACK_INT_INT(wxPyAuiDockArt, wxAuiDefaultDockArt, GetMetric);
 504 IMP_PYCALLBACK_VOID_INTINT(wxPyAuiDockArt, wxAuiDefaultDockArt, SetMetric);
 505 IMP_PYCALLBACK__INTFONT(wxPyAuiDockArt, wxAuiDefaultDockArt, SetFont);
 506 IMP_PYCALLBACK_FONT_INT(wxPyAuiDockArt, wxAuiDefaultDockArt, GetFont);
 507 IMP_PYCALLBACK_COLOUR_INT(wxPyAuiDockArt, wxAuiDefaultDockArt, GetColour);
 508 IMP_PYCALLBACK__INTCOLOUR(wxPyAuiDockArt, wxAuiDefaultDockArt, SetColour);
 509
 510 %}
 511
 512
 513 DocStr(wxPyAuiDockArt,
 514 "This version of the `AuiDockArt` class has been instrumented to be
 515 subclassable in Python and to reflect all calls to the C++ base class
 516 methods to the Python methods implemented in the derived class.", "");
 517
 518 class wxPyAuiDockArt :  public wxAuiDefaultDockArt
 519 {
 520 public:
 521     %pythonAppend wxPyAuiDockArt     setCallbackInfo(PyAuiDockArt)
 522     wxPyAuiDockArt();
 523
 524     void _setCallbackInfo(PyObject* self, PyObject* _class);
 525 };
 526
 527
 528 //---------------------------------------------------------------------------
 529
 530 %extend wxAuiNotebook {
 531     %property(PageCount, GetPageCount, doc="See `GetPageCount`");
 532     %property(Selection, GetSelection, SetSelection, doc="See `GetSelection` and `SetSelection`");
 533 }
 534
 535
 536 %extend wxAuiNotebookEvent {
 537     %property(OldSelection, GetOldSelection, SetOldSelection, doc="See `GetOldSelection` and `SetOldSelection`");
 538     %property(Selection, GetSelection, SetSelection, doc="See `GetSelection` and `SetSelection`");
 539 }
 540
 541
 542 %extend wxAuiTabContainer {
 543     %property(ActivePage, GetActivePage, SetActivePage, doc="See `GetActivePage` and `SetActivePage`");
 544     %property(PageCount, GetPageCount, doc="See `GetPageCount`");
 545     %property(Pages, GetPages, doc="See `GetPages`");
 546 }
 547
 548
 549 %extend wxAuiManager {
 550     %property(AllPanes, GetAllPanes, doc="See `GetAllPanes`");
 551     %property(ArtProvider, GetArtProvider, SetArtProvider, doc="See `GetArtProvider` and `SetArtProvider`");
 552     %property(Flags, GetFlags, SetFlags, doc="See `GetFlags` and `SetFlags`");
 553     %property(ManagedWindow, GetManagedWindow, SetManagedWindow, doc="See `GetManagedWindow` and `SetManagedWindow`");
 554 }
 555
 556
 557 %extend wxAuiManagerEvent {
 558     %property(Button, GetButton, SetButton, doc="See `GetButton` and `SetButton`");
 559     %property(DC, GetDC, SetDC, doc="See `GetDC` and `SetDC`");
 560     %property(Pane, GetPane, SetPane, doc="See `GetPane` and `SetPane`");
 561 }
 562
 563
 564 //---------------------------------------------------------------------------
 565
 566 %{
 567 // A wxTabArt class that knows how to forward virtuals to Python methods
 568 class wxPyAuiTabArt :  public wxAuiDefaultTabArt
 569 {
 570 public:
 571     wxPyAuiTabArt() : wxAuiDefaultTabArt() {}
 572
 573
 574     virtual void DrawBackground( wxDC& dc,
 575                                  wxWindow* wnd,
 576                                  const wxRect& rect )
 577     {
 578         bool found;
 579         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 580         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBackground"))) {
 581             PyObject* odc = wxPyMake_wxObject(&dc, false);
 582             PyObject* ownd = wxPyMake_wxObject(wnd, false);
 583             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 584             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, ownd, orect));
 585             Py_DECREF(odc);
 586             Py_DECREF(ownd);
 587             Py_DECREF(orect);
 588         }
 589         wxPyEndBlockThreads(blocked);
 590         if (!found)
 591             wxAuiDefaultTabArt::DrawBackground(dc, wnd, rect);
 592     }
 593
 594     virtual void DrawTab( wxDC& dc,
 595                           wxWindow* wnd,
 596                           const wxAuiNotebookPage& pane,
 597                           const wxRect& in_rect,
 598                           int close_button_state,
 599                           wxRect* out_tab_rect,
 600                           wxRect* out_button_rect,
 601                           int* x_extent)
 602     {
 603         bool found;
 604         const char* errmsg = "DrawTab should return a sequence containing (tab_rect, button_rect, x_extent)";
 605         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 606         if ((found = wxPyCBH_findCallback(m_myInst, "DrawTab"))) {
 607             PyObject* odc = wxPyMake_wxObject(&dc, false);
 608             PyObject* ownd = wxPyMake_wxObject(wnd, false);
 609             PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiNotebookPage"), 0);
 610             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);
 611             PyObject* ro;
 612             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue(
 613                                              "(OOOOOii)",
 614                                              odc, ownd, orect, opane,
 615                                              close_button_state));
 616             if (ro) {
 617                 if (PySequence_Check(ro) && PyObject_Length(ro) == 3) {
 618                     PyObject* o1 = PySequence_GetItem(ro, 0);
 619                     PyObject* o2 = PySequence_GetItem(ro, 1);
 620                     PyObject* o3 = PySequence_GetItem(ro, 2);
 621                     if (!wxRect_helper(o1, &out_tab_rect))
 622                         PyErr_SetString(PyExc_TypeError, errmsg);
 623                     else if (!wxRect_helper(o2, &out_button_rect))
 624                         PyErr_SetString(PyExc_TypeError, errmsg);
 625                     else if (!PyInt_Check(o3))
 626                         PyErr_SetString(PyExc_TypeError, errmsg);
 627                     else
 628                         *x_extent = PyInt_AsLong(o3);
 629
 630                     Py_DECREF(o1);
 631                     Py_DECREF(o2);
 632                     Py_DECREF(o3);
 633                 }
 634                 else {
 635                     PyErr_SetString(PyExc_TypeError, errmsg);
 636                 }
 637                 Py_DECREF(ro);
 638             }
 639
 640             Py_DECREF(odc);
 641             Py_DECREF(ownd);
 642             Py_DECREF(orect);
 643             Py_DECREF(opane);
 644         }
 645         wxPyEndBlockThreads(blocked);
 646         if (!found)
 647             wxAuiDefaultTabArt::DrawTab(dc, wnd, pane, in_rect, close_button_state, out_tab_rect, out_button_rect, x_extent);
 648     }
 649
 650
 651     virtual void DrawButton( wxDC& dc,
 652                              wxWindow* wnd,
 653                              const wxRect& in_rect,
 654                              int bitmap_id,
 655                              int button_state,
 656                              int orientation,
 657                              wxRect* out_rect)
 658     {
 659         bool found;
 660         const char* errmsg = "DrawButton should return a wxRect";
 661         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 662         if ((found = wxPyCBH_findCallback(m_myInst, "DrawButton"))) {
 663             PyObject* odc = wxPyMake_wxObject(&dc, false);
 664             PyObject* ownd = wxPyMake_wxObject(wnd, false);
 665             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);
 666             PyObject* ro;
 667             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOiiiO)", odc, ownd, orect,
 668                                                                  bitmap_id, button_state, orientation));
 669             if (ro) {
 670                 if (!wxRect_helper(ro, &out_rect))
 671                     PyErr_SetString(PyExc_TypeError, errmsg);
 672                 Py_DECREF(ro);
 673             }
 674
 675             Py_DECREF(odc);
 676             Py_DECREF(ownd);
 677             Py_DECREF(orect);
 678         }
 679         wxPyEndBlockThreads(blocked);
 680         if (!found)
 681             wxAuiDefaultTabArt::DrawButton(dc, wnd, in_rect, bitmap_id, button_state, orientation, out_rect);
 682     }
 683
 684
 685     virtual wxSize GetTabSize( wxDC& dc,
 686                                wxWindow* wnd,
 687                                const wxString& caption,
 688                                const wxBitmap& bitmap,
 689                                bool active,
 690                                int  close_button_state,
 691                                int* x_extent)
 692     {
 693         bool found;
 694         wxSize rv, *prv = &rv;
 695         const char* errmsg = "GetTabSize should return a sequence containing (size, x_extent)";
 696         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 697         if ((found = wxPyCBH_findCallback(m_myInst, "GetTabSize"))) {
 698             PyObject* odc = wxPyMake_wxObject(&dc, false);
 699             PyObject* ownd = wxPyMake_wxObject(wnd, false);
 700             PyObject* otext = wx2PyString(caption);
 701             PyObject* obmp = wxPyMake_wxObject((wxObject*)&bitmap, false);
 702             PyObject* ro;
 703             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue(
 704                                              "(OOOOii)", odc, ownd, otext, obmp, (int)active, close_button_state));
 705             if (ro) {
 706                 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
 707                     PyObject* o1 = PySequence_GetItem(ro, 0);
 708                     PyObject* o2 = PySequence_GetItem(ro, 1);
 709                     if (!wxSize_helper(o1, &prv))
 710                         PyErr_SetString(PyExc_TypeError, errmsg);
 711                     else if (!PyInt_Check(o2))
 712                         PyErr_SetString(PyExc_TypeError, errmsg);
 713                     else
 714                         *x_extent = PyInt_AsLong(o2);
 715
 716                     Py_DECREF(o1);
 717                     Py_DECREF(o2);
 718                 }
 719                 else {
 720                     PyErr_SetString(PyExc_TypeError, errmsg);
 721                 }
 722                 Py_DECREF(ro);
 723             }
 724
 725             Py_DECREF(odc);
 726             Py_DECREF(ownd);
 727             Py_DECREF(otext);
 728             Py_DECREF(obmp);
 729         }
 730         wxPyEndBlockThreads(blocked);
 731         if (!found)
 732             rv = wxAuiDefaultTabArt::GetTabSize(dc, wnd, caption, bitmap, active, close_button_state, x_extent);
 733         return rv;
 734     }
 735
 736 // TODO
 737 //     virtual int ShowDropDown(
 738 //                          wxWindow* wnd,
 739 //                          const wxAuiNotebookPageArray& items,
 740 //                          int active_idx);
 741
 742 //     virtual int GetIndentSize();
 743
 744 //     virtual int GetBestTabCtrlSize(wxWindow* wnd,
 745 //                                    const wxAuiNotebookPageArray& pages,
 746 //                                    const wxSize& required_bmp_size);
 747 //     virtual wxAuiTabArt* Clone();
 748 //     virtual void SetFlags(unsigned int flags);
 749 //     virtual void SetSizingInfo(const wxSize& tab_ctrl_size,
 750 //                                size_t tab_count);
 751 //     virtual int GetIndentSize();
 752
 753
 754
 755     DEC_PYCALLBACK__FONT(SetNormalFont);
 756     DEC_PYCALLBACK__FONT(SetSelectedFont);
 757     DEC_PYCALLBACK__FONT(SetMeasuringFont);
 758
 759     PYPRIVATE;
 760 };
 761
 762
 763 IMP_PYCALLBACK__FONT(wxPyAuiTabArt, wxAuiDefaultTabArt, SetNormalFont);
 764 IMP_PYCALLBACK__FONT(wxPyAuiTabArt, wxAuiDefaultTabArt, SetSelectedFont);
 765 IMP_PYCALLBACK__FONT(wxPyAuiTabArt, wxAuiDefaultTabArt, SetMeasuringFont);
 766 %}
 767
 768
 769 DocStr(wxPyAuiTabArt,
 770 "This version of the `TabArt` class has been instrumented to be
 771 subclassable in Python and to reflect all calls to the C++ base class
 772 methods to the Python methods implemented in the derived class.", "");
 773
 774 class wxPyAuiTabArt :  public wxAuiDefaultTabArt
 775 {
 776 public:
 777     %pythonAppend wxPyAuiTabArt     setCallbackInfo(PyAuiTabArt)
 778     wxPyAuiTabArt();
 779
 780     void _setCallbackInfo(PyObject* self, PyObject* _class);
 781 };
 782
 783
 784 //---------------------------------------------------------------------------
 785
 786