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 wxRect& in_rect,
 520                           const wxString& caption,
 521                           const wxBitmap& bitmap,
 522                           bool active,
 523                           int close_button_state,
 524                           wxRect* out_tab_rect,
 525                           wxRect* out_button_rect,
 526                           int* x_extent)
 527     {
 528         bool found;
 529         const char* errmsg = "DrawTab should return a sequence containing (tab_rect, button_rect, x_extent)";
 530         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 531         if ((found = wxPyCBH_findCallback(m_myInst, "DrawTab"))) {
 532             PyObject* odc = wxPyMake_wxObject(&dc, false);
 533             PyObject* ownd = wxPyMake_wxObject(wnd, false);
 534             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);
 535             PyObject* otext = wx2PyString(caption);
 536             PyObject* obmp = wxPyMake_wxObject((wxObject*)&bitmap, false);
 537             PyObject* ro;
 538             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue(
 539                                              "(OOOOOii)",
 540                                              odc, ownd, orect, otext, obmp,
 541                                              (int)active, close_button_state));
 542             if (ro) {
 543                 if (PySequence_Check(ro) && PyObject_Length(ro) == 3) {
 544                     PyObject* o1 = PySequence_GetItem(ro, 0);
 545                     PyObject* o2 = PySequence_GetItem(ro, 1);
 546                     PyObject* o3 = PySequence_GetItem(ro, 2);
 547                     if (!wxRect_helper(o1, &out_tab_rect))
 548                         PyErr_SetString(PyExc_TypeError, errmsg);
 549                     else if (!wxRect_helper(o2, &out_button_rect))
 550                         PyErr_SetString(PyExc_TypeError, errmsg);
 551                     else if (!PyInt_Check(o3))
 552                         PyErr_SetString(PyExc_TypeError, errmsg);
 553                     else
 554                         *x_extent = PyInt_AsLong(o3);
 555
 556                     Py_DECREF(o1);
 557                     Py_DECREF(o2);
 558                     Py_DECREF(o3);
 559                 }
 560                 else {
 561                     PyErr_SetString(PyExc_TypeError, errmsg);
 562                 }
 563                 Py_DECREF(ro);
 564             }
 565
 566             Py_DECREF(odc);
 567             Py_DECREF(ownd);
 568             Py_DECREF(orect);
 569             Py_DECREF(otext);
 570             Py_DECREF(obmp);
 571         }
 572         wxPyEndBlockThreads(blocked);
 573         if (!found)
 574             wxAuiDefaultTabArt::DrawTab(dc, wnd, in_rect, caption, bitmap, active, close_button_state, out_tab_rect, out_button_rect, x_extent);
 575     }
 576
 577
 578     virtual void DrawButton( wxDC& dc,
 579                              wxWindow* wnd,
 580                              const wxRect& in_rect,
 581                              int bitmap_id,
 582                              int button_state,
 583                              int orientation,
 584                              const wxBitmap& bitmap_override,
 585                              wxRect* out_rect)
 586     {
 587         bool found;
 588         const char* errmsg = "DrawButton should return a wxRect";
 589         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 590         if ((found = wxPyCBH_findCallback(m_myInst, "DrawButton"))) {
 591             PyObject* odc = wxPyMake_wxObject(&dc, false);
 592             PyObject* ownd = wxPyMake_wxObject(wnd, false);
 593             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);
 594             PyObject* obmp = wxPyConstructObject((void*)&bitmap_override, wxT("wxBitmap"), 0);
 595             PyObject* ro;
 596             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOiiiO)", odc, ownd, orect,
 597                                                                  bitmap_id, button_state, orientation,
 598                                                                  obmp));
 599             if (ro) {
 600                 if (!wxRect_helper(ro, &out_rect))
 601                     PyErr_SetString(PyExc_TypeError, errmsg);
 602                 Py_DECREF(ro);
 603             }
 604
 605             Py_DECREF(odc);
 606             Py_DECREF(ownd);
 607             Py_DECREF(orect);
 608             Py_DECREF(obmp);
 609         }
 610         wxPyEndBlockThreads(blocked);
 611         if (!found)
 612             wxAuiDefaultTabArt::DrawButton(dc, wnd, in_rect, bitmap_id, button_state, orientation, bitmap_override, out_rect);
 613     }
 614
 615
 616     virtual wxSize GetTabSize( wxDC& dc,
 617                                wxWindow* wnd,
 618                                const wxString& caption,
 619                                const wxBitmap& bitmap,
 620                                bool active,
 621                                int  close_button_state,
 622                                int* x_extent)
 623     {
 624         bool found;
 625         wxSize rv, *prv = &rv;
 626         const char* errmsg = "GetTabSize should return a sequence containing (size, x_extent)";
 627         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 628         if ((found = wxPyCBH_findCallback(m_myInst, "GetTabSize"))) {
 629             PyObject* odc = wxPyMake_wxObject(&dc, false);
 630             PyObject* ownd = wxPyMake_wxObject(wnd, false);
 631             PyObject* otext = wx2PyString(caption);
 632             PyObject* obmp = wxPyMake_wxObject((wxObject*)&bitmap, false);
 633             PyObject* ro;
 634             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue(
 635                                              "(OOOOii)", odc, ownd, otext, obmp, (int)active, close_button_state));
 636             if (ro) {
 637                 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
 638                     PyObject* o1 = PySequence_GetItem(ro, 0);
 639                     PyObject* o2 = PySequence_GetItem(ro, 1);
 640                     if (!wxSize_helper(o1, &prv))
 641                         PyErr_SetString(PyExc_TypeError, errmsg);
 642                     else if (!PyInt_Check(o2))
 643                         PyErr_SetString(PyExc_TypeError, errmsg);
 644                     else
 645                         *x_extent = PyInt_AsLong(o2);
 646
 647                     Py_DECREF(o1);
 648                     Py_DECREF(o2);
 649                 }
 650                 else {
 651                     PyErr_SetString(PyExc_TypeError, errmsg);
 652                 }
 653                 Py_DECREF(ro);
 654             }
 655
 656             Py_DECREF(odc);
 657             Py_DECREF(ownd);
 658             Py_DECREF(otext);
 659             Py_DECREF(obmp);
 660         }
 661         wxPyEndBlockThreads(blocked);
 662         if (!found)
 663             rv = wxAuiDefaultTabArt::GetTabSize(dc, wnd, caption, bitmap, active, close_button_state, x_extent);
 664         return rv;
 665     }
 666
 667 // TODO
 668 //     virtual int ShowWindowList(
 669 //                          wxWindow* wnd,
 670 //                          const wxArrayString& items,
 671 //                          int active_idx);
 672 //
 673 //     virtual int GetBestTabCtrlSize(wxWindow* wnd,
 674 //                                    wxAuiNotebookPageArray& pages);
 675 //     virtual wxAuiTabArt* Clone();
 676 //     virtual void SetFlags(unsigned int flags);
 677 //     virtual void SetSizingInfo(const wxSize& tab_ctrl_size,
 678 //                                size_t tab_count);
 679 //     virtual int GetIndentSize();
 680
 681
 682
 683     DEC_PYCALLBACK__FONT(SetNormalFont);
 684     DEC_PYCALLBACK__FONT(SetSelectedFont);
 685     DEC_PYCALLBACK__FONT(SetMeasuringFont);
 686 //    DEC_PYCALLBACK_INT_WIN(GetBestTabCtrlSize);
 687
 688     PYPRIVATE;
 689 };
 690
 691
 692 IMP_PYCALLBACK__FONT(wxPyAuiTabArt, wxAuiDefaultTabArt, SetNormalFont);
 693 IMP_PYCALLBACK__FONT(wxPyAuiTabArt, wxAuiDefaultTabArt, SetSelectedFont);
 694 IMP_PYCALLBACK__FONT(wxPyAuiTabArt, wxAuiDefaultTabArt, SetMeasuringFont);
 695 //IMP_PYCALLBACK_INT_WIN(wxPyAuiTabArt, wxAuiDefaultTabArt, GetBestTabCtrlSize);
 696 %}
 697
 698
 699 DocStr(wxPyAuiTabArt,
 700 "This version of the `TabArt` class has been instrumented to be
 701 subclassable in Python and to reflect all calls to the C++ base class
 702 methods to the Python methods implemented in the derived class.", "");
 703
 704 class wxPyAuiTabArt :  public wxAuiDefaultTabArt
 705 {
 706     %pythonAppend wxPyAuiTabArt     setCallbackInfo(PyAuiTabArt)
 707     wxPyAuiTabArt();
 708
 709 };
 710
 711
 712 //---------------------------------------------------------------------------
 713
 714 #undef wxUSE_AUI
 715 #undef WXDLLIMPEXP_AUI
 716
 717 //---------------------------------------------------------------------------
 718