[wxWidgets.git] / 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
7bf85405 RD	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
03e9bead	13	%module windows2
7bf85405	14
03e9bead	15	%{
7bf85405	16	#include "helpers.h"
f6bcfd97	17	#ifdef OLD_GRID
7bf85405	18	#include <wx/grid.h>
f6bcfd97	19	#endif
7bf85405	20	#include <wx/notebook.h>
9c039d08	21	#include <wx/splitter.h>
9416aa89	22	#include <wx/imaglist.h>
b639c3c5 RD	23	#ifdef __WXMSW__
	24	#include <wx/msw/taskbar.h>
	25	#endif
7bf85405 RD	26	%}
	27
	28	//----------------------------------------------------------------------
	29
137b5242 RD	30	%{
	31	// Put some wx default wxChar* values into wxStrings.
	32	DECLARE_DEF_STRING(NOTEBOOK_NAME);
0b85cc38	33	DECLARE_DEF_STRING(PanelNameStr);
b0e5c039	34	DECLARE_DEF_STRING(ControlNameStr);
137b5242 RD	35
	36	static const wxChar* wxSplitterNameStr = wxT("splitter");
	37	DECLARE_DEF_STRING(SplitterNameStr);
	38	static const wxString wxPyEmptyString(wxT(""));
	39	%}
	40
	41	//----------------------------------------------------------------------
	42
7bf85405 RD	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
b8b8dda7	54	%pragma(python) code = "import wx"
9c039d08	55
7bf85405 RD	56	//---------------------------------------------------------------------------
7bf85405 RD	57
1b62f00d RD	58	enum {
	59	/* notebook control event types */
	60	wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
	61	wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING,
	62	};
	63
	64
bb0054cd	65	class wxNotebookEvent : public wxNotifyEvent {
7bf85405	66	public:
09f3d4e6 RD	67	wxNotebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0,
	68	int nSel = -1, int nOldSel = -1);
	69
7bf85405 RD	70	int GetSelection();
7bf85405 RD	71	int GetOldSelection();
bb0054cd RD	72	void SetOldSelection(int page);
bb0054cd RD	73	void SetSelection(int page);
7bf85405 RD	74	};
	75
	76
	77
	78	class wxNotebook : public wxControl {
	79	public:
	80	wxNotebook(wxWindow *parent,
	81	wxWindowID id,
b68dc582 RD	82	const wxPoint& pos = wxDefaultPosition,
b68dc582 RD	83	const wxSize& size = wxDefaultSize,
7bf85405	84	long style = 0,
137b5242	85	const wxString& name = wxPyNOTEBOOK_NAME);
09f3d4e6	86	%name(wxPreNotebook)wxNotebook();
7bf85405	87
09f3d4e6 RD	88	bool Create(wxWindow *parent,
	89	wxWindowID id,
	90	const wxPoint& pos = wxDefaultPosition,
	91	const wxSize& size = wxDefaultSize,
	92	long style = 0,
137b5242	93	const wxString& name = wxPyNOTEBOOK_NAME);
9c039d08	94
0122b7e3	95	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
17c0e08c	96	%pragma(python) addtomethod = "wxPreNotebook:val._setOORInfo(val)"
0122b7e3	97
7bf85405 RD	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;
949853a4	104
7bf85405	105	void SetImageList(wxImageList* imageList);
949853a4 RD	106	void AssignImageList(wxImageList *imageList) ;
	107	%pragma(python) addtomethod = "AssignImageList:_args[0].thisown = 0"
	108
7bf85405 RD	109	wxImageList* GetImageList();
	110	int GetPageImage(int nPage);
	111	bool SetPageImage(int nPage, int nImage);
	112	int GetRowCount();
	113
c368d904 RD	114	void SetPageSize(const wxSize& size);
c368d904 RD	115	void SetPadding(const wxSize& padding);
7bf85405	116	bool DeletePage(int nPage);
cf694132	117	bool RemovePage(int nPage);
7bf85405 RD	118	bool DeleteAllPages();
	119	bool AddPage(/wxNotebookPage/ wxWindow *pPage,
	120	const wxString& strText,
cf694132	121	int bSelect = FALSE,
7bf85405 RD	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);
bb0054cd	128	/wxNotebookPage/ wxWindow *GetPage(int nPage);
7bf85405	129
cf694132 RD	130	%addmethods {
	131	void ResizeChildren() {
	132	wxSizeEvent evt(self->GetClientSize());
4cd9591a	133	self->GetEventHandler()->ProcessEvent(evt);
cf694132 RD	134	}
	135	}
	136
	137
7bf85405 RD	138	};
7bf85405 RD	139
9c039d08 RD	140	//---------------------------------------------------------------------------
9c039d08 RD	141
f6bcfd97	142
1b62f00d RD	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
f6bcfd97 BP	152	enum
	153	{
	154	wxSPLIT_HORIZONTAL,
	155	wxSPLIT_VERTICAL,
	156	wxSPLIT_DRAG_NONE,
	157	wxSPLIT_DRAG_DRAGGING,
	158	wxSPLIT_DRAG_LEFT_DOWN
f6bcfd97 BP	159	};
	160
	161
756ed80c	162	class wxSplitterEvent : public wxNotifyEvent {
bb0054cd	163	public:
09f3d4e6 RD	164	wxSplitterEvent(wxEventType type = wxEVT_NULL,
	165	wxSplitterWindow *splitter = NULL);
	166
bb0054cd RD	167	int GetSashPosition();
	168	int GetX();
	169	int GetY();
	170	wxWindow* GetWindowBeingRemoved();
	171	void SetSashPosition(int pos);
	172	}
	173
	174
	175
	176
9c039d08 RD	177	class wxSplitterWindow : public wxWindow {
	178	public:
	179	wxSplitterWindow(wxWindow* parent, wxWindowID id,
b68dc582 RD	180	const wxPoint& point = wxDefaultPosition,
b68dc582 RD	181	const wxSize& size = wxDefaultSize,
b639c3c5	182	long style=wxSP_3D\|wxCLIP_CHILDREN,
137b5242	183	const wxString& name = wxPySplitterNameStr);
09f3d4e6	184	%name(wxPreSplitterWindow)wxSplitterWindow();
9c039d08	185
09f3d4e6 RD	186	bool Create(wxWindow* parent, wxWindowID id,
	187	const wxPoint& point = wxDefaultPosition,
	188	const wxSize& size = wxDefaultSize,
	189	long style=wxSP_3D\|wxCLIP_CHILDREN,
137b5242	190	const wxString& name = wxPySplitterNameStr);
9c039d08	191
0122b7e3	192	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
17c0e08c	193	%pragma(python) addtomethod = "wxPreSplitterWindow:val._setOORInfo(val)"
09f3d4e6 RD	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
9c039d08	205	int GetSplitMode();
09f3d4e6 RD	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?
9c039d08 RD	232	bool IsSplit();
9c039d08 RD	233
09f3d4e6	234	// Sets the sash size
b639c3c5	235	void SetSashSize(int width);
09f3d4e6 RD	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
3bd1e033 RD	256	// Resizes subwindows
	257	virtual void SizeWindows();
	258
	259	void SetNeedUpdating(bool needUpdating) { m_needUpdating = needUpdating; }
	260	bool GetNeedUpdating() const { return m_needUpdating ; }
	261
9c039d08 RD	262	};
	263
	264	//---------------------------------------------------------------------------
	265
b639c3c5 RD	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	};
9c039d08 RD	277
9c039d08 RD	278
b639c3c5 RD	279	class wxTaskBarIcon : public wxEvtHandler {
	280	public:
	281	wxTaskBarIcon();
	282	~wxTaskBarIcon();
	283
0122b7e3 RD	284	//%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
0122b7e3 RD	285
c368d904	286	// We still use the magic methods here since that is the way it is documented...
b8b8dda7 RD	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)"
b639c3c5	294
137b5242	295	bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxPyEmptyString);
b639c3c5	296	bool RemoveIcon(void);
be4d9c1f	297	bool PopupMenu(wxMenu *menu);
c368d904 RD	298	bool IsIconInstalled();
c368d904 RD	299	bool IsOK();
b639c3c5 RD	300	};
	301	#endif
	302
0b85cc38 RD	303	//---------------------------------------------------------------------------
	304	//---------------------------------------------------------------------------
	305	// wxPyWindow derives from wxWindow and adds support for overriding many of
	306	// the virtual methods in Python derived classes.
	307
b0e5c039 RD	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
0b85cc38	319	// Enable
b0e5c039 RD	320	// Fit
	321	// GetCharHeight
	322	// GetCharWidth
	323	// GetClientAreaOrigin
0b85cc38	324	// GetDefaultItem
0b85cc38	325	// IsTopLevel
0b85cc38	326	// RemoveChild
0b85cc38	327	// SetBackgroundColour
b0e5c039 RD	328	// SetDefaultItem
	329	// SetFocus
	330	// SetFocusFromKbd
0b85cc38	331	// SetForegroundColour
b0e5c039 RD	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	};
0b85cc38	374
b0e5c039	375	IMPLEMENT_DYNAMIC_CLASS(wxPyWindow, wxWindow);
0b85cc38	376
b0e5c039 RD	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);
0b85cc38	381
b0e5c039 RD	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);
0b85cc38	385
b0e5c039 RD	386	IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetVirtualSize);
b0e5c039 RD	387	IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetBestSize);
0b85cc38	388
b0e5c039 RD	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	}
0b85cc38	544
7bf85405	545	//---------------------------------------------------------------------------