reSWIGged

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@24626 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

wxPython/contrib/gizmos/gtk/gizmos.py

@@ -0,0 +1,835 @@
+# This file was created automatically by SWIG.
+# Don't modify this file, modify the SWIG interface instead.
+
+import _gizmos
+
+import windows
+import core
+import controls
+wx = core 
+wxEVT_DYNAMIC_SASH_SPLIT = _gizmos.wxEVT_DYNAMIC_SASH_SPLIT
+wxEVT_DYNAMIC_SASH_UNIFY = _gizmos.wxEVT_DYNAMIC_SASH_UNIFY
+DS_MANAGE_SCROLLBARS = _gizmos.DS_MANAGE_SCROLLBARS
+DS_DRAG_CORNER = _gizmos.DS_DRAG_CORNER
+class DynamicSashSplitEvent(core.CommandEvent):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDynamicSashSplitEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Object target) -> DynamicSashSplitEvent"""
+        newobj = _gizmos.new_DynamicSashSplitEvent(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+
+class DynamicSashSplitEventPtr(DynamicSashSplitEvent):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DynamicSashSplitEvent
+_gizmos.DynamicSashSplitEvent_swigregister(DynamicSashSplitEventPtr)
+
+class DynamicSashUnifyEvent(core.CommandEvent):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDynamicSashUnifyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Object target) -> DynamicSashUnifyEvent"""
+        newobj = _gizmos.new_DynamicSashUnifyEvent(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+
+class DynamicSashUnifyEventPtr(DynamicSashUnifyEvent):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DynamicSashUnifyEvent
+_gizmos.DynamicSashUnifyEvent_swigregister(DynamicSashUnifyEventPtr)
+
+class DynamicSashWindow(core.Window):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDynamicSashWindow 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=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER, 
+    wxString name=wxPyDynamicSashNameStr) -> DynamicSashWindow"""
+        newobj = _gizmos.new_DynamicSashWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def Create(*args, **kwargs):
+        """Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, 
+    long style=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER, 
+    wxString name=wxPyDynamicSashNameStr) -> bool"""
+        return _gizmos.DynamicSashWindow_Create(*args, **kwargs)
+
+    def GetHScrollBar(*args, **kwargs):
+        """GetHScrollBar(Window child) -> ScrollBar"""
+        return _gizmos.DynamicSashWindow_GetHScrollBar(*args, **kwargs)
+
+    def GetVScrollBar(*args, **kwargs):
+        """GetVScrollBar(Window child) -> ScrollBar"""
+        return _gizmos.DynamicSashWindow_GetVScrollBar(*args, **kwargs)
+
+
+class DynamicSashWindowPtr(DynamicSashWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DynamicSashWindow
+_gizmos.DynamicSashWindow_swigregister(DynamicSashWindowPtr)
+
+def PreDynamicSashWindow(*args, **kwargs):
+    """PreDynamicSashWindow() -> DynamicSashWindow"""
+    val = _gizmos.new_PreDynamicSashWindow(*args, **kwargs)
+    val.thisown = 1
+    return val
+
+EVT_DYNAMIC_SASH_SPLIT = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_SPLIT, 1 )
+EVT_DYNAMIC_SASH_UNIFY = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_UNIFY, 1 )
+
+EL_ALLOW_NEW = _gizmos.EL_ALLOW_NEW
+EL_ALLOW_EDIT = _gizmos.EL_ALLOW_EDIT
+EL_ALLOW_DELETE = _gizmos.EL_ALLOW_DELETE
+class EditableListBox(windows.Panel):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxEditableListBox instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id, wxString label, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxEL_ALLOW_NEW|wxEL_ALLOW_EDIT|wxEL_ALLOW_DELETE, 
+    wxString name=wxPyEditableListBoxNameStr) -> EditableListBox"""
+        newobj = _gizmos.new_EditableListBox(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def SetStrings(*args, **kwargs):
+        """SetStrings(wxArrayString strings)"""
+        return _gizmos.EditableListBox_SetStrings(*args, **kwargs)
+
+    def GetStrings(*args, **kwargs):
+        """GetStrings() -> PyObject"""
+        return _gizmos.EditableListBox_GetStrings(*args, **kwargs)
+
+    def GetListCtrl(*args, **kwargs):
+        """GetListCtrl() -> wxListCtrl"""
+        return _gizmos.EditableListBox_GetListCtrl(*args, **kwargs)
+
+    def GetDelButton(*args, **kwargs):
+        """GetDelButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetDelButton(*args, **kwargs)
+
+    def GetNewButton(*args, **kwargs):
+        """GetNewButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetNewButton(*args, **kwargs)
+
+    def GetUpButton(*args, **kwargs):
+        """GetUpButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetUpButton(*args, **kwargs)
+
+    def GetDownButton(*args, **kwargs):
+        """GetDownButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetDownButton(*args, **kwargs)
+
+    def GetEditButton(*args, **kwargs):
+        """GetEditButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetEditButton(*args, **kwargs)
+
+
+class EditableListBoxPtr(EditableListBox):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = EditableListBox
+_gizmos.EditableListBox_swigregister(EditableListBoxPtr)
+
+class RemotelyScrolledTreeCtrl(controls.TreeCtrl):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxRemotelyScrolledTreeCtrl 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=TR_HAS_BUTTONS) -> RemotelyScrolledTreeCtrl"""
+        newobj = _gizmos.new_RemotelyScrolledTreeCtrl(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def HideVScrollbar(*args, **kwargs):
+        """HideVScrollbar()"""
+        return _gizmos.RemotelyScrolledTreeCtrl_HideVScrollbar(*args, **kwargs)
+
+    def AdjustRemoteScrollbars(*args, **kwargs):
+        """AdjustRemoteScrollbars()"""
+        return _gizmos.RemotelyScrolledTreeCtrl_AdjustRemoteScrollbars(*args, **kwargs)
+
+    def GetScrolledWindow(*args, **kwargs):
+        """GetScrolledWindow() -> ScrolledWindow"""
+        return _gizmos.RemotelyScrolledTreeCtrl_GetScrolledWindow(*args, **kwargs)
+
+    def ScrollToLine(*args, **kwargs):
+        """ScrollToLine(int posHoriz, int posVert)"""
+        return _gizmos.RemotelyScrolledTreeCtrl_ScrollToLine(*args, **kwargs)
+
+    def SetCompanionWindow(*args, **kwargs):
+        """SetCompanionWindow(Window companion)"""
+        return _gizmos.RemotelyScrolledTreeCtrl_SetCompanionWindow(*args, **kwargs)
+
+    def GetCompanionWindow(*args, **kwargs):
+        """GetCompanionWindow() -> Window"""
+        return _gizmos.RemotelyScrolledTreeCtrl_GetCompanionWindow(*args, **kwargs)
+
+
+class RemotelyScrolledTreeCtrlPtr(RemotelyScrolledTreeCtrl):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = RemotelyScrolledTreeCtrl
+_gizmos.RemotelyScrolledTreeCtrl_swigregister(RemotelyScrolledTreeCtrlPtr)
+
+class TreeCompanionWindow(core.Window):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxPyTreeCompanionWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=0) -> TreeCompanionWindow"""
+        newobj = _gizmos.new_TreeCompanionWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self);self._setCallbackInfo(self, TreeCompanionWindow)
+
+    def _setCallbackInfo(*args, **kwargs):
+        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        return _gizmos.TreeCompanionWindow__setCallbackInfo(*args, **kwargs)
+
+    def GetTreeCtrl(*args, **kwargs):
+        """GetTreeCtrl() -> RemotelyScrolledTreeCtrl"""
+        return _gizmos.TreeCompanionWindow_GetTreeCtrl(*args, **kwargs)
+
+    def SetTreeCtrl(*args, **kwargs):
+        """SetTreeCtrl(RemotelyScrolledTreeCtrl treeCtrl)"""
+        return _gizmos.TreeCompanionWindow_SetTreeCtrl(*args, **kwargs)
+
+
+class TreeCompanionWindowPtr(TreeCompanionWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = TreeCompanionWindow
+_gizmos.TreeCompanionWindow_swigregister(TreeCompanionWindowPtr)
+
+class ThinSplitterWindow(windows.SplitterWindow):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxThinSplitterWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxSP_3D|wxCLIP_CHILDREN) -> ThinSplitterWindow"""
+        newobj = _gizmos.new_ThinSplitterWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+
+class ThinSplitterWindowPtr(ThinSplitterWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = ThinSplitterWindow
+_gizmos.ThinSplitterWindow_swigregister(ThinSplitterWindowPtr)
+
+class SplitterScrolledWindow(windows.ScrolledWindow):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxSplitterScrolledWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=0) -> SplitterScrolledWindow"""
+        newobj = _gizmos.new_SplitterScrolledWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+
+class SplitterScrolledWindowPtr(SplitterScrolledWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = SplitterScrolledWindow
+_gizmos.SplitterScrolledWindow_swigregister(SplitterScrolledWindowPtr)
+
+LED_ALIGN_LEFT = _gizmos.LED_ALIGN_LEFT
+LED_ALIGN_RIGHT = _gizmos.LED_ALIGN_RIGHT
+LED_ALIGN_CENTER = _gizmos.LED_ALIGN_CENTER
+LED_ALIGN_MASK = _gizmos.LED_ALIGN_MASK
+LED_DRAW_FADED = _gizmos.LED_DRAW_FADED
+class LEDNumberCtrl(core.Control):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxLEDNumberCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxLED_ALIGN_LEFT|wxLED_DRAW_FADED) -> LEDNumberCtrl"""
+        newobj = _gizmos.new_LEDNumberCtrl(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def Create(*args, **kwargs):
+        """Create(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxLED_ALIGN_LEFT|wxLED_DRAW_FADED) -> bool"""
+        return _gizmos.LEDNumberCtrl_Create(*args, **kwargs)
+
+    def GetAlignment(*args, **kwargs):
+        """GetAlignment() -> wxLEDValueAlign"""
+        return _gizmos.LEDNumberCtrl_GetAlignment(*args, **kwargs)
+
+    def GetDrawFaded(*args, **kwargs):
+        """GetDrawFaded() -> bool"""
+        return _gizmos.LEDNumberCtrl_GetDrawFaded(*args, **kwargs)
+
+    def GetValue(*args, **kwargs):
+        """GetValue() -> wxString"""
+        return _gizmos.LEDNumberCtrl_GetValue(*args, **kwargs)
+
+    def SetAlignment(*args, **kwargs):
+        """SetAlignment(wxLEDValueAlign Alignment, bool Redraw=true)"""
+        return _gizmos.LEDNumberCtrl_SetAlignment(*args, **kwargs)
+
+    def SetDrawFaded(*args, **kwargs):
+        """SetDrawFaded(bool DrawFaded, bool Redraw=true)"""
+        return _gizmos.LEDNumberCtrl_SetDrawFaded(*args, **kwargs)
+
+    def SetValue(*args, **kwargs):
+        """SetValue(wxString Value, bool Redraw=true)"""
+        return _gizmos.LEDNumberCtrl_SetValue(*args, **kwargs)
+
+
+class LEDNumberCtrlPtr(LEDNumberCtrl):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = LEDNumberCtrl
+_gizmos.LEDNumberCtrl_swigregister(LEDNumberCtrlPtr)
+
+def PreLEDNumberCtrl(*args, **kwargs):
+    """PreLEDNumberCtrl() -> LEDNumberCtrl"""
+    val = _gizmos.new_PreLEDNumberCtrl(*args, **kwargs)
+    val.thisown = 1
+    return val
+
+TL_ALIGN_LEFT = _gizmos.TL_ALIGN_LEFT
+TL_ALIGN_RIGHT = _gizmos.TL_ALIGN_RIGHT
+TL_ALIGN_CENTER = _gizmos.TL_ALIGN_CENTER
+TREE_HITTEST_ONITEMCOLUMN = _gizmos.TREE_HITTEST_ONITEMCOLUMN
+class TreeListColumnInfo(core.Object):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxTreeListColumnInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(wxString text=wxPyEmptyString, int image=-1, size_t width=100, 
+    wxTreeListColumnAlign alignment=TL_ALIGN_LEFT) -> TreeListColumnInfo"""
+        newobj = _gizmos.new_TreeListColumnInfo(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+    def GetAlignment(*args, **kwargs):
+        """GetAlignment() -> wxTreeListColumnAlign"""
+        return _gizmos.TreeListColumnInfo_GetAlignment(*args, **kwargs)
+
+    def GetText(*args, **kwargs):
+        """GetText() -> wxString"""
+        return _gizmos.TreeListColumnInfo_GetText(*args, **kwargs)
+
+    def GetImage(*args, **kwargs):
+        """GetImage() -> int"""
+        return _gizmos.TreeListColumnInfo_GetImage(*args, **kwargs)
+
+    def GetSelectedImage(*args, **kwargs):
+        """GetSelectedImage() -> int"""
+        return _gizmos.TreeListColumnInfo_GetSelectedImage(*args, **kwargs)
+
+    def GetWidth(*args, **kwargs):
+        """GetWidth() -> size_t"""
+        return _gizmos.TreeListColumnInfo_GetWidth(*args, **kwargs)
+
+    def SetAlignment(*args, **kwargs):
+        """SetAlignment(wxTreeListColumnAlign alignment)"""
+        return _gizmos.TreeListColumnInfo_SetAlignment(*args, **kwargs)
+
+    def SetText(*args, **kwargs):
+        """SetText(wxString text)"""
+        return _gizmos.TreeListColumnInfo_SetText(*args, **kwargs)
+
+    def SetImage(*args, **kwargs):
+        """SetImage(int image)"""
+        return _gizmos.TreeListColumnInfo_SetImage(*args, **kwargs)
+
+    def SetSelectedImage(*args, **kwargs):
+        """SetSelectedImage(int image)"""
+        return _gizmos.TreeListColumnInfo_SetSelectedImage(*args, **kwargs)
+
+    def SetWidth(*args, **kwargs):
+        """SetWidth(size_t with)"""
+        return _gizmos.TreeListColumnInfo_SetWidth(*args, **kwargs)
+
+
+class TreeListColumnInfoPtr(TreeListColumnInfo):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = TreeListColumnInfo
+_gizmos.TreeListColumnInfo_swigregister(TreeListColumnInfoPtr)
+
+class TreeListCtrl(core.Control):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxPyTreeListCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=TR_DEFAULT_STYLE, 
+    Validator validator=DefaultValidator, 
+    wxString name=wxPyTreeListCtrlNameStr) -> TreeListCtrl"""
+        newobj = _gizmos.new_TreeListCtrl(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self);self._setCallbackInfo(self, TreeListCtrl)
+
+    def Create(*args, **kwargs):
+        """Create(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=TR_DEFAULT_STYLE, 
+    Validator validator=DefaultValidator, 
+    wxString name=wxPyTreeListCtrlNameStr) -> bool"""
+        return _gizmos.TreeListCtrl_Create(*args, **kwargs)
+
+    def _setCallbackInfo(*args, **kwargs):
+        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        return _gizmos.TreeListCtrl__setCallbackInfo(*args, **kwargs)
+
+    def GetCount(*args, **kwargs):
+        """GetCount() -> size_t"""
+        return _gizmos.TreeListCtrl_GetCount(*args, **kwargs)
+
+    def GetIndent(*args, **kwargs):
+        """GetIndent() -> unsigned int"""
+        return _gizmos.TreeListCtrl_GetIndent(*args, **kwargs)
+
+    def SetIndent(*args, **kwargs):
+        """SetIndent(unsigned int indent)"""
+        return _gizmos.TreeListCtrl_SetIndent(*args, **kwargs)
+
+    def GetSpacing(*args, **kwargs):
+        """GetSpacing() -> unsigned int"""
+        return _gizmos.TreeListCtrl_GetSpacing(*args, **kwargs)
+
+    def SetSpacing(*args, **kwargs):
+        """SetSpacing(unsigned int spacing)"""
+        return _gizmos.TreeListCtrl_SetSpacing(*args, **kwargs)
+
+    def GetLineSpacing(*args, **kwargs):
+        """GetLineSpacing() -> unsigned int"""
+        return _gizmos.TreeListCtrl_GetLineSpacing(*args, **kwargs)
+
+    def SetLineSpacing(*args, **kwargs):
+        """SetLineSpacing(unsigned int spacing)"""
+        return _gizmos.TreeListCtrl_SetLineSpacing(*args, **kwargs)
+
+    def GetImageList(*args, **kwargs):
+        """GetImageList() -> wxImageList"""
+        return _gizmos.TreeListCtrl_GetImageList(*args, **kwargs)
+
+    def GetStateImageList(*args, **kwargs):
+        """GetStateImageList() -> wxImageList"""
+        return _gizmos.TreeListCtrl_GetStateImageList(*args, **kwargs)
+
+    def GetButtonsImageList(*args, **kwargs):
+        """GetButtonsImageList() -> wxImageList"""
+        return _gizmos.TreeListCtrl_GetButtonsImageList(*args, **kwargs)
+
+    def SetImageList(*args, **kwargs):
+        """SetImageList(wxImageList imageList)"""
+        return _gizmos.TreeListCtrl_SetImageList(*args, **kwargs)
+
+    def SetStateImageList(*args, **kwargs):
+        """SetStateImageList(wxImageList imageList)"""
+        return _gizmos.TreeListCtrl_SetStateImageList(*args, **kwargs)
+
+    def SetButtonsImageList(*args, **kwargs):
+        """SetButtonsImageList(wxImageList imageList)"""
+        return _gizmos.TreeListCtrl_SetButtonsImageList(*args, **kwargs)
+
+    def AssignImageList(*args, **kwargs):
+        """AssignImageList(wxImageList imageList)"""
+        val = _gizmos.TreeListCtrl_AssignImageList(*args, **kwargs)
+        args[1].thisown = 0
+        return val
+
+    def AssignStateImageList(*args, **kwargs):
+        """AssignStateImageList(wxImageList imageList)"""
+        val = _gizmos.TreeListCtrl_AssignStateImageList(*args, **kwargs)
+        args[1].thisown = 0
+        return val
+
+    def AssignButtonsImageList(*args, **kwargs):
+        """AssignButtonsImageList(wxImageList imageList)"""
+        val = _gizmos.TreeListCtrl_AssignButtonsImageList(*args, **kwargs)
+        args[1].thisown = 0
+        return val
+
+    def AddColumn(*args, **kwargs):
+        """AddColumn(wxString text)"""
+        return _gizmos.TreeListCtrl_AddColumn(*args, **kwargs)
+
+    def AddColumnInfo(*args, **kwargs):
+        """AddColumnInfo(TreeListColumnInfo col)"""
+        return _gizmos.TreeListCtrl_AddColumnInfo(*args, **kwargs)
+
+    def InsertColumn(*args, **kwargs):
+        """InsertColumn(size_t before, wxString text)"""
+        return _gizmos.TreeListCtrl_InsertColumn(*args, **kwargs)
+
+    def InsertColumnInfo(*args, **kwargs):
+        """InsertColumnInfo(size_t before, TreeListColumnInfo col)"""
+        return _gizmos.TreeListCtrl_InsertColumnInfo(*args, **kwargs)
+
+    def RemoveColumn(*args, **kwargs):
+        """RemoveColumn(size_t column)"""
+        return _gizmos.TreeListCtrl_RemoveColumn(*args, **kwargs)
+
+    def GetColumnCount(*args, **kwargs):
+        """GetColumnCount() -> size_t"""
+        return _gizmos.TreeListCtrl_GetColumnCount(*args, **kwargs)
+
+    def SetColumnWidth(*args, **kwargs):
+        """SetColumnWidth(size_t column, size_t width)"""
+        return _gizmos.TreeListCtrl_SetColumnWidth(*args, **kwargs)
+
+    def GetColumnWidth(*args, **kwargs):
+        """GetColumnWidth(size_t column) -> int"""
+        return _gizmos.TreeListCtrl_GetColumnWidth(*args, **kwargs)
+
+    def SetMainColumn(*args, **kwargs):
+        """SetMainColumn(size_t column)"""
+        return _gizmos.TreeListCtrl_SetMainColumn(*args, **kwargs)
+
+    def GetMainColumn(*args, **kwargs):
+        """GetMainColumn() -> size_t"""
+        return _gizmos.TreeListCtrl_GetMainColumn(*args, **kwargs)
+
+    def SetColumnText(*args, **kwargs):
+        """SetColumnText(size_t column, wxString text)"""
+        return _gizmos.TreeListCtrl_SetColumnText(*args, **kwargs)
+
+    def GetColumnText(*args, **kwargs):
+        """GetColumnText(size_t column) -> wxString"""
+        return _gizmos.TreeListCtrl_GetColumnText(*args, **kwargs)
+
+    def SetColumn(*args, **kwargs):
+        """SetColumn(size_t column, TreeListColumnInfo info)"""
+        return _gizmos.TreeListCtrl_SetColumn(*args, **kwargs)
+
+    def GetColumn(*args, **kwargs):
+        """GetColumn(size_t column) -> TreeListColumnInfo"""
+        return _gizmos.TreeListCtrl_GetColumn(*args, **kwargs)
+
+    def SetColumnAlignment(*args, **kwargs):
+        """SetColumnAlignment(size_t column, wxTreeListColumnAlign align)"""
+        return _gizmos.TreeListCtrl_SetColumnAlignment(*args, **kwargs)
+
+    def GetColumnAlignment(*args, **kwargs):
+        """GetColumnAlignment(size_t column) -> wxTreeListColumnAlign"""
+        return _gizmos.TreeListCtrl_GetColumnAlignment(*args, **kwargs)
+
+    def SetColumnImage(*args, **kwargs):
+        """SetColumnImage(size_t column, int image)"""
+        return _gizmos.TreeListCtrl_SetColumnImage(*args, **kwargs)
+
+    def GetColumnImage(*args, **kwargs):
+        """GetColumnImage(size_t column) -> int"""
+        return _gizmos.TreeListCtrl_GetColumnImage(*args, **kwargs)
+
+    def GetItemText(*args, **kwargs):
+        """GetItemText(TreeItemId item, int column=-1) -> wxString"""
+        return _gizmos.TreeListCtrl_GetItemText(*args, **kwargs)
+
+    def GetItemImage(*args, **kwargs):
+        """GetItemImage(TreeItemId item, int column=-1, wxTreeItemIcon which=TreeItemIcon_Normal) -> int"""
+        return _gizmos.TreeListCtrl_GetItemImage(*args, **kwargs)
+
+    def SetItemText(*args, **kwargs):
+        """SetItemText(TreeItemId item, wxString text, int column=-1)"""
+        return _gizmos.TreeListCtrl_SetItemText(*args, **kwargs)
+
+    def SetItemImage(*args, **kwargs):
+        """SetItemImage(TreeItemId item, int image, int column=-1, wxTreeItemIcon which=TreeItemIcon_Normal)"""
+        return _gizmos.TreeListCtrl_SetItemImage(*args, **kwargs)
+
+    def GetItemData(*args, **kwargs):
+        """GetItemData(TreeItemId item) -> TreeItemData"""
+        return _gizmos.TreeListCtrl_GetItemData(*args, **kwargs)
+
+    def SetItemData(*args, **kwargs):
+        """SetItemData(TreeItemId item, TreeItemData data)"""
+        return _gizmos.TreeListCtrl_SetItemData(*args, **kwargs)
+
+    def GetItemPyData(*args, **kwargs):
+        """GetItemPyData(TreeItemId item) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetItemPyData(*args, **kwargs)
+
+    def SetItemPyData(*args, **kwargs):
+        """SetItemPyData(TreeItemId item, PyObject obj)"""
+        return _gizmos.TreeListCtrl_SetItemPyData(*args, **kwargs)
+
+    def SetItemHasChildren(*args, **kwargs):
+        """SetItemHasChildren(TreeItemId item, bool has=True)"""
+        return _gizmos.TreeListCtrl_SetItemHasChildren(*args, **kwargs)
+
+    def SetItemBold(*args, **kwargs):
+        """SetItemBold(TreeItemId item, bool bold=True)"""
+        return _gizmos.TreeListCtrl_SetItemBold(*args, **kwargs)
+
+    def SetItemTextColour(*args, **kwargs):
+        """SetItemTextColour(TreeItemId item, wxColour col)"""
+        return _gizmos.TreeListCtrl_SetItemTextColour(*args, **kwargs)
+
+    def SetItemBackgroundColour(*args, **kwargs):
+        """SetItemBackgroundColour(TreeItemId item, wxColour col)"""
+        return _gizmos.TreeListCtrl_SetItemBackgroundColour(*args, **kwargs)
+
+    def SetItemFont(*args, **kwargs):
+        """SetItemFont(TreeItemId item, wxFont font)"""
+        return _gizmos.TreeListCtrl_SetItemFont(*args, **kwargs)
+
+    def GetItemBold(*args, **kwargs):
+        """GetItemBold(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_GetItemBold(*args, **kwargs)
+
+    def GetItemTextColour(*args, **kwargs):
+        """GetItemTextColour(TreeItemId item) -> wxColour"""
+        return _gizmos.TreeListCtrl_GetItemTextColour(*args, **kwargs)
+
+    def GetItemBackgroundColour(*args, **kwargs):
+        """GetItemBackgroundColour(TreeItemId item) -> wxColour"""
+        return _gizmos.TreeListCtrl_GetItemBackgroundColour(*args, **kwargs)
+
+    def GetItemFont(*args, **kwargs):
+        """GetItemFont(TreeItemId item) -> wxFont"""
+        return _gizmos.TreeListCtrl_GetItemFont(*args, **kwargs)
+
+    def IsVisible(*args, **kwargs):
+        """IsVisible(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsVisible(*args, **kwargs)
+
+    def ItemHasChildren(*args, **kwargs):
+        """ItemHasChildren(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_ItemHasChildren(*args, **kwargs)
+
+    def IsExpanded(*args, **kwargs):
+        """IsExpanded(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsExpanded(*args, **kwargs)
+
+    def IsSelected(*args, **kwargs):
+        """IsSelected(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsSelected(*args, **kwargs)
+
+    def IsBold(*args, **kwargs):
+        """IsBold(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsBold(*args, **kwargs)
+
+    def GetChildrenCount(*args, **kwargs):
+        """GetChildrenCount(TreeItemId item, bool recursively=True) -> size_t"""
+        return _gizmos.TreeListCtrl_GetChildrenCount(*args, **kwargs)
+
+    def GetRootItem(*args, **kwargs):
+        """GetRootItem() -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetRootItem(*args, **kwargs)
+
+    def GetSelection(*args, **kwargs):
+        """GetSelection() -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetSelection(*args, **kwargs)
+
+    def GetSelections(*args, **kwargs):
+        """GetSelections() -> PyObject"""
+        return _gizmos.TreeListCtrl_GetSelections(*args, **kwargs)
+
+    def GetItemParent(*args, **kwargs):
+        """GetItemParent(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetItemParent(*args, **kwargs)
+
+    def GetFirstChild(*args, **kwargs):
+        """GetFirstChild(TreeItemId item) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetFirstChild(*args, **kwargs)
+
+    def GetNextChild(*args, **kwargs):
+        """GetNextChild(TreeItemId item, long cookie) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetNextChild(*args, **kwargs)
+
+    def GetLastChild(*args, **kwargs):
+        """GetLastChild(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetLastChild(*args, **kwargs)
+
+    def GetNextSibling(*args, **kwargs):
+        """GetNextSibling(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetNextSibling(*args, **kwargs)
+
+    def GetPrevSibling(*args, **kwargs):
+        """GetPrevSibling(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetPrevSibling(*args, **kwargs)
+
+    def GetFirstVisibleItem(*args, **kwargs):
+        """GetFirstVisibleItem() -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetFirstVisibleItem(*args, **kwargs)
+
+    def GetNextVisible(*args, **kwargs):
+        """GetNextVisible(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetNextVisible(*args, **kwargs)
+
+    def GetPrevVisible(*args, **kwargs):
+        """GetPrevVisible(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetPrevVisible(*args, **kwargs)
+
+    def GetNext(*args, **kwargs):
+        """GetNext(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetNext(*args, **kwargs)
+
+    def AddRoot(*args, **kwargs):
+        """AddRoot(wxString text, int image=-1, int selectedImage=-1, 
+    TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_AddRoot(*args, **kwargs)
+
+    def PrependItem(*args, **kwargs):
+        """PrependItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1, 
+    TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_PrependItem(*args, **kwargs)
+
+    def InsertItem(*args, **kwargs):
+        """InsertItem(TreeItemId parent, TreeItemId idPrevious, wxString text, 
+    int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_InsertItem(*args, **kwargs)
+
+    def InsertItemBefore(*args, **kwargs):
+        """InsertItemBefore(TreeItemId parent, size_t index, wxString text, int image=-1, 
+    int selectedImage=-1, TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_InsertItemBefore(*args, **kwargs)
+
+    def AppendItem(*args, **kwargs):
+        """AppendItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1, 
+    TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_AppendItem(*args, **kwargs)
+
+    def Delete(*args, **kwargs):
+        """Delete(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Delete(*args, **kwargs)
+
+    def DeleteChildren(*args, **kwargs):
+        """DeleteChildren(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_DeleteChildren(*args, **kwargs)
+
+    def DeleteAllItems(*args, **kwargs):
+        """DeleteAllItems()"""
+        return _gizmos.TreeListCtrl_DeleteAllItems(*args, **kwargs)
+
+    def Expand(*args, **kwargs):
+        """Expand(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Expand(*args, **kwargs)
+
+    def ExpandAll(*args, **kwargs):
+        """ExpandAll(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_ExpandAll(*args, **kwargs)
+
+    def Collapse(*args, **kwargs):
+        """Collapse(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Collapse(*args, **kwargs)
+
+    def CollapseAndReset(*args, **kwargs):
+        """CollapseAndReset(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_CollapseAndReset(*args, **kwargs)
+
+    def Toggle(*args, **kwargs):
+        """Toggle(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Toggle(*args, **kwargs)
+
+    def Unselect(*args, **kwargs):
+        """Unselect()"""
+        return _gizmos.TreeListCtrl_Unselect(*args, **kwargs)
+
+    def UnselectAll(*args, **kwargs):
+        """UnselectAll()"""
+        return _gizmos.TreeListCtrl_UnselectAll(*args, **kwargs)
+
+    def SelectItem(*args, **kwargs):
+        """SelectItem(TreeItemId item, bool unselect_others=True, bool extended_select=False)"""
+        return _gizmos.TreeListCtrl_SelectItem(*args, **kwargs)
+
+    def EnsureVisible(*args, **kwargs):
+        """EnsureVisible(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_EnsureVisible(*args, **kwargs)
+
+    def ScrollTo(*args, **kwargs):
+        """ScrollTo(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_ScrollTo(*args, **kwargs)
+
+    def HitTest(*args, **kwargs):
+        """HitTest(Point point, int OUTPUT, int OUTPUT) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_HitTest(*args, **kwargs)
+
+    def GetBoundingRect(*args, **kwargs):
+        """GetBoundingRect(TreeItemId item, bool textOnly=False) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetBoundingRect(*args, **kwargs)
+
+    def EditLabel(*args, **kwargs):
+        """EditLabel(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_EditLabel(*args, **kwargs)
+
+    def Edit(*args, **kwargs):
+        """Edit(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Edit(*args, **kwargs)
+
+    def SortChildren(*args, **kwargs):
+        """SortChildren(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_SortChildren(*args, **kwargs)
+
+    def GetItemSelectedImage(*args, **kwargs):
+        """GetItemSelectedImage(TreeItemId item) -> int"""
+        return _gizmos.TreeListCtrl_GetItemSelectedImage(*args, **kwargs)
+
+    def SetItemSelectedImage(*args, **kwargs):
+        """SetItemSelectedImage(TreeItemId item, int image)"""
+        return _gizmos.TreeListCtrl_SetItemSelectedImage(*args, **kwargs)
+
+    def GetHeaderWindow(*args, **kwargs):
+        """GetHeaderWindow() -> Window"""
+        return _gizmos.TreeListCtrl_GetHeaderWindow(*args, **kwargs)
+
+    def GetMainWindow(*args, **kwargs):
+        """GetMainWindow() -> Window"""
+        return _gizmos.TreeListCtrl_GetMainWindow(*args, **kwargs)
+
+
+class TreeListCtrlPtr(TreeListCtrl):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = TreeListCtrl
+_gizmos.TreeListCtrl_swigregister(TreeListCtrlPtr)
+
+def PreTreeListCtrl(*args, **kwargs):
+    """PreTreeListCtrl() -> TreeListCtrl"""
+    val = _gizmos.new_PreTreeListCtrl(*args, **kwargs)
+    val.thisown = 1
+    return val
+
+

wxPython/contrib/gizmos/mac/gizmos.py

@@ -0,0 +1,835 @@
+# This file was created automatically by SWIG.
+# Don't modify this file, modify the SWIG interface instead.
+
+import _gizmos
+
+import windows
+import core
+import controls
+wx = core 
+wxEVT_DYNAMIC_SASH_SPLIT = _gizmos.wxEVT_DYNAMIC_SASH_SPLIT
+wxEVT_DYNAMIC_SASH_UNIFY = _gizmos.wxEVT_DYNAMIC_SASH_UNIFY
+DS_MANAGE_SCROLLBARS = _gizmos.DS_MANAGE_SCROLLBARS
+DS_DRAG_CORNER = _gizmos.DS_DRAG_CORNER
+class DynamicSashSplitEvent(core.CommandEvent):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDynamicSashSplitEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Object target) -> DynamicSashSplitEvent"""
+        newobj = _gizmos.new_DynamicSashSplitEvent(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+
+class DynamicSashSplitEventPtr(DynamicSashSplitEvent):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DynamicSashSplitEvent
+_gizmos.DynamicSashSplitEvent_swigregister(DynamicSashSplitEventPtr)
+
+class DynamicSashUnifyEvent(core.CommandEvent):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDynamicSashUnifyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Object target) -> DynamicSashUnifyEvent"""
+        newobj = _gizmos.new_DynamicSashUnifyEvent(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+
+class DynamicSashUnifyEventPtr(DynamicSashUnifyEvent):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DynamicSashUnifyEvent
+_gizmos.DynamicSashUnifyEvent_swigregister(DynamicSashUnifyEventPtr)
+
+class DynamicSashWindow(core.Window):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDynamicSashWindow 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=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER, 
+    wxString name=wxPyDynamicSashNameStr) -> DynamicSashWindow"""
+        newobj = _gizmos.new_DynamicSashWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def Create(*args, **kwargs):
+        """Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, 
+    long style=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER, 
+    wxString name=wxPyDynamicSashNameStr) -> bool"""
+        return _gizmos.DynamicSashWindow_Create(*args, **kwargs)
+
+    def GetHScrollBar(*args, **kwargs):
+        """GetHScrollBar(Window child) -> ScrollBar"""
+        return _gizmos.DynamicSashWindow_GetHScrollBar(*args, **kwargs)
+
+    def GetVScrollBar(*args, **kwargs):
+        """GetVScrollBar(Window child) -> ScrollBar"""
+        return _gizmos.DynamicSashWindow_GetVScrollBar(*args, **kwargs)
+
+
+class DynamicSashWindowPtr(DynamicSashWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DynamicSashWindow
+_gizmos.DynamicSashWindow_swigregister(DynamicSashWindowPtr)
+
+def PreDynamicSashWindow(*args, **kwargs):
+    """PreDynamicSashWindow() -> DynamicSashWindow"""
+    val = _gizmos.new_PreDynamicSashWindow(*args, **kwargs)
+    val.thisown = 1
+    return val
+
+EVT_DYNAMIC_SASH_SPLIT = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_SPLIT, 1 )
+EVT_DYNAMIC_SASH_UNIFY = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_UNIFY, 1 )
+
+EL_ALLOW_NEW = _gizmos.EL_ALLOW_NEW
+EL_ALLOW_EDIT = _gizmos.EL_ALLOW_EDIT
+EL_ALLOW_DELETE = _gizmos.EL_ALLOW_DELETE
+class EditableListBox(windows.Panel):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxEditableListBox instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id, wxString label, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxEL_ALLOW_NEW|wxEL_ALLOW_EDIT|wxEL_ALLOW_DELETE, 
+    wxString name=wxPyEditableListBoxNameStr) -> EditableListBox"""
+        newobj = _gizmos.new_EditableListBox(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def SetStrings(*args, **kwargs):
+        """SetStrings(wxArrayString strings)"""
+        return _gizmos.EditableListBox_SetStrings(*args, **kwargs)
+
+    def GetStrings(*args, **kwargs):
+        """GetStrings() -> PyObject"""
+        return _gizmos.EditableListBox_GetStrings(*args, **kwargs)
+
+    def GetListCtrl(*args, **kwargs):
+        """GetListCtrl() -> wxListCtrl"""
+        return _gizmos.EditableListBox_GetListCtrl(*args, **kwargs)
+
+    def GetDelButton(*args, **kwargs):
+        """GetDelButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetDelButton(*args, **kwargs)
+
+    def GetNewButton(*args, **kwargs):
+        """GetNewButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetNewButton(*args, **kwargs)
+
+    def GetUpButton(*args, **kwargs):
+        """GetUpButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetUpButton(*args, **kwargs)
+
+    def GetDownButton(*args, **kwargs):
+        """GetDownButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetDownButton(*args, **kwargs)
+
+    def GetEditButton(*args, **kwargs):
+        """GetEditButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetEditButton(*args, **kwargs)
+
+
+class EditableListBoxPtr(EditableListBox):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = EditableListBox
+_gizmos.EditableListBox_swigregister(EditableListBoxPtr)
+
+class RemotelyScrolledTreeCtrl(controls.TreeCtrl):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxRemotelyScrolledTreeCtrl 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=TR_HAS_BUTTONS) -> RemotelyScrolledTreeCtrl"""
+        newobj = _gizmos.new_RemotelyScrolledTreeCtrl(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def HideVScrollbar(*args, **kwargs):
+        """HideVScrollbar()"""
+        return _gizmos.RemotelyScrolledTreeCtrl_HideVScrollbar(*args, **kwargs)
+
+    def AdjustRemoteScrollbars(*args, **kwargs):
+        """AdjustRemoteScrollbars()"""
+        return _gizmos.RemotelyScrolledTreeCtrl_AdjustRemoteScrollbars(*args, **kwargs)
+
+    def GetScrolledWindow(*args, **kwargs):
+        """GetScrolledWindow() -> ScrolledWindow"""
+        return _gizmos.RemotelyScrolledTreeCtrl_GetScrolledWindow(*args, **kwargs)
+
+    def ScrollToLine(*args, **kwargs):
+        """ScrollToLine(int posHoriz, int posVert)"""
+        return _gizmos.RemotelyScrolledTreeCtrl_ScrollToLine(*args, **kwargs)
+
+    def SetCompanionWindow(*args, **kwargs):
+        """SetCompanionWindow(Window companion)"""
+        return _gizmos.RemotelyScrolledTreeCtrl_SetCompanionWindow(*args, **kwargs)
+
+    def GetCompanionWindow(*args, **kwargs):
+        """GetCompanionWindow() -> Window"""
+        return _gizmos.RemotelyScrolledTreeCtrl_GetCompanionWindow(*args, **kwargs)
+
+
+class RemotelyScrolledTreeCtrlPtr(RemotelyScrolledTreeCtrl):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = RemotelyScrolledTreeCtrl
+_gizmos.RemotelyScrolledTreeCtrl_swigregister(RemotelyScrolledTreeCtrlPtr)
+
+class TreeCompanionWindow(core.Window):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxPyTreeCompanionWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=0) -> TreeCompanionWindow"""
+        newobj = _gizmos.new_TreeCompanionWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self);self._setCallbackInfo(self, TreeCompanionWindow)
+
+    def _setCallbackInfo(*args, **kwargs):
+        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        return _gizmos.TreeCompanionWindow__setCallbackInfo(*args, **kwargs)
+
+    def GetTreeCtrl(*args, **kwargs):
+        """GetTreeCtrl() -> RemotelyScrolledTreeCtrl"""
+        return _gizmos.TreeCompanionWindow_GetTreeCtrl(*args, **kwargs)
+
+    def SetTreeCtrl(*args, **kwargs):
+        """SetTreeCtrl(RemotelyScrolledTreeCtrl treeCtrl)"""
+        return _gizmos.TreeCompanionWindow_SetTreeCtrl(*args, **kwargs)
+
+
+class TreeCompanionWindowPtr(TreeCompanionWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = TreeCompanionWindow
+_gizmos.TreeCompanionWindow_swigregister(TreeCompanionWindowPtr)
+
+class ThinSplitterWindow(windows.SplitterWindow):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxThinSplitterWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxSP_3D|wxCLIP_CHILDREN) -> ThinSplitterWindow"""
+        newobj = _gizmos.new_ThinSplitterWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+
+class ThinSplitterWindowPtr(ThinSplitterWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = ThinSplitterWindow
+_gizmos.ThinSplitterWindow_swigregister(ThinSplitterWindowPtr)
+
+class SplitterScrolledWindow(windows.ScrolledWindow):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxSplitterScrolledWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=0) -> SplitterScrolledWindow"""
+        newobj = _gizmos.new_SplitterScrolledWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+
+class SplitterScrolledWindowPtr(SplitterScrolledWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = SplitterScrolledWindow
+_gizmos.SplitterScrolledWindow_swigregister(SplitterScrolledWindowPtr)
+
+LED_ALIGN_LEFT = _gizmos.LED_ALIGN_LEFT
+LED_ALIGN_RIGHT = _gizmos.LED_ALIGN_RIGHT
+LED_ALIGN_CENTER = _gizmos.LED_ALIGN_CENTER
+LED_ALIGN_MASK = _gizmos.LED_ALIGN_MASK
+LED_DRAW_FADED = _gizmos.LED_DRAW_FADED
+class LEDNumberCtrl(core.Control):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxLEDNumberCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxLED_ALIGN_LEFT|wxLED_DRAW_FADED) -> LEDNumberCtrl"""
+        newobj = _gizmos.new_LEDNumberCtrl(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def Create(*args, **kwargs):
+        """Create(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxLED_ALIGN_LEFT|wxLED_DRAW_FADED) -> bool"""
+        return _gizmos.LEDNumberCtrl_Create(*args, **kwargs)
+
+    def GetAlignment(*args, **kwargs):
+        """GetAlignment() -> wxLEDValueAlign"""
+        return _gizmos.LEDNumberCtrl_GetAlignment(*args, **kwargs)
+
+    def GetDrawFaded(*args, **kwargs):
+        """GetDrawFaded() -> bool"""
+        return _gizmos.LEDNumberCtrl_GetDrawFaded(*args, **kwargs)
+
+    def GetValue(*args, **kwargs):
+        """GetValue() -> wxString"""
+        return _gizmos.LEDNumberCtrl_GetValue(*args, **kwargs)
+
+    def SetAlignment(*args, **kwargs):
+        """SetAlignment(wxLEDValueAlign Alignment, bool Redraw=true)"""
+        return _gizmos.LEDNumberCtrl_SetAlignment(*args, **kwargs)
+
+    def SetDrawFaded(*args, **kwargs):
+        """SetDrawFaded(bool DrawFaded, bool Redraw=true)"""
+        return _gizmos.LEDNumberCtrl_SetDrawFaded(*args, **kwargs)
+
+    def SetValue(*args, **kwargs):
+        """SetValue(wxString Value, bool Redraw=true)"""
+        return _gizmos.LEDNumberCtrl_SetValue(*args, **kwargs)
+
+
+class LEDNumberCtrlPtr(LEDNumberCtrl):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = LEDNumberCtrl
+_gizmos.LEDNumberCtrl_swigregister(LEDNumberCtrlPtr)
+
+def PreLEDNumberCtrl(*args, **kwargs):
+    """PreLEDNumberCtrl() -> LEDNumberCtrl"""
+    val = _gizmos.new_PreLEDNumberCtrl(*args, **kwargs)
+    val.thisown = 1
+    return val
+
+TL_ALIGN_LEFT = _gizmos.TL_ALIGN_LEFT
+TL_ALIGN_RIGHT = _gizmos.TL_ALIGN_RIGHT
+TL_ALIGN_CENTER = _gizmos.TL_ALIGN_CENTER
+TREE_HITTEST_ONITEMCOLUMN = _gizmos.TREE_HITTEST_ONITEMCOLUMN
+class TreeListColumnInfo(core.Object):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxTreeListColumnInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(wxString text=wxPyEmptyString, int image=-1, size_t width=100, 
+    wxTreeListColumnAlign alignment=TL_ALIGN_LEFT) -> TreeListColumnInfo"""
+        newobj = _gizmos.new_TreeListColumnInfo(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+    def GetAlignment(*args, **kwargs):
+        """GetAlignment() -> wxTreeListColumnAlign"""
+        return _gizmos.TreeListColumnInfo_GetAlignment(*args, **kwargs)
+
+    def GetText(*args, **kwargs):
+        """GetText() -> wxString"""
+        return _gizmos.TreeListColumnInfo_GetText(*args, **kwargs)
+
+    def GetImage(*args, **kwargs):
+        """GetImage() -> int"""
+        return _gizmos.TreeListColumnInfo_GetImage(*args, **kwargs)
+
+    def GetSelectedImage(*args, **kwargs):
+        """GetSelectedImage() -> int"""
+        return _gizmos.TreeListColumnInfo_GetSelectedImage(*args, **kwargs)
+
+    def GetWidth(*args, **kwargs):
+        """GetWidth() -> size_t"""
+        return _gizmos.TreeListColumnInfo_GetWidth(*args, **kwargs)
+
+    def SetAlignment(*args, **kwargs):
+        """SetAlignment(wxTreeListColumnAlign alignment)"""
+        return _gizmos.TreeListColumnInfo_SetAlignment(*args, **kwargs)
+
+    def SetText(*args, **kwargs):
+        """SetText(wxString text)"""
+        return _gizmos.TreeListColumnInfo_SetText(*args, **kwargs)
+
+    def SetImage(*args, **kwargs):
+        """SetImage(int image)"""
+        return _gizmos.TreeListColumnInfo_SetImage(*args, **kwargs)
+
+    def SetSelectedImage(*args, **kwargs):
+        """SetSelectedImage(int image)"""
+        return _gizmos.TreeListColumnInfo_SetSelectedImage(*args, **kwargs)
+
+    def SetWidth(*args, **kwargs):
+        """SetWidth(size_t with)"""
+        return _gizmos.TreeListColumnInfo_SetWidth(*args, **kwargs)
+
+
+class TreeListColumnInfoPtr(TreeListColumnInfo):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = TreeListColumnInfo
+_gizmos.TreeListColumnInfo_swigregister(TreeListColumnInfoPtr)
+
+class TreeListCtrl(core.Control):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxPyTreeListCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=TR_DEFAULT_STYLE, 
+    Validator validator=DefaultValidator, 
+    wxString name=wxPyTreeListCtrlNameStr) -> TreeListCtrl"""
+        newobj = _gizmos.new_TreeListCtrl(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self);self._setCallbackInfo(self, TreeListCtrl)
+
+    def Create(*args, **kwargs):
+        """Create(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=TR_DEFAULT_STYLE, 
+    Validator validator=DefaultValidator, 
+    wxString name=wxPyTreeListCtrlNameStr) -> bool"""
+        return _gizmos.TreeListCtrl_Create(*args, **kwargs)
+
+    def _setCallbackInfo(*args, **kwargs):
+        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        return _gizmos.TreeListCtrl__setCallbackInfo(*args, **kwargs)
+
+    def GetCount(*args, **kwargs):
+        """GetCount() -> size_t"""
+        return _gizmos.TreeListCtrl_GetCount(*args, **kwargs)
+
+    def GetIndent(*args, **kwargs):
+        """GetIndent() -> unsigned int"""
+        return _gizmos.TreeListCtrl_GetIndent(*args, **kwargs)
+
+    def SetIndent(*args, **kwargs):
+        """SetIndent(unsigned int indent)"""
+        return _gizmos.TreeListCtrl_SetIndent(*args, **kwargs)
+
+    def GetSpacing(*args, **kwargs):
+        """GetSpacing() -> unsigned int"""
+        return _gizmos.TreeListCtrl_GetSpacing(*args, **kwargs)
+
+    def SetSpacing(*args, **kwargs):
+        """SetSpacing(unsigned int spacing)"""
+        return _gizmos.TreeListCtrl_SetSpacing(*args, **kwargs)
+
+    def GetLineSpacing(*args, **kwargs):
+        """GetLineSpacing() -> unsigned int"""
+        return _gizmos.TreeListCtrl_GetLineSpacing(*args, **kwargs)
+
+    def SetLineSpacing(*args, **kwargs):
+        """SetLineSpacing(unsigned int spacing)"""
+        return _gizmos.TreeListCtrl_SetLineSpacing(*args, **kwargs)
+
+    def GetImageList(*args, **kwargs):
+        """GetImageList() -> wxImageList"""
+        return _gizmos.TreeListCtrl_GetImageList(*args, **kwargs)
+
+    def GetStateImageList(*args, **kwargs):
+        """GetStateImageList() -> wxImageList"""
+        return _gizmos.TreeListCtrl_GetStateImageList(*args, **kwargs)
+
+    def GetButtonsImageList(*args, **kwargs):
+        """GetButtonsImageList() -> wxImageList"""
+        return _gizmos.TreeListCtrl_GetButtonsImageList(*args, **kwargs)
+
+    def SetImageList(*args, **kwargs):
+        """SetImageList(wxImageList imageList)"""
+        return _gizmos.TreeListCtrl_SetImageList(*args, **kwargs)
+
+    def SetStateImageList(*args, **kwargs):
+        """SetStateImageList(wxImageList imageList)"""
+        return _gizmos.TreeListCtrl_SetStateImageList(*args, **kwargs)
+
+    def SetButtonsImageList(*args, **kwargs):
+        """SetButtonsImageList(wxImageList imageList)"""
+        return _gizmos.TreeListCtrl_SetButtonsImageList(*args, **kwargs)
+
+    def AssignImageList(*args, **kwargs):
+        """AssignImageList(wxImageList imageList)"""
+        val = _gizmos.TreeListCtrl_AssignImageList(*args, **kwargs)
+        args[1].thisown = 0
+        return val
+
+    def AssignStateImageList(*args, **kwargs):
+        """AssignStateImageList(wxImageList imageList)"""
+        val = _gizmos.TreeListCtrl_AssignStateImageList(*args, **kwargs)
+        args[1].thisown = 0
+        return val
+
+    def AssignButtonsImageList(*args, **kwargs):
+        """AssignButtonsImageList(wxImageList imageList)"""
+        val = _gizmos.TreeListCtrl_AssignButtonsImageList(*args, **kwargs)
+        args[1].thisown = 0
+        return val
+
+    def AddColumn(*args, **kwargs):
+        """AddColumn(wxString text)"""
+        return _gizmos.TreeListCtrl_AddColumn(*args, **kwargs)
+
+    def AddColumnInfo(*args, **kwargs):
+        """AddColumnInfo(TreeListColumnInfo col)"""
+        return _gizmos.TreeListCtrl_AddColumnInfo(*args, **kwargs)
+
+    def InsertColumn(*args, **kwargs):
+        """InsertColumn(size_t before, wxString text)"""
+        return _gizmos.TreeListCtrl_InsertColumn(*args, **kwargs)
+
+    def InsertColumnInfo(*args, **kwargs):
+        """InsertColumnInfo(size_t before, TreeListColumnInfo col)"""
+        return _gizmos.TreeListCtrl_InsertColumnInfo(*args, **kwargs)
+
+    def RemoveColumn(*args, **kwargs):
+        """RemoveColumn(size_t column)"""
+        return _gizmos.TreeListCtrl_RemoveColumn(*args, **kwargs)
+
+    def GetColumnCount(*args, **kwargs):
+        """GetColumnCount() -> size_t"""
+        return _gizmos.TreeListCtrl_GetColumnCount(*args, **kwargs)
+
+    def SetColumnWidth(*args, **kwargs):
+        """SetColumnWidth(size_t column, size_t width)"""
+        return _gizmos.TreeListCtrl_SetColumnWidth(*args, **kwargs)
+
+    def GetColumnWidth(*args, **kwargs):
+        """GetColumnWidth(size_t column) -> int"""
+        return _gizmos.TreeListCtrl_GetColumnWidth(*args, **kwargs)
+
+    def SetMainColumn(*args, **kwargs):
+        """SetMainColumn(size_t column)"""
+        return _gizmos.TreeListCtrl_SetMainColumn(*args, **kwargs)
+
+    def GetMainColumn(*args, **kwargs):
+        """GetMainColumn() -> size_t"""
+        return _gizmos.TreeListCtrl_GetMainColumn(*args, **kwargs)
+
+    def SetColumnText(*args, **kwargs):
+        """SetColumnText(size_t column, wxString text)"""
+        return _gizmos.TreeListCtrl_SetColumnText(*args, **kwargs)
+
+    def GetColumnText(*args, **kwargs):
+        """GetColumnText(size_t column) -> wxString"""
+        return _gizmos.TreeListCtrl_GetColumnText(*args, **kwargs)
+
+    def SetColumn(*args, **kwargs):
+        """SetColumn(size_t column, TreeListColumnInfo info)"""
+        return _gizmos.TreeListCtrl_SetColumn(*args, **kwargs)
+
+    def GetColumn(*args, **kwargs):
+        """GetColumn(size_t column) -> TreeListColumnInfo"""
+        return _gizmos.TreeListCtrl_GetColumn(*args, **kwargs)
+
+    def SetColumnAlignment(*args, **kwargs):
+        """SetColumnAlignment(size_t column, wxTreeListColumnAlign align)"""
+        return _gizmos.TreeListCtrl_SetColumnAlignment(*args, **kwargs)
+
+    def GetColumnAlignment(*args, **kwargs):
+        """GetColumnAlignment(size_t column) -> wxTreeListColumnAlign"""
+        return _gizmos.TreeListCtrl_GetColumnAlignment(*args, **kwargs)
+
+    def SetColumnImage(*args, **kwargs):
+        """SetColumnImage(size_t column, int image)"""
+        return _gizmos.TreeListCtrl_SetColumnImage(*args, **kwargs)
+
+    def GetColumnImage(*args, **kwargs):
+        """GetColumnImage(size_t column) -> int"""
+        return _gizmos.TreeListCtrl_GetColumnImage(*args, **kwargs)
+
+    def GetItemText(*args, **kwargs):
+        """GetItemText(TreeItemId item, int column=-1) -> wxString"""
+        return _gizmos.TreeListCtrl_GetItemText(*args, **kwargs)
+
+    def GetItemImage(*args, **kwargs):
+        """GetItemImage(TreeItemId item, int column=-1, wxTreeItemIcon which=TreeItemIcon_Normal) -> int"""
+        return _gizmos.TreeListCtrl_GetItemImage(*args, **kwargs)
+
+    def SetItemText(*args, **kwargs):
+        """SetItemText(TreeItemId item, wxString text, int column=-1)"""
+        return _gizmos.TreeListCtrl_SetItemText(*args, **kwargs)
+
+    def SetItemImage(*args, **kwargs):
+        """SetItemImage(TreeItemId item, int image, int column=-1, wxTreeItemIcon which=TreeItemIcon_Normal)"""
+        return _gizmos.TreeListCtrl_SetItemImage(*args, **kwargs)
+
+    def GetItemData(*args, **kwargs):
+        """GetItemData(TreeItemId item) -> TreeItemData"""
+        return _gizmos.TreeListCtrl_GetItemData(*args, **kwargs)
+
+    def SetItemData(*args, **kwargs):
+        """SetItemData(TreeItemId item, TreeItemData data)"""
+        return _gizmos.TreeListCtrl_SetItemData(*args, **kwargs)
+
+    def GetItemPyData(*args, **kwargs):
+        """GetItemPyData(TreeItemId item) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetItemPyData(*args, **kwargs)
+
+    def SetItemPyData(*args, **kwargs):
+        """SetItemPyData(TreeItemId item, PyObject obj)"""
+        return _gizmos.TreeListCtrl_SetItemPyData(*args, **kwargs)
+
+    def SetItemHasChildren(*args, **kwargs):
+        """SetItemHasChildren(TreeItemId item, bool has=True)"""
+        return _gizmos.TreeListCtrl_SetItemHasChildren(*args, **kwargs)
+
+    def SetItemBold(*args, **kwargs):
+        """SetItemBold(TreeItemId item, bool bold=True)"""
+        return _gizmos.TreeListCtrl_SetItemBold(*args, **kwargs)
+
+    def SetItemTextColour(*args, **kwargs):
+        """SetItemTextColour(TreeItemId item, wxColour col)"""
+        return _gizmos.TreeListCtrl_SetItemTextColour(*args, **kwargs)
+
+    def SetItemBackgroundColour(*args, **kwargs):
+        """SetItemBackgroundColour(TreeItemId item, wxColour col)"""
+        return _gizmos.TreeListCtrl_SetItemBackgroundColour(*args, **kwargs)
+
+    def SetItemFont(*args, **kwargs):
+        """SetItemFont(TreeItemId item, wxFont font)"""
+        return _gizmos.TreeListCtrl_SetItemFont(*args, **kwargs)
+
+    def GetItemBold(*args, **kwargs):
+        """GetItemBold(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_GetItemBold(*args, **kwargs)
+
+    def GetItemTextColour(*args, **kwargs):
+        """GetItemTextColour(TreeItemId item) -> wxColour"""
+        return _gizmos.TreeListCtrl_GetItemTextColour(*args, **kwargs)
+
+    def GetItemBackgroundColour(*args, **kwargs):
+        """GetItemBackgroundColour(TreeItemId item) -> wxColour"""
+        return _gizmos.TreeListCtrl_GetItemBackgroundColour(*args, **kwargs)
+
+    def GetItemFont(*args, **kwargs):
+        """GetItemFont(TreeItemId item) -> wxFont"""
+        return _gizmos.TreeListCtrl_GetItemFont(*args, **kwargs)
+
+    def IsVisible(*args, **kwargs):
+        """IsVisible(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsVisible(*args, **kwargs)
+
+    def ItemHasChildren(*args, **kwargs):
+        """ItemHasChildren(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_ItemHasChildren(*args, **kwargs)
+
+    def IsExpanded(*args, **kwargs):
+        """IsExpanded(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsExpanded(*args, **kwargs)
+
+    def IsSelected(*args, **kwargs):
+        """IsSelected(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsSelected(*args, **kwargs)
+
+    def IsBold(*args, **kwargs):
+        """IsBold(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsBold(*args, **kwargs)
+
+    def GetChildrenCount(*args, **kwargs):
+        """GetChildrenCount(TreeItemId item, bool recursively=True) -> size_t"""
+        return _gizmos.TreeListCtrl_GetChildrenCount(*args, **kwargs)
+
+    def GetRootItem(*args, **kwargs):
+        """GetRootItem() -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetRootItem(*args, **kwargs)
+
+    def GetSelection(*args, **kwargs):
+        """GetSelection() -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetSelection(*args, **kwargs)
+
+    def GetSelections(*args, **kwargs):
+        """GetSelections() -> PyObject"""
+        return _gizmos.TreeListCtrl_GetSelections(*args, **kwargs)
+
+    def GetItemParent(*args, **kwargs):
+        """GetItemParent(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetItemParent(*args, **kwargs)
+
+    def GetFirstChild(*args, **kwargs):
+        """GetFirstChild(TreeItemId item) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetFirstChild(*args, **kwargs)
+
+    def GetNextChild(*args, **kwargs):
+        """GetNextChild(TreeItemId item, long cookie) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetNextChild(*args, **kwargs)
+
+    def GetLastChild(*args, **kwargs):
+        """GetLastChild(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetLastChild(*args, **kwargs)
+
+    def GetNextSibling(*args, **kwargs):
+        """GetNextSibling(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetNextSibling(*args, **kwargs)
+
+    def GetPrevSibling(*args, **kwargs):
+        """GetPrevSibling(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetPrevSibling(*args, **kwargs)
+
+    def GetFirstVisibleItem(*args, **kwargs):
+        """GetFirstVisibleItem() -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetFirstVisibleItem(*args, **kwargs)
+
+    def GetNextVisible(*args, **kwargs):
+        """GetNextVisible(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetNextVisible(*args, **kwargs)
+
+    def GetPrevVisible(*args, **kwargs):
+        """GetPrevVisible(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetPrevVisible(*args, **kwargs)
+
+    def GetNext(*args, **kwargs):
+        """GetNext(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetNext(*args, **kwargs)
+
+    def AddRoot(*args, **kwargs):
+        """AddRoot(wxString text, int image=-1, int selectedImage=-1, 
+    TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_AddRoot(*args, **kwargs)
+
+    def PrependItem(*args, **kwargs):
+        """PrependItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1, 
+    TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_PrependItem(*args, **kwargs)
+
+    def InsertItem(*args, **kwargs):
+        """InsertItem(TreeItemId parent, TreeItemId idPrevious, wxString text, 
+    int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_InsertItem(*args, **kwargs)
+
+    def InsertItemBefore(*args, **kwargs):
+        """InsertItemBefore(TreeItemId parent, size_t index, wxString text, int image=-1, 
+    int selectedImage=-1, TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_InsertItemBefore(*args, **kwargs)
+
+    def AppendItem(*args, **kwargs):
+        """AppendItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1, 
+    TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_AppendItem(*args, **kwargs)
+
+    def Delete(*args, **kwargs):
+        """Delete(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Delete(*args, **kwargs)
+
+    def DeleteChildren(*args, **kwargs):
+        """DeleteChildren(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_DeleteChildren(*args, **kwargs)
+
+    def DeleteAllItems(*args, **kwargs):
+        """DeleteAllItems()"""
+        return _gizmos.TreeListCtrl_DeleteAllItems(*args, **kwargs)
+
+    def Expand(*args, **kwargs):
+        """Expand(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Expand(*args, **kwargs)
+
+    def ExpandAll(*args, **kwargs):
+        """ExpandAll(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_ExpandAll(*args, **kwargs)
+
+    def Collapse(*args, **kwargs):
+        """Collapse(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Collapse(*args, **kwargs)
+
+    def CollapseAndReset(*args, **kwargs):
+        """CollapseAndReset(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_CollapseAndReset(*args, **kwargs)
+
+    def Toggle(*args, **kwargs):
+        """Toggle(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Toggle(*args, **kwargs)
+
+    def Unselect(*args, **kwargs):
+        """Unselect()"""
+        return _gizmos.TreeListCtrl_Unselect(*args, **kwargs)
+
+    def UnselectAll(*args, **kwargs):
+        """UnselectAll()"""
+        return _gizmos.TreeListCtrl_UnselectAll(*args, **kwargs)
+
+    def SelectItem(*args, **kwargs):
+        """SelectItem(TreeItemId item, bool unselect_others=True, bool extended_select=False)"""
+        return _gizmos.TreeListCtrl_SelectItem(*args, **kwargs)
+
+    def EnsureVisible(*args, **kwargs):
+        """EnsureVisible(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_EnsureVisible(*args, **kwargs)
+
+    def ScrollTo(*args, **kwargs):
+        """ScrollTo(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_ScrollTo(*args, **kwargs)
+
+    def HitTest(*args, **kwargs):
+        """HitTest(Point point, int OUTPUT, int OUTPUT) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_HitTest(*args, **kwargs)
+
+    def GetBoundingRect(*args, **kwargs):
+        """GetBoundingRect(TreeItemId item, bool textOnly=False) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetBoundingRect(*args, **kwargs)
+
+    def EditLabel(*args, **kwargs):
+        """EditLabel(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_EditLabel(*args, **kwargs)
+
+    def Edit(*args, **kwargs):
+        """Edit(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Edit(*args, **kwargs)
+
+    def SortChildren(*args, **kwargs):
+        """SortChildren(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_SortChildren(*args, **kwargs)
+
+    def GetItemSelectedImage(*args, **kwargs):
+        """GetItemSelectedImage(TreeItemId item) -> int"""
+        return _gizmos.TreeListCtrl_GetItemSelectedImage(*args, **kwargs)
+
+    def SetItemSelectedImage(*args, **kwargs):
+        """SetItemSelectedImage(TreeItemId item, int image)"""
+        return _gizmos.TreeListCtrl_SetItemSelectedImage(*args, **kwargs)
+
+    def GetHeaderWindow(*args, **kwargs):
+        """GetHeaderWindow() -> Window"""
+        return _gizmos.TreeListCtrl_GetHeaderWindow(*args, **kwargs)
+
+    def GetMainWindow(*args, **kwargs):
+        """GetMainWindow() -> Window"""
+        return _gizmos.TreeListCtrl_GetMainWindow(*args, **kwargs)
+
+
+class TreeListCtrlPtr(TreeListCtrl):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = TreeListCtrl
+_gizmos.TreeListCtrl_swigregister(TreeListCtrlPtr)
+
+def PreTreeListCtrl(*args, **kwargs):
+    """PreTreeListCtrl() -> TreeListCtrl"""
+    val = _gizmos.new_PreTreeListCtrl(*args, **kwargs)
+    val.thisown = 1
+    return val
+
+

wxPython/contrib/gizmos/msw/gizmos.py

@@ -0,0 +1,835 @@
+# This file was created automatically by SWIG.
+# Don't modify this file, modify the SWIG interface instead.
+
+import _gizmos
+
+import windows
+import core
+import controls
+wx = core 
+wxEVT_DYNAMIC_SASH_SPLIT = _gizmos.wxEVT_DYNAMIC_SASH_SPLIT
+wxEVT_DYNAMIC_SASH_UNIFY = _gizmos.wxEVT_DYNAMIC_SASH_UNIFY
+DS_MANAGE_SCROLLBARS = _gizmos.DS_MANAGE_SCROLLBARS
+DS_DRAG_CORNER = _gizmos.DS_DRAG_CORNER
+class DynamicSashSplitEvent(core.CommandEvent):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDynamicSashSplitEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Object target) -> DynamicSashSplitEvent"""
+        newobj = _gizmos.new_DynamicSashSplitEvent(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+
+class DynamicSashSplitEventPtr(DynamicSashSplitEvent):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DynamicSashSplitEvent
+_gizmos.DynamicSashSplitEvent_swigregister(DynamicSashSplitEventPtr)
+
+class DynamicSashUnifyEvent(core.CommandEvent):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDynamicSashUnifyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Object target) -> DynamicSashUnifyEvent"""
+        newobj = _gizmos.new_DynamicSashUnifyEvent(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+
+class DynamicSashUnifyEventPtr(DynamicSashUnifyEvent):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DynamicSashUnifyEvent
+_gizmos.DynamicSashUnifyEvent_swigregister(DynamicSashUnifyEventPtr)
+
+class DynamicSashWindow(core.Window):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxDynamicSashWindow 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=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER, 
+    wxString name=wxPyDynamicSashNameStr) -> DynamicSashWindow"""
+        newobj = _gizmos.new_DynamicSashWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def Create(*args, **kwargs):
+        """Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, 
+    long style=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER, 
+    wxString name=wxPyDynamicSashNameStr) -> bool"""
+        return _gizmos.DynamicSashWindow_Create(*args, **kwargs)
+
+    def GetHScrollBar(*args, **kwargs):
+        """GetHScrollBar(Window child) -> ScrollBar"""
+        return _gizmos.DynamicSashWindow_GetHScrollBar(*args, **kwargs)
+
+    def GetVScrollBar(*args, **kwargs):
+        """GetVScrollBar(Window child) -> ScrollBar"""
+        return _gizmos.DynamicSashWindow_GetVScrollBar(*args, **kwargs)
+
+
+class DynamicSashWindowPtr(DynamicSashWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = DynamicSashWindow
+_gizmos.DynamicSashWindow_swigregister(DynamicSashWindowPtr)
+
+def PreDynamicSashWindow(*args, **kwargs):
+    """PreDynamicSashWindow() -> DynamicSashWindow"""
+    val = _gizmos.new_PreDynamicSashWindow(*args, **kwargs)
+    val.thisown = 1
+    return val
+
+EVT_DYNAMIC_SASH_SPLIT = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_SPLIT, 1 )
+EVT_DYNAMIC_SASH_UNIFY = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_UNIFY, 1 )
+
+EL_ALLOW_NEW = _gizmos.EL_ALLOW_NEW
+EL_ALLOW_EDIT = _gizmos.EL_ALLOW_EDIT
+EL_ALLOW_DELETE = _gizmos.EL_ALLOW_DELETE
+class EditableListBox(windows.Panel):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxEditableListBox instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id, wxString label, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxEL_ALLOW_NEW|wxEL_ALLOW_EDIT|wxEL_ALLOW_DELETE, 
+    wxString name=wxPyEditableListBoxNameStr) -> EditableListBox"""
+        newobj = _gizmos.new_EditableListBox(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def SetStrings(*args, **kwargs):
+        """SetStrings(wxArrayString strings)"""
+        return _gizmos.EditableListBox_SetStrings(*args, **kwargs)
+
+    def GetStrings(*args, **kwargs):
+        """GetStrings() -> PyObject"""
+        return _gizmos.EditableListBox_GetStrings(*args, **kwargs)
+
+    def GetListCtrl(*args, **kwargs):
+        """GetListCtrl() -> wxListCtrl"""
+        return _gizmos.EditableListBox_GetListCtrl(*args, **kwargs)
+
+    def GetDelButton(*args, **kwargs):
+        """GetDelButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetDelButton(*args, **kwargs)
+
+    def GetNewButton(*args, **kwargs):
+        """GetNewButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetNewButton(*args, **kwargs)
+
+    def GetUpButton(*args, **kwargs):
+        """GetUpButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetUpButton(*args, **kwargs)
+
+    def GetDownButton(*args, **kwargs):
+        """GetDownButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetDownButton(*args, **kwargs)
+
+    def GetEditButton(*args, **kwargs):
+        """GetEditButton() -> BitmapButton"""
+        return _gizmos.EditableListBox_GetEditButton(*args, **kwargs)
+
+
+class EditableListBoxPtr(EditableListBox):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = EditableListBox
+_gizmos.EditableListBox_swigregister(EditableListBoxPtr)
+
+class RemotelyScrolledTreeCtrl(controls.TreeCtrl):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxRemotelyScrolledTreeCtrl 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=TR_HAS_BUTTONS) -> RemotelyScrolledTreeCtrl"""
+        newobj = _gizmos.new_RemotelyScrolledTreeCtrl(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def HideVScrollbar(*args, **kwargs):
+        """HideVScrollbar()"""
+        return _gizmos.RemotelyScrolledTreeCtrl_HideVScrollbar(*args, **kwargs)
+
+    def AdjustRemoteScrollbars(*args, **kwargs):
+        """AdjustRemoteScrollbars()"""
+        return _gizmos.RemotelyScrolledTreeCtrl_AdjustRemoteScrollbars(*args, **kwargs)
+
+    def GetScrolledWindow(*args, **kwargs):
+        """GetScrolledWindow() -> ScrolledWindow"""
+        return _gizmos.RemotelyScrolledTreeCtrl_GetScrolledWindow(*args, **kwargs)
+
+    def ScrollToLine(*args, **kwargs):
+        """ScrollToLine(int posHoriz, int posVert)"""
+        return _gizmos.RemotelyScrolledTreeCtrl_ScrollToLine(*args, **kwargs)
+
+    def SetCompanionWindow(*args, **kwargs):
+        """SetCompanionWindow(Window companion)"""
+        return _gizmos.RemotelyScrolledTreeCtrl_SetCompanionWindow(*args, **kwargs)
+
+    def GetCompanionWindow(*args, **kwargs):
+        """GetCompanionWindow() -> Window"""
+        return _gizmos.RemotelyScrolledTreeCtrl_GetCompanionWindow(*args, **kwargs)
+
+
+class RemotelyScrolledTreeCtrlPtr(RemotelyScrolledTreeCtrl):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = RemotelyScrolledTreeCtrl
+_gizmos.RemotelyScrolledTreeCtrl_swigregister(RemotelyScrolledTreeCtrlPtr)
+
+class TreeCompanionWindow(core.Window):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxPyTreeCompanionWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=0) -> TreeCompanionWindow"""
+        newobj = _gizmos.new_TreeCompanionWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self);self._setCallbackInfo(self, TreeCompanionWindow)
+
+    def _setCallbackInfo(*args, **kwargs):
+        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        return _gizmos.TreeCompanionWindow__setCallbackInfo(*args, **kwargs)
+
+    def GetTreeCtrl(*args, **kwargs):
+        """GetTreeCtrl() -> RemotelyScrolledTreeCtrl"""
+        return _gizmos.TreeCompanionWindow_GetTreeCtrl(*args, **kwargs)
+
+    def SetTreeCtrl(*args, **kwargs):
+        """SetTreeCtrl(RemotelyScrolledTreeCtrl treeCtrl)"""
+        return _gizmos.TreeCompanionWindow_SetTreeCtrl(*args, **kwargs)
+
+
+class TreeCompanionWindowPtr(TreeCompanionWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = TreeCompanionWindow
+_gizmos.TreeCompanionWindow_swigregister(TreeCompanionWindowPtr)
+
+class ThinSplitterWindow(windows.SplitterWindow):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxThinSplitterWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxSP_3D|wxCLIP_CHILDREN) -> ThinSplitterWindow"""
+        newobj = _gizmos.new_ThinSplitterWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+
+class ThinSplitterWindowPtr(ThinSplitterWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = ThinSplitterWindow
+_gizmos.ThinSplitterWindow_swigregister(ThinSplitterWindowPtr)
+
+class SplitterScrolledWindow(windows.ScrolledWindow):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxSplitterScrolledWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=0) -> SplitterScrolledWindow"""
+        newobj = _gizmos.new_SplitterScrolledWindow(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+
+class SplitterScrolledWindowPtr(SplitterScrolledWindow):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = SplitterScrolledWindow
+_gizmos.SplitterScrolledWindow_swigregister(SplitterScrolledWindowPtr)
+
+LED_ALIGN_LEFT = _gizmos.LED_ALIGN_LEFT
+LED_ALIGN_RIGHT = _gizmos.LED_ALIGN_RIGHT
+LED_ALIGN_CENTER = _gizmos.LED_ALIGN_CENTER
+LED_ALIGN_MASK = _gizmos.LED_ALIGN_MASK
+LED_DRAW_FADED = _gizmos.LED_DRAW_FADED
+class LEDNumberCtrl(core.Control):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxLEDNumberCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxLED_ALIGN_LEFT|wxLED_DRAW_FADED) -> LEDNumberCtrl"""
+        newobj = _gizmos.new_LEDNumberCtrl(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self)
+
+    def Create(*args, **kwargs):
+        """Create(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=wxLED_ALIGN_LEFT|wxLED_DRAW_FADED) -> bool"""
+        return _gizmos.LEDNumberCtrl_Create(*args, **kwargs)
+
+    def GetAlignment(*args, **kwargs):
+        """GetAlignment() -> wxLEDValueAlign"""
+        return _gizmos.LEDNumberCtrl_GetAlignment(*args, **kwargs)
+
+    def GetDrawFaded(*args, **kwargs):
+        """GetDrawFaded() -> bool"""
+        return _gizmos.LEDNumberCtrl_GetDrawFaded(*args, **kwargs)
+
+    def GetValue(*args, **kwargs):
+        """GetValue() -> wxString"""
+        return _gizmos.LEDNumberCtrl_GetValue(*args, **kwargs)
+
+    def SetAlignment(*args, **kwargs):
+        """SetAlignment(wxLEDValueAlign Alignment, bool Redraw=true)"""
+        return _gizmos.LEDNumberCtrl_SetAlignment(*args, **kwargs)
+
+    def SetDrawFaded(*args, **kwargs):
+        """SetDrawFaded(bool DrawFaded, bool Redraw=true)"""
+        return _gizmos.LEDNumberCtrl_SetDrawFaded(*args, **kwargs)
+
+    def SetValue(*args, **kwargs):
+        """SetValue(wxString Value, bool Redraw=true)"""
+        return _gizmos.LEDNumberCtrl_SetValue(*args, **kwargs)
+
+
+class LEDNumberCtrlPtr(LEDNumberCtrl):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = LEDNumberCtrl
+_gizmos.LEDNumberCtrl_swigregister(LEDNumberCtrlPtr)
+
+def PreLEDNumberCtrl(*args, **kwargs):
+    """PreLEDNumberCtrl() -> LEDNumberCtrl"""
+    val = _gizmos.new_PreLEDNumberCtrl(*args, **kwargs)
+    val.thisown = 1
+    return val
+
+TL_ALIGN_LEFT = _gizmos.TL_ALIGN_LEFT
+TL_ALIGN_RIGHT = _gizmos.TL_ALIGN_RIGHT
+TL_ALIGN_CENTER = _gizmos.TL_ALIGN_CENTER
+TREE_HITTEST_ONITEMCOLUMN = _gizmos.TREE_HITTEST_ONITEMCOLUMN
+class TreeListColumnInfo(core.Object):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxTreeListColumnInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(wxString text=wxPyEmptyString, int image=-1, size_t width=100, 
+    wxTreeListColumnAlign alignment=TL_ALIGN_LEFT) -> TreeListColumnInfo"""
+        newobj = _gizmos.new_TreeListColumnInfo(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+    def GetAlignment(*args, **kwargs):
+        """GetAlignment() -> wxTreeListColumnAlign"""
+        return _gizmos.TreeListColumnInfo_GetAlignment(*args, **kwargs)
+
+    def GetText(*args, **kwargs):
+        """GetText() -> wxString"""
+        return _gizmos.TreeListColumnInfo_GetText(*args, **kwargs)
+
+    def GetImage(*args, **kwargs):
+        """GetImage() -> int"""
+        return _gizmos.TreeListColumnInfo_GetImage(*args, **kwargs)
+
+    def GetSelectedImage(*args, **kwargs):
+        """GetSelectedImage() -> int"""
+        return _gizmos.TreeListColumnInfo_GetSelectedImage(*args, **kwargs)
+
+    def GetWidth(*args, **kwargs):
+        """GetWidth() -> size_t"""
+        return _gizmos.TreeListColumnInfo_GetWidth(*args, **kwargs)
+
+    def SetAlignment(*args, **kwargs):
+        """SetAlignment(wxTreeListColumnAlign alignment)"""
+        return _gizmos.TreeListColumnInfo_SetAlignment(*args, **kwargs)
+
+    def SetText(*args, **kwargs):
+        """SetText(wxString text)"""
+        return _gizmos.TreeListColumnInfo_SetText(*args, **kwargs)
+
+    def SetImage(*args, **kwargs):
+        """SetImage(int image)"""
+        return _gizmos.TreeListColumnInfo_SetImage(*args, **kwargs)
+
+    def SetSelectedImage(*args, **kwargs):
+        """SetSelectedImage(int image)"""
+        return _gizmos.TreeListColumnInfo_SetSelectedImage(*args, **kwargs)
+
+    def SetWidth(*args, **kwargs):
+        """SetWidth(size_t with)"""
+        return _gizmos.TreeListColumnInfo_SetWidth(*args, **kwargs)
+
+
+class TreeListColumnInfoPtr(TreeListColumnInfo):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = TreeListColumnInfo
+_gizmos.TreeListColumnInfo_swigregister(TreeListColumnInfoPtr)
+
+class TreeListCtrl(core.Control):
+    """"""
+    def __repr__(self):
+        return "<%s.%s; proxy of C++ wxPyTreeListCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def __init__(self, *args, **kwargs):
+        """__init__(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=TR_DEFAULT_STYLE, 
+    Validator validator=DefaultValidator, 
+    wxString name=wxPyTreeListCtrlNameStr) -> TreeListCtrl"""
+        newobj = _gizmos.new_TreeListCtrl(*args, **kwargs)
+        self.this = newobj.this
+        self.thisown = 1
+        del newobj.thisown
+        self._setOORInfo(self);self._setCallbackInfo(self, TreeListCtrl)
+
+    def Create(*args, **kwargs):
+        """Create(Window parent, int id=-1, Point pos=DefaultPosition, 
+    Size size=DefaultSize, long style=TR_DEFAULT_STYLE, 
+    Validator validator=DefaultValidator, 
+    wxString name=wxPyTreeListCtrlNameStr) -> bool"""
+        return _gizmos.TreeListCtrl_Create(*args, **kwargs)
+
+    def _setCallbackInfo(*args, **kwargs):
+        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        return _gizmos.TreeListCtrl__setCallbackInfo(*args, **kwargs)
+
+    def GetCount(*args, **kwargs):
+        """GetCount() -> size_t"""
+        return _gizmos.TreeListCtrl_GetCount(*args, **kwargs)
+
+    def GetIndent(*args, **kwargs):
+        """GetIndent() -> unsigned int"""
+        return _gizmos.TreeListCtrl_GetIndent(*args, **kwargs)
+
+    def SetIndent(*args, **kwargs):
+        """SetIndent(unsigned int indent)"""
+        return _gizmos.TreeListCtrl_SetIndent(*args, **kwargs)
+
+    def GetSpacing(*args, **kwargs):
+        """GetSpacing() -> unsigned int"""
+        return _gizmos.TreeListCtrl_GetSpacing(*args, **kwargs)
+
+    def SetSpacing(*args, **kwargs):
+        """SetSpacing(unsigned int spacing)"""
+        return _gizmos.TreeListCtrl_SetSpacing(*args, **kwargs)
+
+    def GetLineSpacing(*args, **kwargs):
+        """GetLineSpacing() -> unsigned int"""
+        return _gizmos.TreeListCtrl_GetLineSpacing(*args, **kwargs)
+
+    def SetLineSpacing(*args, **kwargs):
+        """SetLineSpacing(unsigned int spacing)"""
+        return _gizmos.TreeListCtrl_SetLineSpacing(*args, **kwargs)
+
+    def GetImageList(*args, **kwargs):
+        """GetImageList() -> wxImageList"""
+        return _gizmos.TreeListCtrl_GetImageList(*args, **kwargs)
+
+    def GetStateImageList(*args, **kwargs):
+        """GetStateImageList() -> wxImageList"""
+        return _gizmos.TreeListCtrl_GetStateImageList(*args, **kwargs)
+
+    def GetButtonsImageList(*args, **kwargs):
+        """GetButtonsImageList() -> wxImageList"""
+        return _gizmos.TreeListCtrl_GetButtonsImageList(*args, **kwargs)
+
+    def SetImageList(*args, **kwargs):
+        """SetImageList(wxImageList imageList)"""
+        return _gizmos.TreeListCtrl_SetImageList(*args, **kwargs)
+
+    def SetStateImageList(*args, **kwargs):
+        """SetStateImageList(wxImageList imageList)"""
+        return _gizmos.TreeListCtrl_SetStateImageList(*args, **kwargs)
+
+    def SetButtonsImageList(*args, **kwargs):
+        """SetButtonsImageList(wxImageList imageList)"""
+        return _gizmos.TreeListCtrl_SetButtonsImageList(*args, **kwargs)
+
+    def AssignImageList(*args, **kwargs):
+        """AssignImageList(wxImageList imageList)"""
+        val = _gizmos.TreeListCtrl_AssignImageList(*args, **kwargs)
+        args[1].thisown = 0
+        return val
+
+    def AssignStateImageList(*args, **kwargs):
+        """AssignStateImageList(wxImageList imageList)"""
+        val = _gizmos.TreeListCtrl_AssignStateImageList(*args, **kwargs)
+        args[1].thisown = 0
+        return val
+
+    def AssignButtonsImageList(*args, **kwargs):
+        """AssignButtonsImageList(wxImageList imageList)"""
+        val = _gizmos.TreeListCtrl_AssignButtonsImageList(*args, **kwargs)
+        args[1].thisown = 0
+        return val
+
+    def AddColumn(*args, **kwargs):
+        """AddColumn(wxString text)"""
+        return _gizmos.TreeListCtrl_AddColumn(*args, **kwargs)
+
+    def AddColumnInfo(*args, **kwargs):
+        """AddColumnInfo(TreeListColumnInfo col)"""
+        return _gizmos.TreeListCtrl_AddColumnInfo(*args, **kwargs)
+
+    def InsertColumn(*args, **kwargs):
+        """InsertColumn(size_t before, wxString text)"""
+        return _gizmos.TreeListCtrl_InsertColumn(*args, **kwargs)
+
+    def InsertColumnInfo(*args, **kwargs):
+        """InsertColumnInfo(size_t before, TreeListColumnInfo col)"""
+        return _gizmos.TreeListCtrl_InsertColumnInfo(*args, **kwargs)
+
+    def RemoveColumn(*args, **kwargs):
+        """RemoveColumn(size_t column)"""
+        return _gizmos.TreeListCtrl_RemoveColumn(*args, **kwargs)
+
+    def GetColumnCount(*args, **kwargs):
+        """GetColumnCount() -> size_t"""
+        return _gizmos.TreeListCtrl_GetColumnCount(*args, **kwargs)
+
+    def SetColumnWidth(*args, **kwargs):
+        """SetColumnWidth(size_t column, size_t width)"""
+        return _gizmos.TreeListCtrl_SetColumnWidth(*args, **kwargs)
+
+    def GetColumnWidth(*args, **kwargs):
+        """GetColumnWidth(size_t column) -> int"""
+        return _gizmos.TreeListCtrl_GetColumnWidth(*args, **kwargs)
+
+    def SetMainColumn(*args, **kwargs):
+        """SetMainColumn(size_t column)"""
+        return _gizmos.TreeListCtrl_SetMainColumn(*args, **kwargs)
+
+    def GetMainColumn(*args, **kwargs):
+        """GetMainColumn() -> size_t"""
+        return _gizmos.TreeListCtrl_GetMainColumn(*args, **kwargs)
+
+    def SetColumnText(*args, **kwargs):
+        """SetColumnText(size_t column, wxString text)"""
+        return _gizmos.TreeListCtrl_SetColumnText(*args, **kwargs)
+
+    def GetColumnText(*args, **kwargs):
+        """GetColumnText(size_t column) -> wxString"""
+        return _gizmos.TreeListCtrl_GetColumnText(*args, **kwargs)
+
+    def SetColumn(*args, **kwargs):
+        """SetColumn(size_t column, TreeListColumnInfo info)"""
+        return _gizmos.TreeListCtrl_SetColumn(*args, **kwargs)
+
+    def GetColumn(*args, **kwargs):
+        """GetColumn(size_t column) -> TreeListColumnInfo"""
+        return _gizmos.TreeListCtrl_GetColumn(*args, **kwargs)
+
+    def SetColumnAlignment(*args, **kwargs):
+        """SetColumnAlignment(size_t column, wxTreeListColumnAlign align)"""
+        return _gizmos.TreeListCtrl_SetColumnAlignment(*args, **kwargs)
+
+    def GetColumnAlignment(*args, **kwargs):
+        """GetColumnAlignment(size_t column) -> wxTreeListColumnAlign"""
+        return _gizmos.TreeListCtrl_GetColumnAlignment(*args, **kwargs)
+
+    def SetColumnImage(*args, **kwargs):
+        """SetColumnImage(size_t column, int image)"""
+        return _gizmos.TreeListCtrl_SetColumnImage(*args, **kwargs)
+
+    def GetColumnImage(*args, **kwargs):
+        """GetColumnImage(size_t column) -> int"""
+        return _gizmos.TreeListCtrl_GetColumnImage(*args, **kwargs)
+
+    def GetItemText(*args, **kwargs):
+        """GetItemText(TreeItemId item, int column=-1) -> wxString"""
+        return _gizmos.TreeListCtrl_GetItemText(*args, **kwargs)
+
+    def GetItemImage(*args, **kwargs):
+        """GetItemImage(TreeItemId item, int column=-1, wxTreeItemIcon which=TreeItemIcon_Normal) -> int"""
+        return _gizmos.TreeListCtrl_GetItemImage(*args, **kwargs)
+
+    def SetItemText(*args, **kwargs):
+        """SetItemText(TreeItemId item, wxString text, int column=-1)"""
+        return _gizmos.TreeListCtrl_SetItemText(*args, **kwargs)
+
+    def SetItemImage(*args, **kwargs):
+        """SetItemImage(TreeItemId item, int image, int column=-1, wxTreeItemIcon which=TreeItemIcon_Normal)"""
+        return _gizmos.TreeListCtrl_SetItemImage(*args, **kwargs)
+
+    def GetItemData(*args, **kwargs):
+        """GetItemData(TreeItemId item) -> TreeItemData"""
+        return _gizmos.TreeListCtrl_GetItemData(*args, **kwargs)
+
+    def SetItemData(*args, **kwargs):
+        """SetItemData(TreeItemId item, TreeItemData data)"""
+        return _gizmos.TreeListCtrl_SetItemData(*args, **kwargs)
+
+    def GetItemPyData(*args, **kwargs):
+        """GetItemPyData(TreeItemId item) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetItemPyData(*args, **kwargs)
+
+    def SetItemPyData(*args, **kwargs):
+        """SetItemPyData(TreeItemId item, PyObject obj)"""
+        return _gizmos.TreeListCtrl_SetItemPyData(*args, **kwargs)
+
+    def SetItemHasChildren(*args, **kwargs):
+        """SetItemHasChildren(TreeItemId item, bool has=True)"""
+        return _gizmos.TreeListCtrl_SetItemHasChildren(*args, **kwargs)
+
+    def SetItemBold(*args, **kwargs):
+        """SetItemBold(TreeItemId item, bool bold=True)"""
+        return _gizmos.TreeListCtrl_SetItemBold(*args, **kwargs)
+
+    def SetItemTextColour(*args, **kwargs):
+        """SetItemTextColour(TreeItemId item, wxColour col)"""
+        return _gizmos.TreeListCtrl_SetItemTextColour(*args, **kwargs)
+
+    def SetItemBackgroundColour(*args, **kwargs):
+        """SetItemBackgroundColour(TreeItemId item, wxColour col)"""
+        return _gizmos.TreeListCtrl_SetItemBackgroundColour(*args, **kwargs)
+
+    def SetItemFont(*args, **kwargs):
+        """SetItemFont(TreeItemId item, wxFont font)"""
+        return _gizmos.TreeListCtrl_SetItemFont(*args, **kwargs)
+
+    def GetItemBold(*args, **kwargs):
+        """GetItemBold(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_GetItemBold(*args, **kwargs)
+
+    def GetItemTextColour(*args, **kwargs):
+        """GetItemTextColour(TreeItemId item) -> wxColour"""
+        return _gizmos.TreeListCtrl_GetItemTextColour(*args, **kwargs)
+
+    def GetItemBackgroundColour(*args, **kwargs):
+        """GetItemBackgroundColour(TreeItemId item) -> wxColour"""
+        return _gizmos.TreeListCtrl_GetItemBackgroundColour(*args, **kwargs)
+
+    def GetItemFont(*args, **kwargs):
+        """GetItemFont(TreeItemId item) -> wxFont"""
+        return _gizmos.TreeListCtrl_GetItemFont(*args, **kwargs)
+
+    def IsVisible(*args, **kwargs):
+        """IsVisible(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsVisible(*args, **kwargs)
+
+    def ItemHasChildren(*args, **kwargs):
+        """ItemHasChildren(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_ItemHasChildren(*args, **kwargs)
+
+    def IsExpanded(*args, **kwargs):
+        """IsExpanded(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsExpanded(*args, **kwargs)
+
+    def IsSelected(*args, **kwargs):
+        """IsSelected(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsSelected(*args, **kwargs)
+
+    def IsBold(*args, **kwargs):
+        """IsBold(TreeItemId item) -> bool"""
+        return _gizmos.TreeListCtrl_IsBold(*args, **kwargs)
+
+    def GetChildrenCount(*args, **kwargs):
+        """GetChildrenCount(TreeItemId item, bool recursively=True) -> size_t"""
+        return _gizmos.TreeListCtrl_GetChildrenCount(*args, **kwargs)
+
+    def GetRootItem(*args, **kwargs):
+        """GetRootItem() -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetRootItem(*args, **kwargs)
+
+    def GetSelection(*args, **kwargs):
+        """GetSelection() -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetSelection(*args, **kwargs)
+
+    def GetSelections(*args, **kwargs):
+        """GetSelections() -> PyObject"""
+        return _gizmos.TreeListCtrl_GetSelections(*args, **kwargs)
+
+    def GetItemParent(*args, **kwargs):
+        """GetItemParent(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetItemParent(*args, **kwargs)
+
+    def GetFirstChild(*args, **kwargs):
+        """GetFirstChild(TreeItemId item) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetFirstChild(*args, **kwargs)
+
+    def GetNextChild(*args, **kwargs):
+        """GetNextChild(TreeItemId item, long cookie) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetNextChild(*args, **kwargs)
+
+    def GetLastChild(*args, **kwargs):
+        """GetLastChild(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetLastChild(*args, **kwargs)
+
+    def GetNextSibling(*args, **kwargs):
+        """GetNextSibling(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetNextSibling(*args, **kwargs)
+
+    def GetPrevSibling(*args, **kwargs):
+        """GetPrevSibling(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetPrevSibling(*args, **kwargs)
+
+    def GetFirstVisibleItem(*args, **kwargs):
+        """GetFirstVisibleItem() -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetFirstVisibleItem(*args, **kwargs)
+
+    def GetNextVisible(*args, **kwargs):
+        """GetNextVisible(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetNextVisible(*args, **kwargs)
+
+    def GetPrevVisible(*args, **kwargs):
+        """GetPrevVisible(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetPrevVisible(*args, **kwargs)
+
+    def GetNext(*args, **kwargs):
+        """GetNext(TreeItemId item) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_GetNext(*args, **kwargs)
+
+    def AddRoot(*args, **kwargs):
+        """AddRoot(wxString text, int image=-1, int selectedImage=-1, 
+    TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_AddRoot(*args, **kwargs)
+
+    def PrependItem(*args, **kwargs):
+        """PrependItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1, 
+    TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_PrependItem(*args, **kwargs)
+
+    def InsertItem(*args, **kwargs):
+        """InsertItem(TreeItemId parent, TreeItemId idPrevious, wxString text, 
+    int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_InsertItem(*args, **kwargs)
+
+    def InsertItemBefore(*args, **kwargs):
+        """InsertItemBefore(TreeItemId parent, size_t index, wxString text, int image=-1, 
+    int selectedImage=-1, TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_InsertItemBefore(*args, **kwargs)
+
+    def AppendItem(*args, **kwargs):
+        """AppendItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1, 
+    TreeItemData data=None) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_AppendItem(*args, **kwargs)
+
+    def Delete(*args, **kwargs):
+        """Delete(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Delete(*args, **kwargs)
+
+    def DeleteChildren(*args, **kwargs):
+        """DeleteChildren(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_DeleteChildren(*args, **kwargs)
+
+    def DeleteAllItems(*args, **kwargs):
+        """DeleteAllItems()"""
+        return _gizmos.TreeListCtrl_DeleteAllItems(*args, **kwargs)
+
+    def Expand(*args, **kwargs):
+        """Expand(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Expand(*args, **kwargs)
+
+    def ExpandAll(*args, **kwargs):
+        """ExpandAll(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_ExpandAll(*args, **kwargs)
+
+    def Collapse(*args, **kwargs):
+        """Collapse(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Collapse(*args, **kwargs)
+
+    def CollapseAndReset(*args, **kwargs):
+        """CollapseAndReset(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_CollapseAndReset(*args, **kwargs)
+
+    def Toggle(*args, **kwargs):
+        """Toggle(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Toggle(*args, **kwargs)
+
+    def Unselect(*args, **kwargs):
+        """Unselect()"""
+        return _gizmos.TreeListCtrl_Unselect(*args, **kwargs)
+
+    def UnselectAll(*args, **kwargs):
+        """UnselectAll()"""
+        return _gizmos.TreeListCtrl_UnselectAll(*args, **kwargs)
+
+    def SelectItem(*args, **kwargs):
+        """SelectItem(TreeItemId item, bool unselect_others=True, bool extended_select=False)"""
+        return _gizmos.TreeListCtrl_SelectItem(*args, **kwargs)
+
+    def EnsureVisible(*args, **kwargs):
+        """EnsureVisible(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_EnsureVisible(*args, **kwargs)
+
+    def ScrollTo(*args, **kwargs):
+        """ScrollTo(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_ScrollTo(*args, **kwargs)
+
+    def HitTest(*args, **kwargs):
+        """HitTest(Point point, int OUTPUT, int OUTPUT) -> TreeItemId"""
+        return _gizmos.TreeListCtrl_HitTest(*args, **kwargs)
+
+    def GetBoundingRect(*args, **kwargs):
+        """GetBoundingRect(TreeItemId item, bool textOnly=False) -> PyObject"""
+        return _gizmos.TreeListCtrl_GetBoundingRect(*args, **kwargs)
+
+    def EditLabel(*args, **kwargs):
+        """EditLabel(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_EditLabel(*args, **kwargs)
+
+    def Edit(*args, **kwargs):
+        """Edit(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_Edit(*args, **kwargs)
+
+    def SortChildren(*args, **kwargs):
+        """SortChildren(TreeItemId item)"""
+        return _gizmos.TreeListCtrl_SortChildren(*args, **kwargs)
+
+    def GetItemSelectedImage(*args, **kwargs):
+        """GetItemSelectedImage(TreeItemId item) -> int"""
+        return _gizmos.TreeListCtrl_GetItemSelectedImage(*args, **kwargs)
+
+    def SetItemSelectedImage(*args, **kwargs):
+        """SetItemSelectedImage(TreeItemId item, int image)"""
+        return _gizmos.TreeListCtrl_SetItemSelectedImage(*args, **kwargs)
+
+    def GetHeaderWindow(*args, **kwargs):
+        """GetHeaderWindow() -> Window"""
+        return _gizmos.TreeListCtrl_GetHeaderWindow(*args, **kwargs)
+
+    def GetMainWindow(*args, **kwargs):
+        """GetMainWindow() -> Window"""
+        return _gizmos.TreeListCtrl_GetMainWindow(*args, **kwargs)
+
+
+class TreeListCtrlPtr(TreeListCtrl):
+    def __init__(self, this):
+        self.this = this
+        if not hasattr(self,"thisown"): self.thisown = 0
+        self.__class__ = TreeListCtrl
+_gizmos.TreeListCtrl_swigregister(TreeListCtrlPtr)
+
+def PreTreeListCtrl(*args, **kwargs):
+    """PreTreeListCtrl() -> TreeListCtrl"""
+    val = _gizmos.new_PreTreeListCtrl(*args, **kwargs)
+    val.thisown = 1
+    return val
+
+

wxPython/src/mac/controls.py

@@ -993,7 +993,9 @@ class TextCtrl(core.Control):
         return _controls.TextCtrl_IsMultiLine(*args, **kwargs)
 
     def GetSelection(*args, **kwargs):
-        """GetSelection(long OUTPUT, long OUTPUT)"""
+        """GetSelection() -> (from, to)
+
+If the return values from and to are the same, there is no selection."""
         return _controls.TextCtrl_GetSelection(*args, **kwargs)
 
     def GetStringSelection(*args, **kwargs):
@@ -1065,7 +1067,7 @@ class TextCtrl(core.Control):
         return _controls.TextCtrl_XYToPosition(*args, **kwargs)
 
     def PositionToXY(*args, **kwargs):
-        """PositionToXY(long pos, long OUTPUT, long OUTPUT)"""
+        """PositionToXY(long pos) -> (x, y)"""
         return _controls.TextCtrl_PositionToXY(*args, **kwargs)
 
     def ShowPosition(*args, **kwargs):
@@ -1874,7 +1876,9 @@ class Notebook(BookCtrl):
         return _controls.Notebook_SetTabSize(*args, **kwargs)
 
     def HitTest(*args, **kwargs):
-        """HitTest(Point pt, long OUTPUT) -> int"""
+        """HitTest(Point pt) -> (tab, where)
+
+Returns the tab which is hit, and flags indicating where using wxNB_HITTEST_ flags."""
         return _controls.Notebook_HitTest(*args, **kwargs)
 
     def CalcSizeFromPage(*args, **kwargs):
@@ -3220,7 +3224,10 @@ class ListCtrl(core.Control):
         return _controls.ListCtrl_FindItemAtPos(*args, **kwargs)
 
     def HitTest(*args, **kwargs):
-        """HitTest(Point point, int OUTPUT) -> long"""
+        """HitTest(Point point) -> (item, where)
+
+Determines which item (if any) is at the specified point,
+giving details in the second return value (see wxLIST_HITTEST_... flags.)"""
         return _controls.ListCtrl_HitTest(*args, **kwargs)
 
     def InsertItem(*args, **kwargs):
@@ -3949,7 +3956,13 @@ class TreeCtrl(core.Control):
         return _controls.TreeCtrl_SortChildren(*args, **kwargs)
 
     def HitTest(*args, **kwargs):
-        """HitTest(Point point, int OUTPUT) -> TreeItemId"""
+        """HitTest(Point point) -> (item, where)
+
+Determine which item (if any) belongs the given point.  The
+coordinates specified are relative to the client area of tree ctrl
+and the where return value is set to a bitmask of wxTREE_HITTEST_xxx
+constants.
+"""
         return _controls.TreeCtrl_HitTest(*args, **kwargs)
 
     def GetBoundingRect(*args, **kwargs):
@@ -4062,7 +4075,12 @@ class GenericDirCtrl(core.Control):
         return _controls.GenericDirCtrl_GetFilterListCtrl(*args, **kwargs)
 
     def FindChild(*args, **kwargs):
-        """FindChild(TreeItemId parentId, wxString path, bool OUTPUT) -> TreeItemId"""
+        """FindChild(wxTreeItemId parentId, wxString path) -> (item, done)
+
+Find the child that matches the first part of 'path'.  E.g. if a child path is
+"/usr" and 'path' is "/usr/include" then the child for /usr is returned.
+If the path string has been used (we're at the leaf), done is set to True
+"""
         return _controls.GenericDirCtrl_FindChild(*args, **kwargs)
 
     def DoResize(*args, **kwargs):
@@ -4160,15 +4178,15 @@ class PyControl(core.Control):
         return _controls.PyControl_base_DoSetVirtualSize(*args, **kwargs)
 
     def base_DoGetSize(*args, **kwargs):
-        """base_DoGetSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetSize() -> (width, height)"""
         return _controls.PyControl_base_DoGetSize(*args, **kwargs)
 
     def base_DoGetClientSize(*args, **kwargs):
-        """base_DoGetClientSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetClientSize() -> (width, height)"""
         return _controls.PyControl_base_DoGetClientSize(*args, **kwargs)
 
     def base_DoGetPosition(*args, **kwargs):
-        """base_DoGetPosition(int OUTPUT, int OUTPUT)"""
+        """base_DoGetPosition() -> (x,y)"""
         return _controls.PyControl_base_DoGetPosition(*args, **kwargs)
 
     def base_DoGetVirtualSize(*args, **kwargs):

wxPython/src/mac/core.py

@@ -4396,105 +4396,177 @@ class PyApp(EvtHandler):
         return _core.PyApp__setCallbackInfo(*args, **kwargs)
 
     def GetAppName(*args, **kwargs):
-        """GetAppName() -> wxString"""
+        """GetAppName() -> wxString
+
+Get the application name."""
         return _core.PyApp_GetAppName(*args, **kwargs)
 
     def SetAppName(*args, **kwargs):
-        """SetAppName(wxString name)"""
+        """SetAppName(wxString name)
+
+Set the application name. This value may be used automatically
+by wxConfig and such."""
         return _core.PyApp_SetAppName(*args, **kwargs)
 
     def GetClassName(*args, **kwargs):
         """GetClassName() -> wxString
 
-Returns the class name of the C++ object using wxRTTI."""
+Get the application's class name."""
         return _core.PyApp_GetClassName(*args, **kwargs)
 
     def SetClassName(*args, **kwargs):
-        """SetClassName(wxString name)"""
+        """SetClassName(wxString name)
+
+Set the application's class name. This value may be used for X-resources if
+applicable for the platform"""
         return _core.PyApp_SetClassName(*args, **kwargs)
 
     def GetVendorName(*args, **kwargs):
-        """GetVendorName() -> wxString"""
+        """GetVendorName() -> wxString
+
+Get the application's vendor name."""
         return _core.PyApp_GetVendorName(*args, **kwargs)
 
     def SetVendorName(*args, **kwargs):
-        """SetVendorName(wxString name)"""
+        """SetVendorName(wxString name)
+
+Set the application's vendor name. This value may be used automatically
+by wxConfig and such."""
         return _core.PyApp_SetVendorName(*args, **kwargs)
 
     def GetTraits(*args, **kwargs):
-        """GetTraits() -> wxAppTraits"""
+        """GetTraits() -> wxAppTraits
+
+Create the app traits object to which we delegate for everything which either
+should be configurable by the user (then he can change the default behaviour
+simply by overriding CreateTraits() and returning his own traits object) or
+which is GUI/console dependent as then wxAppTraits allows us to abstract the
+differences behind the common facade"""
         return _core.PyApp_GetTraits(*args, **kwargs)
 
     def ProcessPendingEvents(*args, **kwargs):
-        """ProcessPendingEvents()"""
+        """ProcessPendingEvents()
+
+Process all events in the wxPendingEvents list -- it is necessary to call this
+function to process posted events. This happens during each event loop
+iteration."""
         return _core.PyApp_ProcessPendingEvents(*args, **kwargs)
 
     def Yield(*args, **kwargs):
-        """Yield(bool onlyIfNeeded=False) -> bool"""
+        """Yield(bool onlyIfNeeded=False) -> bool
+
+Process all currently pending events right now, instead of waiting until
+return to the event loop.  It is an error to call Yield() recursively unless
+the value of onlyIfNeeded is True.
+
+WARNING: This function is dangerous as it can lead to unexpected
+         reentrancies (i.e. when called from an event handler it
+         may result in calling the same event handler again), use
+         with _extreme_ care or, better, don't use at all!
+"""
         return _core.PyApp_Yield(*args, **kwargs)
 
     def WakeUpIdle(*args, **kwargs):
-        """WakeUpIdle()"""
+        """WakeUpIdle()
+
+Make sure that idle events are sent again"""
         return _core.PyApp_WakeUpIdle(*args, **kwargs)
 
     def MainLoop(*args, **kwargs):
-        """MainLoop() -> int"""
+        """MainLoop() -> int
+
+Execute the main GUI loop, the function returns when the loop ends."""
         return _core.PyApp_MainLoop(*args, **kwargs)
 
     def Exit(*args, **kwargs):
-        """Exit()"""
+        """Exit()
+
+Exit the main loop thus terminating the application."""
         return _core.PyApp_Exit(*args, **kwargs)
 
     def ExitMainLoop(*args, **kwargs):
-        """ExitMainLoop()"""
+        """ExitMainLoop()
+
+Exit the main GUI loop during the next iteration (i.e. it does not
+stop the program immediately!)"""
         return _core.PyApp_ExitMainLoop(*args, **kwargs)
 
     def Pending(*args, **kwargs):
-        """Pending() -> bool"""
+        """Pending() -> bool
+
+Returns True if there are unprocessed events in the event queue."""
         return _core.PyApp_Pending(*args, **kwargs)
 
     def Dispatch(*args, **kwargs):
-        """Dispatch() -> bool"""
+        """Dispatch() -> bool
+
+Process the first event in the event queue (blocks until an event
+appears if there are none currently)"""
         return _core.PyApp_Dispatch(*args, **kwargs)
 
     def ProcessIdle(*args, **kwargs):
-        """ProcessIdle() -> bool"""
+        """ProcessIdle() -> bool
+
+Called from the MainLoop when the application becomes idle and sends an
+IdleEvent to all interested parties.  Returns True is more idle events are
+needed, False if not."""
         return _core.PyApp_ProcessIdle(*args, **kwargs)
 
     def SendIdleEvents(*args, **kwargs):
-        """SendIdleEvents(Window win, IdleEvent event) -> bool"""
+        """SendIdleEvents(Window win, IdleEvent event) -> bool
+
+Send idle event to window and all subwindows.  Returns True if more idle time
+is requested."""
         return _core.PyApp_SendIdleEvents(*args, **kwargs)
 
-    def OnIdle(*args, **kwargs):
-        """OnIdle(IdleEvent event)"""
-        return _core.PyApp_OnIdle(*args, **kwargs)
-
     def IsActive(*args, **kwargs):
-        """IsActive() -> bool"""
+        """IsActive() -> bool
+
+Return True if our app has focus."""
         return _core.PyApp_IsActive(*args, **kwargs)
 
     def SetTopWindow(*args, **kwargs):
-        """SetTopWindow(Window win)"""
+        """SetTopWindow(Window win)
+
+Set the "main" top level window"""
         return _core.PyApp_SetTopWindow(*args, **kwargs)
 
     def GetTopWindow(*args, **kwargs):
-        """GetTopWindow() -> Window"""
+        """GetTopWindow() -> Window
+
+Return the "main" top level window (if it hadn't been set previously with
+SetTopWindow(), will return just some top level window and, if there not any,
+will return None)"""
         return _core.PyApp_GetTopWindow(*args, **kwargs)
 
     def SetExitOnFrameDelete(*args, **kwargs):
-        """SetExitOnFrameDelete(bool flag)"""
+        """SetExitOnFrameDelete(bool flag)
+
+Control the exit behaviour: by default, the program will exit the main loop
+(and so, usually, terminate) when the last top-level program window is
+deleted.  Beware that if you disable this behaviour (with
+SetExitOnFrameDelete(False)), you'll have to call ExitMainLoop() explicitly
+from somewhere.
+"""
         return _core.PyApp_SetExitOnFrameDelete(*args, **kwargs)
 
     def GetExitOnFrameDelete(*args, **kwargs):
-        """GetExitOnFrameDelete() -> bool"""
+        """GetExitOnFrameDelete() -> bool
+
+Get the current exit behaviour setting."""
         return _core.PyApp_GetExitOnFrameDelete(*args, **kwargs)
 
     def SetUseBestVisual(*args, **kwargs):
-        """SetUseBestVisual(bool flag)"""
+        """SetUseBestVisual(bool flag)
+
+Set whether the app should try to use the best available visual on systems
+where more than one is available, (Sun, SGI, XFree86 4, etc.)"""
         return _core.PyApp_SetUseBestVisual(*args, **kwargs)
 
     def GetUseBestVisual(*args, **kwargs):
-        """GetUseBestVisual() -> bool"""
+        """GetUseBestVisual() -> bool
+
+Get current UseBestVisual setting."""
         return _core.PyApp_GetUseBestVisual(*args, **kwargs)
 
     def SetPrintMode(*args, **kwargs):
@@ -4505,14 +4577,25 @@ Returns the class name of the C++ object using wxRTTI."""
         """GetPrintMode() -> int"""
         return _core.PyApp_GetPrintMode(*args, **kwargs)
 
-    def GetAssertMode(*args, **kwargs):
-        """GetAssertMode() -> int"""
-        return _core.PyApp_GetAssertMode(*args, **kwargs)
-
     def SetAssertMode(*args, **kwargs):
-        """SetAssertMode(int mode)"""
+        """SetAssertMode(int mode)
+
+Set the OnAssert behaviour for debug and hybrid builds.  The following flags
+may be or'd together:
+
+ wxPYAPP_ASSERT_SUPPRESS         Don't do anything
+ wxPYAPP_ASSERT_EXCEPTION        Turn it into a Python exception if possible (default)
+ wxPYAPP_ASSERT_DIALOG           Display a message dialog
+ wxPYAPP_ASSERT_LOG              Write the assertion info to the wxLog
+"""
         return _core.PyApp_SetAssertMode(*args, **kwargs)
 
+    def GetAssertMode(*args, **kwargs):
+        """GetAssertMode() -> int
+
+Get the current OnAssert behaviour setting."""
+        return _core.PyApp_GetAssertMode(*args, **kwargs)
+
     def GetMacSupportPCMenuShortcuts(*args, **kwargs):
         """PyApp.GetMacSupportPCMenuShortcuts() -> bool"""
         return _core.PyApp_GetMacSupportPCMenuShortcuts(*args, **kwargs)
@@ -4564,11 +4647,16 @@ Returns the class name of the C++ object using wxRTTI."""
 
     SetMacHelpMenuTitleName = staticmethod(SetMacHelpMenuTitleName)
     def _BootstrapApp(*args, **kwargs):
-        """_BootstrapApp()"""
+        """_BootstrapApp()
+
+For internal use only"""
         return _core.PyApp__BootstrapApp(*args, **kwargs)
 
     def GetComCtl32Version(*args, **kwargs):
-        """PyApp.GetComCtl32Version() -> int"""
+        """PyApp.GetComCtl32Version() -> int
+
+Returns 400, 470, 471 for comctl32.dll 4.00, 4.70, 4.71 or 0 if it
+wasn't found at all.  Raises an exception on non-Windows platforms."""
         return _core.PyApp_GetComCtl32Version(*args, **kwargs)
 
     GetComCtl32Version = staticmethod(GetComCtl32Version)
@@ -4621,91 +4709,135 @@ def PyApp_SetMacHelpMenuTitleName(*args, **kwargs):
     return _core.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
 
 def PyApp_GetComCtl32Version(*args, **kwargs):
-    """PyApp_GetComCtl32Version() -> int"""
+    """PyApp_GetComCtl32Version() -> int
+
+Returns 400, 470, 471 for comctl32.dll 4.00, 4.70, 4.71 or 0 if it
+wasn't found at all.  Raises an exception on non-Windows platforms."""
     return _core.PyApp_GetComCtl32Version(*args, **kwargs)
 
 #---------------------------------------------------------------------------
 
 
 def Exit(*args, **kwargs):
-    """Exit()"""
+    """Exit()
+
+Force an exit of the application.  Convenience for wx.GetApp().Exit()"""
     return _core.Exit(*args, **kwargs)
 
 def Yield(*args, **kwargs):
-    """Yield() -> bool"""
+    """Yield() -> bool
+
+Yield to other apps/messages.  Convenience for wx.GetApp().Yield()"""
     return _core.Yield(*args, **kwargs)
 
 def YieldIfNeeded(*args, **kwargs):
-    """YieldIfNeeded() -> bool"""
+    """YieldIfNeeded() -> bool
+
+Yield to other apps/messages.  Convenience for wx.GetApp().Yield(True)"""
     return _core.YieldIfNeeded(*args, **kwargs)
 
 def SafeYield(*args, **kwargs):
-    """SafeYield(Window win=None, bool onlyIfNeeded=False) -> bool"""
+    """SafeYield(Window win=None, bool onlyIfNeeded=False) -> bool
+
+This function is similar to wx.Yield, except that it disables the user input
+to all program windows before calling wx.Yield and re-enables it again
+afterwards. If win is not None, this window will remain enabled, allowing the
+implementation of some limited user interaction.
+
+Returns the result of the call to wx.Yield."""
     return _core.SafeYield(*args, **kwargs)
 
 def WakeUpIdle(*args, **kwargs):
-    """WakeUpIdle()"""
+    """WakeUpIdle()
+
+Cause the message queue to become empty again, so idle events will be sent."""
     return _core.WakeUpIdle(*args, **kwargs)
 
 def PostEvent(*args, **kwargs):
-    """PostEvent(EvtHandler dest, Event event)"""
+    """PostEvent(EvtHandler dest, Event event)
+
+Send an event to a window or other wx.EvtHandler to be processed later."""
     return _core.PostEvent(*args, **kwargs)
 
 def App_CleanUp(*args, **kwargs):
-    """App_CleanUp()"""
+    """App_CleanUp()
+
+For internal use only, it is used to cleanup after wxWindows when Python shuts down."""
     return _core.App_CleanUp(*args, **kwargs)
 
 def GetApp(*args, **kwargs):
-    """GetApp() -> PyApp"""
+    """GetApp() -> PyApp
+
+Return a reference to the current wxApp object."""
     return _core.GetApp(*args, **kwargs)
 #----------------------------------------------------------------------
 
 class PyOnDemandOutputWindow:
+    """
+    A class that can be used for redirecting Python's stdout and
+    stderr streams.  It will do nothing until something is wrriten to
+    the stream at which point it will create a Frame with a text area
+    and write the text there.
+    """
     def __init__(self, title = "wxPython: stdout/stderr"):
         self.frame  = None
         self.title  = title
         self.parent = None
 
     def SetParent(self, parent):
+        """Set the window to be used as the popup Frame's parent."""
         self.parent = parent
 
+
+    def CreateOutputWindow(self, st):
+        self.frame = wx.Frame(self.parent, -1, self.title,
+                              style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
+        self.text  = wxTextCtrl(self.frame, -1, "",
+                                style = wx.TE_MULTILINE | wx.TE_READONLY)
+        self.frame.SetSize((450, 300))
+        self.frame.Show(True)
+        EVT_CLOSE(self.frame, self.OnCloseWindow)
+        
+
+    # These methods provide the file-like output behaviour.
+    def write(self, text):
+        """
+        Create the output window if needed and write the string to it.
+        If not called in the context of the gui thread then uses
+        CallAfter to do the work there.
+        """        
+        if self.frame is None:
+            if not wx.Thread_IsMain():
+                wx.CallAfter(self.CreateOutputWindow, text)
+            else:
+                self.CreateOutputWindow(text)
+        else:
+            if not wx.Thread_IsMain():
+                wx.CallAfter(self.text.AppendText, text)
+            else:
+                self.text.AppendText(text)
+
+
+    def close(self):
+        if self.frame is not None:
+            wx.CallAfter(self.frame.Close)
+
+
     def OnCloseWindow(self, event):
-        if self.frame != None:
+        if self.frame is not None:
             self.frame.Destroy()
         self.frame = None
         self.text  = None
 
-    # These methods provide the file-like output behaviour.
-    def write(self, str):
-        if not wx.Thread_IsMain():
-            # Aquire the GUI mutex before making GUI calls.  Mutex is released
-            # when locker is deleted at the end of this function.
-            locker = wx.MutexGuiLocker()
-
-        if not self.frame:
-            self.frame = wx.Frame(self.parent, -1, self.title,
-                                 style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
-            self.text  = wxTextCtrl(self.frame, -1, "",
-                                    style = wx.TE_MULTILINE | wx.TE_READONLY)
-            self.frame.SetSize((450, 300))
-            self.frame.Show(True)
-            EVT_CLOSE(self.frame, self.OnCloseWindow)
-        self.text.AppendText(str)
-
-    def close(self):
-        if self.frame != None:
-            if not wx.Thread_IsMain():
-                locker = wx.MutexGuiLocker()
-            self.frame.Close()
-
-
 #----------------------------------------------------------------------
-# The main application class.  Derive from this and implement an OnInit
-# method that creates a frame and then calls self.SetTopWindow(frame)
 
 _defRedirect = (wx.Platform == '__WXMSW__' or wx.Platform == '__WXMAC__')
 
 class App(wx.PyApp):
+    """
+    The main application class.  Derive from this and implement an OnInit
+    method that creates a frame and then calls self.SetTopWindow(frame)
+    """
     outputWindowClass = PyOnDemandOutputWindow
 
     def __init__(self, redirect=_defRedirect, filename=None, useBestVisual=False):
@@ -4796,13 +4928,20 @@ App_GetComCtl32Version           = _core.PyApp_GetComCtl32Version
 #----------------------------------------------------------------------------
 
 class PySimpleApp(wx.App):
-    def __init__(self, redirect=False, filename=None):
-        wx.App.__init__(self, redirect, filename)
+    """
+    A simple application class.  You can just create one of these and
+    then then make your top level windows later, and not have to worry
+    about OnInit."""
+
+    def __init__(self, redirect=False, filename=None, useBestVisual=False):
+        wx.App.__init__(self, redirect, filename, useBestVisual)
+        
     def OnInit(self):
         wx.InitAllImageHandlers()
         return True
 
 
+# Is anybody using this one?
 class PyWidgetTester(wx.App):
     def __init__(self, size = (250, 100)):
         self.size = size
@@ -5589,13 +5728,13 @@ Get the width, height, decent and leading of the text using the current or speci
         return _core.Window_GetToolTip(*args, **kwargs)
 
     def SetDropTarget(*args, **kwargs):
-        """SetDropTarget(wxDropTarget dropTarget)"""
+        """SetDropTarget(wxPyDropTarget dropTarget)"""
         val = _core.Window_SetDropTarget(*args, **kwargs)
         args[1].thisown = 0
         return val
 
     def GetDropTarget(*args, **kwargs):
-        """GetDropTarget() -> wxDropTarget"""
+        """GetDropTarget() -> wxPyDropTarget"""
         return _core.Window_GetDropTarget(*args, **kwargs)
 
     def SetConstraints(*args, **kwargs):
@@ -7455,7 +7594,7 @@ class LayoutConstraints(Object):
         self.thisown = 1
         del newobj.thisown
     def SatisfyConstraints(*args, **kwargs):
-        """SatisfyConstraints(Window win, int OUTPUT) -> bool"""
+        """SatisfyConstraints(Window win) -> (areSatisfied, noChanges)"""
         return _core.LayoutConstraints_SatisfyConstraints(*args, **kwargs)
 
     def AreSatisfied(*args, **kwargs):
@@ -7472,16 +7611,13 @@ _core.LayoutConstraints_swigregister(LayoutConstraintsPtr)
 
 #----------------------------------------------------------------------------
 
-# Use Python's bool constants if available, make aliases if not
+# Use Python's bool constants if available, make some if not
 try:
     True
 except NameError:
-    True = 1==1
-    False = 1==0
+    __builtins__.True = 1==1
+    __builtins__.False = 1==0
 
-# Backwards compaatibility
-TRUE  = true  = True
-FALSE = false = False
 
 
 # workarounds for bad wxRTTI names

wxPython/src/mac/core_wrap.cpp

@@ -321,7 +321,7 @@ SWIGEXPORT(void)              SWIG_Python_InstallConstants(PyObject *d, swig_con
 #define  SWIGTYPE_p_wxPyApp swig_types[103] 
 #define  SWIGTYPE_p_wxCommandEvent swig_types[104] 
 #define  SWIGTYPE_p_wxPyCommandEvent swig_types[105] 
-#define  SWIGTYPE_p_wxDropTarget swig_types[106] 
+#define  SWIGTYPE_p_wxPyDropTarget swig_types[106] 
 #define  SWIGTYPE_p_wxChildFocusEvent swig_types[107] 
 #define  SWIGTYPE_p_wxFocusEvent swig_types[108] 
 #define  SWIGTYPE_p_wxDropFilesEvent swig_types[109] 
@@ -17740,36 +17740,6 @@ static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *self, PyObject *args, PyOb
 }
 
 
-static PyObject *_wrap_PyApp_OnIdle(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxPyApp *arg1 = (wxPyApp *) 0 ;
-    wxIdleEvent *arg2 = 0 ;
-    PyObject * obj0 = 0 ;
-    PyObject * obj1 = 0 ;
-    char *kwnames[] = {
-        (char *) "self",(char *) "event", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_OnIdle",kwnames,&obj0,&obj1)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyApp,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxIdleEvent,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    if (arg2 == NULL) {
-        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
-    }
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        (arg1)->OnIdle(*arg2);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    Py_INCREF(Py_None); resultobj = Py_None;
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_PyApp_IsActive(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyApp *arg1 = (wxPyApp *) 0 ;
@@ -18005,31 +17975,6 @@ static PyObject *_wrap_PyApp_GetPrintMode(PyObject *self, PyObject *args, PyObje
 }
 
 
-static PyObject *_wrap_PyApp_GetAssertMode(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxPyApp *arg1 = (wxPyApp *) 0 ;
-    int result;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyApp,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = (int)(arg1)->GetAssertMode();
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    resultobj = PyInt_FromLong((long)result);
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyApp *arg1 = (wxPyApp *) 0 ;
@@ -18055,6 +18000,31 @@ static PyObject *_wrap_PyApp_SetAssertMode(PyObject *self, PyObject *args, PyObj
 }
 
 
+static PyObject *_wrap_PyApp_GetAssertMode(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxPyApp *arg1 = (wxPyApp *) 0 ;
+    int result;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyApp,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = (int)(arg1)->GetAssertMode();
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    resultobj = PyInt_FromLong((long)result);
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     bool result;
@@ -23670,7 +23640,7 @@ static PyObject *_wrap_Window_GetToolTip(PyObject *self, PyObject *args, PyObjec
 static PyObject *_wrap_Window_SetDropTarget(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxWindow *arg1 = (wxWindow *) 0 ;
-    wxDropTarget *arg2 = (wxDropTarget *) 0 ;
+    wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
     PyObject * obj0 = 0 ;
     PyObject * obj1 = 0 ;
     char *kwnames[] = {
@@ -23679,7 +23649,7 @@ static PyObject *_wrap_Window_SetDropTarget(PyObject *self, PyObject *args, PyOb
     
     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
     if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxDropTarget,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxPyDropTarget,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
     {
         PyThreadState* __tstate = wxPyBeginAllowThreads();
         (arg1)->SetDropTarget(arg2);
@@ -23697,7 +23667,7 @@ static PyObject *_wrap_Window_SetDropTarget(PyObject *self, PyObject *args, PyOb
 static PyObject *_wrap_Window_GetDropTarget(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxWindow *arg1 = (wxWindow *) 0 ;
-    wxDropTarget *result;
+    wxPyDropTarget *result;
     PyObject * obj0 = 0 ;
     char *kwnames[] = {
         (char *) "self", NULL 
@@ -23707,12 +23677,12 @@ static PyObject *_wrap_Window_GetDropTarget(PyObject *self, PyObject *args, PyOb
     if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
     {
         PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = (wxDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
+        result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
         
         wxPyEndAllowThreads(__tstate);
         if (PyErr_Occurred()) SWIG_fail;
     }
-    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_wxDropTarget, 0);
+    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_wxPyDropTarget, 0);
     return resultobj;
     fail:
     return NULL;
@@ -35612,7 +35582,6 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"PyApp_OnIdle", (PyCFunction) _wrap_PyApp_OnIdle, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS },
@@ -35622,8 +35591,8 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS },
@@ -36771,7 +36740,7 @@ static swig_type_info _swigt__p_wxMouseEvent[] = {{"_p_wxMouseEvent", 0, "wxMous
 static swig_type_info _swigt__p_wxPyApp[] = {{"_p_wxPyApp", 0, "wxPyApp *", 0},{"_p_wxPyApp"},{0}};
 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent},{"_p_wxCommandEvent"},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent},{0}};
 static swig_type_info _swigt__p_wxPyCommandEvent[] = {{"_p_wxPyCommandEvent", 0, "wxPyCommandEvent *", 0},{"_p_wxPyCommandEvent"},{0}};
-static swig_type_info _swigt__p_wxDropTarget[] = {{"_p_wxDropTarget", 0, "wxDropTarget *", 0},{"_p_wxDropTarget"},{0}};
+static swig_type_info _swigt__p_wxPyDropTarget[] = {{"_p_wxPyDropTarget", 0, "wxPyDropTarget *", 0},{"_p_wxPyDropTarget"},{0}};
 static swig_type_info _swigt__p_wxChildFocusEvent[] = {{"_p_wxChildFocusEvent", 0, "wxChildFocusEvent *", 0},{"_p_wxChildFocusEvent"},{0}};
 static swig_type_info _swigt__p_wxFocusEvent[] = {{"_p_wxFocusEvent", 0, "wxFocusEvent *", 0},{"_p_wxFocusEvent"},{0}};
 static swig_type_info _swigt__p_wxDropFilesEvent[] = {{"_p_wxDropFilesEvent", 0, "wxDropFilesEvent *", 0},{"_p_wxDropFilesEvent"},{0}};
@@ -36887,7 +36856,7 @@ _swigt__p_wxMouseEvent,
 _swigt__p_wxPyApp, 
 _swigt__p_wxCommandEvent, 
 _swigt__p_wxPyCommandEvent, 
-_swigt__p_wxDropTarget, 
+_swigt__p_wxPyDropTarget, 
 _swigt__p_wxChildFocusEvent, 
 _swigt__p_wxFocusEvent, 
 _swigt__p_wxDropFilesEvent, 

wxPython/src/mac/gdi.py

@@ -146,13 +146,14 @@ class Palette(GDIObject):
         return _gdi.Palette_GetPixel(*args, **kwargs)
 
     def GetRGB(*args, **kwargs):
-        """GetRGB(int pixel, byte OUTPUT, byte OUTPUT, byte OUTPUT) -> bool"""
+        """GetRGB(int pixel) -> (R,G,B)"""
         return _gdi.Palette_GetRGB(*args, **kwargs)
 
     def Ok(*args, **kwargs):
         """Ok() -> bool"""
         return _gdi.Palette_Ok(*args, **kwargs)
 
+    def __nonzero__(self): return self.Ok() 
 
 class PalettePtr(Palette):
     def __init__(self, this):
@@ -2231,7 +2232,7 @@ class DC(core.Object):
         return _gdi.DC_DestroyClippingRegion(*args, **kwargs)
 
     def GetClippingBox(*args, **kwargs):
-        """GetClippingBox(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT)"""
+        """GetClippingBox() -> (x, y, width, height)"""
         return _gdi.DC_GetClippingBox(*args, **kwargs)
 
     def GetClippingRect(*args, **kwargs):
@@ -2247,35 +2248,52 @@ class DC(core.Object):
         return _gdi.DC_GetCharWidth(*args, **kwargs)
 
     def GetTextExtent(*args, **kwargs):
-        """GetTextExtent(wxString string, int OUTPUT, int OUTPUT)"""
+        """GetTextExtent(wxString string) -> (width, height)
+
+Get the width and height of the text using the current font.
+Only works for single line strings."""
         return _gdi.DC_GetTextExtent(*args, **kwargs)
 
     def GetFullTextExtent(*args, **kwargs):
-        """GetFullTextExtent(wxString string, int OUTPUT, int OUTPUT, int OUTPUT, 
-    int OUTPUT, Font font=None)"""
+        """GetFullTextExtent(wxString string, Font font=None) ->
+   (width, height, descent, externalLeading)
+
+Get the width, height, decent and leading of the text using the current or specified font.
+Only works for single line strings."""
         return _gdi.DC_GetFullTextExtent(*args, **kwargs)
 
     def GetMultiLineTextExtent(*args, **kwargs):
-        """GetMultiLineTextExtent(wxString text, int OUTPUT, int OUTPUT, int OUTPUT, 
-    Font font=None)"""
+        """GetMultiLineTextExtent(wxString string, Font font=None) ->
+   (width, height, descent, externalLeading)
+
+Get the width, height, decent and leading of the text using the current or specified font.
+Works for single as well as multi-line strings."""
         return _gdi.DC_GetMultiLineTextExtent(*args, **kwargs)
 
-    def GetSizeTuple(*args, **kwargs):
-        """GetSizeTuple(int OUTPUT, int OUTPUT)"""
-        return _gdi.DC_GetSizeTuple(*args, **kwargs)
-
     def GetSize(*args, **kwargs):
-        """GetSize() -> Size"""
+        """GetSize() -> Size
+
+Get the DC size in device units."""
         return _gdi.DC_GetSize(*args, **kwargs)
 
-    def GetSizeMMWH(*args, **kwargs):
-        """GetSizeMMWH(int OUTPUT, int OUTPUT)"""
-        return _gdi.DC_GetSizeMMWH(*args, **kwargs)
+    def GetSizeTuple(*args, **kwargs):
+        """GetSizeTuple() -> (width, height)
+
+Get the DC size in device units."""
+        return _gdi.DC_GetSizeTuple(*args, **kwargs)
 
     def GetSizeMM(*args, **kwargs):
-        """GetSizeMM() -> Size"""
+        """GetSizeMM() -> Size
+
+Get the DC size in milimeters."""
         return _gdi.DC_GetSizeMM(*args, **kwargs)
 
+    def GetSizeMMTuple(*args, **kwargs):
+        """GetSizeMMTuple() -> (width, height)
+
+Get the DC size in milimeters."""
+        return _gdi.DC_GetSizeMMTuple(*args, **kwargs)
+
     def DeviceToLogicalX(*args, **kwargs):
         """DeviceToLogicalX(int x) -> int"""
         return _gdi.DC_DeviceToLogicalX(*args, **kwargs)
@@ -2373,7 +2391,7 @@ class DC(core.Object):
         return _gdi.DC_SetMapMode(*args, **kwargs)
 
     def GetUserScale(*args, **kwargs):
-        """GetUserScale(double OUTPUT, double OUTPUT)"""
+        """GetUserScale() -> (xScale, yScale)"""
         return _gdi.DC_GetUserScale(*args, **kwargs)
 
     def SetUserScale(*args, **kwargs):
@@ -2381,33 +2399,33 @@ class DC(core.Object):
         return _gdi.DC_SetUserScale(*args, **kwargs)
 
     def GetLogicalScale(*args, **kwargs):
-        """GetLogicalScale(double OUTPUT, double OUTPUT)"""
+        """GetLogicalScale() -> (xScale, yScale)"""
         return _gdi.DC_GetLogicalScale(*args, **kwargs)
 
     def SetLogicalScale(*args, **kwargs):
         """SetLogicalScale(double x, double y)"""
         return _gdi.DC_SetLogicalScale(*args, **kwargs)
 
-    def GetLogicalOriginTuple(*args, **kwargs):
-        """GetLogicalOriginTuple(int OUTPUT, int OUTPUT)"""
-        return _gdi.DC_GetLogicalOriginTuple(*args, **kwargs)
-
     def GetLogicalOrigin(*args, **kwargs):
         """GetLogicalOrigin() -> Point"""
         return _gdi.DC_GetLogicalOrigin(*args, **kwargs)
 
+    def GetLogicalOriginTuple(*args, **kwargs):
+        """GetLogicalOriginTuple() -> (x,y)"""
+        return _gdi.DC_GetLogicalOriginTuple(*args, **kwargs)
+
     def SetLogicalOrigin(*args, **kwargs):
         """SetLogicalOrigin(int x, int y)"""
         return _gdi.DC_SetLogicalOrigin(*args, **kwargs)
 
-    def GetDeviceOriginTuple(*args, **kwargs):
-        """GetDeviceOriginTuple(int OUTPUT, int OUTPUT)"""
-        return _gdi.DC_GetDeviceOriginTuple(*args, **kwargs)
-
     def GetDeviceOrigin(*args, **kwargs):
         """GetDeviceOrigin() -> Point"""
         return _gdi.DC_GetDeviceOrigin(*args, **kwargs)
 
+    def GetDeviceOriginTuple(*args, **kwargs):
+        """GetDeviceOriginTuple() -> (x,y)"""
+        return _gdi.DC_GetDeviceOriginTuple(*args, **kwargs)
+
     def SetDeviceOrigin(*args, **kwargs):
         """SetDeviceOrigin(int x, int y)"""
         return _gdi.DC_SetDeviceOrigin(*args, **kwargs)
@@ -2457,7 +2475,7 @@ class DC(core.Object):
         return _gdi.DC_MaxY(*args, **kwargs)
 
     def GetBoundingBox(*args, **kwargs):
-        """GetBoundingBox(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT)"""
+        """GetBoundingBox() -> (x1,y1, x2,y2)"""
         return _gdi.DC_GetBoundingBox(*args, **kwargs)
 
     def __nonzero__(self): return self.Ok() 
@@ -2941,7 +2959,7 @@ class ImageList(core.Object):
         return _gdi.ImageList_RemoveAll(*args, **kwargs)
 
     def GetSize(*args, **kwargs):
-        """GetSize(int index, int OUTPUT, int OUTPUT)"""
+        """GetSize() -> (width,height)"""
         return _gdi.ImageList_GetSize(*args, **kwargs)
 
 

wxPython/src/mac/gdi_wrap.cpp

@@ -11251,44 +11251,6 @@ static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *self, PyObject *args,
 }
 
 
-static PyObject *_wrap_DC_GetSizeTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxDC *arg1 = (wxDC *) 0 ;
-    int *arg2 = (int *) 0 ;
-    int *arg3 = (int *) 0 ;
-    int temp2 ;
-    int temp3 ;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self", NULL 
-    };
-    
-    arg2 = &temp2;
-    arg3 = &temp3;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        (arg1)->GetSize(arg2,arg3);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    Py_INCREF(Py_None); resultobj = Py_None;
-    {
-        PyObject *o = PyInt_FromLong((long) (*arg2));
-        resultobj = t_output_helper(resultobj,o);
-    }
-    {
-        PyObject *o = PyInt_FromLong((long) (*arg3));
-        resultobj = t_output_helper(resultobj,o);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_DC_GetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -11318,7 +11280,7 @@ static PyObject *_wrap_DC_GetSize(PyObject *self, PyObject *args, PyObject *kwar
 }
 
 
-static PyObject *_wrap_DC_GetSizeMMWH(PyObject *self, PyObject *args, PyObject *kwargs) {
+static PyObject *_wrap_DC_GetSizeTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
     int *arg2 = (int *) 0 ;
@@ -11332,11 +11294,11 @@ static PyObject *_wrap_DC_GetSizeMMWH(PyObject *self, PyObject *args, PyObject *
     
     arg2 = &temp2;
     arg3 = &temp3;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMWH",kwnames,&obj0)) goto fail;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
     if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
     {
         PyThreadState* __tstate = wxPyBeginAllowThreads();
-        ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
+        (arg1)->GetSize(arg2,arg3);
         
         wxPyEndAllowThreads(__tstate);
         if (PyErr_Occurred()) SWIG_fail;
@@ -11385,6 +11347,44 @@ static PyObject *_wrap_DC_GetSizeMM(PyObject *self, PyObject *args, PyObject *kw
 }
 
 
+static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxDC *arg1 = (wxDC *) 0 ;
+    int *arg2 = (int *) 0 ;
+    int *arg3 = (int *) 0 ;
+    int temp2 ;
+    int temp3 ;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self", NULL 
+    };
+    
+    arg2 = &temp2;
+    arg3 = &temp3;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    Py_INCREF(Py_None); resultobj = Py_None;
+    {
+        PyObject *o = PyInt_FromLong((long) (*arg2));
+        resultobj = t_output_helper(resultobj,o);
+    }
+    {
+        PyObject *o = PyInt_FromLong((long) (*arg3));
+        resultobj = t_output_helper(resultobj,o);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -12155,6 +12155,35 @@ static PyObject *_wrap_DC_SetLogicalScale(PyObject *self, PyObject *args, PyObje
 }
 
 
+static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxDC *arg1 = (wxDC *) 0 ;
+    wxPoint result;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = ((wxDC const *)arg1)->GetLogicalOrigin();
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    {
+        wxPoint * resultptr;
+        resultptr = new wxPoint((wxPoint &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -12193,35 +12222,6 @@ static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *self, PyObject *args,
 }
 
 
-static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxDC *arg1 = (wxDC *) 0 ;
-    wxPoint result;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = ((wxDC const *)arg1)->GetLogicalOrigin();
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    {
-        wxPoint * resultptr;
-        resultptr = new wxPoint((wxPoint &) result);
-        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -12248,6 +12248,35 @@ static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *self, PyObject *args, PyObj
 }
 
 
+static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxDC *arg1 = (wxDC *) 0 ;
+    wxPoint result;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = ((wxDC const *)arg1)->GetDeviceOrigin();
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    {
+        wxPoint * resultptr;
+        resultptr = new wxPoint((wxPoint &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -12286,35 +12315,6 @@ static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *self, PyObject *args, P
 }
 
 
-static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxDC *arg1 = (wxDC *) 0 ;
-    wxPoint result;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = ((wxDC const *)arg1)->GetDeviceOrigin();
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    {
-        wxPoint * resultptr;
-        resultptr = new wxPoint((wxPoint &) result);
-        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -16089,10 +16089,10 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"DC_GetSizeMMWH", (PyCFunction) _wrap_DC_GetSizeMMWH, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS },
@@ -16121,11 +16121,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS },
@@ -17164,5 +17164,9 @@ SWIGEXPORT(void) SWIG_init(void) {
     SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
     SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
     SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
+    
+    // Work around a chicken/egg problem in drawlist.cpp
+    wxPyDrawList_SetAPIPtr();
+    
 }
 

wxPython/src/mac/grid.py

@@ -506,7 +506,7 @@ class GridCellChoiceEditor(GridCellEditor):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxGridCellChoiceEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(int LCOUNT=0, wxString choices=None, bool allowOthers=False) -> GridCellChoiceEditor"""
+        """__init__(int choices=0, wxString choices_array=None, bool allowOthers=False) -> GridCellChoiceEditor"""
         newobj = _grid.new_GridCellChoiceEditor(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -696,11 +696,11 @@ class GridCellAttr(object):
         return _grid.GridCellAttr_GetFont(*args, **kwargs)
 
     def GetAlignment(*args, **kwargs):
-        """GetAlignment(int OUTPUT, int OUTPUT)"""
+        """GetAlignment() -> (hAlign, vAlign)"""
         return _grid.GridCellAttr_GetAlignment(*args, **kwargs)
 
     def GetSize(*args, **kwargs):
-        """GetSize(int OUTPUT, int OUTPUT)"""
+        """GetSize() -> (num_rows, num_cols)"""
         return _grid.GridCellAttr_GetSize(*args, **kwargs)
 
     def GetOverflow(*args, **kwargs):
@@ -1314,7 +1314,7 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_DrawTextRectangle(*args, **kwargs)
 
     def GetTextBoxSize(*args, **kwargs):
-        """GetTextBoxSize(wxDC dc, wxArrayString lines, long OUTPUT, long OUTPUT)"""
+        """GetTextBoxSize(DC dc, list lines) -> (width, height)"""
         return _grid.Grid_GetTextBoxSize(*args, **kwargs)
 
     def BeginBatch(*args, **kwargs):
@@ -1494,11 +1494,11 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetLabelFont(*args, **kwargs)
 
     def GetRowLabelAlignment(*args, **kwargs):
-        """GetRowLabelAlignment(int OUTPUT, int OUTPUT)"""
+        """GetRowLabelAlignment() -> (horiz, vert)"""
         return _grid.Grid_GetRowLabelAlignment(*args, **kwargs)
 
     def GetColLabelAlignment(*args, **kwargs):
-        """GetColLabelAlignment(int OUTPUT, int OUTPUT)"""
+        """GetColLabelAlignment() -> (horiz, vert)"""
         return _grid.Grid_GetColLabelAlignment(*args, **kwargs)
 
     def GetColLabelTextOrientation(*args, **kwargs):
@@ -1698,11 +1698,11 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetCellFont(*args, **kwargs)
 
     def GetDefaultCellAlignment(*args, **kwargs):
-        """GetDefaultCellAlignment(int OUTPUT, int OUTPUT)"""
+        """GetDefaultCellAlignment() -> (horiz, vert)"""
         return _grid.Grid_GetDefaultCellAlignment(*args, **kwargs)
 
     def GetCellAlignment(*args, **kwargs):
-        """GetCellAlignment(int row, int col, int OUTPUT, int OUTPUT)"""
+        """GetCellAlignment() -> (horiz, vert)"""
         return _grid.Grid_GetCellAlignment(*args, **kwargs)
 
     def GetDefaultCellOverflow(*args, **kwargs):
@@ -1714,7 +1714,7 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetCellOverflow(*args, **kwargs)
 
     def GetCellSize(*args, **kwargs):
-        """GetCellSize(int row, int col, int OUTPUT, int OUTPUT)"""
+        """GetCellSize(int row, int col) -> (num_rows, num_cols)"""
         return _grid.Grid_GetCellSize(*args, **kwargs)
 
     def SetDefaultRowSize(*args, **kwargs):

wxPython/src/mac/grid_wrap.cpp

@@ -3151,18 +3151,22 @@ static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *self, PyObject *args,
     wxString *arg2 = (wxString *) NULL ;
     bool arg3 = (bool) False ;
     wxGridCellChoiceEditor *result;
+    PyObject * obj0 = 0 ;
     PyObject * obj1 = 0 ;
-    PyObject * obj2 = 0 ;
     char *kwnames[] = {
-        (char *) "LCOUNT",(char *) "choices",(char *) "allowOthers", NULL 
+        (char *) "choices",(char *) "allowOthers", NULL 
     };
     
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|iOO:new_GridCellChoiceEditor",kwnames,&arg1,&obj1,&obj2)) goto fail;
-    if (obj1) {
-        if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxString,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) goto fail;
+    if (obj0) {
+        {
+            arg1 = PyList_Size(obj0);
+            arg2 = wxString_LIST_helper(obj0);
+            if (arg2 == NULL) SWIG_fail;
+        }
     }
-    if (obj2) {
-        arg3 = PyInt_AsLong(obj2) ? true : false;
+    if (obj1) {
+        arg3 = PyInt_AsLong(obj1) ? true : false;
         if (PyErr_Occurred()) SWIG_fail;
     }
     {
@@ -3173,8 +3177,14 @@ static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *self, PyObject *args,
         if (PyErr_Occurred()) SWIG_fail;
     }
     resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_wxGridCellChoiceEditor, 1);
+    {
+        if (arg2) delete [] arg2;
+    }
     return resultobj;
     fail:
+    {
+        if (arg2) delete [] arg2;
+    }
     return NULL;
 }
 

wxPython/src/mac/html.py

@@ -27,6 +27,13 @@ HTML_INDENT_ALL = _html.HTML_INDENT_ALL
 HTML_COND_ISANCHOR = _html.HTML_COND_ISANCHOR
 HTML_COND_ISIMAGEMAP = _html.HTML_COND_ISIMAGEMAP
 HTML_COND_USER = _html.HTML_COND_USER
+HTML_FONT_SIZE_1 = _html.HTML_FONT_SIZE_1
+HTML_FONT_SIZE_2 = _html.HTML_FONT_SIZE_2
+HTML_FONT_SIZE_3 = _html.HTML_FONT_SIZE_3
+HTML_FONT_SIZE_4 = _html.HTML_FONT_SIZE_4
+HTML_FONT_SIZE_5 = _html.HTML_FONT_SIZE_5
+HTML_FONT_SIZE_6 = _html.HTML_FONT_SIZE_6
+HTML_FONT_SIZE_7 = _html.HTML_FONT_SIZE_7
 HW_SCROLLBAR_NEVER = _html.HW_SCROLLBAR_NEVER
 HW_SCROLLBAR_AUTO = _html.HW_SCROLLBAR_AUTO
 HW_NO_SELECTION = _html.HW_NO_SELECTION

wxPython/src/mac/html_wrap.cpp

@@ -10668,6 +10668,13 @@ static swig_const_info swig_const_table[] = {
 { SWIG_PY_INT,     (char *)"HTML_COND_ISANCHOR", (long) wxHTML_COND_ISANCHOR, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HTML_COND_ISIMAGEMAP", (long) wxHTML_COND_ISIMAGEMAP, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HTML_COND_USER", (long) wxHTML_COND_USER, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_1", (long) wxHTML_FONT_SIZE_1, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_2", (long) wxHTML_FONT_SIZE_2, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_3", (long) wxHTML_FONT_SIZE_3, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_4", (long) wxHTML_FONT_SIZE_4, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_5", (long) wxHTML_FONT_SIZE_5, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_6", (long) wxHTML_FONT_SIZE_6, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_7", (long) wxHTML_FONT_SIZE_7, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HW_SCROLLBAR_NEVER", (long) wxHW_SCROLLBAR_NEVER, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HW_SCROLLBAR_AUTO", (long) wxHW_SCROLLBAR_AUTO, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HW_NO_SELECTION", (long) wxHW_NO_SELECTION, 0, 0, 0},

wxPython/src/mac/misc.py

@@ -256,7 +256,7 @@ def GetElapsedTime(*args, **kwargs):
     return _misc.GetElapsedTime(*args, **kwargs)
 
 def GetMousePosition(*args, **kwargs):
-    """GetMousePosition(int OUTPUT, int OUTPUT)"""
+    """GetMousePosition() -> (x,y)"""
     return _misc.GetMousePosition(*args, **kwargs)
 
 def IsBusy(*args, **kwargs):
@@ -276,7 +276,7 @@ def StartTimer(*args, **kwargs):
     return _misc.StartTimer(*args, **kwargs)
 
 def GetOsVersion(*args, **kwargs):
-    """GetOsVersion(int OUTPUT, int OUTPUT) -> int"""
+    """GetOsVersion() -> (platform, major, minor)"""
     return _misc.GetOsVersion(*args, **kwargs)
 
 def GetOsDescription(*args, **kwargs):
@@ -420,7 +420,7 @@ def GetDisplayDepth(*args, **kwargs):
     return _misc.GetDisplayDepth(*args, **kwargs)
 
 def DisplaySize(*args, **kwargs):
-    """DisplaySize(int OUTPUT, int OUTPUT)"""
+    """DisplaySize() -> (width, height)"""
     return _misc.DisplaySize(*args, **kwargs)
 
 def GetDisplaySize(*args, **kwargs):
@@ -428,7 +428,7 @@ def GetDisplaySize(*args, **kwargs):
     return _misc.GetDisplaySize(*args, **kwargs)
 
 def DisplaySizeMM(*args, **kwargs):
-    """DisplaySizeMM(int OUTPUT, int OUTPUT)"""
+    """DisplaySizeMM() -> (width, height)"""
     return _misc.DisplaySizeMM(*args, **kwargs)
 
 def GetDisplaySizeMM(*args, **kwargs):
@@ -436,7 +436,7 @@ def GetDisplaySizeMM(*args, **kwargs):
     return _misc.GetDisplaySizeMM(*args, **kwargs)
 
 def ClientDisplayRect(*args, **kwargs):
-    """ClientDisplayRect(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT)"""
+    """ClientDisplayRect() -> (x, y, width, height)"""
     return _misc.ClientDisplayRect(*args, **kwargs)
 
 def GetClientDisplayRect(*args, **kwargs):
@@ -580,22 +580,22 @@ class Caret(object):
         """IsVisible() -> bool"""
         return _misc.Caret_IsVisible(*args, **kwargs)
 
-    def GetPositionTuple(*args, **kwargs):
-        """GetPositionTuple(int OUTPUT, int OUTPUT)"""
-        return _misc.Caret_GetPositionTuple(*args, **kwargs)
-
     def GetPosition(*args, **kwargs):
         """GetPosition() -> Point"""
         return _misc.Caret_GetPosition(*args, **kwargs)
 
-    def GetSizeTuple(*args, **kwargs):
-        """GetSizeTuple(int OUTPUT, int OUTPUT)"""
-        return _misc.Caret_GetSizeTuple(*args, **kwargs)
+    def GetPositionTuple(*args, **kwargs):
+        """GetPositionTuple() -> (x,y)"""
+        return _misc.Caret_GetPositionTuple(*args, **kwargs)
 
     def GetSize(*args, **kwargs):
         """GetSize() -> Size"""
         return _misc.Caret_GetSize(*args, **kwargs)
 
+    def GetSizeTuple(*args, **kwargs):
+        """GetSizeTuple() -> (width, height)"""
+        return _misc.Caret_GetSizeTuple(*args, **kwargs)
+
     def GetWindow(*args, **kwargs):
         """GetWindow() -> Window"""
         return _misc.Caret_GetWindow(*args, **kwargs)
@@ -624,6 +624,7 @@ class Caret(object):
         """Hide()"""
         return _misc.Caret_Hide(*args, **kwargs)
 
+    def __nonzero__(self): return self.IsOk() 
 
 class CaretPtr(Caret):
     def __init__(self, this):
@@ -934,12 +935,18 @@ class Timer(core.EvtHandler):
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
+        self._setCallbackInfo(self, Timer)
+
     def __del__(self, destroy=_misc.delete_Timer):
         """__del__()"""
         try:
             if self.thisown: destroy(self)
         except: pass
 
+    def _setCallbackInfo(*args, **kwargs):
+        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        return _misc.Timer__setCallbackInfo(*args, **kwargs)
+
     def SetOwner(*args, **kwargs):
         """SetOwner(EvtHandler owner, int id=-1)"""
         return _misc.Timer_SetOwner(*args, **kwargs)
@@ -952,10 +959,6 @@ class Timer(core.EvtHandler):
         """Stop()"""
         return _misc.Timer_Stop(*args, **kwargs)
 
-    def Notify(*args, **kwargs):
-        """Notify()"""
-        return _misc.Timer_Notify(*args, **kwargs)
-
     def IsRunning(*args, **kwargs):
         """IsRunning() -> bool"""
         return _misc.Timer_IsRunning(*args, **kwargs)
@@ -2902,12 +2905,12 @@ class DateTime(object):
 
     GetCentury = staticmethod(GetCentury)
     def GetNumberOfDaysinYear(*args, **kwargs):
-        """DateTime.GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> wxDateTime_t"""
+        """DateTime.GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> int"""
         return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
 
     GetNumberOfDaysinYear = staticmethod(GetNumberOfDaysinYear)
     def GetNumberOfDaysInMonth(*args, **kwargs):
-        """DateTime.GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> wxDateTime_t"""
+        """DateTime.GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> int"""
         return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
 
     GetNumberOfDaysInMonth = staticmethod(GetNumberOfDaysInMonth)
@@ -2922,7 +2925,9 @@ class DateTime(object):
 
     GetWeekDayName = staticmethod(GetWeekDayName)
     def GetAmPmStrings(*args, **kwargs):
-        """DateTime.GetAmPmStrings(wxString OUTPUT, wxString OUTPUT)"""
+        """GetAmPmStrings() -> (am, pm)
+
+Get the AM and PM strings in the current locale (may be empty)"""
         return _misc.DateTime_GetAmPmStrings(*args, **kwargs)
 
     GetAmPmStrings = staticmethod(GetAmPmStrings)
@@ -2981,14 +2986,13 @@ class DateTime(object):
         return _misc.DateTime_SetJDN(*args, **kwargs)
 
     def SetHMS(*args, **kwargs):
-        """SetHMS(wxDateTime_t hour, wxDateTime_t minute=0, wxDateTime_t second=0, 
-    wxDateTime_t millisec=0) -> DateTime"""
+        """SetHMS(int hour, int minute=0, int second=0, int millisec=0) -> DateTime"""
         return _misc.DateTime_SetHMS(*args, **kwargs)
 
     def Set(*args, **kwargs):
-        """Set(wxDateTime_t day, wxDateTime::Month month=Inv_Month, 
-    int year=Inv_Year, wxDateTime_t hour=0, wxDateTime_t minute=0, 
-    wxDateTime_t second=0, wxDateTime_t millisec=0) -> DateTime"""
+        """Set(int day, wxDateTime::Month month=Inv_Month, int year=Inv_Year, 
+    int hour=0, int minute=0, int second=0, 
+    int millisec=0) -> DateTime"""
         return _misc.DateTime_Set(*args, **kwargs)
 
     def ResetTime(*args, **kwargs):
@@ -3004,23 +3008,23 @@ class DateTime(object):
         return _misc.DateTime_SetMonth(*args, **kwargs)
 
     def SetDay(*args, **kwargs):
-        """SetDay(wxDateTime_t day) -> DateTime"""
+        """SetDay(int day) -> DateTime"""
         return _misc.DateTime_SetDay(*args, **kwargs)
 
     def SetHour(*args, **kwargs):
-        """SetHour(wxDateTime_t hour) -> DateTime"""
+        """SetHour(int hour) -> DateTime"""
         return _misc.DateTime_SetHour(*args, **kwargs)
 
     def SetMinute(*args, **kwargs):
-        """SetMinute(wxDateTime_t minute) -> DateTime"""
+        """SetMinute(int minute) -> DateTime"""
         return _misc.DateTime_SetMinute(*args, **kwargs)
 
     def SetSecond(*args, **kwargs):
-        """SetSecond(wxDateTime_t second) -> DateTime"""
+        """SetSecond(int second) -> DateTime"""
         return _misc.DateTime_SetSecond(*args, **kwargs)
 
     def SetMillisecond(*args, **kwargs):
-        """SetMillisecond(wxDateTime_t millisecond) -> DateTime"""
+        """SetMillisecond(int millisecond) -> DateTime"""
         return _misc.DateTime_SetMillisecond(*args, **kwargs)
 
     def SetToWeekDayInSameWeek(*args, **kwargs):
@@ -3063,13 +3067,11 @@ class DateTime(object):
         return _misc.DateTime_GetLastWeekDay(*args, **kwargs)
 
     def SetToTheWeek(*args, **kwargs):
-        """SetToTheWeek(wxDateTime_t numWeek, wxDateTime::WeekDay weekday=Mon, 
-    wxDateTime::WeekFlags flags=Monday_First) -> bool"""
+        """SetToTheWeek(int numWeek, wxDateTime::WeekDay weekday=Mon, wxDateTime::WeekFlags flags=Monday_First) -> bool"""
         return _misc.DateTime_SetToTheWeek(*args, **kwargs)
 
     def GetWeek(*args, **kwargs):
-        """GetWeek(wxDateTime_t numWeek, wxDateTime::WeekDay weekday=Mon, 
-    wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
+        """GetWeek(int numWeek, wxDateTime::WeekDay weekday=Mon, wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
         return _misc.DateTime_GetWeek(*args, **kwargs)
 
     def SetToLastMonthDay(*args, **kwargs):
@@ -3081,11 +3083,11 @@ class DateTime(object):
         return _misc.DateTime_GetLastMonthDay(*args, **kwargs)
 
     def SetToYearDay(*args, **kwargs):
-        """SetToYearDay(wxDateTime_t yday) -> DateTime"""
+        """SetToYearDay(int yday) -> DateTime"""
         return _misc.DateTime_SetToYearDay(*args, **kwargs)
 
     def GetYearDay(*args, **kwargs):
-        """GetYearDay(wxDateTime_t yday) -> DateTime"""
+        """GetYearDay(int yday) -> DateTime"""
         return _misc.DateTime_GetYearDay(*args, **kwargs)
 
     def GetJulianDayNumber(*args, **kwargs):
@@ -3145,7 +3147,7 @@ class DateTime(object):
         return _misc.DateTime_GetMonth(*args, **kwargs)
 
     def GetDay(*args, **kwargs):
-        """GetDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetDay(*args, **kwargs)
 
     def GetWeekDay(*args, **kwargs):
@@ -3153,31 +3155,31 @@ class DateTime(object):
         return _misc.DateTime_GetWeekDay(*args, **kwargs)
 
     def GetHour(*args, **kwargs):
-        """GetHour(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetHour(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetHour(*args, **kwargs)
 
     def GetMinute(*args, **kwargs):
-        """GetMinute(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetMinute(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetMinute(*args, **kwargs)
 
     def GetSecond(*args, **kwargs):
-        """GetSecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetSecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetSecond(*args, **kwargs)
 
     def GetMillisecond(*args, **kwargs):
-        """GetMillisecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetMillisecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetMillisecond(*args, **kwargs)
 
     def GetDayOfYear(*args, **kwargs):
-        """GetDayOfYear(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetDayOfYear(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetDayOfYear(*args, **kwargs)
 
     def GetWeekOfYear(*args, **kwargs):
-        """GetWeekOfYear(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetWeekOfYear(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetWeekOfYear(*args, **kwargs)
 
     def GetWeekOfMonth(*args, **kwargs):
-        """GetWeekOfMonth(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetWeekOfMonth(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetWeekOfMonth(*args, **kwargs)
 
     def IsWorkDay(*args, **kwargs):
@@ -3367,11 +3369,11 @@ def DateTime_GetCentury(*args, **kwargs):
     return _misc.DateTime_GetCentury(*args, **kwargs)
 
 def DateTime_GetNumberOfDaysinYear(*args, **kwargs):
-    """DateTime_GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> wxDateTime_t"""
+    """DateTime_GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> int"""
     return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
 
 def DateTime_GetNumberOfDaysInMonth(*args, **kwargs):
-    """DateTime_GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> wxDateTime_t"""
+    """DateTime_GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> int"""
     return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
 
 def DateTime_GetMonthName(*args, **kwargs):
@@ -3383,7 +3385,9 @@ def DateTime_GetWeekDayName(*args, **kwargs):
     return _misc.DateTime_GetWeekDayName(*args, **kwargs)
 
 def DateTime_GetAmPmStrings(*args, **kwargs):
-    """DateTime_GetAmPmStrings(wxString OUTPUT, wxString OUTPUT)"""
+    """GetAmPmStrings() -> (am, pm)
+
+Get the AM and PM strings in the current locale (may be empty)"""
     return _misc.DateTime_GetAmPmStrings(*args, **kwargs)
 
 def DateTime_IsDSTApplicable(*args, **kwargs):
@@ -3423,16 +3427,15 @@ def DateTimeFromJDN(*args, **kwargs):
     return val
 
 def DateTimeFromHMS(*args, **kwargs):
-    """DateTimeFromHMS(wxDateTime_t hour, wxDateTime_t minute=0, wxDateTime_t second=0, 
-    wxDateTime_t millisec=0) -> DateTime"""
+    """DateTimeFromHMS(int hour, int minute=0, int second=0, int millisec=0) -> DateTime"""
     val = _misc.new_DateTimeFromHMS(*args, **kwargs)
     val.thisown = 1
     return val
 
 def DateTimeFromDMY(*args, **kwargs):
-    """DateTimeFromDMY(wxDateTime_t day, wxDateTime::Month month=Inv_Month, 
-    int year=Inv_Year, wxDateTime_t hour=0, wxDateTime_t minute=0, 
-    wxDateTime_t second=0, wxDateTime_t millisec=0) -> DateTime"""
+    """DateTimeFromDMY(int day, wxDateTime::Month month=Inv_Month, int year=Inv_Year, 
+    int hour=0, int minute=0, int second=0, 
+    int millisec=0) -> DateTime"""
     val = _misc.new_DateTimeFromDMY(*args, **kwargs)
     val.thisown = 1
     return val

wxPython/src/mac/windows.py

@@ -91,9 +91,7 @@ class ScrolledWindow(Panel):
     def GetScrollPixelsPerUnit(*args, **kwargs):
         """GetScrollPixelsPerUnit() -> (xUnit, yUnit)
 
-
-        get the size of one logical unit in physical ones
-        """
+Get the size of one logical unit in physical units."""
         return _windows.ScrolledWindow_GetScrollPixelsPerUnit(*args, **kwargs)
 
     def EnableScrolling(*args, **kwargs):
@@ -101,7 +99,9 @@ class ScrolledWindow(Panel):
         return _windows.ScrolledWindow_EnableScrolling(*args, **kwargs)
 
     def GetViewStart(*args, **kwargs):
-        """GetViewStart(int OUTPUT, int OUTPUT)"""
+        """GetViewStart() -> (x,y)
+
+Get the view start"""
         return _windows.ScrolledWindow_GetViewStart(*args, **kwargs)
 
     def SetScale(*args, **kwargs):
@@ -117,13 +117,17 @@ class ScrolledWindow(Panel):
         return _windows.ScrolledWindow_GetScaleY(*args, **kwargs)
 
     def CalcScrolledPosition(*args):
-        """CalcScrolledPosition(int x, int y, int OUTPUT, int OUTPUT)
-CalcScrolledPosition(Point pt) -> Point"""
+        """CalcScrolledPosition(Point pt) -> Point
+CalcScrolledPosition(int x, int y) -> (sx, sy)
+
+Translate between scrolled and unscrolled coordinates."""
         return _windows.ScrolledWindow_CalcScrolledPosition(*args)
 
     def CalcUnscrolledPosition(*args):
-        """CalcUnscrolledPosition(int x, int y, int OUTPUT, int OUTPUT)
-CalcUnscrolledPosition(Point pt) -> Point"""
+        """CalcUnscrolledPosition(Point pt) -> Point
+CalcUnscrolledPosition(int x, int y) -> (ux, uy)
+
+Translate between scrolled and unscrolled coordinates."""
         return _windows.ScrolledWindow_CalcUnscrolledPosition(*args)
 
     def AdjustScrollbars(*args, **kwargs):
@@ -661,7 +665,7 @@ class StatusBar(core.Window):
         return _windows.StatusBar_SetStatusWidths(*args, **kwargs)
 
     def GetFieldRect(*args, **kwargs):
-        """GetFieldRect(int i, Rect rect) -> bool"""
+        """GetFieldRect(int i) -> Rect"""
         return _windows.StatusBar_GetFieldRect(*args, **kwargs)
 
     def SetMinHeight(*args, **kwargs):
@@ -2459,15 +2463,15 @@ class PyWindow(core.Window):
         return _windows.PyWindow_base_DoSetVirtualSize(*args, **kwargs)
 
     def base_DoGetSize(*args, **kwargs):
-        """base_DoGetSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetSize() -> (width, height)"""
         return _windows.PyWindow_base_DoGetSize(*args, **kwargs)
 
     def base_DoGetClientSize(*args, **kwargs):
-        """base_DoGetClientSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetClientSize() -> (width, height)"""
         return _windows.PyWindow_base_DoGetClientSize(*args, **kwargs)
 
     def base_DoGetPosition(*args, **kwargs):
-        """base_DoGetPosition(int OUTPUT, int OUTPUT)"""
+        """base_DoGetPosition() -> (x,y)"""
         return _windows.PyWindow_base_DoGetPosition(*args, **kwargs)
 
     def base_DoGetVirtualSize(*args, **kwargs):
@@ -2556,15 +2560,15 @@ class PyPanel(Panel):
         return _windows.PyPanel_base_DoSetVirtualSize(*args, **kwargs)
 
     def base_DoGetSize(*args, **kwargs):
-        """base_DoGetSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetSize() -> (width, height)"""
         return _windows.PyPanel_base_DoGetSize(*args, **kwargs)
 
     def base_DoGetClientSize(*args, **kwargs):
-        """base_DoGetClientSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetClientSize() -> (width, height)"""
         return _windows.PyPanel_base_DoGetClientSize(*args, **kwargs)
 
     def base_DoGetPosition(*args, **kwargs):
-        """base_DoGetPosition(int OUTPUT, int OUTPUT)"""
+        """base_DoGetPosition() -> (x,y)"""
         return _windows.PyPanel_base_DoGetPosition(*args, **kwargs)
 
     def base_DoGetVirtualSize(*args, **kwargs):
@@ -3256,20 +3260,20 @@ class Printout(core.Object):
         """SetDC(wxDC dc)"""
         return _windows.Printout_SetDC(*args, **kwargs)
 
-    def GetPageSizePixels(*args, **kwargs):
-        """GetPageSizePixels(int OUTPUT, int OUTPUT)"""
-        return _windows.Printout_GetPageSizePixels(*args, **kwargs)
-
     def SetPageSizePixels(*args, **kwargs):
         """SetPageSizePixels(int w, int h)"""
         return _windows.Printout_SetPageSizePixels(*args, **kwargs)
 
+    def GetPageSizePixels(*args, **kwargs):
+        """GetPageSizePixels() -> (w, h)"""
+        return _windows.Printout_GetPageSizePixels(*args, **kwargs)
+
     def SetPageSizeMM(*args, **kwargs):
         """SetPageSizeMM(int w, int h)"""
         return _windows.Printout_SetPageSizeMM(*args, **kwargs)
 
     def GetPageSizeMM(*args, **kwargs):
-        """GetPageSizeMM(int OUTPUT, int OUTPUT)"""
+        """GetPageSizeMM() -> (w, h)"""
         return _windows.Printout_GetPageSizeMM(*args, **kwargs)
 
     def SetPPIScreen(*args, **kwargs):
@@ -3277,7 +3281,7 @@ class Printout(core.Object):
         return _windows.Printout_SetPPIScreen(*args, **kwargs)
 
     def GetPPIScreen(*args, **kwargs):
-        """GetPPIScreen(int OUTPUT, int OUTPUT)"""
+        """GetPPIScreen() -> (x,y)"""
         return _windows.Printout_GetPPIScreen(*args, **kwargs)
 
     def SetPPIPrinter(*args, **kwargs):
@@ -3285,7 +3289,7 @@ class Printout(core.Object):
         return _windows.Printout_SetPPIPrinter(*args, **kwargs)
 
     def GetPPIPrinter(*args, **kwargs):
-        """GetPPIPrinter(int OUTPUT, int OUTPUT)"""
+        """GetPPIPrinter() -> (x,y)"""
         return _windows.Printout_GetPPIPrinter(*args, **kwargs)
 
     def IsPreview(*args, **kwargs):
@@ -3316,14 +3320,14 @@ class Printout(core.Object):
         """base_OnPreparePrinting()"""
         return _windows.Printout_base_OnPreparePrinting(*args, **kwargs)
 
-    def base_GetPageInfo(*args, **kwargs):
-        """base_GetPageInfo(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT)"""
-        return _windows.Printout_base_GetPageInfo(*args, **kwargs)
-
     def base_HasPage(*args, **kwargs):
         """base_HasPage(int page) -> bool"""
         return _windows.Printout_base_HasPage(*args, **kwargs)
 
+    def base_GetPageInfo(*args, **kwargs):
+        """base_GetPageInfo() -> (minPage, maxPage, pageFrom, pageTo)"""
+        return _windows.Printout_base_GetPageInfo(*args, **kwargs)
+
 
 class PrintoutPtr(Printout):
     def __init__(self, this):

wxPython/src/mac/windows_wrap.cpp

@@ -365,6 +365,11 @@ bool wxDialog_IsModalShowing(wxDialog *self){
         }
 
 
+wxRect wxStatusBar_GetFieldRect(wxStatusBar *self,int i){
+            wxRect r;
+            self->GetFieldRect(i, r);
+            return r;
+        }
 
     static const wxChar* wxSplitterNameStr = wxT("splitter");
     DECLARE_DEF_STRING(SplitterNameStr);
@@ -1661,6 +1666,39 @@ static PyObject *_wrap_ScrolledWindow_GetScaleY(PyObject *self, PyObject *args,
 
 
 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(PyObject *self, PyObject *args) {
+    PyObject *resultobj;
+    wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
+    wxPoint *arg2 = 0 ;
+    wxPoint result;
+    wxPoint temp2 ;
+    PyObject * obj0 = 0 ;
+    PyObject * obj1 = 0 ;
+    
+    if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxScrolledWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        arg2 = &temp2;
+        if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
+    }
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = ((wxScrolledWindow const *)arg1)->CalcScrolledPosition((wxPoint const &)*arg2);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    {
+        wxPoint * resultptr;
+        resultptr = new wxPoint((wxPoint &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
+static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(PyObject *self, PyObject *args) {
     PyObject *resultobj;
     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
     int arg2 ;
@@ -1697,39 +1735,6 @@ static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(PyObject *sel
 }
 
 
-static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(PyObject *self, PyObject *args) {
-    PyObject *resultobj;
-    wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
-    wxPoint *arg2 = 0 ;
-    wxPoint result;
-    wxPoint temp2 ;
-    PyObject * obj0 = 0 ;
-    PyObject * obj1 = 0 ;
-    
-    if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxScrolledWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        arg2 = &temp2;
-        if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
-    }
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = ((wxScrolledWindow const *)arg1)->CalcScrolledPosition((wxPoint const &)*arg2);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    {
-        wxPoint * resultptr;
-        resultptr = new wxPoint((wxPoint &) result);
-        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObject *args) {
     int argc;
     PyObject *argv[4];
@@ -1755,7 +1760,7 @@ static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObj
                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
             }
             if (_v) {
-                return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(self,args);
+                return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(self,args);
             }
         }
     }
@@ -1779,7 +1784,7 @@ static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObj
                     _v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
                 }
                 if (_v) {
-                    return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(self,args);
+                    return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(self,args);
                 }
             }
         }
@@ -1791,6 +1796,39 @@ static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObj
 
 
 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(PyObject *self, PyObject *args) {
+    PyObject *resultobj;
+    wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
+    wxPoint *arg2 = 0 ;
+    wxPoint result;
+    wxPoint temp2 ;
+    PyObject * obj0 = 0 ;
+    PyObject * obj1 = 0 ;
+    
+    if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxScrolledWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        arg2 = &temp2;
+        if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
+    }
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition((wxPoint const &)*arg2);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    {
+        wxPoint * resultptr;
+        resultptr = new wxPoint((wxPoint &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
+static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(PyObject *self, PyObject *args) {
     PyObject *resultobj;
     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
     int arg2 ;
@@ -1827,39 +1865,6 @@ static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(PyObject *s
 }
 
 
-static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(PyObject *self, PyObject *args) {
-    PyObject *resultobj;
-    wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
-    wxPoint *arg2 = 0 ;
-    wxPoint result;
-    wxPoint temp2 ;
-    PyObject * obj0 = 0 ;
-    PyObject * obj1 = 0 ;
-    
-    if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxScrolledWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        arg2 = &temp2;
-        if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
-    }
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition((wxPoint const &)*arg2);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    {
-        wxPoint * resultptr;
-        resultptr = new wxPoint((wxPoint &) result);
-        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition(PyObject *self, PyObject *args) {
     int argc;
     PyObject *argv[4];
@@ -1885,7 +1890,7 @@ static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition(PyObject *self, PyO
                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
             }
             if (_v) {
-                return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(self,args);
+                return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(self,args);
             }
         }
     }
@@ -1909,7 +1914,7 @@ static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition(PyObject *self, PyO
                     _v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
                 }
                 if (_v) {
-                    return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(self,args);
+                    return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(self,args);
                 }
             }
         }
@@ -4903,29 +4908,26 @@ static PyObject *_wrap_StatusBar_GetFieldRect(PyObject *self, PyObject *args, Py
     PyObject *resultobj;
     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
     int arg2 ;
-    wxRect *arg3 = 0 ;
-    bool result;
-    wxRect temp3 ;
+    wxRect result;
     PyObject * obj0 = 0 ;
-    PyObject * obj2 = 0 ;
     char *kwnames[] = {
-        (char *) "self",(char *) "i",(char *) "rect", NULL 
+        (char *) "self",(char *) "i", NULL 
     };
     
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OiO:StatusBar_GetFieldRect",kwnames,&obj0,&arg2,&obj2)) goto fail;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oi:StatusBar_GetFieldRect",kwnames,&obj0,&arg2)) goto fail;
     if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxStatusBar,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        arg3 = &temp3;
-        if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
-    }
     {
         PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = (bool)((wxStatusBar const *)arg1)->GetFieldRect(arg2,*arg3);
+        result = wxStatusBar_GetFieldRect(arg1,arg2);
         
         wxPyEndAllowThreads(__tstate);
         if (PyErr_Occurred()) SWIG_fail;
     }
-    resultobj = PyInt_FromLong((long)result);
+    {
+        wxRect * resultptr;
+        resultptr = new wxRect((wxRect &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxRect, 1);
+    }
     return resultobj;
     fail:
     return NULL;
@@ -18296,6 +18298,32 @@ static PyObject *_wrap_Printout_SetDC(PyObject *self, PyObject *args, PyObject *
 }
 
 
+static PyObject *_wrap_Printout_SetPageSizePixels(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
+    int arg2 ;
+    int arg3 ;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self",(char *) "w",(char *) "h", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oii:Printout_SetPageSizePixels",kwnames,&obj0,&arg2,&arg3)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyPrintout,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        (arg1)->SetPageSizePixels(arg2,arg3);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    Py_INCREF(Py_None); resultobj = Py_None;
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_Printout_GetPageSizePixels(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
@@ -18334,32 +18362,6 @@ static PyObject *_wrap_Printout_GetPageSizePixels(PyObject *self, PyObject *args
 }
 
 
-static PyObject *_wrap_Printout_SetPageSizePixels(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
-    int arg2 ;
-    int arg3 ;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self",(char *) "w",(char *) "h", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oii:Printout_SetPageSizePixels",kwnames,&obj0,&arg2,&arg3)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyPrintout,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        (arg1)->SetPageSizePixels(arg2,arg3);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    Py_INCREF(Py_None); resultobj = Py_None;
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_Printout_SetPageSizeMM(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
@@ -18728,6 +18730,32 @@ static PyObject *_wrap_Printout_base_OnPreparePrinting(PyObject *self, PyObject
 }
 
 
+static PyObject *_wrap_Printout_base_HasPage(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
+    int arg2 ;
+    bool result;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self",(char *) "page", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oi:Printout_base_HasPage",kwnames,&obj0,&arg2)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyPrintout,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = (bool)(arg1)->base_HasPage(arg2);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    resultobj = PyInt_FromLong((long)result);
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_Printout_base_GetPageInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
@@ -18780,32 +18808,6 @@ static PyObject *_wrap_Printout_base_GetPageInfo(PyObject *self, PyObject *args,
 }
 
 
-static PyObject *_wrap_Printout_base_HasPage(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
-    int arg2 ;
-    bool result;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self",(char *) "page", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oi:Printout_base_HasPage",kwnames,&obj0,&arg2)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyPrintout,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = (bool)(arg1)->base_HasPage(arg2);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    resultobj = PyInt_FromLong((long)result);
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject * Printout_swigregister(PyObject *self, PyObject *args) {
     PyObject *obj;
     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
@@ -21266,8 +21268,8 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"Printout_GetTitle", (PyCFunction) _wrap_Printout_GetTitle, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_GetDC", (PyCFunction) _wrap_Printout_GetDC, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_SetDC", (PyCFunction) _wrap_Printout_SetDC, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"Printout_GetPageSizePixels", (PyCFunction) _wrap_Printout_GetPageSizePixels, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_SetPageSizePixels", (PyCFunction) _wrap_Printout_SetPageSizePixels, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"Printout_GetPageSizePixels", (PyCFunction) _wrap_Printout_GetPageSizePixels, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_SetPageSizeMM", (PyCFunction) _wrap_Printout_SetPageSizeMM, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_GetPageSizeMM", (PyCFunction) _wrap_Printout_GetPageSizeMM, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_SetPPIScreen", (PyCFunction) _wrap_Printout_SetPPIScreen, METH_VARARGS | METH_KEYWORDS },
@@ -21281,8 +21283,8 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"Printout_base_OnBeginPrinting", (PyCFunction) _wrap_Printout_base_OnBeginPrinting, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_base_OnEndPrinting", (PyCFunction) _wrap_Printout_base_OnEndPrinting, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_base_OnPreparePrinting", (PyCFunction) _wrap_Printout_base_OnPreparePrinting, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"Printout_base_GetPageInfo", (PyCFunction) _wrap_Printout_base_GetPageInfo, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_base_HasPage", (PyCFunction) _wrap_Printout_base_HasPage, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"Printout_base_GetPageInfo", (PyCFunction) _wrap_Printout_base_GetPageInfo, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_swigregister", Printout_swigregister, METH_VARARGS },
 	 { (char *)"new_PreviewCanvas", (PyCFunction) _wrap_new_PreviewCanvas, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PreviewCanvas_swigregister", PreviewCanvas_swigregister, METH_VARARGS },

wxPython/src/mac/wizard.py

@@ -111,15 +111,15 @@ class PyWizardPage(WizardPage):
         return _wizard.PyWizardPage_base_DoSetVirtualSize(*args, **kwargs)
 
     def base_DoGetSize(*args, **kwargs):
-        """base_DoGetSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetSize() -> (width, height)"""
         return _wizard.PyWizardPage_base_DoGetSize(*args, **kwargs)
 
     def base_DoGetClientSize(*args, **kwargs):
-        """base_DoGetClientSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetClientSize() -> (width, height)"""
         return _wizard.PyWizardPage_base_DoGetClientSize(*args, **kwargs)
 
     def base_DoGetPosition(*args, **kwargs):
-        """base_DoGetPosition(int OUTPUT, int OUTPUT)"""
+        """base_DoGetPosition() -> (x,y)"""
         return _wizard.PyWizardPage_base_DoGetPosition(*args, **kwargs)
 
     def base_DoGetVirtualSize(*args, **kwargs):

wxPython/src/msw/controls.py

@@ -1005,7 +1005,9 @@ class TextCtrl(core.Control):
         return _controls.TextCtrl_IsMultiLine(*args, **kwargs)
 
     def GetSelection(*args, **kwargs):
-        """GetSelection(long OUTPUT, long OUTPUT)"""
+        """GetSelection() -> (from, to)
+
+If the return values from and to are the same, there is no selection."""
         return _controls.TextCtrl_GetSelection(*args, **kwargs)
 
     def GetStringSelection(*args, **kwargs):
@@ -1077,7 +1079,7 @@ class TextCtrl(core.Control):
         return _controls.TextCtrl_XYToPosition(*args, **kwargs)
 
     def PositionToXY(*args, **kwargs):
-        """PositionToXY(long pos, long OUTPUT, long OUTPUT)"""
+        """PositionToXY(long pos) -> (x, y)"""
         return _controls.TextCtrl_PositionToXY(*args, **kwargs)
 
     def ShowPosition(*args, **kwargs):
@@ -1913,7 +1915,9 @@ class Notebook(BookCtrl):
         return _controls.Notebook_SetTabSize(*args, **kwargs)
 
     def HitTest(*args, **kwargs):
-        """HitTest(Point pt, long OUTPUT) -> int"""
+        """HitTest(Point pt) -> (tab, where)
+
+Returns the tab which is hit, and flags indicating where using wxNB_HITTEST_ flags."""
         return _controls.Notebook_HitTest(*args, **kwargs)
 
     def CalcSizeFromPage(*args, **kwargs):
@@ -3267,7 +3271,10 @@ class ListCtrl(core.Control):
         return _controls.ListCtrl_FindItemAtPos(*args, **kwargs)
 
     def HitTest(*args, **kwargs):
-        """HitTest(Point point, int OUTPUT) -> long"""
+        """HitTest(Point point) -> (item, where)
+
+Determines which item (if any) is at the specified point,
+giving details in the second return value (see wxLIST_HITTEST_... flags.)"""
         return _controls.ListCtrl_HitTest(*args, **kwargs)
 
     def InsertItem(*args, **kwargs):
@@ -4004,7 +4011,13 @@ class TreeCtrl(core.Control):
         return _controls.TreeCtrl_SortChildren(*args, **kwargs)
 
     def HitTest(*args, **kwargs):
-        """HitTest(Point point, int OUTPUT) -> TreeItemId"""
+        """HitTest(Point point) -> (item, where)
+
+Determine which item (if any) belongs the given point.  The
+coordinates specified are relative to the client area of tree ctrl
+and the where return value is set to a bitmask of wxTREE_HITTEST_xxx
+constants.
+"""
         return _controls.TreeCtrl_HitTest(*args, **kwargs)
 
     def GetBoundingRect(*args, **kwargs):
@@ -4117,7 +4130,12 @@ class GenericDirCtrl(core.Control):
         return _controls.GenericDirCtrl_GetFilterListCtrl(*args, **kwargs)
 
     def FindChild(*args, **kwargs):
-        """FindChild(TreeItemId parentId, wxString path, bool OUTPUT) -> TreeItemId"""
+        """FindChild(wxTreeItemId parentId, wxString path) -> (item, done)
+
+Find the child that matches the first part of 'path'.  E.g. if a child path is
+"/usr" and 'path' is "/usr/include" then the child for /usr is returned.
+If the path string has been used (we're at the leaf), done is set to True
+"""
         return _controls.GenericDirCtrl_FindChild(*args, **kwargs)
 
     def DoResize(*args, **kwargs):
@@ -4215,15 +4233,15 @@ class PyControl(core.Control):
         return _controls.PyControl_base_DoSetVirtualSize(*args, **kwargs)
 
     def base_DoGetSize(*args, **kwargs):
-        """base_DoGetSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetSize() -> (width, height)"""
         return _controls.PyControl_base_DoGetSize(*args, **kwargs)
 
     def base_DoGetClientSize(*args, **kwargs):
-        """base_DoGetClientSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetClientSize() -> (width, height)"""
         return _controls.PyControl_base_DoGetClientSize(*args, **kwargs)
 
     def base_DoGetPosition(*args, **kwargs):
-        """base_DoGetPosition(int OUTPUT, int OUTPUT)"""
+        """base_DoGetPosition() -> (x,y)"""
         return _controls.PyControl_base_DoGetPosition(*args, **kwargs)
 
     def base_DoGetVirtualSize(*args, **kwargs):

wxPython/src/msw/core.py

@@ -4396,105 +4396,177 @@ class PyApp(EvtHandler):
         return _core.PyApp__setCallbackInfo(*args, **kwargs)
 
     def GetAppName(*args, **kwargs):
-        """GetAppName() -> wxString"""
+        """GetAppName() -> wxString
+
+Get the application name."""
         return _core.PyApp_GetAppName(*args, **kwargs)
 
     def SetAppName(*args, **kwargs):
-        """SetAppName(wxString name)"""
+        """SetAppName(wxString name)
+
+Set the application name. This value may be used automatically
+by wxConfig and such."""
         return _core.PyApp_SetAppName(*args, **kwargs)
 
     def GetClassName(*args, **kwargs):
         """GetClassName() -> wxString
 
-Returns the class name of the C++ object using wxRTTI."""
+Get the application's class name."""
         return _core.PyApp_GetClassName(*args, **kwargs)
 
     def SetClassName(*args, **kwargs):
-        """SetClassName(wxString name)"""
+        """SetClassName(wxString name)
+
+Set the application's class name. This value may be used for X-resources if
+applicable for the platform"""
         return _core.PyApp_SetClassName(*args, **kwargs)
 
     def GetVendorName(*args, **kwargs):
-        """GetVendorName() -> wxString"""
+        """GetVendorName() -> wxString
+
+Get the application's vendor name."""
         return _core.PyApp_GetVendorName(*args, **kwargs)
 
     def SetVendorName(*args, **kwargs):
-        """SetVendorName(wxString name)"""
+        """SetVendorName(wxString name)
+
+Set the application's vendor name. This value may be used automatically
+by wxConfig and such."""
         return _core.PyApp_SetVendorName(*args, **kwargs)
 
     def GetTraits(*args, **kwargs):
-        """GetTraits() -> wxAppTraits"""
+        """GetTraits() -> wxAppTraits
+
+Create the app traits object to which we delegate for everything which either
+should be configurable by the user (then he can change the default behaviour
+simply by overriding CreateTraits() and returning his own traits object) or
+which is GUI/console dependent as then wxAppTraits allows us to abstract the
+differences behind the common facade"""
         return _core.PyApp_GetTraits(*args, **kwargs)
 
     def ProcessPendingEvents(*args, **kwargs):
-        """ProcessPendingEvents()"""
+        """ProcessPendingEvents()
+
+Process all events in the wxPendingEvents list -- it is necessary to call this
+function to process posted events. This happens during each event loop
+iteration."""
         return _core.PyApp_ProcessPendingEvents(*args, **kwargs)
 
     def Yield(*args, **kwargs):
-        """Yield(bool onlyIfNeeded=False) -> bool"""
+        """Yield(bool onlyIfNeeded=False) -> bool
+
+Process all currently pending events right now, instead of waiting until
+return to the event loop.  It is an error to call Yield() recursively unless
+the value of onlyIfNeeded is True.
+
+WARNING: This function is dangerous as it can lead to unexpected
+         reentrancies (i.e. when called from an event handler it
+         may result in calling the same event handler again), use
+         with _extreme_ care or, better, don't use at all!
+"""
         return _core.PyApp_Yield(*args, **kwargs)
 
     def WakeUpIdle(*args, **kwargs):
-        """WakeUpIdle()"""
+        """WakeUpIdle()
+
+Make sure that idle events are sent again"""
         return _core.PyApp_WakeUpIdle(*args, **kwargs)
 
     def MainLoop(*args, **kwargs):
-        """MainLoop() -> int"""
+        """MainLoop() -> int
+
+Execute the main GUI loop, the function returns when the loop ends."""
         return _core.PyApp_MainLoop(*args, **kwargs)
 
     def Exit(*args, **kwargs):
-        """Exit()"""
+        """Exit()
+
+Exit the main loop thus terminating the application."""
         return _core.PyApp_Exit(*args, **kwargs)
 
     def ExitMainLoop(*args, **kwargs):
-        """ExitMainLoop()"""
+        """ExitMainLoop()
+
+Exit the main GUI loop during the next iteration (i.e. it does not
+stop the program immediately!)"""
         return _core.PyApp_ExitMainLoop(*args, **kwargs)
 
     def Pending(*args, **kwargs):
-        """Pending() -> bool"""
+        """Pending() -> bool
+
+Returns True if there are unprocessed events in the event queue."""
         return _core.PyApp_Pending(*args, **kwargs)
 
     def Dispatch(*args, **kwargs):
-        """Dispatch() -> bool"""
+        """Dispatch() -> bool
+
+Process the first event in the event queue (blocks until an event
+appears if there are none currently)"""
         return _core.PyApp_Dispatch(*args, **kwargs)
 
     def ProcessIdle(*args, **kwargs):
-        """ProcessIdle() -> bool"""
+        """ProcessIdle() -> bool
+
+Called from the MainLoop when the application becomes idle and sends an
+IdleEvent to all interested parties.  Returns True is more idle events are
+needed, False if not."""
         return _core.PyApp_ProcessIdle(*args, **kwargs)
 
     def SendIdleEvents(*args, **kwargs):
-        """SendIdleEvents(Window win, IdleEvent event) -> bool"""
+        """SendIdleEvents(Window win, IdleEvent event) -> bool
+
+Send idle event to window and all subwindows.  Returns True if more idle time
+is requested."""
         return _core.PyApp_SendIdleEvents(*args, **kwargs)
 
-    def OnIdle(*args, **kwargs):
-        """OnIdle(IdleEvent event)"""
-        return _core.PyApp_OnIdle(*args, **kwargs)
-
     def IsActive(*args, **kwargs):
-        """IsActive() -> bool"""
+        """IsActive() -> bool
+
+Return True if our app has focus."""
         return _core.PyApp_IsActive(*args, **kwargs)
 
     def SetTopWindow(*args, **kwargs):
-        """SetTopWindow(Window win)"""
+        """SetTopWindow(Window win)
+
+Set the "main" top level window"""
         return _core.PyApp_SetTopWindow(*args, **kwargs)
 
     def GetTopWindow(*args, **kwargs):
-        """GetTopWindow() -> Window"""
+        """GetTopWindow() -> Window
+
+Return the "main" top level window (if it hadn't been set previously with
+SetTopWindow(), will return just some top level window and, if there not any,
+will return None)"""
         return _core.PyApp_GetTopWindow(*args, **kwargs)
 
     def SetExitOnFrameDelete(*args, **kwargs):
-        """SetExitOnFrameDelete(bool flag)"""
+        """SetExitOnFrameDelete(bool flag)
+
+Control the exit behaviour: by default, the program will exit the main loop
+(and so, usually, terminate) when the last top-level program window is
+deleted.  Beware that if you disable this behaviour (with
+SetExitOnFrameDelete(False)), you'll have to call ExitMainLoop() explicitly
+from somewhere.
+"""
         return _core.PyApp_SetExitOnFrameDelete(*args, **kwargs)
 
     def GetExitOnFrameDelete(*args, **kwargs):
-        """GetExitOnFrameDelete() -> bool"""
+        """GetExitOnFrameDelete() -> bool
+
+Get the current exit behaviour setting."""
         return _core.PyApp_GetExitOnFrameDelete(*args, **kwargs)
 
     def SetUseBestVisual(*args, **kwargs):
-        """SetUseBestVisual(bool flag)"""
+        """SetUseBestVisual(bool flag)
+
+Set whether the app should try to use the best available visual on systems
+where more than one is available, (Sun, SGI, XFree86 4, etc.)"""
         return _core.PyApp_SetUseBestVisual(*args, **kwargs)
 
     def GetUseBestVisual(*args, **kwargs):
-        """GetUseBestVisual() -> bool"""
+        """GetUseBestVisual() -> bool
+
+Get current UseBestVisual setting."""
         return _core.PyApp_GetUseBestVisual(*args, **kwargs)
 
     def SetPrintMode(*args, **kwargs):
@@ -4505,14 +4577,25 @@ Returns the class name of the C++ object using wxRTTI."""
         """GetPrintMode() -> int"""
         return _core.PyApp_GetPrintMode(*args, **kwargs)
 
-    def GetAssertMode(*args, **kwargs):
-        """GetAssertMode() -> int"""
-        return _core.PyApp_GetAssertMode(*args, **kwargs)
-
     def SetAssertMode(*args, **kwargs):
-        """SetAssertMode(int mode)"""
+        """SetAssertMode(int mode)
+
+Set the OnAssert behaviour for debug and hybrid builds.  The following flags
+may be or'd together:
+
+ wxPYAPP_ASSERT_SUPPRESS         Don't do anything
+ wxPYAPP_ASSERT_EXCEPTION        Turn it into a Python exception if possible (default)
+ wxPYAPP_ASSERT_DIALOG           Display a message dialog
+ wxPYAPP_ASSERT_LOG              Write the assertion info to the wxLog
+"""
         return _core.PyApp_SetAssertMode(*args, **kwargs)
 
+    def GetAssertMode(*args, **kwargs):
+        """GetAssertMode() -> int
+
+Get the current OnAssert behaviour setting."""
+        return _core.PyApp_GetAssertMode(*args, **kwargs)
+
     def GetMacSupportPCMenuShortcuts(*args, **kwargs):
         """PyApp.GetMacSupportPCMenuShortcuts() -> bool"""
         return _core.PyApp_GetMacSupportPCMenuShortcuts(*args, **kwargs)
@@ -4564,11 +4647,16 @@ Returns the class name of the C++ object using wxRTTI."""
 
     SetMacHelpMenuTitleName = staticmethod(SetMacHelpMenuTitleName)
     def _BootstrapApp(*args, **kwargs):
-        """_BootstrapApp()"""
+        """_BootstrapApp()
+
+For internal use only"""
         return _core.PyApp__BootstrapApp(*args, **kwargs)
 
     def GetComCtl32Version(*args, **kwargs):
-        """PyApp.GetComCtl32Version() -> int"""
+        """PyApp.GetComCtl32Version() -> int
+
+Returns 400, 470, 471 for comctl32.dll 4.00, 4.70, 4.71 or 0 if it
+wasn't found at all.  Raises an exception on non-Windows platforms."""
         return _core.PyApp_GetComCtl32Version(*args, **kwargs)
 
     GetComCtl32Version = staticmethod(GetComCtl32Version)
@@ -4621,91 +4709,135 @@ def PyApp_SetMacHelpMenuTitleName(*args, **kwargs):
     return _core.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
 
 def PyApp_GetComCtl32Version(*args, **kwargs):
-    """PyApp_GetComCtl32Version() -> int"""
+    """PyApp_GetComCtl32Version() -> int
+
+Returns 400, 470, 471 for comctl32.dll 4.00, 4.70, 4.71 or 0 if it
+wasn't found at all.  Raises an exception on non-Windows platforms."""
     return _core.PyApp_GetComCtl32Version(*args, **kwargs)
 
 #---------------------------------------------------------------------------
 
 
 def Exit(*args, **kwargs):
-    """Exit()"""
+    """Exit()
+
+Force an exit of the application.  Convenience for wx.GetApp().Exit()"""
     return _core.Exit(*args, **kwargs)
 
 def Yield(*args, **kwargs):
-    """Yield() -> bool"""
+    """Yield() -> bool
+
+Yield to other apps/messages.  Convenience for wx.GetApp().Yield()"""
     return _core.Yield(*args, **kwargs)
 
 def YieldIfNeeded(*args, **kwargs):
-    """YieldIfNeeded() -> bool"""
+    """YieldIfNeeded() -> bool
+
+Yield to other apps/messages.  Convenience for wx.GetApp().Yield(True)"""
     return _core.YieldIfNeeded(*args, **kwargs)
 
 def SafeYield(*args, **kwargs):
-    """SafeYield(Window win=None, bool onlyIfNeeded=False) -> bool"""
+    """SafeYield(Window win=None, bool onlyIfNeeded=False) -> bool
+
+This function is similar to wx.Yield, except that it disables the user input
+to all program windows before calling wx.Yield and re-enables it again
+afterwards. If win is not None, this window will remain enabled, allowing the
+implementation of some limited user interaction.
+
+Returns the result of the call to wx.Yield."""
     return _core.SafeYield(*args, **kwargs)
 
 def WakeUpIdle(*args, **kwargs):
-    """WakeUpIdle()"""
+    """WakeUpIdle()
+
+Cause the message queue to become empty again, so idle events will be sent."""
     return _core.WakeUpIdle(*args, **kwargs)
 
 def PostEvent(*args, **kwargs):
-    """PostEvent(EvtHandler dest, Event event)"""
+    """PostEvent(EvtHandler dest, Event event)
+
+Send an event to a window or other wx.EvtHandler to be processed later."""
     return _core.PostEvent(*args, **kwargs)
 
 def App_CleanUp(*args, **kwargs):
-    """App_CleanUp()"""
+    """App_CleanUp()
+
+For internal use only, it is used to cleanup after wxWindows when Python shuts down."""
     return _core.App_CleanUp(*args, **kwargs)
 
 def GetApp(*args, **kwargs):
-    """GetApp() -> PyApp"""
+    """GetApp() -> PyApp
+
+Return a reference to the current wxApp object."""
     return _core.GetApp(*args, **kwargs)
 #----------------------------------------------------------------------
 
 class PyOnDemandOutputWindow:
+    """
+    A class that can be used for redirecting Python's stdout and
+    stderr streams.  It will do nothing until something is wrriten to
+    the stream at which point it will create a Frame with a text area
+    and write the text there.
+    """
     def __init__(self, title = "wxPython: stdout/stderr"):
         self.frame  = None
         self.title  = title
         self.parent = None
 
     def SetParent(self, parent):
+        """Set the window to be used as the popup Frame's parent."""
         self.parent = parent
 
+
+    def CreateOutputWindow(self, st):
+        self.frame = wx.Frame(self.parent, -1, self.title,
+                              style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
+        self.text  = wxTextCtrl(self.frame, -1, "",
+                                style = wx.TE_MULTILINE | wx.TE_READONLY)
+        self.frame.SetSize((450, 300))
+        self.frame.Show(True)
+        EVT_CLOSE(self.frame, self.OnCloseWindow)
+        
+
+    # These methods provide the file-like output behaviour.
+    def write(self, text):
+        """
+        Create the output window if needed and write the string to it.
+        If not called in the context of the gui thread then uses
+        CallAfter to do the work there.
+        """        
+        if self.frame is None:
+            if not wx.Thread_IsMain():
+                wx.CallAfter(self.CreateOutputWindow, text)
+            else:
+                self.CreateOutputWindow(text)
+        else:
+            if not wx.Thread_IsMain():
+                wx.CallAfter(self.text.AppendText, text)
+            else:
+                self.text.AppendText(text)
+
+
+    def close(self):
+        if self.frame is not None:
+            wx.CallAfter(self.frame.Close)
+
+
     def OnCloseWindow(self, event):
-        if self.frame != None:
+        if self.frame is not None:
             self.frame.Destroy()
         self.frame = None
         self.text  = None
 
-    # These methods provide the file-like output behaviour.
-    def write(self, str):
-        if not wx.Thread_IsMain():
-            # Aquire the GUI mutex before making GUI calls.  Mutex is released
-            # when locker is deleted at the end of this function.
-            locker = wx.MutexGuiLocker()
-
-        if not self.frame:
-            self.frame = wx.Frame(self.parent, -1, self.title,
-                                 style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
-            self.text  = wxTextCtrl(self.frame, -1, "",
-                                    style = wx.TE_MULTILINE | wx.TE_READONLY)
-            self.frame.SetSize((450, 300))
-            self.frame.Show(True)
-            EVT_CLOSE(self.frame, self.OnCloseWindow)
-        self.text.AppendText(str)
-
-    def close(self):
-        if self.frame != None:
-            if not wx.Thread_IsMain():
-                locker = wx.MutexGuiLocker()
-            self.frame.Close()
-
-
 #----------------------------------------------------------------------
-# The main application class.  Derive from this and implement an OnInit
-# method that creates a frame and then calls self.SetTopWindow(frame)
 
 _defRedirect = (wx.Platform == '__WXMSW__' or wx.Platform == '__WXMAC__')
 
 class App(wx.PyApp):
+    """
+    The main application class.  Derive from this and implement an OnInit
+    method that creates a frame and then calls self.SetTopWindow(frame)
+    """
     outputWindowClass = PyOnDemandOutputWindow
 
     def __init__(self, redirect=_defRedirect, filename=None, useBestVisual=False):
@@ -4796,13 +4928,20 @@ App_GetComCtl32Version           = _core.PyApp_GetComCtl32Version
 #----------------------------------------------------------------------------
 
 class PySimpleApp(wx.App):
-    def __init__(self, redirect=False, filename=None):
-        wx.App.__init__(self, redirect, filename)
+    """
+    A simple application class.  You can just create one of these and
+    then then make your top level windows later, and not have to worry
+    about OnInit."""
+
+    def __init__(self, redirect=False, filename=None, useBestVisual=False):
+        wx.App.__init__(self, redirect, filename, useBestVisual)
+        
     def OnInit(self):
         wx.InitAllImageHandlers()
         return True
 
 
+# Is anybody using this one?
 class PyWidgetTester(wx.App):
     def __init__(self, size = (250, 100)):
         self.size = size
@@ -5593,13 +5732,13 @@ Get the width, height, decent and leading of the text using the current or speci
         return _core.Window_GetToolTip(*args, **kwargs)
 
     def SetDropTarget(*args, **kwargs):
-        """SetDropTarget(wxDropTarget dropTarget)"""
+        """SetDropTarget(wxPyDropTarget dropTarget)"""
         val = _core.Window_SetDropTarget(*args, **kwargs)
         args[1].thisown = 0
         return val
 
     def GetDropTarget(*args, **kwargs):
-        """GetDropTarget() -> wxDropTarget"""
+        """GetDropTarget() -> wxPyDropTarget"""
         return _core.Window_GetDropTarget(*args, **kwargs)
 
     def DragAcceptFiles(*args, **kwargs):
@@ -7519,7 +7658,7 @@ class LayoutConstraints(Object):
         self.thisown = 1
         del newobj.thisown
     def SatisfyConstraints(*args, **kwargs):
-        """SatisfyConstraints(Window win, int OUTPUT) -> bool"""
+        """SatisfyConstraints(Window win) -> (areSatisfied, noChanges)"""
         return _core.LayoutConstraints_SatisfyConstraints(*args, **kwargs)
 
     def AreSatisfied(*args, **kwargs):
@@ -7536,16 +7675,13 @@ _core.LayoutConstraints_swigregister(LayoutConstraintsPtr)
 
 #----------------------------------------------------------------------------
 
-# Use Python's bool constants if available, make aliases if not
+# Use Python's bool constants if available, make some if not
 try:
     True
 except NameError:
-    True = 1==1
-    False = 1==0
+    __builtins__.True = 1==1
+    __builtins__.False = 1==0
 
-# Backwards compaatibility
-TRUE  = true  = True
-FALSE = false = False
 
 
 # workarounds for bad wxRTTI names

wxPython/src/msw/core_wrap.cpp

@@ -321,7 +321,7 @@ SWIGEXPORT(void)              SWIG_Python_InstallConstants(PyObject *d, swig_con
 #define  SWIGTYPE_p_wxPyApp swig_types[103] 
 #define  SWIGTYPE_p_wxCommandEvent swig_types[104] 
 #define  SWIGTYPE_p_wxPyCommandEvent swig_types[105] 
-#define  SWIGTYPE_p_wxDropTarget swig_types[106] 
+#define  SWIGTYPE_p_wxPyDropTarget swig_types[106] 
 #define  SWIGTYPE_p_wxChildFocusEvent swig_types[107] 
 #define  SWIGTYPE_p_wxFocusEvent swig_types[108] 
 #define  SWIGTYPE_p_wxDropFilesEvent swig_types[109] 
@@ -17738,36 +17738,6 @@ static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *self, PyObject *args, PyOb
 }
 
 
-static PyObject *_wrap_PyApp_OnIdle(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxPyApp *arg1 = (wxPyApp *) 0 ;
-    wxIdleEvent *arg2 = 0 ;
-    PyObject * obj0 = 0 ;
-    PyObject * obj1 = 0 ;
-    char *kwnames[] = {
-        (char *) "self",(char *) "event", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_OnIdle",kwnames,&obj0,&obj1)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyApp,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxIdleEvent,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    if (arg2 == NULL) {
-        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
-    }
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        (arg1)->OnIdle(*arg2);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    Py_INCREF(Py_None); resultobj = Py_None;
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_PyApp_IsActive(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyApp *arg1 = (wxPyApp *) 0 ;
@@ -18003,31 +17973,6 @@ static PyObject *_wrap_PyApp_GetPrintMode(PyObject *self, PyObject *args, PyObje
 }
 
 
-static PyObject *_wrap_PyApp_GetAssertMode(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxPyApp *arg1 = (wxPyApp *) 0 ;
-    int result;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyApp,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = (int)(arg1)->GetAssertMode();
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    resultobj = PyInt_FromLong((long)result);
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyApp *arg1 = (wxPyApp *) 0 ;
@@ -18053,6 +17998,31 @@ static PyObject *_wrap_PyApp_SetAssertMode(PyObject *self, PyObject *args, PyObj
 }
 
 
+static PyObject *_wrap_PyApp_GetAssertMode(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxPyApp *arg1 = (wxPyApp *) 0 ;
+    int result;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyApp,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = (int)(arg1)->GetAssertMode();
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    resultobj = PyInt_FromLong((long)result);
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     bool result;
@@ -23698,7 +23668,7 @@ static PyObject *_wrap_Window_GetToolTip(PyObject *self, PyObject *args, PyObjec
 static PyObject *_wrap_Window_SetDropTarget(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxWindow *arg1 = (wxWindow *) 0 ;
-    wxDropTarget *arg2 = (wxDropTarget *) 0 ;
+    wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
     PyObject * obj0 = 0 ;
     PyObject * obj1 = 0 ;
     char *kwnames[] = {
@@ -23707,7 +23677,7 @@ static PyObject *_wrap_Window_SetDropTarget(PyObject *self, PyObject *args, PyOb
     
     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
     if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxDropTarget,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxPyDropTarget,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
     {
         PyThreadState* __tstate = wxPyBeginAllowThreads();
         (arg1)->SetDropTarget(arg2);
@@ -23725,7 +23695,7 @@ static PyObject *_wrap_Window_SetDropTarget(PyObject *self, PyObject *args, PyOb
 static PyObject *_wrap_Window_GetDropTarget(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxWindow *arg1 = (wxWindow *) 0 ;
-    wxDropTarget *result;
+    wxPyDropTarget *result;
     PyObject * obj0 = 0 ;
     char *kwnames[] = {
         (char *) "self", NULL 
@@ -23735,12 +23705,12 @@ static PyObject *_wrap_Window_GetDropTarget(PyObject *self, PyObject *args, PyOb
     if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
     {
         PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = (wxDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
+        result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
         
         wxPyEndAllowThreads(__tstate);
         if (PyErr_Occurred()) SWIG_fail;
     }
-    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_wxDropTarget, 0);
+    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_wxPyDropTarget, 0);
     return resultobj;
     fail:
     return NULL;
@@ -36073,7 +36043,6 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"PyApp_OnIdle", (PyCFunction) _wrap_PyApp_OnIdle, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS },
@@ -36083,8 +36052,8 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS },
@@ -37248,7 +37217,7 @@ static swig_type_info _swigt__p_wxMouseEvent[] = {{"_p_wxMouseEvent", 0, "wxMous
 static swig_type_info _swigt__p_wxPyApp[] = {{"_p_wxPyApp", 0, "wxPyApp *", 0},{"_p_wxPyApp"},{0}};
 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent},{"_p_wxCommandEvent"},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent},{0}};
 static swig_type_info _swigt__p_wxPyCommandEvent[] = {{"_p_wxPyCommandEvent", 0, "wxPyCommandEvent *", 0},{"_p_wxPyCommandEvent"},{0}};
-static swig_type_info _swigt__p_wxDropTarget[] = {{"_p_wxDropTarget", 0, "wxDropTarget *", 0},{"_p_wxDropTarget"},{0}};
+static swig_type_info _swigt__p_wxPyDropTarget[] = {{"_p_wxPyDropTarget", 0, "wxPyDropTarget *", 0},{"_p_wxPyDropTarget"},{0}};
 static swig_type_info _swigt__p_wxChildFocusEvent[] = {{"_p_wxChildFocusEvent", 0, "wxChildFocusEvent *", 0},{"_p_wxChildFocusEvent"},{0}};
 static swig_type_info _swigt__p_wxFocusEvent[] = {{"_p_wxFocusEvent", 0, "wxFocusEvent *", 0},{"_p_wxFocusEvent"},{0}};
 static swig_type_info _swigt__p_wxDropFilesEvent[] = {{"_p_wxDropFilesEvent", 0, "wxDropFilesEvent *", 0},{"_p_wxDropFilesEvent"},{0}};
@@ -37364,7 +37333,7 @@ _swigt__p_wxMouseEvent,
 _swigt__p_wxPyApp, 
 _swigt__p_wxCommandEvent, 
 _swigt__p_wxPyCommandEvent, 
-_swigt__p_wxDropTarget, 
+_swigt__p_wxPyDropTarget, 
 _swigt__p_wxChildFocusEvent, 
 _swigt__p_wxFocusEvent, 
 _swigt__p_wxDropFilesEvent, 

wxPython/src/msw/gdi.py

@@ -146,13 +146,14 @@ class Palette(GDIObject):
         return _gdi.Palette_GetPixel(*args, **kwargs)
 
     def GetRGB(*args, **kwargs):
-        """GetRGB(int pixel, byte OUTPUT, byte OUTPUT, byte OUTPUT) -> bool"""
+        """GetRGB(int pixel) -> (R,G,B)"""
         return _gdi.Palette_GetRGB(*args, **kwargs)
 
     def Ok(*args, **kwargs):
         """Ok() -> bool"""
         return _gdi.Palette_Ok(*args, **kwargs)
 
+    def __nonzero__(self): return self.Ok() 
 
 class PalettePtr(Palette):
     def __init__(self, this):
@@ -2311,7 +2312,7 @@ class DC(core.Object):
         return _gdi.DC_DestroyClippingRegion(*args, **kwargs)
 
     def GetClippingBox(*args, **kwargs):
-        """GetClippingBox(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT)"""
+        """GetClippingBox() -> (x, y, width, height)"""
         return _gdi.DC_GetClippingBox(*args, **kwargs)
 
     def GetClippingRect(*args, **kwargs):
@@ -2327,35 +2328,52 @@ class DC(core.Object):
         return _gdi.DC_GetCharWidth(*args, **kwargs)
 
     def GetTextExtent(*args, **kwargs):
-        """GetTextExtent(wxString string, int OUTPUT, int OUTPUT)"""
+        """GetTextExtent(wxString string) -> (width, height)
+
+Get the width and height of the text using the current font.
+Only works for single line strings."""
         return _gdi.DC_GetTextExtent(*args, **kwargs)
 
     def GetFullTextExtent(*args, **kwargs):
-        """GetFullTextExtent(wxString string, int OUTPUT, int OUTPUT, int OUTPUT, 
-    int OUTPUT, Font font=None)"""
+        """GetFullTextExtent(wxString string, Font font=None) ->
+   (width, height, descent, externalLeading)
+
+Get the width, height, decent and leading of the text using the current or specified font.
+Only works for single line strings."""
         return _gdi.DC_GetFullTextExtent(*args, **kwargs)
 
     def GetMultiLineTextExtent(*args, **kwargs):
-        """GetMultiLineTextExtent(wxString text, int OUTPUT, int OUTPUT, int OUTPUT, 
-    Font font=None)"""
+        """GetMultiLineTextExtent(wxString string, Font font=None) ->
+   (width, height, descent, externalLeading)
+
+Get the width, height, decent and leading of the text using the current or specified font.
+Works for single as well as multi-line strings."""
         return _gdi.DC_GetMultiLineTextExtent(*args, **kwargs)
 
-    def GetSizeTuple(*args, **kwargs):
-        """GetSizeTuple(int OUTPUT, int OUTPUT)"""
-        return _gdi.DC_GetSizeTuple(*args, **kwargs)
-
     def GetSize(*args, **kwargs):
-        """GetSize() -> Size"""
+        """GetSize() -> Size
+
+Get the DC size in device units."""
         return _gdi.DC_GetSize(*args, **kwargs)
 
-    def GetSizeMMWH(*args, **kwargs):
-        """GetSizeMMWH(int OUTPUT, int OUTPUT)"""
-        return _gdi.DC_GetSizeMMWH(*args, **kwargs)
+    def GetSizeTuple(*args, **kwargs):
+        """GetSizeTuple() -> (width, height)
+
+Get the DC size in device units."""
+        return _gdi.DC_GetSizeTuple(*args, **kwargs)
 
     def GetSizeMM(*args, **kwargs):
-        """GetSizeMM() -> Size"""
+        """GetSizeMM() -> Size
+
+Get the DC size in milimeters."""
         return _gdi.DC_GetSizeMM(*args, **kwargs)
 
+    def GetSizeMMTuple(*args, **kwargs):
+        """GetSizeMMTuple() -> (width, height)
+
+Get the DC size in milimeters."""
+        return _gdi.DC_GetSizeMMTuple(*args, **kwargs)
+
     def DeviceToLogicalX(*args, **kwargs):
         """DeviceToLogicalX(int x) -> int"""
         return _gdi.DC_DeviceToLogicalX(*args, **kwargs)
@@ -2453,7 +2471,7 @@ class DC(core.Object):
         return _gdi.DC_SetMapMode(*args, **kwargs)
 
     def GetUserScale(*args, **kwargs):
-        """GetUserScale(double OUTPUT, double OUTPUT)"""
+        """GetUserScale() -> (xScale, yScale)"""
         return _gdi.DC_GetUserScale(*args, **kwargs)
 
     def SetUserScale(*args, **kwargs):
@@ -2461,33 +2479,33 @@ class DC(core.Object):
         return _gdi.DC_SetUserScale(*args, **kwargs)
 
     def GetLogicalScale(*args, **kwargs):
-        """GetLogicalScale(double OUTPUT, double OUTPUT)"""
+        """GetLogicalScale() -> (xScale, yScale)"""
         return _gdi.DC_GetLogicalScale(*args, **kwargs)
 
     def SetLogicalScale(*args, **kwargs):
         """SetLogicalScale(double x, double y)"""
         return _gdi.DC_SetLogicalScale(*args, **kwargs)
 
-    def GetLogicalOriginTuple(*args, **kwargs):
-        """GetLogicalOriginTuple(int OUTPUT, int OUTPUT)"""
-        return _gdi.DC_GetLogicalOriginTuple(*args, **kwargs)
-
     def GetLogicalOrigin(*args, **kwargs):
         """GetLogicalOrigin() -> Point"""
         return _gdi.DC_GetLogicalOrigin(*args, **kwargs)
 
+    def GetLogicalOriginTuple(*args, **kwargs):
+        """GetLogicalOriginTuple() -> (x,y)"""
+        return _gdi.DC_GetLogicalOriginTuple(*args, **kwargs)
+
     def SetLogicalOrigin(*args, **kwargs):
         """SetLogicalOrigin(int x, int y)"""
         return _gdi.DC_SetLogicalOrigin(*args, **kwargs)
 
-    def GetDeviceOriginTuple(*args, **kwargs):
-        """GetDeviceOriginTuple(int OUTPUT, int OUTPUT)"""
-        return _gdi.DC_GetDeviceOriginTuple(*args, **kwargs)
-
     def GetDeviceOrigin(*args, **kwargs):
         """GetDeviceOrigin() -> Point"""
         return _gdi.DC_GetDeviceOrigin(*args, **kwargs)
 
+    def GetDeviceOriginTuple(*args, **kwargs):
+        """GetDeviceOriginTuple() -> (x,y)"""
+        return _gdi.DC_GetDeviceOriginTuple(*args, **kwargs)
+
     def SetDeviceOrigin(*args, **kwargs):
         """SetDeviceOrigin(int x, int y)"""
         return _gdi.DC_SetDeviceOrigin(*args, **kwargs)
@@ -2537,7 +2555,7 @@ class DC(core.Object):
         return _gdi.DC_MaxY(*args, **kwargs)
 
     def GetBoundingBox(*args, **kwargs):
-        """GetBoundingBox(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT)"""
+        """GetBoundingBox() -> (x1,y1, x2,y2)"""
         return _gdi.DC_GetBoundingBox(*args, **kwargs)
 
     def __nonzero__(self): return self.Ok() 
@@ -3056,7 +3074,7 @@ class ImageList(core.Object):
         return _gdi.ImageList_RemoveAll(*args, **kwargs)
 
     def GetSize(*args, **kwargs):
-        """GetSize(int index, int OUTPUT, int OUTPUT)"""
+        """GetSize() -> (width,height)"""
         return _gdi.ImageList_GetSize(*args, **kwargs)
 
 

wxPython/src/msw/gdi_wrap.cpp

@@ -11781,44 +11781,6 @@ static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *self, PyObject *args,
 }
 
 
-static PyObject *_wrap_DC_GetSizeTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxDC *arg1 = (wxDC *) 0 ;
-    int *arg2 = (int *) 0 ;
-    int *arg3 = (int *) 0 ;
-    int temp2 ;
-    int temp3 ;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self", NULL 
-    };
-    
-    arg2 = &temp2;
-    arg3 = &temp3;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        (arg1)->GetSize(arg2,arg3);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    Py_INCREF(Py_None); resultobj = Py_None;
-    {
-        PyObject *o = PyInt_FromLong((long) (*arg2));
-        resultobj = t_output_helper(resultobj,o);
-    }
-    {
-        PyObject *o = PyInt_FromLong((long) (*arg3));
-        resultobj = t_output_helper(resultobj,o);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_DC_GetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -11848,7 +11810,7 @@ static PyObject *_wrap_DC_GetSize(PyObject *self, PyObject *args, PyObject *kwar
 }
 
 
-static PyObject *_wrap_DC_GetSizeMMWH(PyObject *self, PyObject *args, PyObject *kwargs) {
+static PyObject *_wrap_DC_GetSizeTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
     int *arg2 = (int *) 0 ;
@@ -11862,11 +11824,11 @@ static PyObject *_wrap_DC_GetSizeMMWH(PyObject *self, PyObject *args, PyObject *
     
     arg2 = &temp2;
     arg3 = &temp3;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMWH",kwnames,&obj0)) goto fail;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
     if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
     {
         PyThreadState* __tstate = wxPyBeginAllowThreads();
-        ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
+        (arg1)->GetSize(arg2,arg3);
         
         wxPyEndAllowThreads(__tstate);
         if (PyErr_Occurred()) SWIG_fail;
@@ -11915,6 +11877,44 @@ static PyObject *_wrap_DC_GetSizeMM(PyObject *self, PyObject *args, PyObject *kw
 }
 
 
+static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxDC *arg1 = (wxDC *) 0 ;
+    int *arg2 = (int *) 0 ;
+    int *arg3 = (int *) 0 ;
+    int temp2 ;
+    int temp3 ;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self", NULL 
+    };
+    
+    arg2 = &temp2;
+    arg3 = &temp3;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    Py_INCREF(Py_None); resultobj = Py_None;
+    {
+        PyObject *o = PyInt_FromLong((long) (*arg2));
+        resultobj = t_output_helper(resultobj,o);
+    }
+    {
+        PyObject *o = PyInt_FromLong((long) (*arg3));
+        resultobj = t_output_helper(resultobj,o);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -12685,6 +12685,35 @@ static PyObject *_wrap_DC_SetLogicalScale(PyObject *self, PyObject *args, PyObje
 }
 
 
+static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxDC *arg1 = (wxDC *) 0 ;
+    wxPoint result;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = ((wxDC const *)arg1)->GetLogicalOrigin();
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    {
+        wxPoint * resultptr;
+        resultptr = new wxPoint((wxPoint &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -12723,35 +12752,6 @@ static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *self, PyObject *args,
 }
 
 
-static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxDC *arg1 = (wxDC *) 0 ;
-    wxPoint result;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = ((wxDC const *)arg1)->GetLogicalOrigin();
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    {
-        wxPoint * resultptr;
-        resultptr = new wxPoint((wxPoint &) result);
-        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -12778,6 +12778,35 @@ static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *self, PyObject *args, PyObj
 }
 
 
+static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxDC *arg1 = (wxDC *) 0 ;
+    wxPoint result;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = ((wxDC const *)arg1)->GetDeviceOrigin();
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    {
+        wxPoint * resultptr;
+        resultptr = new wxPoint((wxPoint &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -12816,35 +12845,6 @@ static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *self, PyObject *args, P
 }
 
 
-static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxDC *arg1 = (wxDC *) 0 ;
-    wxPoint result;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDC,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = ((wxDC const *)arg1)->GetDeviceOrigin();
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    {
-        wxPoint * resultptr;
-        resultptr = new wxPoint((wxPoint &) result);
-        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxDC *arg1 = (wxDC *) 0 ;
@@ -16856,10 +16856,10 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"DC_GetSizeMMWH", (PyCFunction) _wrap_DC_GetSizeMMWH, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS },
@@ -16888,11 +16888,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS },
@@ -17939,5 +17939,9 @@ SWIGEXPORT(void) SWIG_init(void) {
     SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
     SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
     SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
+    
+    // Work around a chicken/egg problem in drawlist.cpp
+    wxPyDrawList_SetAPIPtr();
+    
 }
 

wxPython/src/msw/grid.py

@@ -506,7 +506,7 @@ class GridCellChoiceEditor(GridCellEditor):
     def __repr__(self):
         return "<%s.%s; proxy of C++ wxGridCellChoiceEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
     def __init__(self, *args, **kwargs):
-        """__init__(int LCOUNT=0, wxString choices=None, bool allowOthers=False) -> GridCellChoiceEditor"""
+        """__init__(int choices=0, wxString choices_array=None, bool allowOthers=False) -> GridCellChoiceEditor"""
         newobj = _grid.new_GridCellChoiceEditor(*args, **kwargs)
         self.this = newobj.this
         self.thisown = 1
@@ -696,11 +696,11 @@ class GridCellAttr(object):
         return _grid.GridCellAttr_GetFont(*args, **kwargs)
 
     def GetAlignment(*args, **kwargs):
-        """GetAlignment(int OUTPUT, int OUTPUT)"""
+        """GetAlignment() -> (hAlign, vAlign)"""
         return _grid.GridCellAttr_GetAlignment(*args, **kwargs)
 
     def GetSize(*args, **kwargs):
-        """GetSize(int OUTPUT, int OUTPUT)"""
+        """GetSize() -> (num_rows, num_cols)"""
         return _grid.GridCellAttr_GetSize(*args, **kwargs)
 
     def GetOverflow(*args, **kwargs):
@@ -1314,7 +1314,7 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_DrawTextRectangle(*args, **kwargs)
 
     def GetTextBoxSize(*args, **kwargs):
-        """GetTextBoxSize(wxDC dc, wxArrayString lines, long OUTPUT, long OUTPUT)"""
+        """GetTextBoxSize(DC dc, list lines) -> (width, height)"""
         return _grid.Grid_GetTextBoxSize(*args, **kwargs)
 
     def BeginBatch(*args, **kwargs):
@@ -1494,11 +1494,11 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetLabelFont(*args, **kwargs)
 
     def GetRowLabelAlignment(*args, **kwargs):
-        """GetRowLabelAlignment(int OUTPUT, int OUTPUT)"""
+        """GetRowLabelAlignment() -> (horiz, vert)"""
         return _grid.Grid_GetRowLabelAlignment(*args, **kwargs)
 
     def GetColLabelAlignment(*args, **kwargs):
-        """GetColLabelAlignment(int OUTPUT, int OUTPUT)"""
+        """GetColLabelAlignment() -> (horiz, vert)"""
         return _grid.Grid_GetColLabelAlignment(*args, **kwargs)
 
     def GetColLabelTextOrientation(*args, **kwargs):
@@ -1698,11 +1698,11 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetCellFont(*args, **kwargs)
 
     def GetDefaultCellAlignment(*args, **kwargs):
-        """GetDefaultCellAlignment(int OUTPUT, int OUTPUT)"""
+        """GetDefaultCellAlignment() -> (horiz, vert)"""
         return _grid.Grid_GetDefaultCellAlignment(*args, **kwargs)
 
     def GetCellAlignment(*args, **kwargs):
-        """GetCellAlignment(int row, int col, int OUTPUT, int OUTPUT)"""
+        """GetCellAlignment() -> (horiz, vert)"""
         return _grid.Grid_GetCellAlignment(*args, **kwargs)
 
     def GetDefaultCellOverflow(*args, **kwargs):
@@ -1714,7 +1714,7 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetCellOverflow(*args, **kwargs)
 
     def GetCellSize(*args, **kwargs):
-        """GetCellSize(int row, int col, int OUTPUT, int OUTPUT)"""
+        """GetCellSize(int row, int col) -> (num_rows, num_cols)"""
         return _grid.Grid_GetCellSize(*args, **kwargs)
 
     def SetDefaultRowSize(*args, **kwargs):

wxPython/src/msw/grid_wrap.cpp

@@ -3151,18 +3151,22 @@ static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *self, PyObject *args,
     wxString *arg2 = (wxString *) NULL ;
     bool arg3 = (bool) False ;
     wxGridCellChoiceEditor *result;
+    PyObject * obj0 = 0 ;
     PyObject * obj1 = 0 ;
-    PyObject * obj2 = 0 ;
     char *kwnames[] = {
-        (char *) "LCOUNT",(char *) "choices",(char *) "allowOthers", NULL 
+        (char *) "choices",(char *) "allowOthers", NULL 
     };
     
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|iOO:new_GridCellChoiceEditor",kwnames,&arg1,&obj1,&obj2)) goto fail;
-    if (obj1) {
-        if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxString,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) goto fail;
+    if (obj0) {
+        {
+            arg1 = PyList_Size(obj0);
+            arg2 = wxString_LIST_helper(obj0);
+            if (arg2 == NULL) SWIG_fail;
+        }
     }
-    if (obj2) {
-        arg3 = PyInt_AsLong(obj2) ? true : false;
+    if (obj1) {
+        arg3 = PyInt_AsLong(obj1) ? true : false;
         if (PyErr_Occurred()) SWIG_fail;
     }
     {
@@ -3173,8 +3177,14 @@ static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *self, PyObject *args,
         if (PyErr_Occurred()) SWIG_fail;
     }
     resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_wxGridCellChoiceEditor, 1);
+    {
+        if (arg2) delete [] arg2;
+    }
     return resultobj;
     fail:
+    {
+        if (arg2) delete [] arg2;
+    }
     return NULL;
 }
 

wxPython/src/msw/html.py

@@ -27,6 +27,13 @@ HTML_INDENT_ALL = _html.HTML_INDENT_ALL
 HTML_COND_ISANCHOR = _html.HTML_COND_ISANCHOR
 HTML_COND_ISIMAGEMAP = _html.HTML_COND_ISIMAGEMAP
 HTML_COND_USER = _html.HTML_COND_USER
+HTML_FONT_SIZE_1 = _html.HTML_FONT_SIZE_1
+HTML_FONT_SIZE_2 = _html.HTML_FONT_SIZE_2
+HTML_FONT_SIZE_3 = _html.HTML_FONT_SIZE_3
+HTML_FONT_SIZE_4 = _html.HTML_FONT_SIZE_4
+HTML_FONT_SIZE_5 = _html.HTML_FONT_SIZE_5
+HTML_FONT_SIZE_6 = _html.HTML_FONT_SIZE_6
+HTML_FONT_SIZE_7 = _html.HTML_FONT_SIZE_7
 HW_SCROLLBAR_NEVER = _html.HW_SCROLLBAR_NEVER
 HW_SCROLLBAR_AUTO = _html.HW_SCROLLBAR_AUTO
 HW_NO_SELECTION = _html.HW_NO_SELECTION

wxPython/src/msw/html_wrap.cpp

@@ -10662,6 +10662,13 @@ static swig_const_info swig_const_table[] = {
 { SWIG_PY_INT,     (char *)"HTML_COND_ISANCHOR", (long) wxHTML_COND_ISANCHOR, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HTML_COND_ISIMAGEMAP", (long) wxHTML_COND_ISIMAGEMAP, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HTML_COND_USER", (long) wxHTML_COND_USER, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_1", (long) wxHTML_FONT_SIZE_1, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_2", (long) wxHTML_FONT_SIZE_2, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_3", (long) wxHTML_FONT_SIZE_3, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_4", (long) wxHTML_FONT_SIZE_4, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_5", (long) wxHTML_FONT_SIZE_5, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_6", (long) wxHTML_FONT_SIZE_6, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"HTML_FONT_SIZE_7", (long) wxHTML_FONT_SIZE_7, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HW_SCROLLBAR_NEVER", (long) wxHW_SCROLLBAR_NEVER, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HW_SCROLLBAR_AUTO", (long) wxHW_SCROLLBAR_AUTO, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"HW_NO_SELECTION", (long) wxHW_NO_SELECTION, 0, 0, 0},

wxPython/src/msw/misc.py

@@ -256,7 +256,7 @@ def GetElapsedTime(*args, **kwargs):
     return _misc.GetElapsedTime(*args, **kwargs)
 
 def GetMousePosition(*args, **kwargs):
-    """GetMousePosition(int OUTPUT, int OUTPUT)"""
+    """GetMousePosition() -> (x,y)"""
     return _misc.GetMousePosition(*args, **kwargs)
 
 def IsBusy(*args, **kwargs):
@@ -276,7 +276,7 @@ def StartTimer(*args, **kwargs):
     return _misc.StartTimer(*args, **kwargs)
 
 def GetOsVersion(*args, **kwargs):
-    """GetOsVersion(int OUTPUT, int OUTPUT) -> int"""
+    """GetOsVersion() -> (platform, major, minor)"""
     return _misc.GetOsVersion(*args, **kwargs)
 
 def GetOsDescription(*args, **kwargs):
@@ -420,7 +420,7 @@ def GetDisplayDepth(*args, **kwargs):
     return _misc.GetDisplayDepth(*args, **kwargs)
 
 def DisplaySize(*args, **kwargs):
-    """DisplaySize(int OUTPUT, int OUTPUT)"""
+    """DisplaySize() -> (width, height)"""
     return _misc.DisplaySize(*args, **kwargs)
 
 def GetDisplaySize(*args, **kwargs):
@@ -428,7 +428,7 @@ def GetDisplaySize(*args, **kwargs):
     return _misc.GetDisplaySize(*args, **kwargs)
 
 def DisplaySizeMM(*args, **kwargs):
-    """DisplaySizeMM(int OUTPUT, int OUTPUT)"""
+    """DisplaySizeMM() -> (width, height)"""
     return _misc.DisplaySizeMM(*args, **kwargs)
 
 def GetDisplaySizeMM(*args, **kwargs):
@@ -436,7 +436,7 @@ def GetDisplaySizeMM(*args, **kwargs):
     return _misc.GetDisplaySizeMM(*args, **kwargs)
 
 def ClientDisplayRect(*args, **kwargs):
-    """ClientDisplayRect(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT)"""
+    """ClientDisplayRect() -> (x, y, width, height)"""
     return _misc.ClientDisplayRect(*args, **kwargs)
 
 def GetClientDisplayRect(*args, **kwargs):
@@ -580,22 +580,22 @@ class Caret(object):
         """IsVisible() -> bool"""
         return _misc.Caret_IsVisible(*args, **kwargs)
 
-    def GetPositionTuple(*args, **kwargs):
-        """GetPositionTuple(int OUTPUT, int OUTPUT)"""
-        return _misc.Caret_GetPositionTuple(*args, **kwargs)
-
     def GetPosition(*args, **kwargs):
         """GetPosition() -> Point"""
         return _misc.Caret_GetPosition(*args, **kwargs)
 
-    def GetSizeTuple(*args, **kwargs):
-        """GetSizeTuple(int OUTPUT, int OUTPUT)"""
-        return _misc.Caret_GetSizeTuple(*args, **kwargs)
+    def GetPositionTuple(*args, **kwargs):
+        """GetPositionTuple() -> (x,y)"""
+        return _misc.Caret_GetPositionTuple(*args, **kwargs)
 
     def GetSize(*args, **kwargs):
         """GetSize() -> Size"""
         return _misc.Caret_GetSize(*args, **kwargs)
 
+    def GetSizeTuple(*args, **kwargs):
+        """GetSizeTuple() -> (width, height)"""
+        return _misc.Caret_GetSizeTuple(*args, **kwargs)
+
     def GetWindow(*args, **kwargs):
         """GetWindow() -> Window"""
         return _misc.Caret_GetWindow(*args, **kwargs)
@@ -624,6 +624,7 @@ class Caret(object):
         """Hide()"""
         return _misc.Caret_Hide(*args, **kwargs)
 
+    def __nonzero__(self): return self.IsOk() 
 
 class CaretPtr(Caret):
     def __init__(self, this):
@@ -934,12 +935,18 @@ class Timer(core.EvtHandler):
         self.this = newobj.this
         self.thisown = 1
         del newobj.thisown
+        self._setCallbackInfo(self, Timer)
+
     def __del__(self, destroy=_misc.delete_Timer):
         """__del__()"""
         try:
             if self.thisown: destroy(self)
         except: pass
 
+    def _setCallbackInfo(*args, **kwargs):
+        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        return _misc.Timer__setCallbackInfo(*args, **kwargs)
+
     def SetOwner(*args, **kwargs):
         """SetOwner(EvtHandler owner, int id=-1)"""
         return _misc.Timer_SetOwner(*args, **kwargs)
@@ -952,10 +959,6 @@ class Timer(core.EvtHandler):
         """Stop()"""
         return _misc.Timer_Stop(*args, **kwargs)
 
-    def Notify(*args, **kwargs):
-        """Notify()"""
-        return _misc.Timer_Notify(*args, **kwargs)
-
     def IsRunning(*args, **kwargs):
         """IsRunning() -> bool"""
         return _misc.Timer_IsRunning(*args, **kwargs)
@@ -2902,12 +2905,12 @@ class DateTime(object):
 
     GetCentury = staticmethod(GetCentury)
     def GetNumberOfDaysinYear(*args, **kwargs):
-        """DateTime.GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> wxDateTime_t"""
+        """DateTime.GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> int"""
         return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
 
     GetNumberOfDaysinYear = staticmethod(GetNumberOfDaysinYear)
     def GetNumberOfDaysInMonth(*args, **kwargs):
-        """DateTime.GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> wxDateTime_t"""
+        """DateTime.GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> int"""
         return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
 
     GetNumberOfDaysInMonth = staticmethod(GetNumberOfDaysInMonth)
@@ -2922,7 +2925,9 @@ class DateTime(object):
 
     GetWeekDayName = staticmethod(GetWeekDayName)
     def GetAmPmStrings(*args, **kwargs):
-        """DateTime.GetAmPmStrings(wxString OUTPUT, wxString OUTPUT)"""
+        """GetAmPmStrings() -> (am, pm)
+
+Get the AM and PM strings in the current locale (may be empty)"""
         return _misc.DateTime_GetAmPmStrings(*args, **kwargs)
 
     GetAmPmStrings = staticmethod(GetAmPmStrings)
@@ -2981,14 +2986,13 @@ class DateTime(object):
         return _misc.DateTime_SetJDN(*args, **kwargs)
 
     def SetHMS(*args, **kwargs):
-        """SetHMS(wxDateTime_t hour, wxDateTime_t minute=0, wxDateTime_t second=0, 
-    wxDateTime_t millisec=0) -> DateTime"""
+        """SetHMS(int hour, int minute=0, int second=0, int millisec=0) -> DateTime"""
         return _misc.DateTime_SetHMS(*args, **kwargs)
 
     def Set(*args, **kwargs):
-        """Set(wxDateTime_t day, wxDateTime::Month month=Inv_Month, 
-    int year=Inv_Year, wxDateTime_t hour=0, wxDateTime_t minute=0, 
-    wxDateTime_t second=0, wxDateTime_t millisec=0) -> DateTime"""
+        """Set(int day, wxDateTime::Month month=Inv_Month, int year=Inv_Year, 
+    int hour=0, int minute=0, int second=0, 
+    int millisec=0) -> DateTime"""
         return _misc.DateTime_Set(*args, **kwargs)
 
     def ResetTime(*args, **kwargs):
@@ -3004,23 +3008,23 @@ class DateTime(object):
         return _misc.DateTime_SetMonth(*args, **kwargs)
 
     def SetDay(*args, **kwargs):
-        """SetDay(wxDateTime_t day) -> DateTime"""
+        """SetDay(int day) -> DateTime"""
         return _misc.DateTime_SetDay(*args, **kwargs)
 
     def SetHour(*args, **kwargs):
-        """SetHour(wxDateTime_t hour) -> DateTime"""
+        """SetHour(int hour) -> DateTime"""
         return _misc.DateTime_SetHour(*args, **kwargs)
 
     def SetMinute(*args, **kwargs):
-        """SetMinute(wxDateTime_t minute) -> DateTime"""
+        """SetMinute(int minute) -> DateTime"""
         return _misc.DateTime_SetMinute(*args, **kwargs)
 
     def SetSecond(*args, **kwargs):
-        """SetSecond(wxDateTime_t second) -> DateTime"""
+        """SetSecond(int second) -> DateTime"""
         return _misc.DateTime_SetSecond(*args, **kwargs)
 
     def SetMillisecond(*args, **kwargs):
-        """SetMillisecond(wxDateTime_t millisecond) -> DateTime"""
+        """SetMillisecond(int millisecond) -> DateTime"""
         return _misc.DateTime_SetMillisecond(*args, **kwargs)
 
     def SetToWeekDayInSameWeek(*args, **kwargs):
@@ -3063,13 +3067,11 @@ class DateTime(object):
         return _misc.DateTime_GetLastWeekDay(*args, **kwargs)
 
     def SetToTheWeek(*args, **kwargs):
-        """SetToTheWeek(wxDateTime_t numWeek, wxDateTime::WeekDay weekday=Mon, 
-    wxDateTime::WeekFlags flags=Monday_First) -> bool"""
+        """SetToTheWeek(int numWeek, wxDateTime::WeekDay weekday=Mon, wxDateTime::WeekFlags flags=Monday_First) -> bool"""
         return _misc.DateTime_SetToTheWeek(*args, **kwargs)
 
     def GetWeek(*args, **kwargs):
-        """GetWeek(wxDateTime_t numWeek, wxDateTime::WeekDay weekday=Mon, 
-    wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
+        """GetWeek(int numWeek, wxDateTime::WeekDay weekday=Mon, wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
         return _misc.DateTime_GetWeek(*args, **kwargs)
 
     def SetToLastMonthDay(*args, **kwargs):
@@ -3081,11 +3083,11 @@ class DateTime(object):
         return _misc.DateTime_GetLastMonthDay(*args, **kwargs)
 
     def SetToYearDay(*args, **kwargs):
-        """SetToYearDay(wxDateTime_t yday) -> DateTime"""
+        """SetToYearDay(int yday) -> DateTime"""
         return _misc.DateTime_SetToYearDay(*args, **kwargs)
 
     def GetYearDay(*args, **kwargs):
-        """GetYearDay(wxDateTime_t yday) -> DateTime"""
+        """GetYearDay(int yday) -> DateTime"""
         return _misc.DateTime_GetYearDay(*args, **kwargs)
 
     def GetJulianDayNumber(*args, **kwargs):
@@ -3145,7 +3147,7 @@ class DateTime(object):
         return _misc.DateTime_GetMonth(*args, **kwargs)
 
     def GetDay(*args, **kwargs):
-        """GetDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetDay(*args, **kwargs)
 
     def GetWeekDay(*args, **kwargs):
@@ -3153,31 +3155,31 @@ class DateTime(object):
         return _misc.DateTime_GetWeekDay(*args, **kwargs)
 
     def GetHour(*args, **kwargs):
-        """GetHour(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetHour(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetHour(*args, **kwargs)
 
     def GetMinute(*args, **kwargs):
-        """GetMinute(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetMinute(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetMinute(*args, **kwargs)
 
     def GetSecond(*args, **kwargs):
-        """GetSecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetSecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetSecond(*args, **kwargs)
 
     def GetMillisecond(*args, **kwargs):
-        """GetMillisecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetMillisecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetMillisecond(*args, **kwargs)
 
     def GetDayOfYear(*args, **kwargs):
-        """GetDayOfYear(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetDayOfYear(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetDayOfYear(*args, **kwargs)
 
     def GetWeekOfYear(*args, **kwargs):
-        """GetWeekOfYear(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetWeekOfYear(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetWeekOfYear(*args, **kwargs)
 
     def GetWeekOfMonth(*args, **kwargs):
-        """GetWeekOfMonth(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime_t"""
+        """GetWeekOfMonth(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
         return _misc.DateTime_GetWeekOfMonth(*args, **kwargs)
 
     def IsWorkDay(*args, **kwargs):
@@ -3367,11 +3369,11 @@ def DateTime_GetCentury(*args, **kwargs):
     return _misc.DateTime_GetCentury(*args, **kwargs)
 
 def DateTime_GetNumberOfDaysinYear(*args, **kwargs):
-    """DateTime_GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> wxDateTime_t"""
+    """DateTime_GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> int"""
     return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
 
 def DateTime_GetNumberOfDaysInMonth(*args, **kwargs):
-    """DateTime_GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> wxDateTime_t"""
+    """DateTime_GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> int"""
     return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
 
 def DateTime_GetMonthName(*args, **kwargs):
@@ -3383,7 +3385,9 @@ def DateTime_GetWeekDayName(*args, **kwargs):
     return _misc.DateTime_GetWeekDayName(*args, **kwargs)
 
 def DateTime_GetAmPmStrings(*args, **kwargs):
-    """DateTime_GetAmPmStrings(wxString OUTPUT, wxString OUTPUT)"""
+    """GetAmPmStrings() -> (am, pm)
+
+Get the AM and PM strings in the current locale (may be empty)"""
     return _misc.DateTime_GetAmPmStrings(*args, **kwargs)
 
 def DateTime_IsDSTApplicable(*args, **kwargs):
@@ -3423,16 +3427,15 @@ def DateTimeFromJDN(*args, **kwargs):
     return val
 
 def DateTimeFromHMS(*args, **kwargs):
-    """DateTimeFromHMS(wxDateTime_t hour, wxDateTime_t minute=0, wxDateTime_t second=0, 
-    wxDateTime_t millisec=0) -> DateTime"""
+    """DateTimeFromHMS(int hour, int minute=0, int second=0, int millisec=0) -> DateTime"""
     val = _misc.new_DateTimeFromHMS(*args, **kwargs)
     val.thisown = 1
     return val
 
 def DateTimeFromDMY(*args, **kwargs):
-    """DateTimeFromDMY(wxDateTime_t day, wxDateTime::Month month=Inv_Month, 
-    int year=Inv_Year, wxDateTime_t hour=0, wxDateTime_t minute=0, 
-    wxDateTime_t second=0, wxDateTime_t millisec=0) -> DateTime"""
+    """DateTimeFromDMY(int day, wxDateTime::Month month=Inv_Month, int year=Inv_Year, 
+    int hour=0, int minute=0, int second=0, 
+    int millisec=0) -> DateTime"""
     val = _misc.new_DateTimeFromDMY(*args, **kwargs)
     val.thisown = 1
     return val

wxPython/src/msw/windows.py

@@ -91,9 +91,7 @@ class ScrolledWindow(Panel):
     def GetScrollPixelsPerUnit(*args, **kwargs):
         """GetScrollPixelsPerUnit() -> (xUnit, yUnit)
 
-
-        get the size of one logical unit in physical ones
-        """
+Get the size of one logical unit in physical units."""
         return _windows.ScrolledWindow_GetScrollPixelsPerUnit(*args, **kwargs)
 
     def EnableScrolling(*args, **kwargs):
@@ -101,7 +99,9 @@ class ScrolledWindow(Panel):
         return _windows.ScrolledWindow_EnableScrolling(*args, **kwargs)
 
     def GetViewStart(*args, **kwargs):
-        """GetViewStart(int OUTPUT, int OUTPUT)"""
+        """GetViewStart() -> (x,y)
+
+Get the view start"""
         return _windows.ScrolledWindow_GetViewStart(*args, **kwargs)
 
     def SetScale(*args, **kwargs):
@@ -117,13 +117,17 @@ class ScrolledWindow(Panel):
         return _windows.ScrolledWindow_GetScaleY(*args, **kwargs)
 
     def CalcScrolledPosition(*args):
-        """CalcScrolledPosition(int x, int y, int OUTPUT, int OUTPUT)
-CalcScrolledPosition(Point pt) -> Point"""
+        """CalcScrolledPosition(Point pt) -> Point
+CalcScrolledPosition(int x, int y) -> (sx, sy)
+
+Translate between scrolled and unscrolled coordinates."""
         return _windows.ScrolledWindow_CalcScrolledPosition(*args)
 
     def CalcUnscrolledPosition(*args):
-        """CalcUnscrolledPosition(int x, int y, int OUTPUT, int OUTPUT)
-CalcUnscrolledPosition(Point pt) -> Point"""
+        """CalcUnscrolledPosition(Point pt) -> Point
+CalcUnscrolledPosition(int x, int y) -> (ux, uy)
+
+Translate between scrolled and unscrolled coordinates."""
         return _windows.ScrolledWindow_CalcUnscrolledPosition(*args)
 
     def AdjustScrollbars(*args, **kwargs):
@@ -661,7 +665,7 @@ class StatusBar(core.Window):
         return _windows.StatusBar_SetStatusWidths(*args, **kwargs)
 
     def GetFieldRect(*args, **kwargs):
-        """GetFieldRect(int i, Rect rect) -> bool"""
+        """GetFieldRect(int i) -> Rect"""
         return _windows.StatusBar_GetFieldRect(*args, **kwargs)
 
     def SetMinHeight(*args, **kwargs):
@@ -2519,15 +2523,15 @@ class PyWindow(core.Window):
         return _windows.PyWindow_base_DoSetVirtualSize(*args, **kwargs)
 
     def base_DoGetSize(*args, **kwargs):
-        """base_DoGetSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetSize() -> (width, height)"""
         return _windows.PyWindow_base_DoGetSize(*args, **kwargs)
 
     def base_DoGetClientSize(*args, **kwargs):
-        """base_DoGetClientSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetClientSize() -> (width, height)"""
         return _windows.PyWindow_base_DoGetClientSize(*args, **kwargs)
 
     def base_DoGetPosition(*args, **kwargs):
-        """base_DoGetPosition(int OUTPUT, int OUTPUT)"""
+        """base_DoGetPosition() -> (x,y)"""
         return _windows.PyWindow_base_DoGetPosition(*args, **kwargs)
 
     def base_DoGetVirtualSize(*args, **kwargs):
@@ -2616,15 +2620,15 @@ class PyPanel(Panel):
         return _windows.PyPanel_base_DoSetVirtualSize(*args, **kwargs)
 
     def base_DoGetSize(*args, **kwargs):
-        """base_DoGetSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetSize() -> (width, height)"""
         return _windows.PyPanel_base_DoGetSize(*args, **kwargs)
 
     def base_DoGetClientSize(*args, **kwargs):
-        """base_DoGetClientSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetClientSize() -> (width, height)"""
         return _windows.PyPanel_base_DoGetClientSize(*args, **kwargs)
 
     def base_DoGetPosition(*args, **kwargs):
-        """base_DoGetPosition(int OUTPUT, int OUTPUT)"""
+        """base_DoGetPosition() -> (x,y)"""
         return _windows.PyPanel_base_DoGetPosition(*args, **kwargs)
 
     def base_DoGetVirtualSize(*args, **kwargs):
@@ -3316,20 +3320,20 @@ class Printout(core.Object):
         """SetDC(wxDC dc)"""
         return _windows.Printout_SetDC(*args, **kwargs)
 
-    def GetPageSizePixels(*args, **kwargs):
-        """GetPageSizePixels(int OUTPUT, int OUTPUT)"""
-        return _windows.Printout_GetPageSizePixels(*args, **kwargs)
-
     def SetPageSizePixels(*args, **kwargs):
         """SetPageSizePixels(int w, int h)"""
         return _windows.Printout_SetPageSizePixels(*args, **kwargs)
 
+    def GetPageSizePixels(*args, **kwargs):
+        """GetPageSizePixels() -> (w, h)"""
+        return _windows.Printout_GetPageSizePixels(*args, **kwargs)
+
     def SetPageSizeMM(*args, **kwargs):
         """SetPageSizeMM(int w, int h)"""
         return _windows.Printout_SetPageSizeMM(*args, **kwargs)
 
     def GetPageSizeMM(*args, **kwargs):
-        """GetPageSizeMM(int OUTPUT, int OUTPUT)"""
+        """GetPageSizeMM() -> (w, h)"""
         return _windows.Printout_GetPageSizeMM(*args, **kwargs)
 
     def SetPPIScreen(*args, **kwargs):
@@ -3337,7 +3341,7 @@ class Printout(core.Object):
         return _windows.Printout_SetPPIScreen(*args, **kwargs)
 
     def GetPPIScreen(*args, **kwargs):
-        """GetPPIScreen(int OUTPUT, int OUTPUT)"""
+        """GetPPIScreen() -> (x,y)"""
         return _windows.Printout_GetPPIScreen(*args, **kwargs)
 
     def SetPPIPrinter(*args, **kwargs):
@@ -3345,7 +3349,7 @@ class Printout(core.Object):
         return _windows.Printout_SetPPIPrinter(*args, **kwargs)
 
     def GetPPIPrinter(*args, **kwargs):
-        """GetPPIPrinter(int OUTPUT, int OUTPUT)"""
+        """GetPPIPrinter() -> (x,y)"""
         return _windows.Printout_GetPPIPrinter(*args, **kwargs)
 
     def IsPreview(*args, **kwargs):
@@ -3376,14 +3380,14 @@ class Printout(core.Object):
         """base_OnPreparePrinting()"""
         return _windows.Printout_base_OnPreparePrinting(*args, **kwargs)
 
-    def base_GetPageInfo(*args, **kwargs):
-        """base_GetPageInfo(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT)"""
-        return _windows.Printout_base_GetPageInfo(*args, **kwargs)
-
     def base_HasPage(*args, **kwargs):
         """base_HasPage(int page) -> bool"""
         return _windows.Printout_base_HasPage(*args, **kwargs)
 
+    def base_GetPageInfo(*args, **kwargs):
+        """base_GetPageInfo() -> (minPage, maxPage, pageFrom, pageTo)"""
+        return _windows.Printout_base_GetPageInfo(*args, **kwargs)
+
 
 class PrintoutPtr(Printout):
     def __init__(self, this):

wxPython/src/msw/windows_wrap.cpp

@@ -365,6 +365,11 @@ bool wxDialog_IsModalShowing(wxDialog *self){
         }
 
 
+wxRect wxStatusBar_GetFieldRect(wxStatusBar *self,int i){
+            wxRect r;
+            self->GetFieldRect(i, r);
+            return r;
+        }
 
     static const wxChar* wxSplitterNameStr = wxT("splitter");
     DECLARE_DEF_STRING(SplitterNameStr);
@@ -1666,6 +1671,39 @@ static PyObject *_wrap_ScrolledWindow_GetScaleY(PyObject *self, PyObject *args,
 
 
 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(PyObject *self, PyObject *args) {
+    PyObject *resultobj;
+    wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
+    wxPoint *arg2 = 0 ;
+    wxPoint result;
+    wxPoint temp2 ;
+    PyObject * obj0 = 0 ;
+    PyObject * obj1 = 0 ;
+    
+    if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxScrolledWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        arg2 = &temp2;
+        if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
+    }
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = ((wxScrolledWindow const *)arg1)->CalcScrolledPosition((wxPoint const &)*arg2);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    {
+        wxPoint * resultptr;
+        resultptr = new wxPoint((wxPoint &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
+static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(PyObject *self, PyObject *args) {
     PyObject *resultobj;
     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
     int arg2 ;
@@ -1702,39 +1740,6 @@ static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(PyObject *sel
 }
 
 
-static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(PyObject *self, PyObject *args) {
-    PyObject *resultobj;
-    wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
-    wxPoint *arg2 = 0 ;
-    wxPoint result;
-    wxPoint temp2 ;
-    PyObject * obj0 = 0 ;
-    PyObject * obj1 = 0 ;
-    
-    if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxScrolledWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        arg2 = &temp2;
-        if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
-    }
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = ((wxScrolledWindow const *)arg1)->CalcScrolledPosition((wxPoint const &)*arg2);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    {
-        wxPoint * resultptr;
-        resultptr = new wxPoint((wxPoint &) result);
-        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObject *args) {
     int argc;
     PyObject *argv[4];
@@ -1760,7 +1765,7 @@ static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObj
                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
             }
             if (_v) {
-                return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(self,args);
+                return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(self,args);
             }
         }
     }
@@ -1784,7 +1789,7 @@ static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObj
                     _v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
                 }
                 if (_v) {
-                    return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(self,args);
+                    return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(self,args);
                 }
             }
         }
@@ -1796,6 +1801,39 @@ static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObj
 
 
 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(PyObject *self, PyObject *args) {
+    PyObject *resultobj;
+    wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
+    wxPoint *arg2 = 0 ;
+    wxPoint result;
+    wxPoint temp2 ;
+    PyObject * obj0 = 0 ;
+    PyObject * obj1 = 0 ;
+    
+    if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxScrolledWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        arg2 = &temp2;
+        if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
+    }
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition((wxPoint const &)*arg2);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    {
+        wxPoint * resultptr;
+        resultptr = new wxPoint((wxPoint &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
+    }
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
+static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(PyObject *self, PyObject *args) {
     PyObject *resultobj;
     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
     int arg2 ;
@@ -1832,39 +1870,6 @@ static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(PyObject *s
 }
 
 
-static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(PyObject *self, PyObject *args) {
-    PyObject *resultobj;
-    wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
-    wxPoint *arg2 = 0 ;
-    wxPoint result;
-    wxPoint temp2 ;
-    PyObject * obj0 = 0 ;
-    PyObject * obj1 = 0 ;
-    
-    if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxScrolledWindow,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        arg2 = &temp2;
-        if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
-    }
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition((wxPoint const &)*arg2);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    {
-        wxPoint * resultptr;
-        resultptr = new wxPoint((wxPoint &) result);
-        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPoint, 1);
-    }
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition(PyObject *self, PyObject *args) {
     int argc;
     PyObject *argv[4];
@@ -1890,7 +1895,7 @@ static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition(PyObject *self, PyO
                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
             }
             if (_v) {
-                return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(self,args);
+                return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(self,args);
             }
         }
     }
@@ -1914,7 +1919,7 @@ static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition(PyObject *self, PyO
                     _v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
                 }
                 if (_v) {
-                    return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(self,args);
+                    return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(self,args);
                 }
             }
         }
@@ -4908,29 +4913,26 @@ static PyObject *_wrap_StatusBar_GetFieldRect(PyObject *self, PyObject *args, Py
     PyObject *resultobj;
     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
     int arg2 ;
-    wxRect *arg3 = 0 ;
-    bool result;
-    wxRect temp3 ;
+    wxRect result;
     PyObject * obj0 = 0 ;
-    PyObject * obj2 = 0 ;
     char *kwnames[] = {
-        (char *) "self",(char *) "i",(char *) "rect", NULL 
+        (char *) "self",(char *) "i", NULL 
     };
     
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OiO:StatusBar_GetFieldRect",kwnames,&obj0,&arg2,&obj2)) goto fail;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oi:StatusBar_GetFieldRect",kwnames,&obj0,&arg2)) goto fail;
     if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxStatusBar,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        arg3 = &temp3;
-        if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
-    }
     {
         PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = (bool)((wxStatusBar const *)arg1)->GetFieldRect(arg2,*arg3);
+        result = wxStatusBar_GetFieldRect(arg1,arg2);
         
         wxPyEndAllowThreads(__tstate);
         if (PyErr_Occurred()) SWIG_fail;
     }
-    resultobj = PyInt_FromLong((long)result);
+    {
+        wxRect * resultptr;
+        resultptr = new wxRect((wxRect &) result);
+        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxRect, 1);
+    }
     return resultobj;
     fail:
     return NULL;
@@ -18685,6 +18687,32 @@ static PyObject *_wrap_Printout_SetDC(PyObject *self, PyObject *args, PyObject *
 }
 
 
+static PyObject *_wrap_Printout_SetPageSizePixels(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
+    int arg2 ;
+    int arg3 ;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self",(char *) "w",(char *) "h", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oii:Printout_SetPageSizePixels",kwnames,&obj0,&arg2,&arg3)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyPrintout,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        (arg1)->SetPageSizePixels(arg2,arg3);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    Py_INCREF(Py_None); resultobj = Py_None;
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_Printout_GetPageSizePixels(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
@@ -18723,32 +18751,6 @@ static PyObject *_wrap_Printout_GetPageSizePixels(PyObject *self, PyObject *args
 }
 
 
-static PyObject *_wrap_Printout_SetPageSizePixels(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
-    int arg2 ;
-    int arg3 ;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self",(char *) "w",(char *) "h", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oii:Printout_SetPageSizePixels",kwnames,&obj0,&arg2,&arg3)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyPrintout,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        (arg1)->SetPageSizePixels(arg2,arg3);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    Py_INCREF(Py_None); resultobj = Py_None;
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject *_wrap_Printout_SetPageSizeMM(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
@@ -19117,6 +19119,32 @@ static PyObject *_wrap_Printout_base_OnPreparePrinting(PyObject *self, PyObject
 }
 
 
+static PyObject *_wrap_Printout_base_HasPage(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject *resultobj;
+    wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
+    int arg2 ;
+    bool result;
+    PyObject * obj0 = 0 ;
+    char *kwnames[] = {
+        (char *) "self",(char *) "page", NULL 
+    };
+    
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oi:Printout_base_HasPage",kwnames,&obj0,&arg2)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyPrintout,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    {
+        PyThreadState* __tstate = wxPyBeginAllowThreads();
+        result = (bool)(arg1)->base_HasPage(arg2);
+        
+        wxPyEndAllowThreads(__tstate);
+        if (PyErr_Occurred()) SWIG_fail;
+    }
+    resultobj = PyInt_FromLong((long)result);
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject *_wrap_Printout_base_GetPageInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject *resultobj;
     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
@@ -19169,32 +19197,6 @@ static PyObject *_wrap_Printout_base_GetPageInfo(PyObject *self, PyObject *args,
 }
 
 
-static PyObject *_wrap_Printout_base_HasPage(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject *resultobj;
-    wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
-    int arg2 ;
-    bool result;
-    PyObject * obj0 = 0 ;
-    char *kwnames[] = {
-        (char *) "self",(char *) "page", NULL 
-    };
-    
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oi:Printout_base_HasPage",kwnames,&obj0,&arg2)) goto fail;
-    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPyPrintout,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
-    {
-        PyThreadState* __tstate = wxPyBeginAllowThreads();
-        result = (bool)(arg1)->base_HasPage(arg2);
-        
-        wxPyEndAllowThreads(__tstate);
-        if (PyErr_Occurred()) SWIG_fail;
-    }
-    resultobj = PyInt_FromLong((long)result);
-    return resultobj;
-    fail:
-    return NULL;
-}
-
-
 static PyObject * Printout_swigregister(PyObject *self, PyObject *args) {
     PyObject *obj;
     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
@@ -21668,8 +21670,8 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"Printout_GetTitle", (PyCFunction) _wrap_Printout_GetTitle, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_GetDC", (PyCFunction) _wrap_Printout_GetDC, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_SetDC", (PyCFunction) _wrap_Printout_SetDC, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"Printout_GetPageSizePixels", (PyCFunction) _wrap_Printout_GetPageSizePixels, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_SetPageSizePixels", (PyCFunction) _wrap_Printout_SetPageSizePixels, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"Printout_GetPageSizePixels", (PyCFunction) _wrap_Printout_GetPageSizePixels, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_SetPageSizeMM", (PyCFunction) _wrap_Printout_SetPageSizeMM, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_GetPageSizeMM", (PyCFunction) _wrap_Printout_GetPageSizeMM, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_SetPPIScreen", (PyCFunction) _wrap_Printout_SetPPIScreen, METH_VARARGS | METH_KEYWORDS },
@@ -21683,8 +21685,8 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"Printout_base_OnBeginPrinting", (PyCFunction) _wrap_Printout_base_OnBeginPrinting, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_base_OnEndPrinting", (PyCFunction) _wrap_Printout_base_OnEndPrinting, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_base_OnPreparePrinting", (PyCFunction) _wrap_Printout_base_OnPreparePrinting, METH_VARARGS | METH_KEYWORDS },
-	 { (char *)"Printout_base_GetPageInfo", (PyCFunction) _wrap_Printout_base_GetPageInfo, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_base_HasPage", (PyCFunction) _wrap_Printout_base_HasPage, METH_VARARGS | METH_KEYWORDS },
+	 { (char *)"Printout_base_GetPageInfo", (PyCFunction) _wrap_Printout_base_GetPageInfo, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"Printout_swigregister", Printout_swigregister, METH_VARARGS },
 	 { (char *)"new_PreviewCanvas", (PyCFunction) _wrap_new_PreviewCanvas, METH_VARARGS | METH_KEYWORDS },
 	 { (char *)"PreviewCanvas_swigregister", PreviewCanvas_swigregister, METH_VARARGS },

wxPython/src/msw/wizard.py

@@ -111,15 +111,15 @@ class PyWizardPage(WizardPage):
         return _wizard.PyWizardPage_base_DoSetVirtualSize(*args, **kwargs)
 
     def base_DoGetSize(*args, **kwargs):
-        """base_DoGetSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetSize() -> (width, height)"""
         return _wizard.PyWizardPage_base_DoGetSize(*args, **kwargs)
 
     def base_DoGetClientSize(*args, **kwargs):
-        """base_DoGetClientSize(int OUTPUT, int OUTPUT)"""
+        """base_DoGetClientSize() -> (width, height)"""
         return _wizard.PyWizardPage_base_DoGetClientSize(*args, **kwargs)
 
     def base_DoGetPosition(*args, **kwargs):
-        """base_DoGetPosition(int OUTPUT, int OUTPUT)"""
+        """base_DoGetPosition() -> (x,y)"""
         return _wizard.PyWizardPage_base_DoGetPosition(*args, **kwargs)
 
     def base_DoGetVirtualSize(*args, **kwargs):