From d00d1b88181d632fb4c6ef4478d8536c583fe45a Mon Sep 17 00:00:00 2001 From: Robin Dunn Date: Fri, 26 Mar 2004 19:37:03 +0000 Subject: [PATCH] reSWIGged git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@26370 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- wxPython/src/gtk/windows.py | 270 ++++++++++++++++++++++++++--- wxPython/src/gtk/windows_wrap.cpp | 26 +++ wxPython/src/mac/windows.py | 270 ++++++++++++++++++++++++++--- wxPython/src/mac/windows_wrap.cpp | 26 +++ wxPython/src/msw/html.py | 4 + wxPython/src/msw/html_wrap.cpp | 27 +++ wxPython/src/msw/windows.py | 271 +++++++++++++++++++++++++++--- wxPython/src/msw/windows_wrap.cpp | 26 +++ 8 files changed, 839 insertions(+), 81 deletions(-) diff --git a/wxPython/src/gtk/windows.py b/wxPython/src/gtk/windows.py index d94eb8a3be..101768212b 100644 --- a/wxPython/src/gtk/windows.py +++ b/wxPython/src/gtk/windows.py @@ -668,12 +668,20 @@ SPLIT_DRAG_NONE = _windows.SPLIT_DRAG_NONE SPLIT_DRAG_DRAGGING = _windows.SPLIT_DRAG_DRAGGING SPLIT_DRAG_LEFT_DOWN = _windows.SPLIT_DRAG_LEFT_DOWN class SplitterWindow(core.Window): + """ + wx.SplitterWindow manages up to two subwindows or panes, + with an optional vertical or horizontal split which can be + used with the mouse or programmatically. + + """ def __repr__(self): return "<%s.%s; proxy of C++ wxSplitterWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): """ __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> SplitterWindow + + Constructor. Creates and shows a SplitterWindow. """ if kwargs.has_key('point'): kwargs['pos'] = kwargs['point'] newobj = _windows.new_SplitterWindow(*args, **kwargs) @@ -686,87 +694,254 @@ class SplitterWindow(core.Window): """ Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> bool + + Create the GUI part of the SplitterWindow for the 2-phase create. """ return _windows.SplitterWindow_Create(*args, **kwargs) def GetWindow1(*args, **kwargs): - """GetWindow1() -> Window""" + """ + GetWindow1() -> Window + + Gets the only or left/top pane. + """ return _windows.SplitterWindow_GetWindow1(*args, **kwargs) def GetWindow2(*args, **kwargs): - """GetWindow2() -> Window""" + """ + GetWindow2() -> Window + + Gets the right/bottom pane. + """ return _windows.SplitterWindow_GetWindow2(*args, **kwargs) def SetSplitMode(*args, **kwargs): - """SetSplitMode(int mode)""" + """ + SetSplitMode(int mode) + + Sets the split mode. The mode can be wx.SPLIT_VERTICAL or + wx.SPLIT_HORIZONTAL. This only sets the internal variable; + does not update the display. + """ return _windows.SplitterWindow_SetSplitMode(*args, **kwargs) def GetSplitMode(*args, **kwargs): - """GetSplitMode() -> int""" + """ + GetSplitMode() -> int + + Gets the split mode + """ return _windows.SplitterWindow_GetSplitMode(*args, **kwargs) def Initialize(*args, **kwargs): - """Initialize(Window window)""" + """ + Initialize(Window window) + + Initializes the splitter window to have one pane. This + should be called if you wish to initially view only a single + pane in the splitter window. + """ return _windows.SplitterWindow_Initialize(*args, **kwargs) def SplitVertically(*args, **kwargs): - """SplitVertically(Window window1, Window window2, int sashPosition=0) -> bool""" + """ + SplitVertically(Window window1, Window window2, int sashPosition=0) -> bool + + Initializes the left and right panes of the splitter window. + + window1 The left pane. + window2 The right pane. + sashPosition The initial position of the sash. If this + value is positive, it specifies the size + of the left pane. If it is negative, it is + absolute value gives the size of the right + pane. Finally, specify 0 (default) to + choose the default position (half of the + total window width). + + Returns True if successful, False otherwise (the window was + already split). + + SplitVertically should be called if you wish to initially + view two panes. It can also be called at any subsequent + time, but the application should check that the window is + not currently split using IsSplit. + """ return _windows.SplitterWindow_SplitVertically(*args, **kwargs) def SplitHorizontally(*args, **kwargs): - """SplitHorizontally(Window window1, Window window2, int sashPosition=0) -> bool""" + """ + SplitHorizontally(Window window1, Window window2, int sashPosition=0) -> bool + + Initializes the top and bottom panes of the splitter window. + + window1 The top pane. + window2 The bottom pane. + sashPosition The initial position of the sash. If this + value is positive, it specifies the size + of the upper pane. If it is negative, it + is absolute value gives the size of the + lower pane. Finally, specify 0 (default) + to choose the default position (half of + the total window height). + + Returns True if successful, False otherwise (the window was + already split). + + SplitHorizontally should be called if you wish to initially + view two panes. It can also be called at any subsequent + time, but the application should check that the window is + not currently split using IsSplit. + """ return _windows.SplitterWindow_SplitHorizontally(*args, **kwargs) def Unsplit(*args, **kwargs): - """Unsplit(Window toRemove=None) -> bool""" + """ + Unsplit(Window toRemove=None) -> bool + + Unsplits the window. Pass the pane to remove, or None to + remove the right or bottom pane. Returns True if + successful, False otherwise (the window was not split). + + This function will not actually delete the pane being + removed; it sends EVT_SPLITTER_UNSPLIT which can be handled + for the desired behaviour. By default, the pane being + removed is only hidden. + """ return _windows.SplitterWindow_Unsplit(*args, **kwargs) def ReplaceWindow(*args, **kwargs): - """ReplaceWindow(Window winOld, Window winNew) -> bool""" + """ + ReplaceWindow(Window winOld, Window winNew) -> bool + + This function replaces one of the windows managed by the + SplitterWindow with another one. It is in general better to + use it instead of calling Unsplit() and then resplitting the + window back because it will provoke much less flicker. It is + valid to call this function whether the splitter has two + windows or only one. + + Both parameters should be non-None and winOld must specify + one of the windows managed by the splitter. If the + parameters are incorrect or the window couldn't be replaced, + False is returned. Otherwise the function will return True, + but please notice that it will not Destroy the replaced + window and you may wish to do it yourself. + """ return _windows.SplitterWindow_ReplaceWindow(*args, **kwargs) + def UpdateSize(*args, **kwargs): + """ + UpdateSize() + + Causes any pending sizing of the sash and child panes to + take place immediately. + + Such resizing normally takes place in idle time, in order to + wait for layout to be completed. However, this can cause + unacceptable flicker as the panes are resized after the + window has been shown. To work around this, you can perform + window layout (for example by sending a size event to the + parent window), and then call this function, before showing + the top-level window. + """ + return _windows.SplitterWindow_UpdateSize(*args, **kwargs) + def IsSplit(*args, **kwargs): - """IsSplit() -> bool""" + """ + IsSplit() -> bool + + Is the window split? + """ return _windows.SplitterWindow_IsSplit(*args, **kwargs) def SetSashSize(*args, **kwargs): - """SetSashSize(int width)""" + """ + SetSashSize(int width) + + Sets the sash size + """ return _windows.SplitterWindow_SetSashSize(*args, **kwargs) def SetBorderSize(*args, **kwargs): - """SetBorderSize(int width)""" + """ + SetBorderSize(int width) + + Sets the border size + """ return _windows.SplitterWindow_SetBorderSize(*args, **kwargs) def GetSashSize(*args, **kwargs): - """GetSashSize() -> int""" + """ + GetSashSize() -> int + + Gets the sash size + """ return _windows.SplitterWindow_GetSashSize(*args, **kwargs) def GetBorderSize(*args, **kwargs): - """GetBorderSize() -> int""" + """ + GetBorderSize() -> int + + Gets the border size + """ return _windows.SplitterWindow_GetBorderSize(*args, **kwargs) def SetSashPosition(*args, **kwargs): - """SetSashPosition(int position, bool redraw=True)""" + """ + SetSashPosition(int position, bool redraw=True) + + Sets the sash position, in pixels. If redraw is Ttrue then + the panes are resized and the sash and border are redrawn. + """ return _windows.SplitterWindow_SetSashPosition(*args, **kwargs) def GetSashPosition(*args, **kwargs): - """GetSashPosition() -> int""" + """ + GetSashPosition() -> int + + Returns the surrent sash position. + """ return _windows.SplitterWindow_GetSashPosition(*args, **kwargs) def SetMinimumPaneSize(*args, **kwargs): - """SetMinimumPaneSize(int min)""" + """ + SetMinimumPaneSize(int min) + + Sets the minimum pane size in pixels. + + The default minimum pane size is zero, which means that + either pane can be reduced to zero by dragging the sash, + thus removing one of the panes. To prevent this behaviour (and + veto out-of-range sash dragging), set a minimum size, + for example 20 pixels. If the wx.SP_PERMIT_UNSPLIT style is + used when a splitter window is created, the window may be + unsplit even if minimum size is non-zero. + """ return _windows.SplitterWindow_SetMinimumPaneSize(*args, **kwargs) def GetMinimumPaneSize(*args, **kwargs): - """GetMinimumPaneSize() -> int""" + """ + GetMinimumPaneSize() -> int + + Gets the minimum pane size in pixels. + """ return _windows.SplitterWindow_GetMinimumPaneSize(*args, **kwargs) def SashHitTest(*args, **kwargs): - """SashHitTest(int x, int y, int tolerance=5) -> bool""" + """ + SashHitTest(int x, int y, int tolerance=5) -> bool + + Tests for x, y over the sash + """ return _windows.SplitterWindow_SashHitTest(*args, **kwargs) def SizeWindows(*args, **kwargs): - """SizeWindows()""" + """ + SizeWindows() + + Resizes subwindows + """ return _windows.SplitterWindow_SizeWindows(*args, **kwargs) def SetNeedUpdating(*args, **kwargs): @@ -787,38 +962,79 @@ _windows.SplitterWindow_swigregister(SplitterWindowPtr) SplitterNameStr = cvar.SplitterNameStr def PreSplitterWindow(*args, **kwargs): - """PreSplitterWindow() -> SplitterWindow""" + """ + PreSplitterWindow() -> SplitterWindow + + Precreate a SplitterWindow for 2-phase creation. + """ val = _windows.new_PreSplitterWindow(*args, **kwargs) val.thisown = 1 return val class SplitterEvent(core.NotifyEvent): + """This class represents the events generated by a splitter control.""" def __repr__(self): return "<%s.%s; proxy of C++ wxSplitterEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(wxEventType type=wxEVT_NULL, SplitterWindow splitter=(wxSplitterWindow *) NULL) -> SplitterEvent""" + """ + __init__(wxEventType type=wxEVT_NULL, SplitterWindow splitter=(wxSplitterWindow *) NULL) -> SplitterEvent + + This class represents the events generated by a splitter control. + """ newobj = _windows.new_SplitterEvent(*args, **kwargs) self.this = newobj.this self.thisown = 1 del newobj.thisown def SetSashPosition(*args, **kwargs): - """SetSashPosition(int pos)""" + """ + SetSashPosition(int pos) + + This funciton is only meaningful during + EVT_SPLITTER_SASH_POS_CHANGING and + EVT_SPLITTER_SASH_POS_CHANGED events. In the case of + _CHANGED events, sets the the new sash position. In the case + of _CHANGING events, sets the new tracking bar position so + visual feedback during dragging will represent that change + that will actually take place. Set to -1 from the event + handler code to prevent repositioning. + """ return _windows.SplitterEvent_SetSashPosition(*args, **kwargs) def GetSashPosition(*args, **kwargs): - """GetSashPosition() -> int""" + """ + GetSashPosition() -> int + + Returns the new sash position while in + EVT_SPLITTER_SASH_POS_CHANGING and + EVT_SPLITTER_SASH_POS_CHANGED events. + """ return _windows.SplitterEvent_GetSashPosition(*args, **kwargs) def GetWindowBeingRemoved(*args, **kwargs): - """GetWindowBeingRemoved() -> Window""" + """ + GetWindowBeingRemoved() -> Window + + Returns a pointer to the window being removed when a + splitter window is unsplit. + """ return _windows.SplitterEvent_GetWindowBeingRemoved(*args, **kwargs) def GetX(*args, **kwargs): - """GetX() -> int""" + """ + GetX() -> int + + Returns the x coordinate of the double-click point in a + EVT_SPLITTER_DCLICK event. + """ return _windows.SplitterEvent_GetX(*args, **kwargs) def GetY(*args, **kwargs): - """GetY() -> int""" + """ + GetY() -> int + + Returns the y coordinate of the double-click point in a + EVT_SPLITTER_DCLICK event. + """ return _windows.SplitterEvent_GetY(*args, **kwargs) diff --git a/wxPython/src/gtk/windows_wrap.cpp b/wxPython/src/gtk/windows_wrap.cpp index fb722b3555..0e6bc636d7 100644 --- a/wxPython/src/gtk/windows_wrap.cpp +++ b/wxPython/src/gtk/windows_wrap.cpp @@ -5746,6 +5746,31 @@ static PyObject *_wrap_SplitterWindow_ReplaceWindow(PyObject *self, PyObject *ar } +static PyObject *_wrap_SplitterWindow_UpdateSize(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject *resultobj; + wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ; + PyObject * obj0 = 0 ; + char *kwnames[] = { + (char *) "self", NULL + }; + + if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_UpdateSize",kwnames,&obj0)) goto fail; + if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_wxSplitterWindow, + SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail; + { + PyThreadState* __tstate = wxPyBeginAllowThreads(); + (arg1)->UpdateSize(); + + wxPyEndAllowThreads(__tstate); + if (PyErr_Occurred()) SWIG_fail; + } + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + static PyObject *_wrap_SplitterWindow_IsSplit(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject *resultobj; wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ; @@ -23301,6 +23326,7 @@ static PyMethodDef SwigMethods[] = { { (char *)"SplitterWindow_SplitHorizontally", (PyCFunction) _wrap_SplitterWindow_SplitHorizontally, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_Unsplit", (PyCFunction) _wrap_SplitterWindow_Unsplit, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_ReplaceWindow", (PyCFunction) _wrap_SplitterWindow_ReplaceWindow, METH_VARARGS | METH_KEYWORDS }, + { (char *)"SplitterWindow_UpdateSize", (PyCFunction) _wrap_SplitterWindow_UpdateSize, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_IsSplit", (PyCFunction) _wrap_SplitterWindow_IsSplit, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_SetSashSize", (PyCFunction) _wrap_SplitterWindow_SetSashSize, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_SetBorderSize", (PyCFunction) _wrap_SplitterWindow_SetBorderSize, METH_VARARGS | METH_KEYWORDS }, diff --git a/wxPython/src/mac/windows.py b/wxPython/src/mac/windows.py index 623ce4be4d..4afc644239 100644 --- a/wxPython/src/mac/windows.py +++ b/wxPython/src/mac/windows.py @@ -673,12 +673,20 @@ SPLIT_DRAG_NONE = _windows.SPLIT_DRAG_NONE SPLIT_DRAG_DRAGGING = _windows.SPLIT_DRAG_DRAGGING SPLIT_DRAG_LEFT_DOWN = _windows.SPLIT_DRAG_LEFT_DOWN class SplitterWindow(core.Window): + """ + wx.SplitterWindow manages up to two subwindows or panes, + with an optional vertical or horizontal split which can be + used with the mouse or programmatically. + + """ def __repr__(self): return "<%s.%s; proxy of C++ wxSplitterWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): """ __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> SplitterWindow + + Constructor. Creates and shows a SplitterWindow. """ if kwargs.has_key('point'): kwargs['pos'] = kwargs['point'] newobj = _windows.new_SplitterWindow(*args, **kwargs) @@ -691,87 +699,254 @@ class SplitterWindow(core.Window): """ Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> bool + + Create the GUI part of the SplitterWindow for the 2-phase create. """ return _windows.SplitterWindow_Create(*args, **kwargs) def GetWindow1(*args, **kwargs): - """GetWindow1() -> Window""" + """ + GetWindow1() -> Window + + Gets the only or left/top pane. + """ return _windows.SplitterWindow_GetWindow1(*args, **kwargs) def GetWindow2(*args, **kwargs): - """GetWindow2() -> Window""" + """ + GetWindow2() -> Window + + Gets the right/bottom pane. + """ return _windows.SplitterWindow_GetWindow2(*args, **kwargs) def SetSplitMode(*args, **kwargs): - """SetSplitMode(int mode)""" + """ + SetSplitMode(int mode) + + Sets the split mode. The mode can be wx.SPLIT_VERTICAL or + wx.SPLIT_HORIZONTAL. This only sets the internal variable; + does not update the display. + """ return _windows.SplitterWindow_SetSplitMode(*args, **kwargs) def GetSplitMode(*args, **kwargs): - """GetSplitMode() -> int""" + """ + GetSplitMode() -> int + + Gets the split mode + """ return _windows.SplitterWindow_GetSplitMode(*args, **kwargs) def Initialize(*args, **kwargs): - """Initialize(Window window)""" + """ + Initialize(Window window) + + Initializes the splitter window to have one pane. This + should be called if you wish to initially view only a single + pane in the splitter window. + """ return _windows.SplitterWindow_Initialize(*args, **kwargs) def SplitVertically(*args, **kwargs): - """SplitVertically(Window window1, Window window2, int sashPosition=0) -> bool""" + """ + SplitVertically(Window window1, Window window2, int sashPosition=0) -> bool + + Initializes the left and right panes of the splitter window. + + window1 The left pane. + window2 The right pane. + sashPosition The initial position of the sash. If this + value is positive, it specifies the size + of the left pane. If it is negative, it is + absolute value gives the size of the right + pane. Finally, specify 0 (default) to + choose the default position (half of the + total window width). + + Returns True if successful, False otherwise (the window was + already split). + + SplitVertically should be called if you wish to initially + view two panes. It can also be called at any subsequent + time, but the application should check that the window is + not currently split using IsSplit. + """ return _windows.SplitterWindow_SplitVertically(*args, **kwargs) def SplitHorizontally(*args, **kwargs): - """SplitHorizontally(Window window1, Window window2, int sashPosition=0) -> bool""" + """ + SplitHorizontally(Window window1, Window window2, int sashPosition=0) -> bool + + Initializes the top and bottom panes of the splitter window. + + window1 The top pane. + window2 The bottom pane. + sashPosition The initial position of the sash. If this + value is positive, it specifies the size + of the upper pane. If it is negative, it + is absolute value gives the size of the + lower pane. Finally, specify 0 (default) + to choose the default position (half of + the total window height). + + Returns True if successful, False otherwise (the window was + already split). + + SplitHorizontally should be called if you wish to initially + view two panes. It can also be called at any subsequent + time, but the application should check that the window is + not currently split using IsSplit. + """ return _windows.SplitterWindow_SplitHorizontally(*args, **kwargs) def Unsplit(*args, **kwargs): - """Unsplit(Window toRemove=None) -> bool""" + """ + Unsplit(Window toRemove=None) -> bool + + Unsplits the window. Pass the pane to remove, or None to + remove the right or bottom pane. Returns True if + successful, False otherwise (the window was not split). + + This function will not actually delete the pane being + removed; it sends EVT_SPLITTER_UNSPLIT which can be handled + for the desired behaviour. By default, the pane being + removed is only hidden. + """ return _windows.SplitterWindow_Unsplit(*args, **kwargs) def ReplaceWindow(*args, **kwargs): - """ReplaceWindow(Window winOld, Window winNew) -> bool""" + """ + ReplaceWindow(Window winOld, Window winNew) -> bool + + This function replaces one of the windows managed by the + SplitterWindow with another one. It is in general better to + use it instead of calling Unsplit() and then resplitting the + window back because it will provoke much less flicker. It is + valid to call this function whether the splitter has two + windows or only one. + + Both parameters should be non-None and winOld must specify + one of the windows managed by the splitter. If the + parameters are incorrect or the window couldn't be replaced, + False is returned. Otherwise the function will return True, + but please notice that it will not Destroy the replaced + window and you may wish to do it yourself. + """ return _windows.SplitterWindow_ReplaceWindow(*args, **kwargs) + def UpdateSize(*args, **kwargs): + """ + UpdateSize() + + Causes any pending sizing of the sash and child panes to + take place immediately. + + Such resizing normally takes place in idle time, in order to + wait for layout to be completed. However, this can cause + unacceptable flicker as the panes are resized after the + window has been shown. To work around this, you can perform + window layout (for example by sending a size event to the + parent window), and then call this function, before showing + the top-level window. + """ + return _windows.SplitterWindow_UpdateSize(*args, **kwargs) + def IsSplit(*args, **kwargs): - """IsSplit() -> bool""" + """ + IsSplit() -> bool + + Is the window split? + """ return _windows.SplitterWindow_IsSplit(*args, **kwargs) def SetSashSize(*args, **kwargs): - """SetSashSize(int width)""" + """ + SetSashSize(int width) + + Sets the sash size + """ return _windows.SplitterWindow_SetSashSize(*args, **kwargs) def SetBorderSize(*args, **kwargs): - """SetBorderSize(int width)""" + """ + SetBorderSize(int width) + + Sets the border size + """ return _windows.SplitterWindow_SetBorderSize(*args, **kwargs) def GetSashSize(*args, **kwargs): - """GetSashSize() -> int""" + """ + GetSashSize() -> int + + Gets the sash size + """ return _windows.SplitterWindow_GetSashSize(*args, **kwargs) def GetBorderSize(*args, **kwargs): - """GetBorderSize() -> int""" + """ + GetBorderSize() -> int + + Gets the border size + """ return _windows.SplitterWindow_GetBorderSize(*args, **kwargs) def SetSashPosition(*args, **kwargs): - """SetSashPosition(int position, bool redraw=True)""" + """ + SetSashPosition(int position, bool redraw=True) + + Sets the sash position, in pixels. If redraw is Ttrue then + the panes are resized and the sash and border are redrawn. + """ return _windows.SplitterWindow_SetSashPosition(*args, **kwargs) def GetSashPosition(*args, **kwargs): - """GetSashPosition() -> int""" + """ + GetSashPosition() -> int + + Returns the surrent sash position. + """ return _windows.SplitterWindow_GetSashPosition(*args, **kwargs) def SetMinimumPaneSize(*args, **kwargs): - """SetMinimumPaneSize(int min)""" + """ + SetMinimumPaneSize(int min) + + Sets the minimum pane size in pixels. + + The default minimum pane size is zero, which means that + either pane can be reduced to zero by dragging the sash, + thus removing one of the panes. To prevent this behaviour (and + veto out-of-range sash dragging), set a minimum size, + for example 20 pixels. If the wx.SP_PERMIT_UNSPLIT style is + used when a splitter window is created, the window may be + unsplit even if minimum size is non-zero. + """ return _windows.SplitterWindow_SetMinimumPaneSize(*args, **kwargs) def GetMinimumPaneSize(*args, **kwargs): - """GetMinimumPaneSize() -> int""" + """ + GetMinimumPaneSize() -> int + + Gets the minimum pane size in pixels. + """ return _windows.SplitterWindow_GetMinimumPaneSize(*args, **kwargs) def SashHitTest(*args, **kwargs): - """SashHitTest(int x, int y, int tolerance=5) -> bool""" + """ + SashHitTest(int x, int y, int tolerance=5) -> bool + + Tests for x, y over the sash + """ return _windows.SplitterWindow_SashHitTest(*args, **kwargs) def SizeWindows(*args, **kwargs): - """SizeWindows()""" + """ + SizeWindows() + + Resizes subwindows + """ return _windows.SplitterWindow_SizeWindows(*args, **kwargs) def SetNeedUpdating(*args, **kwargs): @@ -792,38 +967,79 @@ _windows.SplitterWindow_swigregister(SplitterWindowPtr) SplitterNameStr = cvar.SplitterNameStr def PreSplitterWindow(*args, **kwargs): - """PreSplitterWindow() -> SplitterWindow""" + """ + PreSplitterWindow() -> SplitterWindow + + Precreate a SplitterWindow for 2-phase creation. + """ val = _windows.new_PreSplitterWindow(*args, **kwargs) val.thisown = 1 return val class SplitterEvent(core.NotifyEvent): + """This class represents the events generated by a splitter control.""" def __repr__(self): return "<%s.%s; proxy of C++ wxSplitterEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(wxEventType type=wxEVT_NULL, SplitterWindow splitter=(wxSplitterWindow *) NULL) -> SplitterEvent""" + """ + __init__(wxEventType type=wxEVT_NULL, SplitterWindow splitter=(wxSplitterWindow *) NULL) -> SplitterEvent + + This class represents the events generated by a splitter control. + """ newobj = _windows.new_SplitterEvent(*args, **kwargs) self.this = newobj.this self.thisown = 1 del newobj.thisown def SetSashPosition(*args, **kwargs): - """SetSashPosition(int pos)""" + """ + SetSashPosition(int pos) + + This funciton is only meaningful during + EVT_SPLITTER_SASH_POS_CHANGING and + EVT_SPLITTER_SASH_POS_CHANGED events. In the case of + _CHANGED events, sets the the new sash position. In the case + of _CHANGING events, sets the new tracking bar position so + visual feedback during dragging will represent that change + that will actually take place. Set to -1 from the event + handler code to prevent repositioning. + """ return _windows.SplitterEvent_SetSashPosition(*args, **kwargs) def GetSashPosition(*args, **kwargs): - """GetSashPosition() -> int""" + """ + GetSashPosition() -> int + + Returns the new sash position while in + EVT_SPLITTER_SASH_POS_CHANGING and + EVT_SPLITTER_SASH_POS_CHANGED events. + """ return _windows.SplitterEvent_GetSashPosition(*args, **kwargs) def GetWindowBeingRemoved(*args, **kwargs): - """GetWindowBeingRemoved() -> Window""" + """ + GetWindowBeingRemoved() -> Window + + Returns a pointer to the window being removed when a + splitter window is unsplit. + """ return _windows.SplitterEvent_GetWindowBeingRemoved(*args, **kwargs) def GetX(*args, **kwargs): - """GetX() -> int""" + """ + GetX() -> int + + Returns the x coordinate of the double-click point in a + EVT_SPLITTER_DCLICK event. + """ return _windows.SplitterEvent_GetX(*args, **kwargs) def GetY(*args, **kwargs): - """GetY() -> int""" + """ + GetY() -> int + + Returns the y coordinate of the double-click point in a + EVT_SPLITTER_DCLICK event. + """ return _windows.SplitterEvent_GetY(*args, **kwargs) diff --git a/wxPython/src/mac/windows_wrap.cpp b/wxPython/src/mac/windows_wrap.cpp index f69224664d..a58c4a78e5 100644 --- a/wxPython/src/mac/windows_wrap.cpp +++ b/wxPython/src/mac/windows_wrap.cpp @@ -5803,6 +5803,31 @@ static PyObject *_wrap_SplitterWindow_ReplaceWindow(PyObject *, PyObject *args, } +static PyObject *_wrap_SplitterWindow_UpdateSize(PyObject *, PyObject *args, PyObject *kwargs) { + PyObject *resultobj; + wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ; + PyObject * obj0 = 0 ; + char *kwnames[] = { + (char *) "self", NULL + }; + + if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_UpdateSize",kwnames,&obj0)) goto fail; + if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_wxSplitterWindow, + SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail; + { + PyThreadState* __tstate = wxPyBeginAllowThreads(); + (arg1)->UpdateSize(); + + wxPyEndAllowThreads(__tstate); + if (PyErr_Occurred()) SWIG_fail; + } + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + static PyObject *_wrap_SplitterWindow_IsSplit(PyObject *, PyObject *args, PyObject *kwargs) { PyObject *resultobj; wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ; @@ -23024,6 +23049,7 @@ static PyMethodDef SwigMethods[] = { { (char *)"SplitterWindow_SplitHorizontally", (PyCFunction) _wrap_SplitterWindow_SplitHorizontally, METH_VARARGS | METH_KEYWORDS, NULL }, { (char *)"SplitterWindow_Unsplit", (PyCFunction) _wrap_SplitterWindow_Unsplit, METH_VARARGS | METH_KEYWORDS, NULL }, { (char *)"SplitterWindow_ReplaceWindow", (PyCFunction) _wrap_SplitterWindow_ReplaceWindow, METH_VARARGS | METH_KEYWORDS, NULL }, + { (char *)"SplitterWindow_UpdateSize", (PyCFunction) _wrap_SplitterWindow_UpdateSize, METH_VARARGS | METH_KEYWORDS, NULL }, { (char *)"SplitterWindow_IsSplit", (PyCFunction) _wrap_SplitterWindow_IsSplit, METH_VARARGS | METH_KEYWORDS, NULL }, { (char *)"SplitterWindow_SetSashSize", (PyCFunction) _wrap_SplitterWindow_SetSashSize, METH_VARARGS | METH_KEYWORDS, NULL }, { (char *)"SplitterWindow_SetBorderSize", (PyCFunction) _wrap_SplitterWindow_SetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL }, diff --git a/wxPython/src/msw/html.py b/wxPython/src/msw/html.py index f9b07119a6..ec7c093592 100644 --- a/wxPython/src/msw/html.py +++ b/wxPython/src/msw/html.py @@ -636,6 +636,10 @@ class HtmlCell(core.Object): """GetDescent() -> int""" return _html.HtmlCell_GetDescent(*args, **kwargs) + def GetMaxTotalWidth(*args, **kwargs): + """GetMaxTotalWidth() -> int""" + return _html.HtmlCell_GetMaxTotalWidth(*args, **kwargs) + def GetId(*args, **kwargs): """GetId() -> String""" return _html.HtmlCell_GetId(*args, **kwargs) diff --git a/wxPython/src/msw/html_wrap.cpp b/wxPython/src/msw/html_wrap.cpp index b53a6bc2ba..3dfe75f7f9 100644 --- a/wxPython/src/msw/html_wrap.cpp +++ b/wxPython/src/msw/html_wrap.cpp @@ -4141,6 +4141,32 @@ static PyObject *_wrap_HtmlCell_GetDescent(PyObject *self, PyObject *args, PyObj } +static PyObject *_wrap_HtmlCell_GetMaxTotalWidth(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject *resultobj; + wxHtmlCell *arg1 = (wxHtmlCell *) 0 ; + int result; + PyObject * obj0 = 0 ; + char *kwnames[] = { + (char *) "self", NULL + }; + + if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HtmlCell_GetMaxTotalWidth",kwnames,&obj0)) goto fail; + if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_wxHtmlCell, + SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail; + { + PyThreadState* __tstate = wxPyBeginAllowThreads(); + result = (int)((wxHtmlCell const *)arg1)->GetMaxTotalWidth(); + + wxPyEndAllowThreads(__tstate); + if (PyErr_Occurred()) SWIG_fail; + } + resultobj = SWIG_FromInt((int)result); + return resultobj; + fail: + return NULL; +} + + static PyObject *_wrap_HtmlCell_GetId(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject *resultobj; wxHtmlCell *arg1 = (wxHtmlCell *) 0 ; @@ -10588,6 +10614,7 @@ static PyMethodDef SwigMethods[] = { { (char *)"HtmlCell_GetWidth", (PyCFunction) _wrap_HtmlCell_GetWidth, METH_VARARGS | METH_KEYWORDS }, { (char *)"HtmlCell_GetHeight", (PyCFunction) _wrap_HtmlCell_GetHeight, METH_VARARGS | METH_KEYWORDS }, { (char *)"HtmlCell_GetDescent", (PyCFunction) _wrap_HtmlCell_GetDescent, METH_VARARGS | METH_KEYWORDS }, + { (char *)"HtmlCell_GetMaxTotalWidth", (PyCFunction) _wrap_HtmlCell_GetMaxTotalWidth, METH_VARARGS | METH_KEYWORDS }, { (char *)"HtmlCell_GetId", (PyCFunction) _wrap_HtmlCell_GetId, METH_VARARGS | METH_KEYWORDS }, { (char *)"HtmlCell_SetId", (PyCFunction) _wrap_HtmlCell_SetId, METH_VARARGS | METH_KEYWORDS }, { (char *)"HtmlCell_GetLink", (PyCFunction) _wrap_HtmlCell_GetLink, METH_VARARGS | METH_KEYWORDS }, diff --git a/wxPython/src/msw/windows.py b/wxPython/src/msw/windows.py index 7e1f12c815..f8ac5d7c47 100644 --- a/wxPython/src/msw/windows.py +++ b/wxPython/src/msw/windows.py @@ -673,12 +673,20 @@ SPLIT_DRAG_NONE = _windows.SPLIT_DRAG_NONE SPLIT_DRAG_DRAGGING = _windows.SPLIT_DRAG_DRAGGING SPLIT_DRAG_LEFT_DOWN = _windows.SPLIT_DRAG_LEFT_DOWN class SplitterWindow(core.Window): + """ + wx.SplitterWindow manages up to two subwindows or panes, + with an optional vertical or horizontal split which can be + used with the mouse or programmatically. + + """ def __repr__(self): return "<%s.%s; proxy of C++ wxSplitterWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): """ __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> SplitterWindow + + Constructor. Creates and shows a SplitterWindow. """ if kwargs.has_key('point'): kwargs['pos'] = kwargs['point'] newobj = _windows.new_SplitterWindow(*args, **kwargs) @@ -691,87 +699,254 @@ class SplitterWindow(core.Window): """ Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> bool + + Create the GUI part of the SplitterWindow for the 2-phase create. """ return _windows.SplitterWindow_Create(*args, **kwargs) def GetWindow1(*args, **kwargs): - """GetWindow1() -> Window""" + """ + GetWindow1() -> Window + + Gets the only or left/top pane. + """ return _windows.SplitterWindow_GetWindow1(*args, **kwargs) def GetWindow2(*args, **kwargs): - """GetWindow2() -> Window""" + """ + GetWindow2() -> Window + + Gets the right/bottom pane. + """ return _windows.SplitterWindow_GetWindow2(*args, **kwargs) def SetSplitMode(*args, **kwargs): - """SetSplitMode(int mode)""" + """ + SetSplitMode(int mode) + + Sets the split mode. The mode can be wx.SPLIT_VERTICAL or + wx.SPLIT_HORIZONTAL. This only sets the internal variable; + does not update the display. + """ return _windows.SplitterWindow_SetSplitMode(*args, **kwargs) def GetSplitMode(*args, **kwargs): - """GetSplitMode() -> int""" + """ + GetSplitMode() -> int + + Gets the split mode + """ return _windows.SplitterWindow_GetSplitMode(*args, **kwargs) def Initialize(*args, **kwargs): - """Initialize(Window window)""" + """ + Initialize(Window window) + + Initializes the splitter window to have one pane. This + should be called if you wish to initially view only a single + pane in the splitter window. + """ return _windows.SplitterWindow_Initialize(*args, **kwargs) def SplitVertically(*args, **kwargs): - """SplitVertically(Window window1, Window window2, int sashPosition=0) -> bool""" + """ + SplitVertically(Window window1, Window window2, int sashPosition=0) -> bool + + Initializes the left and right panes of the splitter window. + + window1 The left pane. + window2 The right pane. + sashPosition The initial position of the sash. If this + value is positive, it specifies the size + of the left pane. If it is negative, it is + absolute value gives the size of the right + pane. Finally, specify 0 (default) to + choose the default position (half of the + total window width). + + Returns True if successful, False otherwise (the window was + already split). + + SplitVertically should be called if you wish to initially + view two panes. It can also be called at any subsequent + time, but the application should check that the window is + not currently split using IsSplit. + """ return _windows.SplitterWindow_SplitVertically(*args, **kwargs) def SplitHorizontally(*args, **kwargs): - """SplitHorizontally(Window window1, Window window2, int sashPosition=0) -> bool""" + """ + SplitHorizontally(Window window1, Window window2, int sashPosition=0) -> bool + + Initializes the top and bottom panes of the splitter window. + + window1 The top pane. + window2 The bottom pane. + sashPosition The initial position of the sash. If this + value is positive, it specifies the size + of the upper pane. If it is negative, it + is absolute value gives the size of the + lower pane. Finally, specify 0 (default) + to choose the default position (half of + the total window height). + + Returns True if successful, False otherwise (the window was + already split). + + SplitHorizontally should be called if you wish to initially + view two panes. It can also be called at any subsequent + time, but the application should check that the window is + not currently split using IsSplit. + """ return _windows.SplitterWindow_SplitHorizontally(*args, **kwargs) def Unsplit(*args, **kwargs): - """Unsplit(Window toRemove=None) -> bool""" + """ + Unsplit(Window toRemove=None) -> bool + + Unsplits the window. Pass the pane to remove, or None to + remove the right or bottom pane. Returns True if + successful, False otherwise (the window was not split). + + This function will not actually delete the pane being + removed; it sends EVT_SPLITTER_UNSPLIT which can be handled + for the desired behaviour. By default, the pane being + removed is only hidden. + """ return _windows.SplitterWindow_Unsplit(*args, **kwargs) def ReplaceWindow(*args, **kwargs): - """ReplaceWindow(Window winOld, Window winNew) -> bool""" + """ + ReplaceWindow(Window winOld, Window winNew) -> bool + + This function replaces one of the windows managed by the + SplitterWindow with another one. It is in general better to + use it instead of calling Unsplit() and then resplitting the + window back because it will provoke much less flicker. It is + valid to call this function whether the splitter has two + windows or only one. + + Both parameters should be non-None and winOld must specify + one of the windows managed by the splitter. If the + parameters are incorrect or the window couldn't be replaced, + False is returned. Otherwise the function will return True, + but please notice that it will not Destroy the replaced + window and you may wish to do it yourself. + """ return _windows.SplitterWindow_ReplaceWindow(*args, **kwargs) + def UpdateSize(*args, **kwargs): + """ + UpdateSize() + + Causes any pending sizing of the sash and child panes to + take place immediately. + + Such resizing normally takes place in idle time, in order to + wait for layout to be completed. However, this can cause + unacceptable flicker as the panes are resized after the + window has been shown. To work around this, you can perform + window layout (for example by sending a size event to the + parent window), and then call this function, before showing + the top-level window. + """ + return _windows.SplitterWindow_UpdateSize(*args, **kwargs) + def IsSplit(*args, **kwargs): - """IsSplit() -> bool""" + """ + IsSplit() -> bool + + Is the window split? + """ return _windows.SplitterWindow_IsSplit(*args, **kwargs) def SetSashSize(*args, **kwargs): - """SetSashSize(int width)""" + """ + SetSashSize(int width) + + Sets the sash size + """ return _windows.SplitterWindow_SetSashSize(*args, **kwargs) def SetBorderSize(*args, **kwargs): - """SetBorderSize(int width)""" + """ + SetBorderSize(int width) + + Sets the border size + """ return _windows.SplitterWindow_SetBorderSize(*args, **kwargs) def GetSashSize(*args, **kwargs): - """GetSashSize() -> int""" + """ + GetSashSize() -> int + + Gets the sash size + """ return _windows.SplitterWindow_GetSashSize(*args, **kwargs) def GetBorderSize(*args, **kwargs): - """GetBorderSize() -> int""" + """ + GetBorderSize() -> int + + Gets the border size + """ return _windows.SplitterWindow_GetBorderSize(*args, **kwargs) def SetSashPosition(*args, **kwargs): - """SetSashPosition(int position, bool redraw=True)""" + """ + SetSashPosition(int position, bool redraw=True) + + Sets the sash position, in pixels. If redraw is Ttrue then + the panes are resized and the sash and border are redrawn. + """ return _windows.SplitterWindow_SetSashPosition(*args, **kwargs) def GetSashPosition(*args, **kwargs): - """GetSashPosition() -> int""" + """ + GetSashPosition() -> int + + Returns the surrent sash position. + """ return _windows.SplitterWindow_GetSashPosition(*args, **kwargs) def SetMinimumPaneSize(*args, **kwargs): - """SetMinimumPaneSize(int min)""" + """ + SetMinimumPaneSize(int min) + + Sets the minimum pane size in pixels. + + The default minimum pane size is zero, which means that + either pane can be reduced to zero by dragging the sash, + thus removing one of the panes. To prevent this behaviour (and + veto out-of-range sash dragging), set a minimum size, + for example 20 pixels. If the wx.SP_PERMIT_UNSPLIT style is + used when a splitter window is created, the window may be + unsplit even if minimum size is non-zero. + """ return _windows.SplitterWindow_SetMinimumPaneSize(*args, **kwargs) def GetMinimumPaneSize(*args, **kwargs): - """GetMinimumPaneSize() -> int""" + """ + GetMinimumPaneSize() -> int + + Gets the minimum pane size in pixels. + """ return _windows.SplitterWindow_GetMinimumPaneSize(*args, **kwargs) def SashHitTest(*args, **kwargs): - """SashHitTest(int x, int y, int tolerance=5) -> bool""" + """ + SashHitTest(int x, int y, int tolerance=5) -> bool + + Tests for x, y over the sash + """ return _windows.SplitterWindow_SashHitTest(*args, **kwargs) def SizeWindows(*args, **kwargs): - """SizeWindows()""" + """ + SizeWindows() + + Resizes subwindows + """ return _windows.SplitterWindow_SizeWindows(*args, **kwargs) def SetNeedUpdating(*args, **kwargs): @@ -792,38 +967,79 @@ _windows.SplitterWindow_swigregister(SplitterWindowPtr) SplitterNameStr = cvar.SplitterNameStr def PreSplitterWindow(*args, **kwargs): - """PreSplitterWindow() -> SplitterWindow""" + """ + PreSplitterWindow() -> SplitterWindow + + Precreate a SplitterWindow for 2-phase creation. + """ val = _windows.new_PreSplitterWindow(*args, **kwargs) val.thisown = 1 return val class SplitterEvent(core.NotifyEvent): + """This class represents the events generated by a splitter control.""" def __repr__(self): return "<%s.%s; proxy of C++ wxSplitterEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) def __init__(self, *args, **kwargs): - """__init__(wxEventType type=wxEVT_NULL, SplitterWindow splitter=(wxSplitterWindow *) NULL) -> SplitterEvent""" + """ + __init__(wxEventType type=wxEVT_NULL, SplitterWindow splitter=(wxSplitterWindow *) NULL) -> SplitterEvent + + This class represents the events generated by a splitter control. + """ newobj = _windows.new_SplitterEvent(*args, **kwargs) self.this = newobj.this self.thisown = 1 del newobj.thisown def SetSashPosition(*args, **kwargs): - """SetSashPosition(int pos)""" + """ + SetSashPosition(int pos) + + This funciton is only meaningful during + EVT_SPLITTER_SASH_POS_CHANGING and + EVT_SPLITTER_SASH_POS_CHANGED events. In the case of + _CHANGED events, sets the the new sash position. In the case + of _CHANGING events, sets the new tracking bar position so + visual feedback during dragging will represent that change + that will actually take place. Set to -1 from the event + handler code to prevent repositioning. + """ return _windows.SplitterEvent_SetSashPosition(*args, **kwargs) def GetSashPosition(*args, **kwargs): - """GetSashPosition() -> int""" + """ + GetSashPosition() -> int + + Returns the new sash position while in + EVT_SPLITTER_SASH_POS_CHANGING and + EVT_SPLITTER_SASH_POS_CHANGED events. + """ return _windows.SplitterEvent_GetSashPosition(*args, **kwargs) def GetWindowBeingRemoved(*args, **kwargs): - """GetWindowBeingRemoved() -> Window""" + """ + GetWindowBeingRemoved() -> Window + + Returns a pointer to the window being removed when a + splitter window is unsplit. + """ return _windows.SplitterEvent_GetWindowBeingRemoved(*args, **kwargs) def GetX(*args, **kwargs): - """GetX() -> int""" + """ + GetX() -> int + + Returns the x coordinate of the double-click point in a + EVT_SPLITTER_DCLICK event. + """ return _windows.SplitterEvent_GetX(*args, **kwargs) def GetY(*args, **kwargs): - """GetY() -> int""" + """ + GetY() -> int + + Returns the y coordinate of the double-click point in a + EVT_SPLITTER_DCLICK event. + """ return _windows.SplitterEvent_GetY(*args, **kwargs) @@ -842,6 +1058,7 @@ EVT_SPLITTER_SASH_POS_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_SPLITTER_SASH_PO EVT_SPLITTER_SASH_POS_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING, 1 ) EVT_SPLITTER_DOUBLECLICKED = wx.PyEventBinder( wxEVT_COMMAND_SPLITTER_DOUBLECLICKED, 1 ) EVT_SPLITTER_UNSPLIT = wx.PyEventBinder( wxEVT_COMMAND_SPLITTER_UNSPLIT, 1 ) +EVT_SPLITTER_DCLICK = EVT_SPLITTER_DOUBLECLICKED #--------------------------------------------------------------------------- diff --git a/wxPython/src/msw/windows_wrap.cpp b/wxPython/src/msw/windows_wrap.cpp index df0c973b25..cf2e703870 100644 --- a/wxPython/src/msw/windows_wrap.cpp +++ b/wxPython/src/msw/windows_wrap.cpp @@ -5808,6 +5808,31 @@ static PyObject *_wrap_SplitterWindow_ReplaceWindow(PyObject *self, PyObject *ar } +static PyObject *_wrap_SplitterWindow_UpdateSize(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject *resultobj; + wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ; + PyObject * obj0 = 0 ; + char *kwnames[] = { + (char *) "self", NULL + }; + + if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_UpdateSize",kwnames,&obj0)) goto fail; + if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_wxSplitterWindow, + SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail; + { + PyThreadState* __tstate = wxPyBeginAllowThreads(); + (arg1)->UpdateSize(); + + wxPyEndAllowThreads(__tstate); + if (PyErr_Occurred()) SWIG_fail; + } + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + static PyObject *_wrap_SplitterWindow_IsSplit(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject *resultobj; wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ; @@ -23451,6 +23476,7 @@ static PyMethodDef SwigMethods[] = { { (char *)"SplitterWindow_SplitHorizontally", (PyCFunction) _wrap_SplitterWindow_SplitHorizontally, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_Unsplit", (PyCFunction) _wrap_SplitterWindow_Unsplit, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_ReplaceWindow", (PyCFunction) _wrap_SplitterWindow_ReplaceWindow, METH_VARARGS | METH_KEYWORDS }, + { (char *)"SplitterWindow_UpdateSize", (PyCFunction) _wrap_SplitterWindow_UpdateSize, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_IsSplit", (PyCFunction) _wrap_SplitterWindow_IsSplit, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_SetSashSize", (PyCFunction) _wrap_SplitterWindow_SetSashSize, METH_VARARGS | METH_KEYWORDS }, { (char *)"SplitterWindow_SetBorderSize", (PyCFunction) _wrap_SplitterWindow_SetBorderSize, METH_VARARGS | METH_KEYWORDS }, -- 2.45.2