wxPython/src/windows2.i

/////////////////////////////////////////////////////////////////////////////
// Name:        windows2.i
// Purpose:     SWIG definitions of MORE window classes
//
// Author:      Robin Dunn
//
// Created:     6/2/98
// RCS-ID:      $Id$
// Copyright:   (c) 1998 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

%module windows2

%{
#include "helpers.h"
#ifdef OLD_GRID
#include <wx/grid.h>
#endif
#include <wx/notebook.h>
#include <wx/splitter.h>
#include <wx/imaglist.h>
#ifdef __WXMSW__
#include <wx/msw/taskbar.h>
#endif
%}

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

%{
    // Put some wx default wxChar* values into wxStrings.
    DECLARE_DEF_STRING(NOTEBOOK_NAME);
    DECLARE_DEF_STRING(PanelNameStr);
    DECLARE_DEF_STRING(ControlNameStr);

    static const wxChar* wxSplitterNameStr = wxT("splitter");
    DECLARE_DEF_STRING(SplitterNameStr);
    static const wxString wxPyEmptyString(wxT(""));
%}

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

%include typemaps.i
%include my_typemaps.i

// Import some definitions of other classes, etc.
%import _defs.i
%import misc.i
%import gdi.i
%import windows.i
%import controls.i
%import events.i

%pragma(python) code = "import wx"

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

enum {
     /* notebook control event types */
    wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
    wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING,
};


class wxNotebookEvent : public wxNotifyEvent {
public:
    wxNotebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0,
                    int nSel = -1, int nOldSel = -1);

    int GetSelection();
    int GetOldSelection();
    void SetOldSelection(int page);
    void SetSelection(int page);
};


class wxNotebook : public wxControl {
public:
    wxNotebook(wxWindow *parent,
               wxWindowID id,
               const wxPoint& pos = wxDefaultPosition,
               const wxSize& size = wxDefaultSize,
               long style = 0,
               const wxString& name = wxPyNOTEBOOK_NAME);
    %name(wxPreNotebook)wxNotebook();

    bool Create(wxWindow *parent,
               wxWindowID id,
               const wxPoint& pos = wxDefaultPosition,
               const wxSize& size = wxDefaultSize,
               long style = 0,
               const wxString& name = wxPyNOTEBOOK_NAME);

    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    %pragma(python) addtomethod = "wxPreNotebook:val._setOORInfo(val)"

    int GetPageCount();
    int SetSelection(int nPage);
    void AdvanceSelection(bool bForward = TRUE);
    int GetSelection();
    bool SetPageText(int nPage, const wxString& strText);
    wxString GetPageText(int nPage) const;

    void SetImageList(wxImageList* imageList);
    void AssignImageList(wxImageList *imageList) ;
    %pragma(python) addtomethod = "AssignImageList:_args[0].thisown = 0"

    wxImageList* GetImageList();
    int  GetPageImage(int nPage);
    bool SetPageImage(int nPage, int nImage);
    int GetRowCount();

    void SetPageSize(const wxSize& size);
    void SetPadding(const wxSize& padding);
    bool DeletePage(int nPage);
    bool RemovePage(int nPage);
    bool DeleteAllPages();
    bool AddPage(/*wxNotebookPage*/ wxWindow *pPage,
                 const wxString& strText,
                 int bSelect = FALSE,
                 int imageId = -1);
    bool InsertPage(int nPage,
                    /*wxNotebookPage*/ wxWindow *pPage,
                    const wxString& strText,
                    bool bSelect = FALSE,
                    int imageId = -1);
    /*wxNotebookPage*/ wxWindow *GetPage(int nPage);

    %addmethods {
        void ResizeChildren() {
            wxSizeEvent evt(self->GetClientSize());
            self->GetEventHandler()->ProcessEvent(evt);
        }
    }


};

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


enum {
    /* splitter window events */
    wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING,
    wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED,
    wxEVT_COMMAND_SPLITTER_UNSPLIT,
    wxEVT_COMMAND_SPLITTER_DOUBLECLICKED,
};


enum
{
    wxSPLIT_HORIZONTAL,
    wxSPLIT_VERTICAL,
    wxSPLIT_DRAG_NONE,
    wxSPLIT_DRAG_DRAGGING,
    wxSPLIT_DRAG_LEFT_DOWN
};


class wxSplitterEvent : public wxNotifyEvent {
public:
     wxSplitterEvent(wxEventType type = wxEVT_NULL,
                     wxSplitterWindow *splitter = NULL);

    int GetSashPosition();
    int GetX();
    int GetY();
    wxWindow* GetWindowBeingRemoved();
    void SetSashPosition(int pos);
}


class wxSplitterWindow : public wxWindow {
public:
    wxSplitterWindow(wxWindow* parent, wxWindowID id,
                     const wxPoint& point = wxDefaultPosition,
                     const wxSize& size = wxDefaultSize,
                     long style=wxSP_3D|wxCLIP_CHILDREN,
                     const wxString& name = wxPySplitterNameStr);
    %name(wxPreSplitterWindow)wxSplitterWindow();

    bool Create(wxWindow* parent, wxWindowID id,
                const wxPoint& point = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style=wxSP_3D|wxCLIP_CHILDREN,
                const wxString& name = wxPySplitterNameStr);

    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    %pragma(python) addtomethod = "wxPreSplitterWindow:val._setOORInfo(val)"

    // Gets the only or left/top pane
    wxWindow *GetWindow1();

    // Gets the right/bottom pane
    wxWindow *GetWindow2();

    // Sets the split mode
    void SetSplitMode(int mode);

    // Gets the split mode
    int GetSplitMode();

    // Initialize with one window
    void Initialize(wxWindow *window);

    // Associates the given window with window 2, drawing the appropriate sash
    // and changing the split mode.
    // Does nothing and returns FALSE if the window is already split.
    // A sashPosition of 0 means choose a default sash position,
    // negative sashPosition specifies the size of right/lower pane as it's
    // absolute value rather than the size of left/upper pane.
    virtual bool SplitVertically(wxWindow *window1,
                                 wxWindow *window2,
                                 int sashPosition = 0);
    virtual bool SplitHorizontally(wxWindow *window1,
                                   wxWindow *window2,
                                   int sashPosition = 0);

    // Removes the specified (or second) window from the view
    // Doesn't actually delete the window.
    bool Unsplit(wxWindow *toRemove = NULL);

    // Replaces one of the windows with another one (neither old nor new
    // parameter should be NULL)
    bool ReplaceWindow(wxWindow *winOld, wxWindow *winNew);

    // Is the window split?
    bool IsSplit();

    // Sets the sash size
    void SetSashSize(int width);

    // Sets the border size
    void SetBorderSize(int width);

    // Gets the sash size
    int GetSashSize();

    // Gets the border size
    int GetBorderSize();

    // Set the sash position
    void SetSashPosition(int position, bool redraw = TRUE);

    // Gets the sash position
    int GetSashPosition();

    // If this is zero, we can remove panes by dragging the sash.
    void SetMinimumPaneSize(int min);
    int GetMinimumPaneSize();

    // Resizes subwindows
    virtual void SizeWindows();

    void SetNeedUpdating(bool needUpdating) { m_needUpdating = needUpdating; }
    bool GetNeedUpdating() const { return m_needUpdating ; }

};

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

#ifdef __WXMSW__

enum {
    wxEVT_TASKBAR_MOVE,
    wxEVT_TASKBAR_LEFT_DOWN,
    wxEVT_TASKBAR_LEFT_UP,
    wxEVT_TASKBAR_RIGHT_DOWN,
    wxEVT_TASKBAR_RIGHT_UP,
    wxEVT_TASKBAR_LEFT_DCLICK,
    wxEVT_TASKBAR_RIGHT_DCLICK
};


class wxTaskBarIcon : public wxEvtHandler {
public:
    wxTaskBarIcon();
    ~wxTaskBarIcon();

    //%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"

    // We still use the magic methods here since that is the way it is documented...
    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnMouseMove',    wxEVT_TASKBAR_MOVE)"
    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLButtonDown',  wxEVT_TASKBAR_LEFT_DOWN)"
    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLButtonUp',    wxEVT_TASKBAR_LEFT_UP)"
    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnRButtonDown',  wxEVT_TASKBAR_RIGHT_DOWN)"
    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnRButtonUp',    wxEVT_TASKBAR_RIGHT_UP)"
    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLButtonDClick',wxEVT_TASKBAR_LEFT_DCLICK)"
    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnRButtonDClick',wxEVT_TASKBAR_RIGHT_DCLICK)"

    bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxPyEmptyString);
    bool RemoveIcon(void);
    bool PopupMenu(wxMenu *menu);
    bool IsIconInstalled();
    bool IsOK();
};
#endif

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// wxPyWindow derives from wxWindow and adds support for overriding many of
// the virtual methods in Python derived classes.

//      Which of these should be done???
//      AddChild
//      Destroy
//      DoCaptureMouse
//      DoClientToScreen
//      DoHitTest
//      DoMoveWindow
//      DoPopupMenu
//      DoReleaseMouse
//      DoScreenToClient
//      DoSetToolTip
//      Enable
//      Fit
//      GetCharHeight
//      GetCharWidth
//      GetClientAreaOrigin
//      GetDefaultItem
//      IsTopLevel
//      RemoveChild
//      SetBackgroundColour
//      SetDefaultItem
//      SetFocus
//      SetFocusFromKbd
//      SetForegroundColour
//      SetSizeHints
//      SetVirtualSizeHints
//      Show


%{ // C++ version of Python aware wxWindow
class wxPyWindow : public wxWindow
{
    DECLARE_DYNAMIC_CLASS(wxPyWindow)
public:
    wxPyWindow() : wxWindow() {}
    wxPyWindow(wxWindow* parent, const wxWindowID id,
               const wxPoint& pos = wxDefaultPosition,
               const wxSize& size = wxDefaultSize,
               long style = 0,
               const wxString& name = wxPyPanelNameStr)
        : wxWindow(parent, id, pos, size, style, name) {}


    DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
    DEC_PYCALLBACK_VOID_INT5(DoSetSize);
    DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
    DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);

    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);

    DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
    DEC_PYCALLBACK_SIZE_const(DoGetBestSize);

    DEC_PYCALLBACK__(InitDialog);
    DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
    DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
    DEC_PYCALLBACK_BOOL_(Validate);

    DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
    DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
    DEC_PYCALLBACK_SIZE_const(GetMaxSize);

    PYPRIVATE;
};

IMPLEMENT_DYNAMIC_CLASS(wxPyWindow, wxWindow);

IMP_PYCALLBACK_VOID_INT4(wxPyWindow, wxWindow, DoMoveWindow);
IMP_PYCALLBACK_VOID_INT5(wxPyWindow, wxWindow, DoSetSize);
IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetClientSize);
IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetVirtualSize);

IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetSize);
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetClientSize);
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetPosition);

IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetVirtualSize);
IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetBestSize);

IMP_PYCALLBACK__(wxPyWindow, wxWindow, InitDialog);
IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataFromWindow);
IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataToWindow);
IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, Validate);

IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocus);
IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocusFromKeyboard);
IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, GetMaxSize);

%}

// And now the one for SWIG to see
class wxPyWindow : public wxWindow
{
public:
    wxPyWindow(wxWindow* parent, const wxWindowID id,
               const wxPoint& pos = wxDefaultPosition,
               const wxSize& size = wxDefaultSize,
               long style = 0,
               const wxString& name = wxPyPanelNameStr);

    void _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyWindow)"
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"


    void base_DoMoveWindow(int x, int y, int width, int height);
    void base_DoSetSize(int x, int y, int width, int height,
                        int sizeFlags = wxSIZE_AUTO);
    void base_DoSetClientSize(int width, int height);
    void base_DoSetVirtualSize( int x, int y );

    void base_DoGetSize( int *OUTPUT, int *OUTPUT ) const;
    void base_DoGetClientSize( int *OUTPUT, int *OUTPUT ) const;
    void base_DoGetPosition( int *OUTPUT, int *OUTPUT ) const;

    wxSize base_DoGetVirtualSize() const;
    wxSize base_DoGetBestSize() const;

    void base_InitDialog();
    bool base_TransferDataToWindow();
    bool base_TransferDataFromWindow();
    bool base_Validate();

    bool base_AcceptsFocus() const;
    bool base_AcceptsFocusFromKeyboard() const;
    wxSize base_GetMaxSize() const;
}

//---------------------------------------------------------------------------
// Do the same thing for wxControl


%{ // C++ version of Python aware wxControl
class wxPyControl : public wxControl
{
    DECLARE_DYNAMIC_CLASS(wxPyControl)
public:
    wxPyControl() : wxControl() {}
    wxPyControl(wxWindow* parent, const wxWindowID id,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = 0,
                const wxValidator& validator=wxDefaultValidator,
                const wxString& name = wxPyControlNameStr)
        : wxControl(parent, id, pos, size, style, validator, name) {}


    DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
    DEC_PYCALLBACK_VOID_INT5(DoSetSize);
    DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
    DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);

    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);

    DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
    DEC_PYCALLBACK_SIZE_const(DoGetBestSize);

    DEC_PYCALLBACK__(InitDialog);
    DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
    DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
    DEC_PYCALLBACK_BOOL_(Validate);

    DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
    DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
    DEC_PYCALLBACK_SIZE_const(GetMaxSize);

    PYPRIVATE;
};

IMPLEMENT_DYNAMIC_CLASS(wxPyControl, wxControl);

IMP_PYCALLBACK_VOID_INT4(wxPyControl, wxControl, DoMoveWindow);
IMP_PYCALLBACK_VOID_INT5(wxPyControl, wxControl, DoSetSize);
IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetClientSize);
IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetVirtualSize);

IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetSize);
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetClientSize);
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetPosition);

IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetVirtualSize);
IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetBestSize);

IMP_PYCALLBACK__(wxPyControl, wxControl, InitDialog);
IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataFromWindow);
IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataToWindow);
IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, Validate);

IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocus);
IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocusFromKeyboard);
IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, GetMaxSize);

%}

// And now the one for SWIG to see
class wxPyControl : public wxControl
{
public:
    wxPyControl(wxWindow* parent, const wxWindowID id,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = 0,
                const wxValidator& validator=wxDefaultValidator,
                const wxString& name = wxPyControlNameStr);

    void _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyControl)"
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"


    void base_DoMoveWindow(int x, int y, int width, int height);
    void base_DoSetSize(int x, int y, int width, int height,
                        int sizeFlags = wxSIZE_AUTO);
    void base_DoSetClientSize(int width, int height);
    void base_DoSetVirtualSize( int x, int y );

    void base_DoGetSize( int *OUTPUT, int *OUTPUT ) const;
    void base_DoGetClientSize( int *OUTPUT, int *OUTPUT ) const;
    void base_DoGetPosition( int *OUTPUT, int *OUTPUT ) const;

    wxSize base_DoGetVirtualSize() const;
    wxSize base_DoGetBestSize() const;

    void base_InitDialog();
    bool base_TransferDataToWindow();
    bool base_TransferDataFromWindow();
    bool base_Validate();

    bool base_AcceptsFocus() const;
    bool base_AcceptsFocusFromKeyboard() const;
    wxSize base_GetMaxSize() const;
}

//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: windows2.i
	3	// Purpose: SWIG definitions of MORE window classes
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 6/2/98
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1998 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	%module windows2
	14
	15	%{
	16	#include "helpers.h"
	17	#ifdef OLD_GRID
	18	#include <wx/grid.h>
	19	#endif
	20	#include <wx/notebook.h>
	21	#include <wx/splitter.h>
	22	#include <wx/imaglist.h>
	23	#ifdef __WXMSW__
	24	#include <wx/msw/taskbar.h>
	25	#endif
	26	%}
	27
	28	//----------------------------------------------------------------------
	29
	30	%{
	31	// Put some wx default wxChar* values into wxStrings.
	32	DECLARE_DEF_STRING(NOTEBOOK_NAME);
	33	DECLARE_DEF_STRING(PanelNameStr);
	34	DECLARE_DEF_STRING(ControlNameStr);
	35
	36	static const wxChar* wxSplitterNameStr = wxT("splitter");
	37	DECLARE_DEF_STRING(SplitterNameStr);
	38	static const wxString wxPyEmptyString(wxT(""));
	39	%}
	40
	41	//----------------------------------------------------------------------
	42
	43	%include typemaps.i
	44	%include my_typemaps.i
	45
	46	// Import some definitions of other classes, etc.
	47	%import _defs.i
	48	%import misc.i
	49	%import gdi.i
	50	%import windows.i
	51	%import controls.i
	52	%import events.i
	53
	54	%pragma(python) code = "import wx"
	55
	56	//---------------------------------------------------------------------------
	57
	58	enum {
	59	/* notebook control event types */
	60	wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
	61	wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING,
	62	};
	63
	64
	65	class wxNotebookEvent : public wxNotifyEvent {
	66	public:
	67	wxNotebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0,
	68	int nSel = -1, int nOldSel = -1);
	69
	70	int GetSelection();
	71	int GetOldSelection();
	72	void SetOldSelection(int page);
	73	void SetSelection(int page);
	74	};
	75
	76
	77
	78	class wxNotebook : public wxControl {
	79	public:
	80	wxNotebook(wxWindow *parent,
	81	wxWindowID id,
	82	const wxPoint& pos = wxDefaultPosition,
	83	const wxSize& size = wxDefaultSize,
	84	long style = 0,
	85	const wxString& name = wxPyNOTEBOOK_NAME);
	86	%name(wxPreNotebook)wxNotebook();
	87
	88	bool Create(wxWindow *parent,
	89	wxWindowID id,
	90	const wxPoint& pos = wxDefaultPosition,
	91	const wxSize& size = wxDefaultSize,
	92	long style = 0,
	93	const wxString& name = wxPyNOTEBOOK_NAME);
	94
	95	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	96	%pragma(python) addtomethod = "wxPreNotebook:val._setOORInfo(val)"
	97
	98	int GetPageCount();
	99	int SetSelection(int nPage);
	100	void AdvanceSelection(bool bForward = TRUE);
	101	int GetSelection();
	102	bool SetPageText(int nPage, const wxString& strText);
	103	wxString GetPageText(int nPage) const;
	104
	105	void SetImageList(wxImageList* imageList);
	106	void AssignImageList(wxImageList *imageList) ;
	107	%pragma(python) addtomethod = "AssignImageList:_args[0].thisown = 0"
	108
	109	wxImageList* GetImageList();
	110	int GetPageImage(int nPage);
	111	bool SetPageImage(int nPage, int nImage);
	112	int GetRowCount();
	113
	114	void SetPageSize(const wxSize& size);
	115	void SetPadding(const wxSize& padding);
	116	bool DeletePage(int nPage);
	117	bool RemovePage(int nPage);
	118	bool DeleteAllPages();
	119	bool AddPage(/wxNotebookPage/ wxWindow *pPage,
	120	const wxString& strText,
	121	int bSelect = FALSE,
	122	int imageId = -1);
	123	bool InsertPage(int nPage,
	124	/wxNotebookPage/ wxWindow *pPage,
	125	const wxString& strText,
	126	bool bSelect = FALSE,
	127	int imageId = -1);
	128	/wxNotebookPage/ wxWindow *GetPage(int nPage);
	129
	130	%addmethods {
	131	void ResizeChildren() {
	132	wxSizeEvent evt(self->GetClientSize());
	133	self->GetEventHandler()->ProcessEvent(evt);
	134	}
	135	}
	136
	137
	138	};
	139
	140	//---------------------------------------------------------------------------
	141
	142
	143	enum {
	144	/* splitter window events */
	145	wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING,
	146	wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED,
	147	wxEVT_COMMAND_SPLITTER_UNSPLIT,
	148	wxEVT_COMMAND_SPLITTER_DOUBLECLICKED,
	149	};
	150
	151
	152	enum
	153	{
	154	wxSPLIT_HORIZONTAL,
	155	wxSPLIT_VERTICAL,
	156	wxSPLIT_DRAG_NONE,
	157	wxSPLIT_DRAG_DRAGGING,
	158	wxSPLIT_DRAG_LEFT_DOWN
	159	};
	160
	161
	162	class wxSplitterEvent : public wxNotifyEvent {
	163	public:
	164	wxSplitterEvent(wxEventType type = wxEVT_NULL,
	165	wxSplitterWindow *splitter = NULL);
	166
	167	int GetSashPosition();
	168	int GetX();
	169	int GetY();
	170	wxWindow* GetWindowBeingRemoved();
	171	void SetSashPosition(int pos);
	172	}
	173
	174
	175
	176
	177	class wxSplitterWindow : public wxWindow {
	178	public:
	179	wxSplitterWindow(wxWindow* parent, wxWindowID id,
	180	const wxPoint& point = wxDefaultPosition,
	181	const wxSize& size = wxDefaultSize,
	182	long style=wxSP_3D\|wxCLIP_CHILDREN,
	183	const wxString& name = wxPySplitterNameStr);
	184	%name(wxPreSplitterWindow)wxSplitterWindow();
	185
	186	bool Create(wxWindow* parent, wxWindowID id,
	187	const wxPoint& point = wxDefaultPosition,
	188	const wxSize& size = wxDefaultSize,
	189	long style=wxSP_3D\|wxCLIP_CHILDREN,
	190	const wxString& name = wxPySplitterNameStr);
	191
	192	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	193	%pragma(python) addtomethod = "wxPreSplitterWindow:val._setOORInfo(val)"
	194
	195	// Gets the only or left/top pane
	196	wxWindow *GetWindow1();
	197
	198	// Gets the right/bottom pane
	199	wxWindow *GetWindow2();
	200
	201	// Sets the split mode
	202	void SetSplitMode(int mode);
	203
	204	// Gets the split mode
	205	int GetSplitMode();
	206
	207	// Initialize with one window
	208	void Initialize(wxWindow *window);
	209
	210	// Associates the given window with window 2, drawing the appropriate sash
	211	// and changing the split mode.
	212	// Does nothing and returns FALSE if the window is already split.
	213	// A sashPosition of 0 means choose a default sash position,
	214	// negative sashPosition specifies the size of right/lower pane as it's
	215	// absolute value rather than the size of left/upper pane.
	216	virtual bool SplitVertically(wxWindow *window1,
	217	wxWindow *window2,
	218	int sashPosition = 0);
	219	virtual bool SplitHorizontally(wxWindow *window1,
	220	wxWindow *window2,
	221	int sashPosition = 0);
	222
	223	// Removes the specified (or second) window from the view
	224	// Doesn't actually delete the window.
	225	bool Unsplit(wxWindow *toRemove = NULL);
	226
	227	// Replaces one of the windows with another one (neither old nor new
	228	// parameter should be NULL)
	229	bool ReplaceWindow(wxWindow winOld, wxWindow winNew);
	230
	231	// Is the window split?
	232	bool IsSplit();
	233
	234	// Sets the sash size
	235	void SetSashSize(int width);
	236
	237	// Sets the border size
	238	void SetBorderSize(int width);
	239
	240	// Gets the sash size
	241	int GetSashSize();
	242
	243	// Gets the border size
	244	int GetBorderSize();
	245
	246	// Set the sash position
	247	void SetSashPosition(int position, bool redraw = TRUE);
	248
	249	// Gets the sash position
	250	int GetSashPosition();
	251
	252	// If this is zero, we can remove panes by dragging the sash.
	253	void SetMinimumPaneSize(int min);
	254	int GetMinimumPaneSize();
	255
	256	// Resizes subwindows
	257	virtual void SizeWindows();
	258
	259	void SetNeedUpdating(bool needUpdating) { m_needUpdating = needUpdating; }
	260	bool GetNeedUpdating() const { return m_needUpdating ; }
	261
	262	};
	263
	264	//---------------------------------------------------------------------------
	265
	266	#ifdef __WXMSW__
	267
	268	enum {
	269	wxEVT_TASKBAR_MOVE,
	270	wxEVT_TASKBAR_LEFT_DOWN,
	271	wxEVT_TASKBAR_LEFT_UP,
	272	wxEVT_TASKBAR_RIGHT_DOWN,
	273	wxEVT_TASKBAR_RIGHT_UP,
	274	wxEVT_TASKBAR_LEFT_DCLICK,
	275	wxEVT_TASKBAR_RIGHT_DCLICK
	276	};
	277
	278
	279	class wxTaskBarIcon : public wxEvtHandler {
	280	public:
	281	wxTaskBarIcon();
	282	~wxTaskBarIcon();
	283
	284	//%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	285
	286	// We still use the magic methods here since that is the way it is documented...
	287	%pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnMouseMove', wxEVT_TASKBAR_MOVE)"
	288	%pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLButtonDown', wxEVT_TASKBAR_LEFT_DOWN)"
	289	%pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLButtonUp', wxEVT_TASKBAR_LEFT_UP)"
	290	%pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnRButtonDown', wxEVT_TASKBAR_RIGHT_DOWN)"
	291	%pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnRButtonUp', wxEVT_TASKBAR_RIGHT_UP)"
	292	%pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLButtonDClick',wxEVT_TASKBAR_LEFT_DCLICK)"
	293	%pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnRButtonDClick',wxEVT_TASKBAR_RIGHT_DCLICK)"
	294
	295	bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxPyEmptyString);
	296	bool RemoveIcon(void);
	297	bool PopupMenu(wxMenu *menu);
	298	bool IsIconInstalled();
	299	bool IsOK();
	300	};
	301	#endif
	302
	303	//---------------------------------------------------------------------------
	304	//---------------------------------------------------------------------------
	305	// wxPyWindow derives from wxWindow and adds support for overriding many of
	306	// the virtual methods in Python derived classes.
	307
	308	// Which of these should be done???
	309	// AddChild
	310	// Destroy
	311	// DoCaptureMouse
	312	// DoClientToScreen
	313	// DoHitTest
	314	// DoMoveWindow
	315	// DoPopupMenu
	316	// DoReleaseMouse
	317	// DoScreenToClient
	318	// DoSetToolTip
	319	// Enable
	320	// Fit
	321	// GetCharHeight
	322	// GetCharWidth
	323	// GetClientAreaOrigin
	324	// GetDefaultItem
	325	// IsTopLevel
	326	// RemoveChild
	327	// SetBackgroundColour
	328	// SetDefaultItem
	329	// SetFocus
	330	// SetFocusFromKbd
	331	// SetForegroundColour
	332	// SetSizeHints
	333	// SetVirtualSizeHints
	334	// Show
	335
	336
	337	%{ // C++ version of Python aware wxWindow
	338	class wxPyWindow : public wxWindow
	339	{
	340	DECLARE_DYNAMIC_CLASS(wxPyWindow)
	341	public:
	342	wxPyWindow() : wxWindow() {}
	343	wxPyWindow(wxWindow* parent, const wxWindowID id,
	344	const wxPoint& pos = wxDefaultPosition,
	345	const wxSize& size = wxDefaultSize,
	346	long style = 0,
	347	const wxString& name = wxPyPanelNameStr)
	348	: wxWindow(parent, id, pos, size, style, name) {}
	349
	350
	351	DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
	352	DEC_PYCALLBACK_VOID_INT5(DoSetSize);
	353	DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
	354	DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
	355
	356	DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
	357	DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
	358	DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
	359
	360	DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
	361	DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
	362
	363	DEC_PYCALLBACK__(InitDialog);
	364	DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
	365	DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
	366	DEC_PYCALLBACK_BOOL_(Validate);
	367
	368	DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
	369	DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
	370	DEC_PYCALLBACK_SIZE_const(GetMaxSize);
	371
	372	PYPRIVATE;
	373	};
	374
	375	IMPLEMENT_DYNAMIC_CLASS(wxPyWindow, wxWindow);
	376
	377	IMP_PYCALLBACK_VOID_INT4(wxPyWindow, wxWindow, DoMoveWindow);
	378	IMP_PYCALLBACK_VOID_INT5(wxPyWindow, wxWindow, DoSetSize);
	379	IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetClientSize);
	380	IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetVirtualSize);
	381
	382	IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetSize);
	383	IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetClientSize);
	384	IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetPosition);
	385
	386	IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetVirtualSize);
	387	IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetBestSize);
	388
	389	IMP_PYCALLBACK__(wxPyWindow, wxWindow, InitDialog);
	390	IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataFromWindow);
	391	IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataToWindow);
	392	IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, Validate);
	393
	394	IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocus);
	395	IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocusFromKeyboard);
	396	IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, GetMaxSize);
	397
	398	%}
	399
	400	// And now the one for SWIG to see
	401	class wxPyWindow : public wxWindow
	402	{
	403	public:
	404	wxPyWindow(wxWindow* parent, const wxWindowID id,
	405	const wxPoint& pos = wxDefaultPosition,
	406	const wxSize& size = wxDefaultSize,
	407	long style = 0,
	408	const wxString& name = wxPyPanelNameStr);
	409
	410	void _setCallbackInfo(PyObject* self, PyObject* _class);
	411	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyWindow)"
	412	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	413
	414
	415	void base_DoMoveWindow(int x, int y, int width, int height);
	416	void base_DoSetSize(int x, int y, int width, int height,
	417	int sizeFlags = wxSIZE_AUTO);
	418	void base_DoSetClientSize(int width, int height);
	419	void base_DoSetVirtualSize( int x, int y );
	420
	421	void base_DoGetSize( int OUTPUT, int OUTPUT ) const;
	422	void base_DoGetClientSize( int OUTPUT, int OUTPUT ) const;
	423	void base_DoGetPosition( int OUTPUT, int OUTPUT ) const;
	424
	425	wxSize base_DoGetVirtualSize() const;
	426	wxSize base_DoGetBestSize() const;
	427
	428	void base_InitDialog();
	429	bool base_TransferDataToWindow();
	430	bool base_TransferDataFromWindow();
	431	bool base_Validate();
	432
	433	bool base_AcceptsFocus() const;
	434	bool base_AcceptsFocusFromKeyboard() const;
	435	wxSize base_GetMaxSize() const;
	436	}
	437
	438	//---------------------------------------------------------------------------
	439	// Do the same thing for wxControl
	440
	441
	442	%{ // C++ version of Python aware wxControl
	443	class wxPyControl : public wxControl
	444	{
	445	DECLARE_DYNAMIC_CLASS(wxPyControl)
	446	public:
	447	wxPyControl() : wxControl() {}
	448	wxPyControl(wxWindow* parent, const wxWindowID id,
	449	const wxPoint& pos = wxDefaultPosition,
	450	const wxSize& size = wxDefaultSize,
	451	long style = 0,
	452	const wxValidator& validator=wxDefaultValidator,
	453	const wxString& name = wxPyControlNameStr)
	454	: wxControl(parent, id, pos, size, style, validator, name) {}
	455
	456
	457	DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
	458	DEC_PYCALLBACK_VOID_INT5(DoSetSize);
	459	DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
	460	DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
	461
	462	DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
	463	DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
	464	DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
	465
	466	DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
	467	DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
	468
	469	DEC_PYCALLBACK__(InitDialog);
	470	DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
	471	DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
	472	DEC_PYCALLBACK_BOOL_(Validate);
	473
	474	DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
	475	DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
	476	DEC_PYCALLBACK_SIZE_const(GetMaxSize);
	477
	478	PYPRIVATE;
	479	};
	480
	481	IMPLEMENT_DYNAMIC_CLASS(wxPyControl, wxControl);
	482
	483	IMP_PYCALLBACK_VOID_INT4(wxPyControl, wxControl, DoMoveWindow);
	484	IMP_PYCALLBACK_VOID_INT5(wxPyControl, wxControl, DoSetSize);
	485	IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetClientSize);
	486	IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetVirtualSize);
	487
	488	IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetSize);
	489	IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetClientSize);
	490	IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetPosition);
	491
	492	IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetVirtualSize);
	493	IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetBestSize);
	494
	495	IMP_PYCALLBACK__(wxPyControl, wxControl, InitDialog);
	496	IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataFromWindow);
	497	IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataToWindow);
	498	IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, Validate);
	499
	500	IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocus);
	501	IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocusFromKeyboard);
	502	IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, GetMaxSize);
	503
	504	%}
	505
	506	// And now the one for SWIG to see
	507	class wxPyControl : public wxControl
	508	{
	509	public:
	510	wxPyControl(wxWindow* parent, const wxWindowID id,
	511	const wxPoint& pos = wxDefaultPosition,
	512	const wxSize& size = wxDefaultSize,
	513	long style = 0,
	514	const wxValidator& validator=wxDefaultValidator,
	515	const wxString& name = wxPyControlNameStr);
	516
	517	void _setCallbackInfo(PyObject* self, PyObject* _class);
	518	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyControl)"
	519	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	520
	521
	522	void base_DoMoveWindow(int x, int y, int width, int height);
	523	void base_DoSetSize(int x, int y, int width, int height,
	524	int sizeFlags = wxSIZE_AUTO);
	525	void base_DoSetClientSize(int width, int height);
	526	void base_DoSetVirtualSize( int x, int y );
	527
	528	void base_DoGetSize( int OUTPUT, int OUTPUT ) const;
	529	void base_DoGetClientSize( int OUTPUT, int OUTPUT ) const;
	530	void base_DoGetPosition( int OUTPUT, int OUTPUT ) const;
	531
	532	wxSize base_DoGetVirtualSize() const;
	533	wxSize base_DoGetBestSize() const;
	534
	535	void base_InitDialog();
	536	bool base_TransferDataToWindow();
	537	bool base_TransferDataFromWindow();
	538	bool base_Validate();
	539
	540	bool base_AcceptsFocus() const;
	541	bool base_AcceptsFocusFromKeyboard() const;
	542	wxSize base_GetMaxSize() const;
	543	}
	544
	545	//---------------------------------------------------------------------------