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 **PyAUI adheres to the following principles**
  48
  49   - Use native floating frames to obtain a native look and feel for
  50     all platforms;
  51
  52   - Use existing wxPython code where possible, such as sizer
  53     implementation for frame management;
  54
  55   - Use standard wxPython coding conventions.
  56
  57
  58 **Usage**
  59
  60 The following example shows a simple implementation that utilizes
  61 `wx.aui.FrameManager` to manage three text controls in a frame window::
  62
  63     import wx
  64     import wx.aui
  65
  66     class MyFrame(wx.Frame):
  67
  68         def __init__(self, parent, id=-1, title='wx.aui Test',
  69                      size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
  70             wx.Frame.__init__(self, parent, id, title, pos, size, style)
  71
  72             self._mgr = wx.aui.FrameManager(self)
  73
  74             # create several text controls
  75             text1 = wx.TextCtrl(self, -1, 'Pane 1 - sample text',
  76                                 wx.DefaultPosition, wx.Size(200,150),
  77                                 wx.NO_BORDER | wx.TE_MULTILINE)
  78
  79             text2 = wx.TextCtrl(self, -1, 'Pane 2 - sample text',
  80                                 wx.DefaultPosition, wx.Size(200,150),
  81                                 wx.NO_BORDER | wx.TE_MULTILINE)
  82
  83             text3 = wx.TextCtrl(self, -1, 'Main content window',
  84                                 wx.DefaultPosition, wx.Size(200,150),
  85                                 wx.NO_BORDER | wx.TE_MULTILINE)
  86
  87             # add the panes to the manager
  88             self._mgr.AddPane(text1, wx.LEFT, 'Pane Number One')
  89             self._mgr.AddPane(text2, wx.BOTTOM, 'Pane Number Two')
  90             self._mgr.AddPane(text3, wx.CENTER)
  91
  92             # tell the manager to 'commit' all the changes just made
  93             self._mgr.Update()
  94
  95             self.Bind(wx.EVT_CLOSE, self.OnClose)
  96
  97
  98         def OnClose(self, event):
  99             # deinitialize the frame manager
 100             self._mgr.UnInit()
 101             # delete the frame
 102             self.Destroy()
 103
 104
 105     app = wx.App()
 106     frame = MyFrame(None)
 107     frame.Show()
 108     app.MainLoop()
 109 "
 110 %enddef
 111
 112
 113
 114 %module(package="wx", docstring=DOCSTRING) aui
 115
 116 %{
 117 #include "wx/wxPython/wxPython.h"
 118 #include "wx/wxPython/pyclasses.h"
 119 #include <wx/aui/aui.h>
 120 %}
 121
 122 //---------------------------------------------------------------------------
 123
 124 %import core.i
 125 %import windows.i
 126
 127 %pythoncode { wx = _core }
 128 %pythoncode { __docfilter__ = wx.__DocFilter(globals()) }
 129
 130
 131 %include _aui_docstrings.i
 132
 133 //---------------------------------------------------------------------------
 134
 135
 136 #define wxUSE_AUI 1
 137 #define WXDLLIMPEXP_AUI
 138 #define unsigned
 139 #define wxDEPRECATED(decl)
 140
 141
 142 // We'll skip making wrappers for these, they have overloads that take a
 143 // wxSize or wxPoint
 144 %ignore wxPaneInfo::MaxSize(int x, int y);
 145 %ignore wxPaneInfo::MinSize(int x, int y);
 146 %ignore wxPaneInfo::BestSize(int x, int y);
 147 %ignore wxPaneInfo::FloatingPosition(int x, int y);
 148 %ignore wxPaneInfo::FloatingSize(int x, int y);
 149
 150 // But for these we will do the overloading (see %pythoncode below) so let's
 151 // rename the C++ versions
 152 %rename(_GetPaneByWidget) wxFrameManager::GetPane(wxWindow* window);
 153 %rename(_GetPaneByName)   wxFrameManager::GetPane(const wxString& name);
 154
 155 %rename(_AddPane1) wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info);
 156 %rename(_AddPane2) wxFrameManager::AddPane(wxWindow* window, int direction = wxLEFT,
 157                                            const wxString& caption = wxEmptyString);
 158
 159 %rename(AddPaneAtPos) wxFrameManager::AddPane(wxWindow* window,
 160                                               const wxPaneInfo& pane_info,
 161                                               const wxPoint& drop_pos);
 162
 163 // A typemap for the return value of wxFrameManager::GetAllPanes
 164 %typemap(out) wxPaneInfoArray& {
 165     $result = PyList_New(0);
 166     for (size_t i=0; i < $1->GetCount(); i++) {
 167         PyObject* pane_obj = SWIG_NewPointerObj((void*)(&$1->Item(i)), SWIGTYPE_p_wxPaneInfo, 0);
 168         PyList_Append($result, pane_obj);
 169     }
 170 }
 171
 172
 173 %nokwargs wxAuiTabContainer::SetActivePage;
 174
 175 %pythonAppend wxAuiTabCtrl::wxAuiTabCtrl "self._setOORInfo(self)";
 176
 177 %pythonAppend wxAuiMultiNotebook::wxAuiMultiNotebook    "self._setOORInfo(self)";
 178 %pythonAppend wxAuiMultiNotebook::wxAuiMultiNotebook()  "self._setOORInfo(self)";
 179 %ignore wxAuiMultiNotebook::~wxAuiMultiNotebook;
 180 %rename(PreAuiMultiNotebook) wxAuiMultiNotebook::wxAuiMultiNotebook();
 181
 182 //---------------------------------------------------------------------------
 183 // Get all our defs from the REAL header files.
 184 %include framemanager.h
 185 %include dockart.h
 186 %include floatpane.h
 187 %include auibook.h
 188
 189 //---------------------------------------------------------------------------
 190 // Methods to inject into the FrameManager class that will sort out calls to
 191 // the overloaded versions of GetPane and AddPane
 192
 193 %extend wxFrameManager {
 194     %pythoncode {
 195     def GetPane(self, item):
 196         """
 197         GetPane(self, window_or_info item) -> PaneInfo
 198
 199         GetPane is used to search for a `PaneInfo` object either by
 200         widget reference or by pane name, which acts as a unique id
 201         for a window pane. The returned `PaneInfo` object may then be
 202         modified to change a pane's look, state or position. After one
 203         or more modifications to the `PaneInfo`, `FrameManager.Update`
 204         should be called to realize the changes to the user interface.
 205
 206         If the lookup failed (meaning the pane could not be found in
 207         the manager) GetPane returns an empty `PaneInfo`, a condition
 208         which can be checked by calling `PaneInfo.IsOk`.
 209         """
 210         if isinstance(item, wx.Window):
 211             return self._GetPaneByWidget(item)
 212         else:
 213             return self._GetPaneByName(item)
 214
 215     def AddPane(self, window, info=None, caption=None):
 216         """
 217         AddPane(self, window, info=None, caption=None) -> bool
 218
 219         AddPane tells the frame manager to start managing a child
 220         window. There are two versions of this function. The first
 221         verison accepts a `PaneInfo` object for the ``info`` parameter
 222         and allows the full spectrum of pane parameter
 223         possibilities. (Say that 3 times fast!)
 224
 225         The second version is used for simpler user interfaces which
 226         do not require as much configuration.  In this case the
 227         ``info`` parameter specifies the direction property of the
 228         pane info, and defaults to ``wx.LEFT``.  The pane caption may
 229         also be specified as an extra parameter in this form.
 230         """
 231         if type(info) == PaneInfo:
 232             return self._AddPane1(window, info)
 233         else:
 234             # This Is AddPane2
 235             if info is None:
 236                 info = wx.LEFT
 237             if caption is None:
 238                 caption = ""
 239             return self._AddPane2(window, info, caption)
 240     }
 241
 242     // For backwards compatibility
 243     %pythoncode {
 244          SetFrame = wx._deprecated(SetManagedWindow,
 245                                    "SetFrame is deprecated, use `SetManagedWindow` instead.")
 246          GetFrame = wx._deprecated(GetManagedWindow,
 247                                    "GetFrame is deprecated, use `GetManagedWindow` instead.")
 248     }
 249 }
 250
 251 %extend wxDockInfo {
 252     ~wxDockInfo() {}
 253 }
 254
 255 %extend wxDockUIPart {
 256     ~wxDockUIPart() {}
 257 }
 258
 259 %extend wxPaneButton {
 260     ~wxPaneButton() {}
 261 }
 262
 263 //---------------------------------------------------------------------------
 264
 265 %{
 266 // A wxDocArt class that knows how to forward virtuals to Python methods
 267 class wxPyDockArt :  public wxDefaultDockArt
 268 {
 269     wxPyDockArt() : wxDefaultDockArt() {}
 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             wxDefaultDockArt::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             wxDefaultDockArt::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                           wxPaneInfo& 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("wxPaneInfo"), 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             wxDefaultDockArt::DrawCaption(dc, window, text, rect, pane);
 347     }
 348
 349     virtual void DrawGripper(wxDC& dc,
 350                           wxWindow* window,
 351                           const wxRect& rect,
 352                           wxPaneInfo& 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("wxPaneInfo"), 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             wxDefaultDockArt::DrawGripper(dc, window, rect, pane);
 369     }
 370
 371     virtual void DrawBorder(wxDC& dc,
 372                           wxWindow* window,
 373                           const wxRect& rect,
 374                           wxPaneInfo& 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("wxPaneInfo"), 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             wxDefaultDockArt::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                           wxPaneInfo& 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("wxPaneInfo"), 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             wxDefaultDockArt::DrawPaneButton(dc, window, button, button_state, rect, pane);
 419     }
 420
 421     PYPRIVATE;
 422
 423 };
 424
 425 IMP_PYCALLBACK_INT_INT(wxPyDockArt, wxDefaultDockArt, GetMetric);
 426 IMP_PYCALLBACK_VOID_INTINT(wxPyDockArt, wxDefaultDockArt, SetMetric);
 427 IMP_PYCALLBACK__INTFONT(wxPyDockArt, wxDefaultDockArt, SetFont);
 428 IMP_PYCALLBACK_FONT_INT(wxPyDockArt, wxDefaultDockArt, GetFont);
 429 IMP_PYCALLBACK_COLOUR_INT(wxPyDockArt, wxDefaultDockArt, GetColour);
 430 IMP_PYCALLBACK__INTCOLOUR(wxPyDockArt, wxDefaultDockArt, SetColour);
 431
 432 %}
 433
 434
 435 DocStr(wxPyDockArt,
 436 "This version of the `DockArt` 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 wxPyDockArt :  public wxDefaultDockArt
 441 {
 442     %pythonAppend wxPyDockArt     "self._setCallbackInfo(self, PyDockArt)"
 443     wxPyDocArt();
 444
 445 };
 446
 447
 448 //---------------------------------------------------------------------------
 449
 450 %extend wxAuiMultiNotebook {
 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 wxFrameManager {
 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 wxFrameManagerEvent {
 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 wxPyTabArt :  public wxDefaultTabArt
 489 {
 490     wxPyTabArt() : wxDefaultTabArt() {}
 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             wxDefaultTabArt::DrawBackground(dc, rect);
 508     }
 509
 510     virtual void DrawTab( wxDC* dc,
 511                           const wxRect& in_rect,
 512                           const wxString& caption,
 513                           bool active,
 514                           wxRect* out_rect,
 515                           int* x_extent)
 516     {
 517         bool found;
 518         const char* errmsg = "DrawTab should return a sequence containing (out_rect, x_extent)";
 519         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 520         if ((found = wxPyCBH_findCallback(m_myInst, "DrawTab"))) {
 521             PyObject* odc = wxPyMake_wxObject(dc, false);
 522             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);
 523             PyObject* otext = wx2PyString(caption);
 524             PyObject* ro;
 525             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOi)", odc, orect, otext, (int)active));
 526             if (ro) {
 527                 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
 528                     PyObject* o1 = PySequence_GetItem(ro, 0);
 529                     PyObject* o2 = PySequence_GetItem(ro, 1);
 530                     if (!wxRect_helper(o1, &out_rect))
 531                         PyErr_SetString(PyExc_TypeError, errmsg);
 532                     else if (!PyInt_Check(o2))
 533                         PyErr_SetString(PyExc_TypeError, errmsg);
 534                     else
 535                         *x_extent = PyInt_AsLong(o2);
 536
 537                     Py_DECREF(o1);
 538                     Py_DECREF(o2);
 539                 }
 540                 else {
 541                     PyErr_SetString(PyExc_TypeError, errmsg);
 542                 }
 543                 Py_DECREF(ro);
 544             }
 545
 546             Py_DECREF(odc);
 547             Py_DECREF(orect);
 548             Py_DECREF(otext);
 549         }
 550         wxPyEndBlockThreads(blocked);
 551         if (!found)
 552             wxDefaultTabArt::DrawTab(dc, in_rect, caption, active, out_rect, x_extent);
 553     }
 554
 555
 556     virtual void DrawButton( wxDC* dc,
 557                              const wxRect& in_rect,
 558                              int bitmap_id,
 559                              int button_state,
 560                              int orientation,
 561                              const wxBitmap& bitmap_override,
 562                              wxRect* out_rect)
 563     {
 564         bool found;
 565         const char* errmsg = "DrawButton should return a wxRect";
 566         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 567         if ((found = wxPyCBH_findCallback(m_myInst, "DrawButton"))) {
 568             PyObject* odc = wxPyMake_wxObject(dc, false);
 569             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);
 570             PyObject* obmp = wxPyConstructObject((void*)&bitmap_override, wxT("wxBitmap"), 0);
 571             PyObject* ro;
 572             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOiiiO)", odc, orect,
 573                                                                  bitmap_id, button_state, orientation,
 574                                                                  obmp));
 575             if (ro) {
 576                 if (!wxRect_helper(ro, &out_rect))
 577                     PyErr_SetString(PyExc_TypeError, errmsg);
 578                 Py_DECREF(ro);
 579             }
 580
 581             Py_DECREF(odc);
 582             Py_DECREF(orect);
 583             Py_DECREF(obmp);
 584         }
 585         wxPyEndBlockThreads(blocked);
 586         if (!found)
 587             wxDefaultTabArt::DrawButton(dc, in_rect, bitmap_id, button_state, orientation, bitmap_override, out_rect);
 588     }
 589
 590
 591     virtual wxSize GetTabSize( wxDC* dc,
 592                                const wxString& caption,
 593                                bool active,
 594                                int* x_extent)
 595     {
 596         bool found;
 597         wxSize rv, *prv = &rv;
 598         const char* errmsg = "GetTabSize should return a sequence containing (size, x_extent)";
 599         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 600         if ((found = wxPyCBH_findCallback(m_myInst, "GetTabSize"))) {
 601             PyObject* odc = wxPyMake_wxObject(dc, false);
 602             PyObject* otext = wx2PyString(caption);
 603             PyObject* ro;
 604             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOi)", odc, otext, (int)active));
 605             if (ro) {
 606                 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
 607                     PyObject* o1 = PySequence_GetItem(ro, 0);
 608                     PyObject* o2 = PySequence_GetItem(ro, 1);
 609                     if (!wxSize_helper(o1, &prv))
 610                         PyErr_SetString(PyExc_TypeError, errmsg);
 611                     else if (!PyInt_Check(o2))
 612                         PyErr_SetString(PyExc_TypeError, errmsg);
 613                     else
 614                         *x_extent = PyInt_AsLong(o2);
 615
 616                     Py_DECREF(o1);
 617                     Py_DECREF(o2);
 618                 }
 619                 else {
 620                     PyErr_SetString(PyExc_TypeError, errmsg);
 621                 }
 622                 Py_DECREF(ro);
 623             }
 624
 625             Py_DECREF(odc);
 626             Py_DECREF(otext);
 627         }
 628         wxPyEndBlockThreads(blocked);
 629         if (!found)
 630             rv = wxDefaultTabArt::GetTabSize(dc, caption, active, x_extent);
 631         return rv;
 632     }
 633
 634
 635
 636     DEC_PYCALLBACK__FONT(SetNormalFont);
 637     DEC_PYCALLBACK__FONT(SetSelectedFont);
 638     DEC_PYCALLBACK__FONT(SetMeasuringFont);
 639     DEC_PYCALLBACK_INT_WIN(GetBestTabCtrlSize);
 640
 641     PYPRIVATE;
 642 };
 643
 644
 645 IMP_PYCALLBACK__FONT(wxPyTabArt, wxDefaultTabArt, SetNormalFont);
 646 IMP_PYCALLBACK__FONT(wxPyTabArt, wxDefaultTabArt, SetSelectedFont);
 647 IMP_PYCALLBACK__FONT(wxPyTabArt, wxDefaultTabArt, SetMeasuringFont);
 648 IMP_PYCALLBACK_INT_WIN(wxPyTabArt, wxDefaultTabArt, GetBestTabCtrlSize);
 649 %}
 650
 651
 652 DocStr(wxPyTabArt,
 653 "This version of the `TabArt` class has been instrumented to be
 654 subclassable in Python and to reflect all calls to the C++ base class
 655 methods to the Python methods implemented in the derived class.", "");
 656
 657 class wxPyTabArt :  public wxDefaultTabArt
 658 {
 659     %pythonAppend wxPyTabArt     "self._setCallbackInfo(self, PyTabArt)"
 660     wxPyTabArt();
 661
 662 };
 663
 664
 665 //---------------------------------------------------------------------------
 666
 667 #undef wxUSE_AUI
 668 #undef WXDLLIMPEXP_AUI
 669
 670 //---------------------------------------------------------------------------
 671