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