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

/////////////////////////////////////////////////////////////////////////////
// Name:        aui.i
// Purpose:     Wrappers for the wxAUI classes.
//
// Author:      Robin Dunn
//
// Created:     5-July-2006
// RCS-ID:      $Id$
// Copyright:   (c) 2006 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

%define DOCSTRING
"The wx.aui moduleis an Advanced User Interface library that aims to
implement \"cutting-edge\" interface usability and design features so
developers can quickly and easily create beautiful and usable
application interfaces.

**Vision and Design Principles**

wx.aui attempts to encapsulate the following aspects of the user
interface:

  * Frame Management: Frame management provides the means to open,
    move and hide common controls that are needed to interact with the
    document, and allow these configurations to be saved into
    different perspectives and loaded at a later time.

  * Toolbars: Toolbars are a specialized subset of the frame
    management system and should behave similarly to other docked
    components. However, they also require additional functionality,
    such as \"spring-loaded\" rebar support, \"chevron\" buttons and
    end-user customizability.

  * Modeless Controls: Modeless controls expose a tool palette or set
    of options that float above the application content while allowing
    it to be accessed. Usually accessed by the toolbar, these controls
    disappear when an option is selected, but may also be \"torn off\"
    the toolbar into a floating frame of their own.

  * Look and Feel: Look and feel encompasses the way controls are
    drawn, both when shown statically as well as when they are being
    moved. This aspect of user interface design incorporates \"special
    effects\" such as transparent window dragging as well as frame
    animation.

**PyAUI adheres to the following principles**

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

  - Use existing wxPython code where possible, such as sizer
    implementation for frame management;

  - Use standard wxPython coding conventions.


**Usage**

The following example shows a simple implementation that utilizes
`wx.aui.FrameManager` to manage three text controls in a frame window::

    import wx
    import wx.aui

    class MyFrame(wx.Frame):

        def __init__(self, parent, id=-1, title='wx.aui Test',
                     size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
            wx.Frame.__init__(self, parent, id, title, pos, size, style)

            self._mgr = wx.aui.FrameManager(self)

            # create several text controls
            text1 = wx.TextCtrl(self, -1, 'Pane 1 - sample text',
                                wx.DefaultPosition, wx.Size(200,150),
                                wx.NO_BORDER | wx.TE_MULTILINE)

            text2 = wx.TextCtrl(self, -1, 'Pane 2 - sample text',
                                wx.DefaultPosition, wx.Size(200,150),
                                wx.NO_BORDER | wx.TE_MULTILINE)

            text3 = wx.TextCtrl(self, -1, 'Main content window',
                                wx.DefaultPosition, wx.Size(200,150),
                                wx.NO_BORDER | wx.TE_MULTILINE)

            # add the panes to the manager
            self._mgr.AddPane(text1, wx.LEFT, 'Pane Number One')
            self._mgr.AddPane(text2, wx.BOTTOM, 'Pane Number Two')
            self._mgr.AddPane(text3, wx.CENTER)

            # tell the manager to 'commit' all the changes just made
            self._mgr.Update()

            self.Bind(wx.EVT_CLOSE, self.OnClose)


        def OnClose(self, event):
            # deinitialize the frame manager
            self._mgr.UnInit()
            # delete the frame
            self.Destroy()


    app = wx.App()
    frame = MyFrame(None)
    frame.Show()
    app.MainLoop()
"
%enddef


%module(package="wx", docstring=DOCSTRING) aui

%{
#include "wx/wxPython/wxPython.h"
#include "wx/wxPython/pyclasses.h"
#include <wx/aui/aui.h>
%}

//---------------------------------------------------------------------------

%import core.i
%import windows.i

%pythoncode { wx = _core }
%pythoncode { __docfilter__ = wx.__DocFilter(globals()) }


%include _aui_docstrings.i

//---------------------------------------------------------------------------


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


// 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);

// 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(_AddPane1) wxFrameManager::AddPane(wxWindow* window, const wxPaneInfo& pane_info);
%rename(_AddPane2) wxFrameManager::AddPane(wxWindow* window, int direction = wxLEFT,
                                           const wxString& caption = wxEmptyString);

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

// A typemap for the return value of wxFrameManager::GetAllPanes
%typemap(out) wxPaneInfoArray& {
    $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);
        PyList_Append($result, pane_obj);
    }
}


%nokwargs wxAuiTabContainer::SetActivePage;

%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();

//---------------------------------------------------------------------------
// Get all our defs from the REAL header files.
%include framemanager.h
%include dockart.h
%include floatpane.h
%include auibook.h

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

%extend wxFrameManager {
    %pythoncode {
    def GetPane(self, item):
        """
        GetPane(self, window_or_info item) -> PaneInfo

        GetPane is used to search for a `PaneInfo` object either by
        widget reference or by pane name, which acts as a unique id
        for a window pane. The returned `PaneInfo` object may then be
        modified to change a pane's look, state or position. After one
        or more modifications to the `PaneInfo`, `FrameManager.Update`
        should be called to realize the changes to the user interface.

        If the lookup failed (meaning the pane could not be found in
        the manager) GetPane returns an empty `PaneInfo`, a condition
        which can be checked by calling `PaneInfo.IsOk`.
        """
        if isinstance(item, wx.Window):
            return self._GetPaneByWidget(item)
        else:
            return self._GetPaneByName(item)

    def AddPane(self, window, info=None, caption=None):
        """
        AddPane(self, window, info=None, caption=None) -> bool

        AddPane tells the frame manager to start managing a child
        window. There are two versions of this function. The first
        verison accepts a `PaneInfo` object for the ``info`` parameter
        and allows the full spectrum of pane parameter
        possibilities. (Say that 3 times fast!)

        The second version is used for simpler user interfaces which
        do not require as much configuration.  In this case the
        ``info`` parameter specifies the direction property of the
        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:
            return self._AddPane1(window, info)
        else:
            # This Is AddPane2
            if info is None:
                info = wx.LEFT
            if caption is None:
                caption = ""
            return self._AddPane2(window, info, caption)
    }

    // For backwards compatibility
    %pythoncode {
         SetFrame = wx._deprecated(SetManagedWindow,
                                   "SetFrame is deprecated, use `SetManagedWindow` instead.")
         GetFrame = wx._deprecated(GetManagedWindow,
                                   "GetFrame is deprecated, use `GetManagedWindow` instead.")
    }
}

//---------------------------------------------------------------------------

%{
// A wxDocArt lcass that knows how to forward virtuals to Python methods  
class wxPyDockArt :  public wxDefaultDockArt
{
    wxPyDockArt() : wxDefaultDockArt() {}

    DEC_PYCALLBACK_INT_INT(GetMetric);
    DEC_PYCALLBACK_VOID_INTINT(SetMetric);
    DEC_PYCALLBACK__INTFONT(SetFont);
    DEC_PYCALLBACK_FONT_INT(GetFont);
    DEC_PYCALLBACK_COLOUR_INT(GetColour);
    DEC_PYCALLBACK__INTCOLOUR(SetColour);

    virtual void DrawSash(wxDC& dc,
                          int orientation,
                          const wxRect& rect)
    {
        bool found;
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
        if ((found = wxPyCBH_findCallback(m_myInst, "DrawSash"))) {
            PyObject* odc = wxPyMake_wxObject(&dc, false);
            PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)",
                                                         odc, orientation, orect));
            Py_DECREF(odc);
            Py_DECREF(orect);
        }
        wxPyEndBlockThreads(blocked);
        if (! found)
            wxDefaultDockArt::DrawSash(dc, orientation, rect);
    }

    virtual void DrawBackground(wxDC& dc,
                          int orientation,
                          const wxRect& rect)
    {
        bool found;
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
        if ((found = wxPyCBH_findCallback(m_myInst, "DrawBackground"))) {
            PyObject* odc = wxPyMake_wxObject(&dc, false);
            PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)",
                                                         odc, orientation, orect));
            Py_DECREF(odc);
            Py_DECREF(orect);
        }
        wxPyEndBlockThreads(blocked);
        if (! found)
            wxDefaultDockArt::DrawBackground(dc, orientation, rect);
    }

    virtual void DrawCaption(wxDC& dc,
                          const wxString& text,
                          const wxRect& rect,
                          wxPaneInfo& pane)
    {
        bool found;
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
        if ((found = wxPyCBH_findCallback(m_myInst, "DrawCaption"))) {
            PyObject* odc = wxPyMake_wxObject(&dc, false);
            PyObject* otext = wx2PyString(text);
            PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOO)",
                                                         odc, otext, orect, opane));
            Py_DECREF(odc);
            Py_DECREF(otext);
            Py_DECREF(orect);
            Py_DECREF(opane);
       }
        wxPyEndBlockThreads(blocked);
        if (! found)
            wxDefaultDockArt::DrawCaption(dc, text, rect, pane);
    }

    virtual void DrawGripper(wxDC& dc,
                          const wxRect& rect,
                          wxPaneInfo& pane)
    {
        bool found;
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
        if ((found = wxPyCBH_findCallback(m_myInst, "DrawGripper"))) {
            PyObject* odc = wxPyMake_wxObject(&dc, false);
            PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
            Py_DECREF(odc);
            Py_DECREF(orect);
            Py_DECREF(opane);
        }
        wxPyEndBlockThreads(blocked);
        if (! found)
            wxDefaultDockArt::DrawGripper(dc, rect, pane);
    }

    virtual void DrawBorder(wxDC& dc,
                          const wxRect& rect,
                          wxPaneInfo& pane)
    {
        bool found;
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
        if ((found = wxPyCBH_findCallback(m_myInst, "DrawBorder"))) {
            PyObject* odc = wxPyMake_wxObject(&dc, false);
            PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
            Py_DECREF(odc);
            Py_DECREF(orect);
            Py_DECREF(opane);
       }
        wxPyEndBlockThreads(blocked);
        if (! found)
            wxDefaultDockArt::DrawBorder(dc, rect, pane);
    }

    virtual void DrawPaneButton(wxDC& dc,
                          int button,
                          int button_state,
                          const wxRect& rect,
                          wxPaneInfo& pane)
    {
        bool found;
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
        if ((found = wxPyCBH_findCallback(m_myInst, "DrawPaneButton"))) {
            PyObject* odc = wxPyMake_wxObject(&dc, false);
            PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
            PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiIOO)",
                                                         odc, button, button_state,
                                                         orect, opane));
            Py_DECREF(odc);
            Py_DECREF(orect);
            Py_DECREF(opane);
        }
        wxPyEndBlockThreads(blocked);
        if (! found)
            wxDefaultDockArt::DrawPaneButton(dc, button, button_state, rect, pane);
    }

    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);

%}


DocStr(wxPyDockArt,
"This version of the `DockArt` 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 wxPyDockArt :  public wxDefaultDockArt
{
    %pythonAppend wxPyDockArt     "self._setCallbackInfo(self, PyDockArt)"
    PyDocArt();

};


#undef wxUSE_AUI
#undef WXDLLIMPEXP_AUI

//---------------------------------------------------------------------------
Commit	Line	Data
febb39df RD	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
d7a7616b RD	139	#define wxDEPRECATED(decl)
d7a7616b RD	140
febb39df	141
1c976bff RD	142	// We'll skip making wrappers for these, they have overloads that take a
1c976bff RD	143	// wxSize or wxPoint
febb39df RD	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,
6ec59a2b	157	const wxString& caption = wxEmptyString);
febb39df	158
6ec59a2b RD	159	%rename(AddPaneAtPos) wxFrameManager::AddPane(wxWindow* window,
	160	const wxPaneInfo& pane_info,
	161	const wxPoint& drop_pos);
febb39df RD	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
1c976bff RD	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
febb39df RD	182	//---------------------------------------------------------------------------
	183	// Get all our defs from the REAL header files.
	184	%include framemanager.h
	185	%include dockart.h
	186	%include floatpane.h
1c976bff	187	%include auibook.h
febb39df RD	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 {
d7a7616b	194	%pythoncode {
febb39df RD	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	"""
4c16bedf RD	231	if type(info) == PaneInfo:
4c16bedf RD	232	return self._AddPane1(window, info)
febb39df RD	233	else:
febb39df RD	234	# This Is AddPane2
4c16bedf RD	235	if info is None:
	236	info = wx.LEFT
	237	if caption is None:
	238	caption = ""
	239	return self._AddPane2(window, info, caption)
d7a7616b RD	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	}
febb39df RD	249	}
	250
	251	//---------------------------------------------------------------------------
	252
	253	%{
1c976bff	254	// A wxDocArt lcass that knows how to forward virtuals to Python methods
febb39df RD	255	class wxPyDockArt : public wxDefaultDockArt
	256	{
	257	wxPyDockArt() : wxDefaultDockArt() {}
	258
	259	DEC_PYCALLBACK_INT_INT(GetMetric);
	260	DEC_PYCALLBACK_VOID_INTINT(SetMetric);
	261	DEC_PYCALLBACK__INTFONT(SetFont);
	262	DEC_PYCALLBACK_FONT_INT(GetFont);
	263	DEC_PYCALLBACK_COLOUR_INT(GetColour);
	264	DEC_PYCALLBACK__INTCOLOUR(SetColour);
	265
	266	virtual void DrawSash(wxDC& dc,
	267	int orientation,
	268	const wxRect& rect)
	269	{
	270	bool found;
	271	wxPyBlock_t blocked = wxPyBeginBlockThreads();
	272	if ((found = wxPyCBH_findCallback(m_myInst, "DrawSash"))) {
	273	PyObject* odc = wxPyMake_wxObject(&dc, false);
	274	PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
	275	wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)",
	276	odc, orientation, orect));
	277	Py_DECREF(odc);
	278	Py_DECREF(orect);
	279	}
	280	wxPyEndBlockThreads(blocked);
	281	if (! found)
	282	wxDefaultDockArt::DrawSash(dc, orientation, rect);
	283	}
	284
	285	virtual void DrawBackground(wxDC& dc,
	286	int orientation,
	287	const wxRect& rect)
	288	{
	289	bool found;
	290	wxPyBlock_t blocked = wxPyBeginBlockThreads();
	291	if ((found = wxPyCBH_findCallback(m_myInst, "DrawBackground"))) {
	292	PyObject* odc = wxPyMake_wxObject(&dc, false);
	293	PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
	294	wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)",
	295	odc, orientation, orect));
	296	Py_DECREF(odc);
	297	Py_DECREF(orect);
	298	}
	299	wxPyEndBlockThreads(blocked);
	300	if (! found)
	301	wxDefaultDockArt::DrawBackground(dc, orientation, rect);
	302	}
	303
	304	virtual void DrawCaption(wxDC& dc,
	305	const wxString& text,
	306	const wxRect& rect,
	307	wxPaneInfo& pane)
	308	{
	309	bool found;
	310	wxPyBlock_t blocked = wxPyBeginBlockThreads();
	311	if ((found = wxPyCBH_findCallback(m_myInst, "DrawCaption"))) {
	312	PyObject* odc = wxPyMake_wxObject(&dc, false);
	313	PyObject* otext = wx2PyString(text);
	314	PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
	315	PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
	316	wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOO)",
	317	odc, otext, orect, opane));
	318	Py_DECREF(odc);
319	Py_DECREF(otext);
320	Py_DECREF(orect);
321	Py_DECREF(opane);
322	}
323	wxPyEndBlockThreads(blocked);
324	if (! found)
325	wxDefaultDockArt::DrawCaption(dc, text, rect, pane);
326	}
327
328	virtual void DrawGripper(wxDC& dc,
329	const wxRect& rect,
330	wxPaneInfo& pane)
331	{
332	bool found;
333	wxPyBlock_t blocked = wxPyBeginBlockThreads();
334	if ((found = wxPyCBH_findCallback(m_myInst, "DrawGripper"))) {
335	PyObject* odc = wxPyMake_wxObject(&dc, false);
336	PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
337	PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
338	wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
339	Py_DECREF(odc);
340	Py_DECREF(orect);
341	Py_DECREF(opane);
342	}
343	wxPyEndBlockThreads(blocked);
344	if (! found)
345	wxDefaultDockArt::DrawGripper(dc, rect, pane);
346	}
347
348	virtual void DrawBorder(wxDC& dc,
349	const wxRect& rect,
350	wxPaneInfo& pane)
351	{
352	bool found;
353	wxPyBlock_t blocked = wxPyBeginBlockThreads();
354	if ((found = wxPyCBH_findCallback(m_myInst, "DrawBorder"))) {
355	PyObject* odc = wxPyMake_wxObject(&dc, false);
356	PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
357	PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
358	wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", odc, orect, opane));
359	Py_DECREF(odc);
360	Py_DECREF(orect);
361	Py_DECREF(opane);
362	}
363	wxPyEndBlockThreads(blocked);
364	if (! found)
365	wxDefaultDockArt::DrawBorder(dc, rect, pane);
366	}
367
368	virtual void DrawPaneButton(wxDC& dc,
369	int button,
370	int button_state,
371	const wxRect& rect,
372	wxPaneInfo& pane)
373	{
374	bool found;
375	wxPyBlock_t blocked = wxPyBeginBlockThreads();
376	if ((found = wxPyCBH_findCallback(m_myInst, "DrawPaneButton"))) {
377	PyObject* odc = wxPyMake_wxObject(&dc, false);
378	PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
379	PyObject* opane = wxPyConstructObject((void*)&pane, wxT("wxPaneInfo"), 0);
380	wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiIOO)",
381	odc, button, button_state,
382	orect, opane));
383	Py_DECREF(odc);
384	Py_DECREF(orect);
385	Py_DECREF(opane);
386	}
387	wxPyEndBlockThreads(blocked);
388	if (! found)
389	wxDefaultDockArt::DrawPaneButton(dc, button, button_state, rect, pane);
390	}
391
392	PYPRIVATE;
393
394	};
395
396	IMP_PYCALLBACK_INT_INT(wxPyDockArt, wxDefaultDockArt, GetMetric);
397	IMP_PYCALLBACK_VOID_INTINT(wxPyDockArt, wxDefaultDockArt, SetMetric);
398	IMP_PYCALLBACK__INTFONT(wxPyDockArt, wxDefaultDockArt, SetFont);
399	IMP_PYCALLBACK_FONT_INT(wxPyDockArt, wxDefaultDockArt, GetFont);
400	IMP_PYCALLBACK_COLOUR_INT(wxPyDockArt, wxDefaultDockArt, GetColour);
401	IMP_PYCALLBACK__INTCOLOUR(wxPyDockArt, wxDefaultDockArt, SetColour);
402
403	%}
404
405
406	DocStr(wxPyDockArt,
407	"This version of the `DockArt` class has been instrumented to be
408	subclassable in Python and to reflect all calls to the C++ base class
409	methods to the Python methods implemented in the derived class.", "");
410
411	class wxPyDockArt : public wxDefaultDockArt
412	{
413	%pythonAppend wxPyDockArt "self._setCallbackInfo(self, PyDockArt)"
414	PyDocArt();
415
416	};
417
418
419
420	#undef wxUSE_AUI
421	#undef WXDLLIMPEXP_AUI
422
423	//---------------------------------------------------------------------------
424