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