fixed memory leaks when reading invalid GIFs

[wxWidgets.git] / wxPython / src / aui.i

diff --git a/wxPython/src/aui.i b/wxPython/src/aui.i
index 53baa1d1707d7448308b46a7dc4f6991eb46a497..ee3dcdb88f408ac255c939bfb9844be4ba94aefc 100755 (executable)
--- a/wxPython/src/aui.i
+++ b/wxPython/src/aui.i
@@ -44,7 +44,7 @@ interface:
     effects\" such as transparent window dragging as well as frame
     animation.
 
     effects\" such as transparent window dragging as well as frame
     animation.
 

-**PyAUI adheres to the following principles**
+**wx.aui adheres to the following principles**

 
   - Use native floating frames to obtain a native look and feel for
     all platforms;
 
   - Use native floating frames to obtain a native look and feel for
     all platforms;


@@ -69,7 +69,7 @@ The following example shows a simple implementation that utilizes
                      size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
             wx.Frame.__init__(self, parent, id, title, pos, size, style)
 
                      size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
             wx.Frame.__init__(self, parent, id, title, pos, size, style)
 

-            self._mgr = wx.aui.FrameManager(self)
+            self._mgr = wx.aui.AuiManager(self)

 
             # create several text controls
             text1 = wx.TextCtrl(self, -1, 'Pane 1 - sample text',
 
             # create several text controls
             text1 = wx.TextCtrl(self, -1, 'Pane 1 - sample text',


@@ -132,39 +132,49 @@ The following example shows a simple implementation that utilizes
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

-
+// Preprocessor stuff so SWIG doesn't get confused when %include-ing
+// the aui .h files.
+%ignore wxUSE_AUI;
+%ignore wxUSE_MENUS;
+%ignore wxABI_VERSION;

 #define wxUSE_AUI 1
 #define wxUSE_AUI 1

+#define wxUSE_MENUS 1
+#define wxABI_VERSION 99999
+

 #define WXDLLIMPEXP_AUI
 #define unsigned
 #define wxDEPRECATED(decl)
 #define WXDLLIMPEXP_AUI
 #define unsigned
 #define wxDEPRECATED(decl)

+#define DECLARE_EVENT_TABLE()
+#define DECLARE_DYNAMIC_CLASS(foo)
+

 
 
 // We'll skip making wrappers for these, they have overloads that take a
 // wxSize or wxPoint
 
 
 // We'll skip making wrappers for these, they have overloads that take a
 // wxSize or wxPoint

-%ignore wxPaneInfo::MaxSize(int x, int y);
-%ignore wxPaneInfo::MinSize(int x, int y);
-%ignore wxPaneInfo::BestSize(int x, int y);
-%ignore wxPaneInfo::FloatingPosition(int x, int y);
-%ignore wxPaneInfo::FloatingSize(int x, int y);
+%ignore wxAuiPaneInfo::MaxSize(int x, int y);
+%ignore wxAuiPaneInfo::MinSize(int x, int y);
+%ignore wxAuiPaneInfo::BestSize(int x, int y);
+%ignore wxAuiPaneInfo::FloatingPosition(int x, int y);
+%ignore wxAuiPaneInfo::FloatingSize(int x, int y);

 
 // But for these we will do the overloading (see %pythoncode below) so let's
 // rename the C++ versions
 
 // But for these we will do the overloading (see %pythoncode below) so let's
 // rename the C++ versions

-%rename(_GetPaneByWidget) wxFrameManager::GetPane(wxWindow* window);
-%rename(_GetPaneByName)   wxFrameManager::GetPane(const wxString& name);
+%rename(_GetPaneByWidget) wxAuiManager::GetPane(wxWindow* window);
+%rename(_GetPaneByName)   wxAuiManager::GetPane(const wxString& name);

 
 

-%rename(_AddPane1) wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info);
-%rename(_AddPane2) wxFrameManager::AddPane(wxWindow* window, int direction = wxLEFT,
-                                           const wxString& caption = wxEmptyString);
+%rename(_AddPane1) wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info);
+%rename(_AddPane2) wxAuiManager::AddPane(wxWindow* window, int direction = wxLEFT,
+                                         const wxString& caption = wxEmptyString);

 
 

-%rename(AddPaneAtPos) wxFrameManager::AddPane(wxWindow* window,
-                                              const wxPaneInfo& pane_info,
-                                              const wxPoint& drop_pos);
+%rename(AddPaneAtPos) wxAuiManager::AddPane(wxWindow* window,
+                                            const wxPaneInfo& pane_info,
+                                            const wxPoint& drop_pos);

 
 // A typemap for the return value of wxFrameManager::GetAllPanes
 
 // A typemap for the return value of wxFrameManager::GetAllPanes

-%typemap(out) wxPaneInfoArray& {
+%typemap(out) wxAuiPaneInfoArray& {

     $result = PyList_New(0);
     for (size_t i=0; i < $1->GetCount(); i++) {
     $result = PyList_New(0);
     for (size_t i=0; i < $1->GetCount(); i++) {

-        PyObject* pane_obj = SWIG_NewPointerObj((void*)(&$1->Item(i)), SWIGTYPE_p_wxPaneInfo, 0);
+        PyObject* pane_obj = SWIG_NewPointerObj((void*)(&$1->Item(i)), SWIGTYPE_p_wxAuiPaneInfo, 0);

         PyList_Append($result, pane_obj);
     }
 }
         PyList_Append($result, pane_obj);
     }
 }


@@ -174,23 +184,60 @@ The following example shows a simple implementation that utilizes
 
 %pythonAppend wxAuiTabCtrl::wxAuiTabCtrl "self._setOORInfo(self)";
 
 
 %pythonAppend wxAuiTabCtrl::wxAuiTabCtrl "self._setOORInfo(self)";
 

-%pythonAppend wxAuiMultiNotebook::wxAuiMultiNotebook    "self._setOORInfo(self)";
-%pythonAppend wxAuiMultiNotebook::wxAuiMultiNotebook()  "self._setOORInfo(self)";
-%ignore wxAuiMultiNotebook::~wxAuiMultiNotebook;
-%rename(PreAuiMultiNotebook) wxAuiMultiNotebook::wxAuiMultiNotebook();
+%pythonAppend wxAuiNotebook::wxAuiNotebook    "self._setOORInfo(self)";
+%pythonAppend wxAuiNotebook::wxAuiNotebook()  "val._setOORInfo(val)";
+%ignore wxAuiiNotebook::~wxAuiNotebook;
+%rename(PreAuiNotebook) wxAuiNotebook::wxAuiNotebook();
+
+// Link error...
+%ignore wxAuiDefaultTabArt::SetWindow;        
+
+// ignore this overload
+%ignore wxAuiTabContainer::GetPage(size_t idx) const;
+
+
+
+%pythonAppend wxAuiMDIParentFrame::wxAuiMDIParentFrame    "self._setOORInfo(self)";
+%pythonAppend wxAuiMDIParentFrame::wxAuiMDIParentFrame()  "val._setOORInfo(val)";
+%ignore wxAuiMDIParentFrame::~wxAuiMDIParentFrame;
+%rename(PreAuiMDIParentFrame) wxAuiMDIParentFrame::wxAuiMDIParentFrame();
+
+// Ignore these for now because they need a typemap for the return value, see below.
+%ignore wxAuiMDIParentFrame::GetNotebook;
+%ignore wxAuiMDIParentFrame::GetActiveChild;
+%ignore wxAuiMDIParentFrame::GetClientWindow;
+
+%pythonAppend wxAuiMDIChildFrame::wxAuiMDIChildFrame    "self._setOORInfo(self)";
+%pythonAppend wxAuiMDIChildFrame::wxAuiMDIChildFrame()  "val._setOORInfo(val)";
+%ignore wxAuiMDIChildFrame::~wxAuiMDIChildFrame;
+%rename(PreAuiMDIChildFrame) wxAuiMDIChildFrame::wxAuiMDIChildFrame();
+
+%pythonAppend wxAuiMDIClientWindow::wxAuiMDIClientWindow    "self._setOORInfo(self)";
+%pythonAppend wxAuiMDIClientWindow::wxAuiMDIClientWindow()  "val._setOORInfo(val)";
+%ignore wxAuiMDIClientWindow::~wxAuiMDIClientWindow;
+%rename(PreAuiMDIClientWindow) wxAuiMDIClientWindow::wxAuiMDIClientWindow();
+
+
+%typemap(out) wxEvtHandler*             { $result = wxPyMake_wxObject($1, $owner); }

 
 //---------------------------------------------------------------------------
 // Get all our defs from the REAL header files.
 
 //---------------------------------------------------------------------------
 // Get all our defs from the REAL header files.

+
+#define wxColor wxColour  // fix problem in dockart.h
+

 %include framemanager.h
 %include dockart.h
 %include floatpane.h
 %include auibook.h
 %include framemanager.h
 %include dockart.h
 %include floatpane.h
 %include auibook.h

+%include tabmdi.h
+
+#undef wxColor

 
 //---------------------------------------------------------------------------
 // Methods to inject into the FrameManager class that will sort out calls to
 // the overloaded versions of GetPane and AddPane
 
 
 //---------------------------------------------------------------------------
 // Methods to inject into the FrameManager class that will sort out calls to
 // the overloaded versions of GetPane and AddPane
 

-%extend wxFrameManager {
+%extend wxAuiManager {

     %pythoncode {
     def GetPane(self, item):
         """
     %pythoncode {
     def GetPane(self, item):
         """


@@ -228,7 +275,7 @@ The following example shows a simple implementation that utilizes
         pane info, and defaults to ``wx.LEFT``.  The pane caption may
         also be specified as an extra parameter in this form.
         """
         pane info, and defaults to ``wx.LEFT``.  The pane caption may
         also be specified as an extra parameter in this form.
         """

-        if type(info) == PaneInfo:
+        if type(info) == AuiPaneInfo:

             return self._AddPane1(window, info)
         else:
             # This Is AddPane2
             return self._AddPane1(window, info)
         else:
             # This Is AddPane2


@@ -248,25 +295,56 @@ The following example shows a simple implementation that utilizes
     }
 }
 
     }
 }
 

-%extend wxDockInfo {
-    ~wxDockInfo() {}
+%extend wxAuiDockInfo {
+    ~wxAuiDockInfo() {}

 }
 
 }
 

-%extend wxDockUIPart {
-    ~wxDockUIPart() {}
+%extend wxAuiDockUIPart {
+    ~wxAuiDockUIPart() {}

 }
 
 }
 

-%extend wxPaneButton {
-    ~wxPaneButton() {}
+%extend wxAuiPaneButton {
+    ~wxAuiPaneButton() {}

 }
 
 }
 

+%extend wxAuiMDIParentFrame {
+    %typemap(out) wxAuiNotebook*          { $result = wxPyMake_wxObject($1, $owner); }
+    %typemap(out) wxAuiMDIChildFrame*     { $result = wxPyMake_wxObject($1, $owner); }
+    %typemap(out) wxAuiMDIClientWindow*   { $result = wxPyMake_wxObject($1, $owner); }
+
+    %rename(GetNotebook) _GetNotebook;
+    %rename(GetActiveChild) _GetActiveChild;
+    %rename(GetClientWindow) _GetClientWindow;
+     
+    wxAuiNotebook* _GetNotebook() const
+    {
+        return self->GetNotebook();
+    }
+    
+    wxAuiMDIChildFrame* _GetActiveChild() const
+    {
+        return self->GetActiveChild();
+    }
+    
+    wxAuiMDIClientWindow* _GetClientWindow() const
+    {
+        return self->GetClientWindow();
+    }
+
+    %typemap(out) wxAuiNotebook*;       
+    %typemap(out) wxAuiMDIChildFrame*;  
+    %typemap(out) wxAuiMDIClientWindow*;
+}
+     
+     

 //---------------------------------------------------------------------------
 
 %{
 // A wxDocArt class that knows how to forward virtuals to Python methods
 //---------------------------------------------------------------------------
 
 %{
 // A wxDocArt class that knows how to forward virtuals to Python methods

-class wxPyDockArt :  public wxDefaultDockArt
+class wxPyAuiDockArt :  public wxAuiDefaultDockArt

 {
 {

-    wxPyDockArt() : wxDefaultDockArt() {}
+public:
+    wxPyAuiDockArt() : wxAuiDefaultDockArt() {}

 
     DEC_PYCALLBACK_INT_INT(GetMetric);
     DEC_PYCALLBACK_VOID_INTINT(SetMetric);
 
     DEC_PYCALLBACK_INT_INT(GetMetric);
     DEC_PYCALLBACK_VOID_INTINT(SetMetric);


@@ -294,7 +372,7 @@ class wxPyDockArt :  public wxDefaultDockArt
         }
         wxPyEndBlockThreads(blocked);
         if (! found)
         }
         wxPyEndBlockThreads(blocked);
         if (! found)

-            wxDefaultDockArt::DrawSash(dc, window, orientation, rect);
+            wxAuiDefaultDockArt::DrawSash(dc, window, orientation, rect);

     }
 
     virtual void DrawBackground(wxDC& dc,
     }
 
     virtual void DrawBackground(wxDC& dc,


@@ -316,14 +394,14 @@ class wxPyDockArt :  public wxDefaultDockArt
         }
         wxPyEndBlockThreads(blocked);
         if (! found)
         }
         wxPyEndBlockThreads(blocked);
         if (! found)

-            wxDefaultDockArt::DrawBackground(dc, window, orientation, rect);
+            wxAuiDefaultDockArt::DrawBackground(dc, window, orientation, rect);

     }
 
     virtual void DrawCaption(wxDC& dc,
                           wxWindow* window,
                           const wxString& text,
                           const wxRect& rect,
     }
 
     virtual void DrawCaption(wxDC& dc,
                           wxWindow* window,
                           const wxString& text,
                           const wxRect& rect,

-                          wxPaneInfo& pane)
+                          wxAuiPaneInfo& pane)

     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();


@@ -332,7 +410,7 @@ class wxPyDockArt :  public wxDefaultDockArt
             PyObject* owin = wxPyMake_wxObject(window, false);
             PyObject* otext = wx2PyString(text);
             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
             PyObject* owin = wxPyMake_wxObject(window, false);
             PyObject* otext = wx2PyString(text);
             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);

-            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
+            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiPaneInfo"), 0);

             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOO)",
                                                          odc, owin, otext, orect, opane));
             Py_DECREF(odc);
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOO)",
                                                          odc, owin, otext, orect, opane));
             Py_DECREF(odc);


@@ -343,13 +421,13 @@ class wxPyDockArt :  public wxDefaultDockArt
        }
         wxPyEndBlockThreads(blocked);
         if (! found)
        }
         wxPyEndBlockThreads(blocked);
         if (! found)

-            wxDefaultDockArt::DrawCaption(dc, window, text, rect, pane);
+            wxAuiDefaultDockArt::DrawCaption(dc, window, text, rect, pane);

     }
 
     virtual void DrawGripper(wxDC& dc,
                           wxWindow* window,
                           const wxRect& rect,
     }
 
     virtual void DrawGripper(wxDC& dc,
                           wxWindow* window,
                           const wxRect& rect,

-                          wxPaneInfo& pane)
+                          wxAuiPaneInfo& pane)

     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();


@@ -357,7 +435,7 @@ class wxPyDockArt :  public wxDefaultDockArt
             PyObject* odc = wxPyMake_wxObject(&dc, false);
             PyObject* owin = wxPyMake_wxObject(window, false);
             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
             PyObject* odc = wxPyMake_wxObject(&dc, false);
             PyObject* owin = wxPyMake_wxObject(window, false);
             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);

-            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
+            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiPaneInfo"), 0);

             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOO)", odc, owin, orect, opane));
             Py_DECREF(odc);
             Py_DECREF(orect);
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOO)", odc, owin, orect, opane));
             Py_DECREF(odc);
             Py_DECREF(orect);


@@ -365,13 +443,13 @@ class wxPyDockArt :  public wxDefaultDockArt
         }
         wxPyEndBlockThreads(blocked);
         if (! found)
         }
         wxPyEndBlockThreads(blocked);
         if (! found)

-            wxDefaultDockArt::DrawGripper(dc, window, rect, pane);
+            wxAuiDefaultDockArt::DrawGripper(dc, window, rect, pane);

     }
 
     virtual void DrawBorder(wxDC& dc,
                           wxWindow* window,
                           const wxRect& rect,
     }
 
     virtual void DrawBorder(wxDC& dc,
                           wxWindow* window,
                           const wxRect& rect,

-                          wxPaneInfo& pane)
+                          wxAuiPaneInfo& pane)

     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();


@@ -379,7 +457,7 @@ class wxPyDockArt :  public wxDefaultDockArt
             PyObject* odc = wxPyMake_wxObject(&dc, false);
             PyObject* owin = wxPyMake_wxObject(window, false);
             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
             PyObject* odc = wxPyMake_wxObject(&dc, false);
             PyObject* owin = wxPyMake_wxObject(window, false);
             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);

-            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
+            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiPaneInfo"), 0);

             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
             Py_DECREF(odc);
             Py_DECREF(owin);
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
             Py_DECREF(odc);
             Py_DECREF(owin);


@@ -388,7 +466,7 @@ class wxPyDockArt :  public wxDefaultDockArt
        }
         wxPyEndBlockThreads(blocked);
         if (! found)
        }
         wxPyEndBlockThreads(blocked);
         if (! found)

-            wxDefaultDockArt::DrawBorder(dc, window, rect, pane);
+            wxAuiDefaultDockArt::DrawBorder(dc, window, rect, pane);

     }
 
     virtual void DrawPaneButton(wxDC& dc,
     }
 
     virtual void DrawPaneButton(wxDC& dc,


@@ -396,7 +474,7 @@ class wxPyDockArt :  public wxDefaultDockArt
                           int button,
                           int button_state,
                           const wxRect& rect,
                           int button,
                           int button_state,
                           const wxRect& rect,

-                          wxPaneInfo& pane)
+                          wxAuiPaneInfo& pane)

     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();


@@ -404,7 +482,7 @@ class wxPyDockArt :  public wxDefaultDockArt
             PyObject* odc = wxPyMake_wxObject(&dc, false);
             PyObject* owin = wxPyMake_wxObject(window, false);
             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
             PyObject* odc = wxPyMake_wxObject(&dc, false);
             PyObject* owin = wxPyMake_wxObject(window, false);
             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);

-            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
+            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiPaneInfo"), 0);

             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiIOO)",
                                                          odc, owin, button, button_state,
                                                          orect, opane));
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOiIOO)",
                                                          odc, owin, button, button_state,
                                                          orect, opane));


@@ -415,39 +493,40 @@ class wxPyDockArt :  public wxDefaultDockArt
         }
         wxPyEndBlockThreads(blocked);
         if (! found)
         }
         wxPyEndBlockThreads(blocked);
         if (! found)

-            wxDefaultDockArt::DrawPaneButton(dc, window, button, button_state, rect, pane);
+            wxAuiDefaultDockArt::DrawPaneButton(dc, window, button, button_state, rect, pane);

     }
 
     PYPRIVATE;
 
 };
 
     }
 
     PYPRIVATE;
 
 };
 

-IMP_PYCALLBACK_INT_INT(wxPyDockArt, wxDefaultDockArt, GetMetric);
-IMP_PYCALLBACK_VOID_INTINT(wxPyDockArt, wxDefaultDockArt, SetMetric);
-IMP_PYCALLBACK__INTFONT(wxPyDockArt, wxDefaultDockArt, SetFont);
-IMP_PYCALLBACK_FONT_INT(wxPyDockArt, wxDefaultDockArt, GetFont);
-IMP_PYCALLBACK_COLOUR_INT(wxPyDockArt, wxDefaultDockArt, GetColour);
-IMP_PYCALLBACK__INTCOLOUR(wxPyDockArt, wxDefaultDockArt, SetColour);
+IMP_PYCALLBACK_INT_INT(wxPyAuiDockArt, wxAuiDefaultDockArt, GetMetric);
+IMP_PYCALLBACK_VOID_INTINT(wxPyAuiDockArt, wxAuiDefaultDockArt, SetMetric);
+IMP_PYCALLBACK__INTFONT(wxPyAuiDockArt, wxAuiDefaultDockArt, SetFont);
+IMP_PYCALLBACK_FONT_INT(wxPyAuiDockArt, wxAuiDefaultDockArt, GetFont);
+IMP_PYCALLBACK_COLOUR_INT(wxPyAuiDockArt, wxAuiDefaultDockArt, GetColour);
+IMP_PYCALLBACK__INTCOLOUR(wxPyAuiDockArt, wxAuiDefaultDockArt, SetColour);

 
 %}
 
 
 
 %}
 
 

-DocStr(wxPyDockArt,
-"This version of the `DockArt` class has been instrumented to be
+DocStr(wxPyAuiDockArt,
+"This version of the `AuiDockArt` class has been instrumented to be

 subclassable in Python and to reflect all calls to the C++ base class
 methods to the Python methods implemented in the derived class.", "");
 
 subclassable in Python and to reflect all calls to the C++ base class
 methods to the Python methods implemented in the derived class.", "");
 

-class wxPyDockArt :  public wxDefaultDockArt
+class wxPyAuiDockArt :  public wxAuiDefaultDockArt

 {
 {

-    %pythonAppend wxPyDockArt     "self._setCallbackInfo(self, PyDockArt)"
-    wxPyDocArt();
+public:
+    %pythonAppend wxPyAuiDockArt     setCallbackInfo(PyAuiDockArt)
+    wxPyAuiDockArt();

 
 };
 
 
 //---------------------------------------------------------------------------
 
 
 };
 
 
 //---------------------------------------------------------------------------
 

-%extend wxAuiMultiNotebook {
+%extend wxAuiNotebook {

     %property(PageCount, GetPageCount, doc="See `GetPageCount`");
     %property(Selection, GetSelection, SetSelection, doc="See `GetSelection` and `SetSelection`");
 }
     %property(PageCount, GetPageCount, doc="See `GetPageCount`");
     %property(Selection, GetSelection, SetSelection, doc="See `GetSelection` and `SetSelection`");
 }


@@ -466,7 +545,7 @@ class wxPyDockArt :  public wxDefaultDockArt
 }
 
 
 }
 
 

-%extend wxFrameManager {
+%extend wxAuiManager {

     %property(AllPanes, GetAllPanes, doc="See `GetAllPanes`");
     %property(ArtProvider, GetArtProvider, SetArtProvider, doc="See `GetArtProvider` and `SetArtProvider`");
     %property(Flags, GetFlags, SetFlags, doc="See `GetFlags` and `SetFlags`");
     %property(AllPanes, GetAllPanes, doc="See `GetAllPanes`");
     %property(ArtProvider, GetArtProvider, SetArtProvider, doc="See `GetArtProvider` and `SetArtProvider`");
     %property(Flags, GetFlags, SetFlags, doc="See `GetFlags` and `SetFlags`");


@@ -474,7 +553,7 @@ class wxPyDockArt :  public wxDefaultDockArt
 }
 
 
 }
 
 

-%extend wxFrameManagerEvent {
+%extend wxAuiManagerEvent {

     %property(Button, GetButton, SetButton, doc="See `GetButton` and `SetButton`");
     %property(DC, GetDC, SetDC, doc="See `GetDC` and `SetDC`");
     %property(Pane, GetPane, SetPane, doc="See `GetPane` and `SetPane`");
     %property(Button, GetButton, SetButton, doc="See `GetButton` and `SetButton`");
     %property(DC, GetDC, SetDC, doc="See `GetDC` and `SetDC`");
     %property(Pane, GetPane, SetPane, doc="See `GetPane` and `SetPane`");


@@ -485,57 +564,71 @@ class wxPyDockArt :  public wxDefaultDockArt
 
 %{
 // A wxTabArt class that knows how to forward virtuals to Python methods
 
 %{
 // A wxTabArt class that knows how to forward virtuals to Python methods

-class wxPyTabArt :  public wxDefaultTabArt
+class wxPyAuiTabArt :  public wxAuiDefaultTabArt

 {
 {

-    wxPyTabArt() : wxDefaultTabArt() {}
+public:
+    wxPyAuiTabArt() : wxAuiDefaultTabArt() {}

 
     
 
     

-    virtual void DrawBackground( wxDC* dc,
+    virtual void DrawBackground( wxDC& dc,
+                                 wxWindow* wnd,

                                  const wxRect& rect )
     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBackground"))) {
                                  const wxRect& rect )
     {
         bool found;
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
         if ((found = wxPyCBH_findCallback(m_myInst, "DrawBackground"))) {

-            PyObject* odc = wxPyMake_wxObject(dc, false);
+            PyObject* odc = wxPyMake_wxObject(&dc, false);
+            PyObject* ownd = wxPyMake_wxObject(wnd, false);

             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
             PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);

-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", odc, orect));
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, ownd, orect));

             Py_DECREF(odc);
             Py_DECREF(odc);

+            Py_DECREF(ownd);

             Py_DECREF(orect);
         }
         wxPyEndBlockThreads(blocked);
         if (!found)
             Py_DECREF(orect);
         }
         wxPyEndBlockThreads(blocked);
         if (!found)

-            wxDefaultTabArt::DrawBackground(dc, rect);
+            wxAuiDefaultTabArt::DrawBackground(dc, wnd, rect);

     }
 
     }
 

-    virtual void DrawTab( wxDC* dc,
+    virtual void DrawTab( wxDC& dc,
+                          wxWindow* wnd,
+                          const wxAuiNotebookPage& pane,

                           const wxRect& in_rect,
                           const wxRect& in_rect,

-                          const wxString& caption,
-                          bool active,
-                          wxRect* out_rect,
+                          int close_button_state,
+                          wxRect* out_tab_rect,
+                          wxRect* out_button_rect,

                           int* x_extent)
     {
         bool found;
                           int* x_extent)
     {
         bool found;

-        const char* errmsg = "DrawTab should return a sequence containing (out_rect, x_extent)";
+        const char* errmsg = "DrawTab should return a sequence containing (tab_rect, button_rect, x_extent)";

         wxPyBlock_t blocked = wxPyBeginBlockThreads();
         if ((found = wxPyCBH_findCallback(m_myInst, "DrawTab"))) {
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
         if ((found = wxPyCBH_findCallback(m_myInst, "DrawTab"))) {

-            PyObject* odc = wxPyMake_wxObject(dc, false);
+            PyObject* odc = wxPyMake_wxObject(&dc, false);
+            PyObject* ownd = wxPyMake_wxObject(wnd, false);
+            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxAuiNotebookPage"), 0);

             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);
             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);

-            PyObject* otext = wx2PyString(caption);

             PyObject* ro;
             PyObject* ro;

-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOi)", odc, orect, otext, (int)active));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue(
+                                             "(OOOOOii)",
+                                             odc, ownd, orect, opane,
+                                             close_button_state));

             if (ro) {
             if (ro) {

-                if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
+                if (PySequence_Check(ro) && PyObject_Length(ro) == 3) {

                     PyObject* o1 = PySequence_GetItem(ro, 0);
                     PyObject* o2 = PySequence_GetItem(ro, 1);
                     PyObject* o1 = PySequence_GetItem(ro, 0);
                     PyObject* o2 = PySequence_GetItem(ro, 1);

-                    if (!wxRect_helper(o1, &out_rect)) 
+                    PyObject* o3 = PySequence_GetItem(ro, 2);
+                    if (!wxRect_helper(o1, &out_tab_rect)) 

                         PyErr_SetString(PyExc_TypeError, errmsg);
                         PyErr_SetString(PyExc_TypeError, errmsg);

-                    else if (!PyInt_Check(o2)) 
+                    else if (!wxRect_helper(o2, &out_button_rect)) 
+                        PyErr_SetString(PyExc_TypeError, errmsg);
+                    else if (!PyInt_Check(o3)) 

                         PyErr_SetString(PyExc_TypeError, errmsg);
                     else
                         PyErr_SetString(PyExc_TypeError, errmsg);
                     else

-                        *x_extent = PyInt_AsLong(o2);
+                        *x_extent = PyInt_AsLong(o3);

                     
                     Py_DECREF(o1);
                     Py_DECREF(o2);
                     
                     Py_DECREF(o1);
                     Py_DECREF(o2);

+                    Py_DECREF(o3);

                 }
                 else {
                     PyErr_SetString(PyExc_TypeError, errmsg);
                 }
                 else {
                     PyErr_SetString(PyExc_TypeError, errmsg);


@@ -544,34 +637,34 @@ class wxPyTabArt :  public wxDefaultTabArt
             }
 
             Py_DECREF(odc);
             }
 
             Py_DECREF(odc);

+            Py_DECREF(ownd);

             Py_DECREF(orect);
             Py_DECREF(orect);

-            Py_DECREF(otext);
+            Py_DECREF(opane);

         }
         wxPyEndBlockThreads(blocked);
         if (!found)
         }
         wxPyEndBlockThreads(blocked);
         if (!found)

-            wxDefaultTabArt::DrawTab(dc, in_rect, caption, active, out_rect, x_extent);
+            wxAuiDefaultTabArt::DrawTab(dc, wnd, pane, in_rect, close_button_state, out_tab_rect, out_button_rect, x_extent);

     }
 
 
     }
 
 

-    virtual void DrawButton( wxDC* dc,
+    virtual void DrawButton( wxDC& dc,
+                             wxWindow* wnd,

                              const wxRect& in_rect,
                              int bitmap_id,
                              int button_state,
                              int orientation,
                              const wxRect& in_rect,
                              int bitmap_id,
                              int button_state,
                              int orientation,

-                             const wxBitmap& bitmap_override,

                              wxRect* out_rect)
     {
         bool found;
         const char* errmsg = "DrawButton should return a wxRect";
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
         if ((found = wxPyCBH_findCallback(m_myInst, "DrawButton"))) {
                              wxRect* out_rect)
     {
         bool found;
         const char* errmsg = "DrawButton should return a wxRect";
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
         if ((found = wxPyCBH_findCallback(m_myInst, "DrawButton"))) {

-            PyObject* odc = wxPyMake_wxObject(dc, false);
+            PyObject* odc = wxPyMake_wxObject(&dc, false);
+            PyObject* ownd = wxPyMake_wxObject(wnd, false);

             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);
             PyObject* orect = wxPyConstructObject((void*)&in_rect, wxT("wxRect"), 0);

-            PyObject* obmp = wxPyConstructObject((void*)&bitmap_override, wxT("wxBitmap"), 0);

             PyObject* ro;
             PyObject* ro;

-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOiiiO)", odc, orect,
-                                                                 bitmap_id, button_state, orientation,
-                                                                 obmp));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOiiiO)", odc, ownd, orect,
+                                                                 bitmap_id, button_state, orientation));

             if (ro) {
                 if (!wxRect_helper(ro, &out_rect)) 
                     PyErr_SetString(PyExc_TypeError, errmsg);
             if (ro) {
                 if (!wxRect_helper(ro, &out_rect)) 
                     PyErr_SetString(PyExc_TypeError, errmsg);


@@ -579,18 +672,21 @@ class wxPyTabArt :  public wxDefaultTabArt
             }
 
             Py_DECREF(odc);
             }
 
             Py_DECREF(odc);

+            Py_DECREF(ownd);

             Py_DECREF(orect);
             Py_DECREF(orect);

-            Py_DECREF(obmp);

         }
         wxPyEndBlockThreads(blocked);
         if (!found)
         }
         wxPyEndBlockThreads(blocked);
         if (!found)

-            wxDefaultTabArt::DrawButton(dc, in_rect, bitmap_id, button_state, orientation, bitmap_override, out_rect);
+            wxAuiDefaultTabArt::DrawButton(dc, wnd, in_rect, bitmap_id, button_state, orientation, out_rect);

     }
 
     }
 

-    
-    virtual wxSize GetTabSize( wxDC* dc,
+
+    virtual wxSize GetTabSize( wxDC& dc,
+                               wxWindow* wnd,

                                const wxString& caption,
                                const wxString& caption,

+                               const wxBitmap& bitmap,

                                bool active,
                                bool active,

+                               int  close_button_state,

                                int* x_extent)
     {
         bool found;
                                int* x_extent)
     {
         bool found;


@@ -598,10 +694,13 @@ class wxPyTabArt :  public wxDefaultTabArt
         const char* errmsg = "GetTabSize should return a sequence containing (size, x_extent)";
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
         if ((found = wxPyCBH_findCallback(m_myInst, "GetTabSize"))) {
         const char* errmsg = "GetTabSize should return a sequence containing (size, x_extent)";
         wxPyBlock_t blocked = wxPyBeginBlockThreads();
         if ((found = wxPyCBH_findCallback(m_myInst, "GetTabSize"))) {

-            PyObject* odc = wxPyMake_wxObject(dc, false);
+            PyObject* odc = wxPyMake_wxObject(&dc, false);
+            PyObject* ownd = wxPyMake_wxObject(wnd, false);

             PyObject* otext = wx2PyString(caption);
             PyObject* otext = wx2PyString(caption);

+            PyObject* obmp = wxPyMake_wxObject((wxObject*)&bitmap, false);

             PyObject* ro;
             PyObject* ro;

-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOi)", odc, otext, (int)active));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue(
+                                             "(OOOOii)", odc, ownd, otext, obmp, (int)active, close_button_state));

             if (ro) {
                 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
                     PyObject* o1 = PySequence_GetItem(ro, 0);
             if (ro) {
                 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
                     PyObject* o1 = PySequence_GetItem(ro, 0);


@@ -623,49 +722,65 @@ class wxPyTabArt :  public wxDefaultTabArt
             }
 
             Py_DECREF(odc);
             }
 
             Py_DECREF(odc);

+            Py_DECREF(ownd);

             Py_DECREF(otext);
             Py_DECREF(otext);

+            Py_DECREF(obmp);

         }
         wxPyEndBlockThreads(blocked);
         if (!found)
         }
         wxPyEndBlockThreads(blocked);
         if (!found)

-            rv = wxDefaultTabArt::GetTabSize(dc, caption, active, x_extent);
+            rv = wxAuiDefaultTabArt::GetTabSize(dc, wnd, caption, bitmap, active, close_button_state, x_extent);

         return rv;
     }
         return rv;
     }

-   
-   
+
+// TODO    
+//     virtual int ShowDropDown(
+//                          wxWindow* wnd,
+//                          const wxAuiNotebookPageArray& items,
+//                          int active_idx);
+
+//     virtual int GetIndentSize();
+
+//     virtual int GetBestTabCtrlSize(wxWindow* wnd,
+//                                    const wxAuiNotebookPageArray& pages, 
+//                                    const wxSize& required_bmp_size);      
+//     virtual wxAuiTabArt* Clone();
+//     virtual void SetFlags(unsigned int flags);
+//     virtual void SetSizingInfo(const wxSize& tab_ctrl_size,
+//                                size_t tab_count);
+//     virtual int GetIndentSize();
+    
+

 
     DEC_PYCALLBACK__FONT(SetNormalFont);
     DEC_PYCALLBACK__FONT(SetSelectedFont);
     DEC_PYCALLBACK__FONT(SetMeasuringFont);
 
     DEC_PYCALLBACK__FONT(SetNormalFont);
     DEC_PYCALLBACK__FONT(SetSelectedFont);
     DEC_PYCALLBACK__FONT(SetMeasuringFont);

-    DEC_PYCALLBACK_INT_WIN(GetBestTabCtrlSize);
+//    DEC_PYCALLBACK_INT_WIN(GetBestTabCtrlSize);

 
     PYPRIVATE;
 };
 
 
 
     PYPRIVATE;
 };
 
 

-IMP_PYCALLBACK__FONT(wxPyTabArt, wxDefaultTabArt, SetNormalFont);
-IMP_PYCALLBACK__FONT(wxPyTabArt, wxDefaultTabArt, SetSelectedFont);
-IMP_PYCALLBACK__FONT(wxPyTabArt, wxDefaultTabArt, SetMeasuringFont);
-IMP_PYCALLBACK_INT_WIN(wxPyTabArt, wxDefaultTabArt, GetBestTabCtrlSize);
+IMP_PYCALLBACK__FONT(wxPyAuiTabArt, wxAuiDefaultTabArt, SetNormalFont);
+IMP_PYCALLBACK__FONT(wxPyAuiTabArt, wxAuiDefaultTabArt, SetSelectedFont);
+IMP_PYCALLBACK__FONT(wxPyAuiTabArt, wxAuiDefaultTabArt, SetMeasuringFont);
+//IMP_PYCALLBACK_INT_WIN(wxPyAuiTabArt, wxAuiDefaultTabArt, GetBestTabCtrlSize);

 %}
 
 
 %}
 
 

-DocStr(wxPyTabArt,
+DocStr(wxPyAuiTabArt,

 "This version of the `TabArt` class has been instrumented to be
 subclassable in Python and to reflect all calls to the C++ base class
 methods to the Python methods implemented in the derived class.", "");
 
 "This version of the `TabArt` class has been instrumented to be
 subclassable in Python and to reflect all calls to the C++ base class
 methods to the Python methods implemented in the derived class.", "");
 

-class wxPyTabArt :  public wxDefaultTabArt
+class wxPyAuiTabArt :  public wxAuiDefaultTabArt

 {
 {

-    %pythonAppend wxPyTabArt     "self._setCallbackInfo(self, PyTabArt)"
-    wxPyTabArt();
+public:
+    %pythonAppend wxPyAuiTabArt     setCallbackInfo(PyAuiTabArt)
+    wxPyAuiTabArt();

 
 };
 
 
 //---------------------------------------------------------------------------
 
 
 };
 
 
 //---------------------------------------------------------------------------
 

-#undef wxUSE_AUI
-#undef WXDLLIMPEXP_AUI
-
-//---------------------------------------------------------------------------