Using a new version of SWIG

A few minor fixes


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

utils/wxPython/src/gtk/.cvsignore

@@ -1 +1,4 @@
 _glcanvas.cpp
+helpers.cpp
+libpy.c
+

utils/wxPython/src/gtk/cmndlgs.py

@@ -19,35 +19,34 @@ class wxColourDataPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, cmndlgsc=cmndlgsc):
+    def __del__(self,cmndlgsc=cmndlgsc):
         if self.thisown == 1 :
-            cmndlgsc.delete_wxColourData(self.this)
-    def GetChooseFull(self):
-        val = cmndlgsc.wxColourData_GetChooseFull(self.this)
+            cmndlgsc.delete_wxColourData(self)
+    def GetChooseFull(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxColourData_GetChooseFull,(self,) + _args, _kwargs)
         return val
-    def GetColour(self):
-        val = cmndlgsc.wxColourData_GetColour(self.this)
-        val = wxColourPtr(val)
+    def GetColour(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxColourData_GetColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def GetCustomColour(self,arg0):
-        val = cmndlgsc.wxColourData_GetCustomColour(self.this,arg0)
-        val = wxColourPtr(val)
-        val.thisown = 1
+    def GetCustomColour(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxColourData_GetCustomColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) ; val.thisown = 1
         return val
-    def SetChooseFull(self,arg0):
-        val = cmndlgsc.wxColourData_SetChooseFull(self.this,arg0)
+    def SetChooseFull(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxColourData_SetChooseFull,(self,) + _args, _kwargs)
         return val
-    def SetColour(self,arg0):
-        val = cmndlgsc.wxColourData_SetColour(self.this,arg0.this)
+    def SetColour(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxColourData_SetColour,(self,) + _args, _kwargs)
         return val
-    def SetCustomColour(self,arg0,arg1):
-        val = cmndlgsc.wxColourData_SetCustomColour(self.this,arg0,arg1.this)
+    def SetCustomColour(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxColourData_SetCustomColour,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxColourData instance>"
+        return "<C wxColourData instance at %s>" % (self.this,)
 class wxColourData(wxColourDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxColourData()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxColourData,_args,_kwargs)
         self.thisown = 1
 
 
@@ -57,22 +56,18 @@ class wxColourDialogPtr(wxDialogPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetColourData(self):
-        val = cmndlgsc.wxColourDialog_GetColourData(self.this)
-        val = wxColourDataPtr(val)
+    def GetColourData(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxColourDialog_GetColourData,(self,) + _args, _kwargs)
+        if val: val = wxColourDataPtr(val) 
         return val
-    def ShowModal(self):
-        val = cmndlgsc.wxColourDialog_ShowModal(self.this)
+    def ShowModal(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxColourDialog_ShowModal,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxColourDialog instance>"
+        return "<C wxColourDialog instance at %s>" % (self.this,)
 class wxColourDialog(wxColourDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxColourDialog,(arg0.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxColourDialog,_args,_kwargs)
         self.thisown = 1
         wx._StdDialogCallbacks(self)
 
@@ -83,33 +78,29 @@ class wxDirDialogPtr(wxDialogPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetPath(self):
-        val = cmndlgsc.wxDirDialog_GetPath(self.this)
+    def GetPath(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxDirDialog_GetPath,(self,) + _args, _kwargs)
         return val
-    def GetMessage(self):
-        val = cmndlgsc.wxDirDialog_GetMessage(self.this)
+    def GetMessage(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxDirDialog_GetMessage,(self,) + _args, _kwargs)
         return val
-    def GetStyle(self):
-        val = cmndlgsc.wxDirDialog_GetStyle(self.this)
+    def GetStyle(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxDirDialog_GetStyle,(self,) + _args, _kwargs)
         return val
-    def SetMessage(self,arg0):
-        val = cmndlgsc.wxDirDialog_SetMessage(self.this,arg0)
+    def SetMessage(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxDirDialog_SetMessage,(self,) + _args, _kwargs)
         return val
-    def SetPath(self,arg0):
-        val = cmndlgsc.wxDirDialog_SetPath(self.this,arg0)
+    def SetPath(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxDirDialog_SetPath,(self,) + _args, _kwargs)
         return val
-    def ShowModal(self):
-        val = cmndlgsc.wxDirDialog_ShowModal(self.this)
+    def ShowModal(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxDirDialog_ShowModal,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxDirDialog instance>"
+        return "<C wxDirDialog instance at %s>" % (self.this,)
 class wxDirDialog(wxDirDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[3] = argl[3].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxDirDialog,(arg0.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxDirDialog,_args,_kwargs)
         self.thisown = 1
         wx._StdDialogCallbacks(self)
 
@@ -120,60 +111,56 @@ class wxFileDialogPtr(wxDialogPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetDirectory(self):
-        val = cmndlgsc.wxFileDialog_GetDirectory(self.this)
+    def GetDirectory(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_GetDirectory,(self,) + _args, _kwargs)
         return val
-    def GetFilename(self):
-        val = cmndlgsc.wxFileDialog_GetFilename(self.this)
+    def GetFilename(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_GetFilename,(self,) + _args, _kwargs)
         return val
-    def GetFilterIndex(self):
-        val = cmndlgsc.wxFileDialog_GetFilterIndex(self.this)
+    def GetFilterIndex(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_GetFilterIndex,(self,) + _args, _kwargs)
         return val
-    def GetMessage(self):
-        val = cmndlgsc.wxFileDialog_GetMessage(self.this)
+    def GetMessage(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_GetMessage,(self,) + _args, _kwargs)
         return val
-    def GetPath(self):
-        val = cmndlgsc.wxFileDialog_GetPath(self.this)
+    def GetPath(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_GetPath,(self,) + _args, _kwargs)
         return val
-    def GetStyle(self):
-        val = cmndlgsc.wxFileDialog_GetStyle(self.this)
+    def GetStyle(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_GetStyle,(self,) + _args, _kwargs)
         return val
-    def GetWildcard(self):
-        val = cmndlgsc.wxFileDialog_GetWildcard(self.this)
+    def GetWildcard(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_GetWildcard,(self,) + _args, _kwargs)
         return val
-    def SetDirectory(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetDirectory(self.this,arg0)
+    def SetDirectory(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_SetDirectory,(self,) + _args, _kwargs)
         return val
-    def SetFilename(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetFilename(self.this,arg0)
+    def SetFilename(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_SetFilename,(self,) + _args, _kwargs)
         return val
-    def SetFilterIndex(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetFilterIndex(self.this,arg0)
+    def SetFilterIndex(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_SetFilterIndex,(self,) + _args, _kwargs)
         return val
-    def SetMessage(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetMessage(self.this,arg0)
+    def SetMessage(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_SetMessage,(self,) + _args, _kwargs)
         return val
-    def SetPath(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetPath(self.this,arg0)
+    def SetPath(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_SetPath,(self,) + _args, _kwargs)
         return val
-    def SetStyle(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetStyle(self.this,arg0)
+    def SetStyle(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_SetStyle,(self,) + _args, _kwargs)
         return val
-    def SetWildcard(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetWildcard(self.this,arg0)
+    def SetWildcard(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_SetWildcard,(self,) + _args, _kwargs)
         return val
-    def ShowModal(self):
-        val = cmndlgsc.wxFileDialog_ShowModal(self.this)
+    def ShowModal(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFileDialog_ShowModal,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxFileDialog instance>"
+        return "<C wxFileDialog instance at %s>" % (self.this,)
 class wxFileDialog(wxFileDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[5] = argl[5].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxFileDialog,(arg0.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxFileDialog,_args,_kwargs)
         self.thisown = 1
         wx._StdDialogCallbacks(self)
 
@@ -184,27 +171,23 @@ class wxSingleChoiceDialogPtr(wxDialogPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetSelection(self):
-        val = cmndlgsc.wxSingleChoiceDialog_GetSelection(self.this)
+    def GetSelection(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxSingleChoiceDialog_GetSelection,(self,) + _args, _kwargs)
         return val
-    def GetStringSelection(self):
-        val = cmndlgsc.wxSingleChoiceDialog_GetStringSelection(self.this)
+    def GetStringSelection(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxSingleChoiceDialog_GetStringSelection,(self,) + _args, _kwargs)
         return val
-    def SetSelection(self,arg0):
-        val = cmndlgsc.wxSingleChoiceDialog_SetSelection(self.this,arg0)
+    def SetSelection(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxSingleChoiceDialog_SetSelection,(self,) + _args, _kwargs)
         return val
-    def ShowModal(self):
-        val = cmndlgsc.wxSingleChoiceDialog_ShowModal(self.this)
+    def ShowModal(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxSingleChoiceDialog_ShowModal,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxSingleChoiceDialog instance>"
+        return "<C wxSingleChoiceDialog instance at %s>" % (self.this,)
 class wxSingleChoiceDialog(wxSingleChoiceDialogPtr):
-    def __init__(self,arg0,arg1,arg2,arg3,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxSingleChoiceDialog,(arg0.this,arg1,arg2,arg3,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxSingleChoiceDialog,_args,_kwargs)
         self.thisown = 1
         wx._StdDialogCallbacks(self)
 
@@ -215,24 +198,20 @@ class wxTextEntryDialogPtr(wxDialogPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetValue(self):
-        val = cmndlgsc.wxTextEntryDialog_GetValue(self.this)
+    def GetValue(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxTextEntryDialog_GetValue,(self,) + _args, _kwargs)
         return val
-    def SetValue(self,arg0):
-        val = cmndlgsc.wxTextEntryDialog_SetValue(self.this,arg0)
+    def SetValue(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxTextEntryDialog_SetValue,(self,) + _args, _kwargs)
         return val
-    def ShowModal(self):
-        val = cmndlgsc.wxTextEntryDialog_ShowModal(self.this)
+    def ShowModal(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxTextEntryDialog_ShowModal,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxTextEntryDialog instance>"
+        return "<C wxTextEntryDialog instance at %s>" % (self.this,)
 class wxTextEntryDialog(wxTextEntryDialogPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[3] = argl[3].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxTextEntryDialog,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxTextEntryDialog,_args,_kwargs)
         self.thisown = 1
         wx._StdDialogCallbacks(self)
 
@@ -243,58 +222,56 @@ class wxFontDataPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, cmndlgsc=cmndlgsc):
+    def __del__(self,cmndlgsc=cmndlgsc):
         if self.thisown == 1 :
-            cmndlgsc.delete_wxFontData(self.this)
-    def EnableEffects(self,arg0):
-        val = cmndlgsc.wxFontData_EnableEffects(self.this,arg0)
+            cmndlgsc.delete_wxFontData(self)
+    def EnableEffects(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_EnableEffects,(self,) + _args, _kwargs)
         return val
-    def GetAllowSymbols(self):
-        val = cmndlgsc.wxFontData_GetAllowSymbols(self.this)
+    def GetAllowSymbols(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_GetAllowSymbols,(self,) + _args, _kwargs)
         return val
-    def GetColour(self):
-        val = cmndlgsc.wxFontData_GetColour(self.this)
-        val = wxColourPtr(val)
+    def GetColour(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_GetColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def GetChosenFont(self):
-        val = cmndlgsc.wxFontData_GetChosenFont(self.this)
-        val = wxFontPtr(val)
-        val.thisown = 1
+    def GetChosenFont(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_GetChosenFont,(self,) + _args, _kwargs)
+        if val: val = wxFontPtr(val) ; val.thisown = 1
         return val
-    def GetEnableEffects(self):
-        val = cmndlgsc.wxFontData_GetEnableEffects(self.this)
+    def GetEnableEffects(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_GetEnableEffects,(self,) + _args, _kwargs)
         return val
-    def GetInitialFont(self):
-        val = cmndlgsc.wxFontData_GetInitialFont(self.this)
-        val = wxFontPtr(val)
-        val.thisown = 1
+    def GetInitialFont(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_GetInitialFont,(self,) + _args, _kwargs)
+        if val: val = wxFontPtr(val) ; val.thisown = 1
         return val
-    def GetShowHelp(self):
-        val = cmndlgsc.wxFontData_GetShowHelp(self.this)
+    def GetShowHelp(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_GetShowHelp,(self,) + _args, _kwargs)
         return val
-    def SetAllowSymbols(self,arg0):
-        val = cmndlgsc.wxFontData_SetAllowSymbols(self.this,arg0)
+    def SetAllowSymbols(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_SetAllowSymbols,(self,) + _args, _kwargs)
         return val
-    def SetChosenFont(self,arg0):
-        val = cmndlgsc.wxFontData_SetChosenFont(self.this,arg0.this)
+    def SetChosenFont(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_SetChosenFont,(self,) + _args, _kwargs)
         return val
-    def SetColour(self,arg0):
-        val = cmndlgsc.wxFontData_SetColour(self.this,arg0.this)
+    def SetColour(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_SetColour,(self,) + _args, _kwargs)
         return val
-    def SetInitialFont(self,arg0):
-        val = cmndlgsc.wxFontData_SetInitialFont(self.this,arg0.this)
+    def SetInitialFont(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_SetInitialFont,(self,) + _args, _kwargs)
         return val
-    def SetRange(self,arg0,arg1):
-        val = cmndlgsc.wxFontData_SetRange(self.this,arg0,arg1)
+    def SetRange(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_SetRange,(self,) + _args, _kwargs)
         return val
-    def SetShowHelp(self,arg0):
-        val = cmndlgsc.wxFontData_SetShowHelp(self.this,arg0)
+    def SetShowHelp(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontData_SetShowHelp,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxFontData instance>"
+        return "<C wxFontData instance at %s>" % (self.this,)
 class wxFontData(wxFontDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxFontData()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxFontData,_args,_kwargs)
         self.thisown = 1
 
 
@@ -304,22 +281,18 @@ class wxFontDialogPtr(wxDialogPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetFontData(self):
-        val = cmndlgsc.wxFontDialog_GetFontData(self.this)
-        val = wxFontDataPtr(val)
+    def GetFontData(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontDialog_GetFontData,(self,) + _args, _kwargs)
+        if val: val = wxFontDataPtr(val) 
         return val
-    def ShowModal(self):
-        val = cmndlgsc.wxFontDialog_ShowModal(self.this)
+    def ShowModal(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxFontDialog_ShowModal,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxFontDialog instance>"
+        return "<C wxFontDialog instance at %s>" % (self.this,)
 class wxFontDialog(wxFontDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxFontDialog,(arg0.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxFontDialog,_args,_kwargs)
         self.thisown = 1
         wx._StdDialogCallbacks(self)
 
@@ -330,18 +303,14 @@ class wxMessageDialogPtr(wxDialogPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def ShowModal(self):
-        val = cmndlgsc.wxMessageDialog_ShowModal(self.this)
+    def ShowModal(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxMessageDialog_ShowModal,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxMessageDialog instance>"
+        return "<C wxMessageDialog instance at %s>" % (self.this,)
 class wxMessageDialog(wxMessageDialogPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxMessageDialog,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxMessageDialog,_args,_kwargs)
         self.thisown = 1
         wx._StdDialogCallbacks(self)
 
@@ -352,21 +321,17 @@ class wxProgressDialogPtr(wxFramePtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def Update(self,*args):
-        val = apply(cmndlgsc.wxProgressDialog_Update,(self.this,)+args)
+    def Update(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxProgressDialog_Update,(self,) + _args, _kwargs)
         return val
-    def Resume(self):
-        val = cmndlgsc.wxProgressDialog_Resume(self.this)
+    def Resume(self, *_args, **_kwargs):
+        val = apply(cmndlgsc.wxProgressDialog_Resume,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxProgressDialog instance>"
+        return "<C wxProgressDialog instance at %s>" % (self.this,)
 class wxProgressDialog(wxProgressDialogPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxProgressDialog,(arg0,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(cmndlgsc.new_wxProgressDialog,_args,_kwargs)
         self.thisown = 1
 
 

utils/wxPython/src/gtk/controls2.py

@@ -15,68 +15,68 @@ class wxListItemPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, controls2c=controls2c):
+    def __del__(self,controls2c=controls2c):
         if self.thisown == 1 :
-            controls2c.delete_wxListItem(self.this)
+            controls2c.delete_wxListItem(self)
     def __setattr__(self,name,value):
         if name == "m_mask" :
-            controls2c.wxListItem_m_mask_set(self.this,value)
+            controls2c.wxListItem_m_mask_set(self,value)
             return
         if name == "m_itemId" :
-            controls2c.wxListItem_m_itemId_set(self.this,value)
+            controls2c.wxListItem_m_itemId_set(self,value)
             return
         if name == "m_col" :
-            controls2c.wxListItem_m_col_set(self.this,value)
+            controls2c.wxListItem_m_col_set(self,value)
             return
         if name == "m_state" :
-            controls2c.wxListItem_m_state_set(self.this,value)
+            controls2c.wxListItem_m_state_set(self,value)
             return
         if name == "m_stateMask" :
-            controls2c.wxListItem_m_stateMask_set(self.this,value)
+            controls2c.wxListItem_m_stateMask_set(self,value)
             return
         if name == "m_text" :
-            controls2c.wxListItem_m_text_set(self.this,value)
+            controls2c.wxListItem_m_text_set(self,value)
             return
         if name == "m_image" :
-            controls2c.wxListItem_m_image_set(self.this,value)
+            controls2c.wxListItem_m_image_set(self,value)
             return
         if name == "m_data" :
-            controls2c.wxListItem_m_data_set(self.this,value)
+            controls2c.wxListItem_m_data_set(self,value)
             return
         if name == "m_format" :
-            controls2c.wxListItem_m_format_set(self.this,value)
+            controls2c.wxListItem_m_format_set(self,value)
             return
         if name == "m_width" :
-            controls2c.wxListItem_m_width_set(self.this,value)
+            controls2c.wxListItem_m_width_set(self,value)
             return
         self.__dict__[name] = value
     def __getattr__(self,name):
         if name == "m_mask" : 
-            return controls2c.wxListItem_m_mask_get(self.this)
+            return controls2c.wxListItem_m_mask_get(self)
         if name == "m_itemId" : 
-            return controls2c.wxListItem_m_itemId_get(self.this)
+            return controls2c.wxListItem_m_itemId_get(self)
         if name == "m_col" : 
-            return controls2c.wxListItem_m_col_get(self.this)
+            return controls2c.wxListItem_m_col_get(self)
         if name == "m_state" : 
-            return controls2c.wxListItem_m_state_get(self.this)
+            return controls2c.wxListItem_m_state_get(self)
         if name == "m_stateMask" : 
-            return controls2c.wxListItem_m_stateMask_get(self.this)
+            return controls2c.wxListItem_m_stateMask_get(self)
         if name == "m_text" : 
-            return controls2c.wxListItem_m_text_get(self.this)
+            return controls2c.wxListItem_m_text_get(self)
         if name == "m_image" : 
-            return controls2c.wxListItem_m_image_get(self.this)
+            return controls2c.wxListItem_m_image_get(self)
         if name == "m_data" : 
-            return controls2c.wxListItem_m_data_get(self.this)
+            return controls2c.wxListItem_m_data_get(self)
         if name == "m_format" : 
-            return controls2c.wxListItem_m_format_get(self.this)
+            return controls2c.wxListItem_m_format_get(self)
         if name == "m_width" : 
-            return controls2c.wxListItem_m_width_get(self.this)
+            return controls2c.wxListItem_m_width_get(self)
         raise AttributeError,name
     def __repr__(self):
-        return "<C wxListItem instance>"
+        return "<C wxListItem instance at %s>" % (self.this,)
 class wxListItem(wxListItemPtr):
-    def __init__(self) :
-        self.this = controls2c.new_wxListItem()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(controls2c.new_wxListItem,_args,_kwargs)
         self.thisown = 1
 
 
@@ -88,45 +88,45 @@ class wxListEventPtr(wxCommandEventPtr):
         self.thisown = 0
     def __setattr__(self,name,value):
         if name == "m_code" :
-            controls2c.wxListEvent_m_code_set(self.this,value)
+            controls2c.wxListEvent_m_code_set(self,value)
             return
         if name == "m_itemIndex" :
-            controls2c.wxListEvent_m_itemIndex_set(self.this,value)
+            controls2c.wxListEvent_m_itemIndex_set(self,value)
             return
         if name == "m_oldItemIndex" :
-            controls2c.wxListEvent_m_oldItemIndex_set(self.this,value)
+            controls2c.wxListEvent_m_oldItemIndex_set(self,value)
             return
         if name == "m_col" :
-            controls2c.wxListEvent_m_col_set(self.this,value)
+            controls2c.wxListEvent_m_col_set(self,value)
             return
         if name == "m_cancelled" :
-            controls2c.wxListEvent_m_cancelled_set(self.this,value)
+            controls2c.wxListEvent_m_cancelled_set(self,value)
             return
         if name == "m_pointDrag" :
-            controls2c.wxListEvent_m_pointDrag_set(self.this,value.this)
+            controls2c.wxListEvent_m_pointDrag_set(self,value.this)
             return
         if name == "m_item" :
-            controls2c.wxListEvent_m_item_set(self.this,value.this)
+            controls2c.wxListEvent_m_item_set(self,value.this)
             return
         self.__dict__[name] = value
     def __getattr__(self,name):
         if name == "m_code" : 
-            return controls2c.wxListEvent_m_code_get(self.this)
+            return controls2c.wxListEvent_m_code_get(self)
         if name == "m_itemIndex" : 
-            return controls2c.wxListEvent_m_itemIndex_get(self.this)
+            return controls2c.wxListEvent_m_itemIndex_get(self)
         if name == "m_oldItemIndex" : 
-            return controls2c.wxListEvent_m_oldItemIndex_get(self.this)
+            return controls2c.wxListEvent_m_oldItemIndex_get(self)
         if name == "m_col" : 
-            return controls2c.wxListEvent_m_col_get(self.this)
+            return controls2c.wxListEvent_m_col_get(self)
         if name == "m_cancelled" : 
-            return controls2c.wxListEvent_m_cancelled_get(self.this)
+            return controls2c.wxListEvent_m_cancelled_get(self)
         if name == "m_pointDrag" : 
-            return wxPointPtr(controls2c.wxListEvent_m_pointDrag_get(self.this))
+            return wxPointPtr(controls2c.wxListEvent_m_pointDrag_get(self))
         if name == "m_item" : 
-            return wxListItemPtr(controls2c.wxListEvent_m_item_get(self.this))
+            return wxListItemPtr(controls2c.wxListEvent_m_item_get(self))
         raise AttributeError,name
     def __repr__(self):
-        return "<C wxListEvent instance>"
+        return "<C wxListEvent instance at %s>" % (self.this,)
 class wxListEvent(wxListEventPtr):
     def __init__(self,this):
         self.this = this
@@ -138,165 +138,156 @@ class wxListCtrlPtr(wxControlPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def Arrange(self,*args):
-        val = apply(controls2c.wxListCtrl_Arrange,(self.this,)+args)
+    def Arrange(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_Arrange,(self,) + _args, _kwargs)
         return val
-    def DeleteItem(self,arg0):
-        val = controls2c.wxListCtrl_DeleteItem(self.this,arg0)
+    def DeleteItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_DeleteItem,(self,) + _args, _kwargs)
         return val
-    def DeleteAllItems(self):
-        val = controls2c.wxListCtrl_DeleteAllItems(self.this)
+    def DeleteAllItems(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_DeleteAllItems,(self,) + _args, _kwargs)
         return val
-    def DeleteColumn(self,arg0):
-        val = controls2c.wxListCtrl_DeleteColumn(self.this,arg0)
+    def DeleteColumn(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_DeleteColumn,(self,) + _args, _kwargs)
         return val
-    def DeleteAllColumns(self):
-        val = controls2c.wxListCtrl_DeleteAllColumns(self.this)
+    def DeleteAllColumns(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_DeleteAllColumns,(self,) + _args, _kwargs)
         return val
-    def ClearAll(self):
-        val = controls2c.wxListCtrl_ClearAll(self.this)
+    def ClearAll(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_ClearAll,(self,) + _args, _kwargs)
         return val
-    def EditLabel(self,arg0):
-        val = controls2c.wxListCtrl_EditLabel(self.this,arg0)
+    def EditLabel(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_EditLabel,(self,) + _args, _kwargs)
         return val
-    def EnsureVisible(self,arg0):
-        val = controls2c.wxListCtrl_EnsureVisible(self.this,arg0)
+    def EnsureVisible(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_EnsureVisible,(self,) + _args, _kwargs)
         return val
-    def FindItem(self,arg0,arg1,*args):
-        val = apply(controls2c.wxListCtrl_FindItem,(self.this,arg0,arg1,)+args)
+    def FindItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_FindItem,(self,) + _args, _kwargs)
         return val
-    def FindItemData(self,arg0,arg1):
-        val = controls2c.wxListCtrl_FindItemData(self.this,arg0,arg1)
+    def FindItemData(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_FindItemData,(self,) + _args, _kwargs)
         return val
-    def FindItemAtPos(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_FindItemAtPos(self.this,arg0,arg1.this,arg2)
+    def FindItemAtPos(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_FindItemAtPos,(self,) + _args, _kwargs)
         return val
-    def GetColumn(self,arg0,arg1):
-        val = controls2c.wxListCtrl_GetColumn(self.this,arg0,arg1.this)
+    def GetColumn(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetColumn,(self,) + _args, _kwargs)
         return val
-    def GetColumnWidth(self,arg0):
-        val = controls2c.wxListCtrl_GetColumnWidth(self.this,arg0)
+    def GetColumnWidth(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetColumnWidth,(self,) + _args, _kwargs)
         return val
-    def GetCountPerPage(self):
-        val = controls2c.wxListCtrl_GetCountPerPage(self.this)
+    def GetCountPerPage(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetCountPerPage,(self,) + _args, _kwargs)
         return val
-    def GetImageList(self,arg0):
-        val = controls2c.wxListCtrl_GetImageList(self.this,arg0)
-        val = wxImageListPtr(val)
+    def GetImageList(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetImageList,(self,) + _args, _kwargs)
+        if val: val = wxImageListPtr(val) 
         return val
-    def GetItemData(self,arg0):
-        val = controls2c.wxListCtrl_GetItemData(self.this,arg0)
+    def GetItemData(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetItemData,(self,) + _args, _kwargs)
         return val
-    def GetItem(self,arg0):
-        val = controls2c.wxListCtrl_GetItem(self.this,arg0)
-        val = wxListItemPtr(val)
-        val.thisown = 1
+    def GetItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetItem,(self,) + _args, _kwargs)
+        if val: val = wxListItemPtr(val) ; val.thisown = 1
         return val
-    def GetItemPosition(self,arg0):
-        val = controls2c.wxListCtrl_GetItemPosition(self.this,arg0)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetItemPosition(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetItemPosition,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetItemRect(self,arg0,*args):
-        val = apply(controls2c.wxListCtrl_GetItemRect,(self.this,arg0,)+args)
-        val = wxRectPtr(val)
-        val.thisown = 1
+    def GetItemRect(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetItemRect,(self,) + _args, _kwargs)
+        if val: val = wxRectPtr(val) ; val.thisown = 1
         return val
-    def GetItemState(self,arg0,arg1):
-        val = controls2c.wxListCtrl_GetItemState(self.this,arg0,arg1)
+    def GetItemState(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetItemState,(self,) + _args, _kwargs)
         return val
-    def GetItemCount(self):
-        val = controls2c.wxListCtrl_GetItemCount(self.this)
+    def GetItemCount(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetItemCount,(self,) + _args, _kwargs)
         return val
-    def GetItemSpacing(self,arg0):
-        val = controls2c.wxListCtrl_GetItemSpacing(self.this,arg0)
+    def GetItemSpacing(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetItemSpacing,(self,) + _args, _kwargs)
         return val
-    def GetItemText(self,arg0):
-        val = controls2c.wxListCtrl_GetItemText(self.this,arg0)
+    def GetItemText(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetItemText,(self,) + _args, _kwargs)
         return val
-    def GetNextItem(self,arg0,*args):
-        val = apply(controls2c.wxListCtrl_GetNextItem,(self.this,arg0,)+args)
+    def GetNextItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetNextItem,(self,) + _args, _kwargs)
         return val
-    def GetSelectedItemCount(self):
-        val = controls2c.wxListCtrl_GetSelectedItemCount(self.this)
+    def GetSelectedItemCount(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetSelectedItemCount,(self,) + _args, _kwargs)
         return val
-    def GetTopItem(self):
-        val = controls2c.wxListCtrl_GetTopItem(self.this)
+    def GetTopItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_GetTopItem,(self,) + _args, _kwargs)
         return val
-    def HitTest(self,arg0):
-        val = controls2c.wxListCtrl_HitTest(self.this,arg0.this)
+    def HitTest(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_HitTest,(self,) + _args, _kwargs)
         return val
-    def InsertColumnWith(self,arg0,arg1):
-        val = controls2c.wxListCtrl_InsertColumnWith(self.this,arg0,arg1.this)
+    def InsertColumnWith(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_InsertColumnWith,(self,) + _args, _kwargs)
         return val
-    def InsertColumn(self,arg0,arg1,*args):
-        val = apply(controls2c.wxListCtrl_InsertColumn,(self.this,arg0,arg1,)+args)
+    def InsertColumn(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_InsertColumn,(self,) + _args, _kwargs)
         return val
-    def InsertItem(self,arg0):
-        val = controls2c.wxListCtrl_InsertItem(self.this,arg0.this)
+    def InsertItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_InsertItem,(self,) + _args, _kwargs)
         return val
-    def InsertStringItem(self,arg0,arg1):
-        val = controls2c.wxListCtrl_InsertStringItem(self.this,arg0,arg1)
+    def InsertStringItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_InsertStringItem,(self,) + _args, _kwargs)
         return val
-    def InsertImageItem(self,arg0,arg1):
-        val = controls2c.wxListCtrl_InsertImageItem(self.this,arg0,arg1)
+    def InsertImageItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_InsertImageItem,(self,) + _args, _kwargs)
         return val
-    def InsertImageStringItem(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_InsertImageStringItem(self.this,arg0,arg1,arg2)
+    def InsertImageStringItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_InsertImageStringItem,(self,) + _args, _kwargs)
         return val
-    def ScrollList(self,arg0,arg1):
-        val = controls2c.wxListCtrl_ScrollList(self.this,arg0,arg1)
+    def ScrollList(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_ScrollList,(self,) + _args, _kwargs)
         return val
-    def SetBackgroundColour(self,arg0):
-        val = controls2c.wxListCtrl_SetBackgroundColour(self.this,arg0.this)
+    def SetBackgroundColour(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetBackgroundColour,(self,) + _args, _kwargs)
         return val
-    def SetColumn(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetColumn(self.this,arg0,arg1.this)
+    def SetColumn(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetColumn,(self,) + _args, _kwargs)
         return val
-    def SetColumnWidth(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetColumnWidth(self.this,arg0,arg1)
+    def SetColumnWidth(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetColumnWidth,(self,) + _args, _kwargs)
         return val
-    def SetImageList(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetImageList(self.this,arg0.this,arg1)
+    def SetImageList(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetImageList,(self,) + _args, _kwargs)
         return val
-    def SetItem(self,arg0):
-        val = controls2c.wxListCtrl_SetItem(self.this,arg0.this)
+    def SetItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetItem,(self,) + _args, _kwargs)
         return val
-    def SetStringItem(self,arg0,arg1,arg2,*args):
-        val = apply(controls2c.wxListCtrl_SetStringItem,(self.this,arg0,arg1,arg2,)+args)
+    def SetStringItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetStringItem,(self,) + _args, _kwargs)
         return val
-    def SetItemData(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetItemData(self.this,arg0,arg1)
+    def SetItemData(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetItemData,(self,) + _args, _kwargs)
         return val
-    def SetItemImage(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_SetItemImage(self.this,arg0,arg1,arg2)
+    def SetItemImage(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetItemImage,(self,) + _args, _kwargs)
         return val
-    def SetItemPosition(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetItemPosition(self.this,arg0,arg1.this)
+    def SetItemPosition(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetItemPosition,(self,) + _args, _kwargs)
         return val
-    def SetItemState(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_SetItemState(self.this,arg0,arg1,arg2)
+    def SetItemState(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetItemState,(self,) + _args, _kwargs)
         return val
-    def SetItemText(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetItemText(self.this,arg0,arg1)
+    def SetItemText(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetItemText,(self,) + _args, _kwargs)
         return val
-    def SetSingleStyle(self,arg0,*args):
-        val = apply(controls2c.wxListCtrl_SetSingleStyle,(self.this,arg0,)+args)
+    def SetSingleStyle(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetSingleStyle,(self,) + _args, _kwargs)
         return val
-    def SetWindowStyleFlag(self,arg0):
-        val = controls2c.wxListCtrl_SetWindowStyleFlag(self.this,arg0)
+    def SetWindowStyleFlag(self, *_args, **_kwargs):
+        val = apply(controls2c.wxListCtrl_SetWindowStyleFlag,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxListCtrl instance>"
+        return "<C wxListCtrl instance at %s>" % (self.this,)
 class wxListCtrl(wxListCtrlPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controls2c.new_wxListCtrl,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(controls2c.new_wxListCtrl,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
 
@@ -307,17 +298,17 @@ class wxTreeItemIdPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, controls2c=controls2c):
+    def __del__(self,controls2c=controls2c):
         if self.thisown == 1 :
-            controls2c.delete_wxTreeItemId(self.this)
-    def IsOk(self):
-        val = controls2c.wxTreeItemId_IsOk(self.this)
+            controls2c.delete_wxTreeItemId(self)
+    def IsOk(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeItemId_IsOk,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxTreeItemId instance>"
+        return "<C wxTreeItemId instance at %s>" % (self.this,)
 class wxTreeItemId(wxTreeItemIdPtr):
-    def __init__(self) :
-        self.this = controls2c.new_wxTreeItemId()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(controls2c.new_wxTreeItemId,_args,_kwargs)
         self.thisown = 1
 
 
@@ -327,24 +318,24 @@ class wxTreeItemDataPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetData(self):
-        val = controls2c.wxTreeItemData_GetData(self.this)
+    def GetData(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeItemData_GetData,(self,) + _args, _kwargs)
         return val
-    def SetData(self,arg0):
-        val = controls2c.wxTreeItemData_SetData(self.this,arg0)
+    def SetData(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeItemData_SetData,(self,) + _args, _kwargs)
         return val
-    def GetId(self):
-        val = controls2c.wxTreeItemData_GetId(self.this)
-        val = wxTreeItemIdPtr(val)
+    def GetId(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeItemData_GetId,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) 
         return val
-    def SetId(self,arg0):
-        val = controls2c.wxTreeItemData_SetId(self.this,arg0.this)
+    def SetId(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeItemData_SetId,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxTreeItemData instance>"
+        return "<C wxTreeItemData instance at %s>" % (self.this,)
 class wxTreeItemData(wxTreeItemDataPtr):
-    def __init__(self,*args) :
-        self.this = apply(controls2c.new_wxTreeItemData,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(controls2c.new_wxTreeItemData,_args,_kwargs)
         self.thisown = 1
 
 
@@ -354,29 +345,26 @@ class wxTreeEventPtr(wxNotifyEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetItem(self):
-        val = controls2c.wxTreeEvent_GetItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeEvent_GetItem,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def GetOldItem(self):
-        val = controls2c.wxTreeEvent_GetOldItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetOldItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeEvent_GetOldItem,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def GetPoint(self):
-        val = controls2c.wxTreeEvent_GetPoint(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetPoint(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeEvent_GetPoint,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetCode(self):
-        val = controls2c.wxTreeEvent_GetCode(self.this)
+    def GetCode(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeEvent_GetCode,(self,) + _args, _kwargs)
         return val
-    def GetLabel(self):
-        val = controls2c.wxTreeEvent_GetLabel(self.this)
+    def GetLabel(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeEvent_GetLabel,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxTreeEvent instance>"
+        return "<C wxTreeEvent instance at %s>" % (self.this,)
 class wxTreeEvent(wxTreeEventPtr):
     def __init__(self,this):
         self.this = this
@@ -388,212 +376,183 @@ class wxTreeCtrlPtr(wxControlPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetCount(self):
-        val = controls2c.wxTreeCtrl_GetCount(self.this)
+    def GetCount(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetCount,(self,) + _args, _kwargs)
         return val
-    def GetIndent(self):
-        val = controls2c.wxTreeCtrl_GetIndent(self.this)
+    def GetIndent(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetIndent,(self,) + _args, _kwargs)
         return val
-    def SetIndent(self,arg0):
-        val = controls2c.wxTreeCtrl_SetIndent(self.this,arg0)
+    def SetIndent(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetIndent,(self,) + _args, _kwargs)
         return val
-    def GetImageList(self):
-        val = controls2c.wxTreeCtrl_GetImageList(self.this)
-        val = wxImageListPtr(val)
+    def GetImageList(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetImageList,(self,) + _args, _kwargs)
+        if val: val = wxImageListPtr(val) 
         return val
-    def GetStateImageList(self):
-        val = controls2c.wxTreeCtrl_GetStateImageList(self.this)
-        val = wxImageListPtr(val)
+    def GetStateImageList(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetStateImageList,(self,) + _args, _kwargs)
+        if val: val = wxImageListPtr(val) 
         return val
-    def SetImageList(self,arg0):
-        val = controls2c.wxTreeCtrl_SetImageList(self.this,arg0.this)
+    def SetImageList(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetImageList,(self,) + _args, _kwargs)
         return val
-    def SetStateImageList(self,arg0):
-        val = controls2c.wxTreeCtrl_SetStateImageList(self.this,arg0.this)
+    def SetStateImageList(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetStateImageList,(self,) + _args, _kwargs)
         return val
-    def GetItemText(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemText(self.this,arg0.this)
+    def GetItemText(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetItemText,(self,) + _args, _kwargs)
         return val
-    def GetItemImage(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemImage(self.this,arg0.this)
+    def GetItemImage(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetItemImage,(self,) + _args, _kwargs)
         return val
-    def GetItemSelectedImage(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemSelectedImage(self.this,arg0.this)
+    def GetItemSelectedImage(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetItemSelectedImage,(self,) + _args, _kwargs)
         return val
-    def SetItemText(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemText(self.this,arg0.this,arg1)
+    def SetItemText(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetItemText,(self,) + _args, _kwargs)
         return val
-    def SetItemImage(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemImage(self.this,arg0.this,arg1)
+    def SetItemImage(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetItemImage,(self,) + _args, _kwargs)
         return val
-    def SetItemSelectedImage(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemSelectedImage(self.this,arg0.this,arg1)
+    def SetItemSelectedImage(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetItemSelectedImage,(self,) + _args, _kwargs)
         return val
-    def SetItemHasChildren(self,arg0,*args):
-        val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self.this,arg0.this,)+args)
+    def SetItemHasChildren(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self,) + _args, _kwargs)
         return val
-    def GetItemData(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0.this)
-        val = wxTreeItemDataPtr(val)
+    def GetItemData(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetItemData,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemDataPtr(val) 
         return val
-    def SetItemData(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemData(self.this,arg0.this,arg1.this)
+    def SetItemData(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetItemData,(self,) + _args, _kwargs)
         return val
-    def GetPyData(self,arg0):
-        val = controls2c.wxTreeCtrl_GetPyData(self.this,arg0.this)
+    def GetPyData(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetPyData,(self,) + _args, _kwargs)
         return val
-    def SetPyData(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetPyData(self.this,arg0.this,arg1)
+    def SetPyData(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetPyData,(self,) + _args, _kwargs)
         return val
-    def IsVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_IsVisible(self.this,arg0.this)
+    def IsVisible(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_IsVisible,(self,) + _args, _kwargs)
         return val
-    def ItemHasChildren(self,arg0):
-        val = controls2c.wxTreeCtrl_ItemHasChildren(self.this,arg0.this)
+    def ItemHasChildren(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_ItemHasChildren,(self,) + _args, _kwargs)
         return val
-    def IsExpanded(self,arg0):
-        val = controls2c.wxTreeCtrl_IsExpanded(self.this,arg0.this)
+    def IsExpanded(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_IsExpanded,(self,) + _args, _kwargs)
         return val
-    def IsSelected(self,arg0):
-        val = controls2c.wxTreeCtrl_IsSelected(self.this,arg0.this)
+    def IsSelected(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_IsSelected,(self,) + _args, _kwargs)
         return val
-    def GetRootItem(self):
-        val = controls2c.wxTreeCtrl_GetRootItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetRootItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetRootItem,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def GetSelection(self):
-        val = controls2c.wxTreeCtrl_GetSelection(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetSelection(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetSelection,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def GetParent(self,arg0):
-        val = controls2c.wxTreeCtrl_GetParent(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetParent(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetParent,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def GetChildrenCount(self,arg0,*args):
-        val = apply(controls2c.wxTreeCtrl_GetChildrenCount,(self.this,arg0.this,)+args)
+    def GetChildrenCount(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetChildrenCount,(self,) + _args, _kwargs)
         return val
-    def GetFirstChild(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
+    def GetFirstChild(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetFirstChild,(self,) + _args, _kwargs)
         return val
-    def GetNextChild(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_GetNextChild(self.this,arg0.this,arg1)
+    def GetNextChild(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetNextChild,(self,) + _args, _kwargs)
         return val
-    def GetNextSibling(self,arg0):
-        val = controls2c.wxTreeCtrl_GetNextSibling(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetNextSibling(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetNextSibling,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def GetPrevSibling(self,arg0):
-        val = controls2c.wxTreeCtrl_GetPrevSibling(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetPrevSibling(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetPrevSibling,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def GetFirstVisibleItem(self):
-        val = controls2c.wxTreeCtrl_GetFirstVisibleItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetFirstVisibleItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetFirstVisibleItem,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def GetNextVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_GetNextVisible(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetNextVisible(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetNextVisible,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def GetPrevVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_GetPrevVisible(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def GetPrevVisible(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_GetPrevVisible,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def AddRoot(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_AddRoot,(self.this,arg0,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def AddRoot(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_AddRoot,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def PrependItem(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_PrependItem,(self.this,arg0.this,arg1,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def PrependItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_PrependItem,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def InsertItem(self,arg0,arg1,arg2,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_InsertItem,(self.this,arg0.this,arg1.this,arg2,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def InsertItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_InsertItem,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def AppendItem(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_AppendItem,(self.this,arg0.this,arg1,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def AppendItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_AppendItem,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
-    def Delete(self,arg0):
-        val = controls2c.wxTreeCtrl_Delete(self.this,arg0.this)
+    def Delete(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_Delete,(self,) + _args, _kwargs)
         return val
-    def DeleteChildren(self,arg0):
-        val = controls2c.wxTreeCtrl_DeleteChildren(self.this,arg0.this)
+    def DeleteChildren(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_DeleteChildren,(self,) + _args, _kwargs)
         return val
-    def DeleteAllItems(self):
-        val = controls2c.wxTreeCtrl_DeleteAllItems(self.this)
+    def DeleteAllItems(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_DeleteAllItems,(self,) + _args, _kwargs)
         return val
-    def Expand(self,arg0):
-        val = controls2c.wxTreeCtrl_Expand(self.this,arg0.this)
+    def Expand(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_Expand,(self,) + _args, _kwargs)
         return val
-    def Collapse(self,arg0):
-        val = controls2c.wxTreeCtrl_Collapse(self.this,arg0.this)
+    def Collapse(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_Collapse,(self,) + _args, _kwargs)
         return val
-    def CollapseAndReset(self,arg0):
-        val = controls2c.wxTreeCtrl_CollapseAndReset(self.this,arg0.this)
+    def CollapseAndReset(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_CollapseAndReset,(self,) + _args, _kwargs)
         return val
-    def Toggle(self,arg0):
-        val = controls2c.wxTreeCtrl_Toggle(self.this,arg0.this)
+    def Toggle(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_Toggle,(self,) + _args, _kwargs)
         return val
-    def Unselect(self):
-        val = controls2c.wxTreeCtrl_Unselect(self.this)
+    def Unselect(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_Unselect,(self,) + _args, _kwargs)
         return val
-    def UnselectAll(self):
-        val = controls2c.wxTreeCtrl_UnselectAll(self.this)
+    def UnselectAll(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_UnselectAll,(self,) + _args, _kwargs)
         return val
-    def SelectItem(self,arg0):
-        val = controls2c.wxTreeCtrl_SelectItem(self.this,arg0.this)
+    def SelectItem(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SelectItem,(self,) + _args, _kwargs)
         return val
-    def EnsureVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_EnsureVisible(self.this,arg0.this)
+    def EnsureVisible(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_EnsureVisible,(self,) + _args, _kwargs)
         return val
-    def ScrollTo(self,arg0):
-        val = controls2c.wxTreeCtrl_ScrollTo(self.this,arg0.this)
+    def ScrollTo(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_ScrollTo,(self,) + _args, _kwargs)
         return val
-    def EditLabel(self,arg0):
-        val = controls2c.wxTreeCtrl_EditLabel(self.this,arg0.this)
+    def EditLabel(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_EditLabel,(self,) + _args, _kwargs)
         return val
-    def SetItemBold(self,arg0,*args):
-        val = apply(controls2c.wxTreeCtrl_SetItemBold,(self.this,arg0.this,)+args)
+    def SetItemBold(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_SetItemBold,(self,) + _args, _kwargs)
         return val
-    def IsBold(self,arg0):
-        val = controls2c.wxTreeCtrl_IsBold(self.this,arg0.this)
+    def IsBold(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_IsBold,(self,) + _args, _kwargs)
         return val
-    def HitTest(self,arg0):
-        val = controls2c.wxTreeCtrl_HitTest(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
+    def HitTest(self, *_args, **_kwargs):
+        val = apply(controls2c.wxTreeCtrl_HitTest,(self,) + _args, _kwargs)
+        if val: val = wxTreeItemIdPtr(val) ; val.thisown = 1
         return val
     def __repr__(self):
-        return "<C wxTreeCtrl instance>"
+        return "<C wxTreeCtrl instance at %s>" % (self.this,)
     
     # Redefine a couple methods that SWIG gets a bit confused on...
     def GetFirstChild(self,arg0,arg1):
@@ -608,14 +567,8 @@ class wxTreeCtrlPtr(wxControlPtr):
         return (val1,val2)
 
 class wxTreeCtrl(wxTreeCtrlPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controls2c.new_wxTreeCtrl,(arg0.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(controls2c.new_wxTreeCtrl,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
 

utils/wxPython/src/gtk/events.py

@@ -6,38 +6,38 @@ class wxEventPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetEventObject(self):
-        val = eventsc.wxEvent_GetEventObject(self.this)
+    def GetEventObject(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_GetEventObject,(self,) + _args, _kwargs)
         return val
-    def GetEventType(self):
-        val = eventsc.wxEvent_GetEventType(self.this)
+    def GetEventType(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_GetEventType,(self,) + _args, _kwargs)
         return val
-    def GetId(self):
-        val = eventsc.wxEvent_GetId(self.this)
+    def GetId(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_GetId,(self,) + _args, _kwargs)
         return val
-    def GetSkipped(self):
-        val = eventsc.wxEvent_GetSkipped(self.this)
+    def GetSkipped(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_GetSkipped,(self,) + _args, _kwargs)
         return val
-    def GetTimestamp(self):
-        val = eventsc.wxEvent_GetTimestamp(self.this)
+    def GetTimestamp(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_GetTimestamp,(self,) + _args, _kwargs)
         return val
-    def SetEventObject(self,arg0):
-        val = eventsc.wxEvent_SetEventObject(self.this,arg0)
+    def SetEventObject(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_SetEventObject,(self,) + _args, _kwargs)
         return val
-    def SetEventType(self,arg0):
-        val = eventsc.wxEvent_SetEventType(self.this,arg0)
+    def SetEventType(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_SetEventType,(self,) + _args, _kwargs)
         return val
-    def SetId(self,arg0):
-        val = eventsc.wxEvent_SetId(self.this,arg0)
+    def SetId(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_SetId,(self,) + _args, _kwargs)
         return val
-    def SetTimestamp(self,arg0):
-        val = eventsc.wxEvent_SetTimestamp(self.this,arg0)
+    def SetTimestamp(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_SetTimestamp,(self,) + _args, _kwargs)
         return val
-    def Skip(self,*args):
-        val = apply(eventsc.wxEvent_Skip,(self.this,)+args)
+    def Skip(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEvent_Skip,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxEvent instance>"
+        return "<C wxEvent instance at %s>" % (self.this,)
 class wxEvent(wxEventPtr):
     def __init__(self,this):
         self.this = this
@@ -49,13 +49,12 @@ class wxSizeEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetSize(self):
-        val = eventsc.wxSizeEvent_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
+    def GetSize(self, *_args, **_kwargs):
+        val = apply(eventsc.wxSizeEvent_GetSize,(self,) + _args, _kwargs)
+        if val: val = wxSizePtr(val) ; val.thisown = 1
         return val
     def __repr__(self):
-        return "<C wxSizeEvent instance>"
+        return "<C wxSizeEvent instance at %s>" % (self.this,)
 class wxSizeEvent(wxSizeEventPtr):
     def __init__(self,this):
         self.this = this
@@ -67,26 +66,26 @@ class wxCloseEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def SetLoggingOff(self,arg0):
-        val = eventsc.wxCloseEvent_SetLoggingOff(self.this,arg0)
+    def SetLoggingOff(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCloseEvent_SetLoggingOff,(self,) + _args, _kwargs)
         return val
-    def GetLoggingOff(self):
-        val = eventsc.wxCloseEvent_GetLoggingOff(self.this)
+    def GetLoggingOff(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCloseEvent_GetLoggingOff,(self,) + _args, _kwargs)
         return val
-    def Veto(self,*args):
-        val = apply(eventsc.wxCloseEvent_Veto,(self.this,)+args)
+    def Veto(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCloseEvent_Veto,(self,) + _args, _kwargs)
         return val
-    def CanVeto(self):
-        val = eventsc.wxCloseEvent_CanVeto(self.this)
+    def CanVeto(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCloseEvent_CanVeto,(self,) + _args, _kwargs)
         return val
-    def GetVeto(self):
-        val = eventsc.wxCloseEvent_GetVeto(self.this)
+    def GetVeto(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCloseEvent_GetVeto,(self,) + _args, _kwargs)
         return val
-    def SetCanVeto(self,arg0):
-        val = eventsc.wxCloseEvent_SetCanVeto(self.this,arg0)
+    def SetCanVeto(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCloseEvent_SetCanVeto,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxCloseEvent instance>"
+        return "<C wxCloseEvent instance at %s>" % (self.this,)
 class wxCloseEvent(wxCloseEventPtr):
     def __init__(self,this):
         self.this = this
@@ -98,26 +97,26 @@ class wxCommandEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def Checked(self):
-        val = eventsc.wxCommandEvent_Checked(self.this)
+    def Checked(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCommandEvent_Checked,(self,) + _args, _kwargs)
         return val
-    def GetExtraLong(self):
-        val = eventsc.wxCommandEvent_GetExtraLong(self.this)
+    def GetExtraLong(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCommandEvent_GetExtraLong,(self,) + _args, _kwargs)
         return val
-    def GetInt(self):
-        val = eventsc.wxCommandEvent_GetInt(self.this)
+    def GetInt(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCommandEvent_GetInt,(self,) + _args, _kwargs)
         return val
-    def GetSelection(self):
-        val = eventsc.wxCommandEvent_GetSelection(self.this)
+    def GetSelection(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCommandEvent_GetSelection,(self,) + _args, _kwargs)
         return val
-    def GetString(self):
-        val = eventsc.wxCommandEvent_GetString(self.this)
+    def GetString(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCommandEvent_GetString,(self,) + _args, _kwargs)
         return val
-    def IsSelection(self):
-        val = eventsc.wxCommandEvent_IsSelection(self.this)
+    def IsSelection(self, *_args, **_kwargs):
+        val = apply(eventsc.wxCommandEvent_IsSelection,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxCommandEvent instance>"
+        return "<C wxCommandEvent instance at %s>" % (self.this,)
 class wxCommandEvent(wxCommandEventPtr):
     def __init__(self,this):
         self.this = this
@@ -129,14 +128,14 @@ class wxScrollEventPtr(wxCommandEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetOrientation(self):
-        val = eventsc.wxScrollEvent_GetOrientation(self.this)
+    def GetOrientation(self, *_args, **_kwargs):
+        val = apply(eventsc.wxScrollEvent_GetOrientation,(self,) + _args, _kwargs)
         return val
-    def GetPosition(self):
-        val = eventsc.wxScrollEvent_GetPosition(self.this)
+    def GetPosition(self, *_args, **_kwargs):
+        val = apply(eventsc.wxScrollEvent_GetPosition,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxScrollEvent instance>"
+        return "<C wxScrollEvent instance at %s>" % (self.this,)
 class wxScrollEvent(wxScrollEventPtr):
     def __init__(self,this):
         self.this = this
@@ -149,7 +148,7 @@ class wxSpinEventPtr(wxScrollEventPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxSpinEvent instance>"
+        return "<C wxSpinEvent instance at %s>" % (self.this,)
 class wxSpinEvent(wxSpinEventPtr):
     def __init__(self,this):
         self.this = this
@@ -161,105 +160,103 @@ class wxMouseEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def IsButton(self):
-        val = eventsc.wxMouseEvent_IsButton(self.this)
+    def IsButton(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_IsButton,(self,) + _args, _kwargs)
         return val
-    def ButtonDown(self,*args):
-        val = apply(eventsc.wxMouseEvent_ButtonDown,(self.this,)+args)
+    def ButtonDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_ButtonDown,(self,) + _args, _kwargs)
         return val
-    def ButtonDClick(self,*args):
-        val = apply(eventsc.wxMouseEvent_ButtonDClick,(self.this,)+args)
+    def ButtonDClick(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_ButtonDClick,(self,) + _args, _kwargs)
         return val
-    def ButtonUp(self,*args):
-        val = apply(eventsc.wxMouseEvent_ButtonUp,(self.this,)+args)
+    def ButtonUp(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_ButtonUp,(self,) + _args, _kwargs)
         return val
-    def Button(self,arg0):
-        val = eventsc.wxMouseEvent_Button(self.this,arg0)
+    def Button(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_Button,(self,) + _args, _kwargs)
         return val
-    def ButtonIsDown(self,arg0):
-        val = eventsc.wxMouseEvent_ButtonIsDown(self.this,arg0)
+    def ButtonIsDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_ButtonIsDown,(self,) + _args, _kwargs)
         return val
-    def ControlDown(self):
-        val = eventsc.wxMouseEvent_ControlDown(self.this)
+    def ControlDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_ControlDown,(self,) + _args, _kwargs)
         return val
-    def MetaDown(self):
-        val = eventsc.wxMouseEvent_MetaDown(self.this)
+    def MetaDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_MetaDown,(self,) + _args, _kwargs)
         return val
-    def AltDown(self):
-        val = eventsc.wxMouseEvent_AltDown(self.this)
+    def AltDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_AltDown,(self,) + _args, _kwargs)
         return val
-    def ShiftDown(self):
-        val = eventsc.wxMouseEvent_ShiftDown(self.this)
+    def ShiftDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_ShiftDown,(self,) + _args, _kwargs)
         return val
-    def LeftDown(self):
-        val = eventsc.wxMouseEvent_LeftDown(self.this)
+    def LeftDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_LeftDown,(self,) + _args, _kwargs)
         return val
-    def MiddleDown(self):
-        val = eventsc.wxMouseEvent_MiddleDown(self.this)
+    def MiddleDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_MiddleDown,(self,) + _args, _kwargs)
         return val
-    def RightDown(self):
-        val = eventsc.wxMouseEvent_RightDown(self.this)
+    def RightDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_RightDown,(self,) + _args, _kwargs)
         return val
-    def LeftUp(self):
-        val = eventsc.wxMouseEvent_LeftUp(self.this)
+    def LeftUp(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_LeftUp,(self,) + _args, _kwargs)
         return val
-    def MiddleUp(self):
-        val = eventsc.wxMouseEvent_MiddleUp(self.this)
+    def MiddleUp(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_MiddleUp,(self,) + _args, _kwargs)
         return val
-    def RightUp(self):
-        val = eventsc.wxMouseEvent_RightUp(self.this)
+    def RightUp(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_RightUp,(self,) + _args, _kwargs)
         return val
-    def LeftDClick(self):
-        val = eventsc.wxMouseEvent_LeftDClick(self.this)
+    def LeftDClick(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_LeftDClick,(self,) + _args, _kwargs)
         return val
-    def MiddleDClick(self):
-        val = eventsc.wxMouseEvent_MiddleDClick(self.this)
+    def MiddleDClick(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_MiddleDClick,(self,) + _args, _kwargs)
         return val
-    def RightDClick(self):
-        val = eventsc.wxMouseEvent_RightDClick(self.this)
+    def RightDClick(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_RightDClick,(self,) + _args, _kwargs)
         return val
-    def LeftIsDown(self):
-        val = eventsc.wxMouseEvent_LeftIsDown(self.this)
+    def LeftIsDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_LeftIsDown,(self,) + _args, _kwargs)
         return val
-    def MiddleIsDown(self):
-        val = eventsc.wxMouseEvent_MiddleIsDown(self.this)
+    def MiddleIsDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_MiddleIsDown,(self,) + _args, _kwargs)
         return val
-    def RightIsDown(self):
-        val = eventsc.wxMouseEvent_RightIsDown(self.this)
+    def RightIsDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_RightIsDown,(self,) + _args, _kwargs)
         return val
-    def Dragging(self):
-        val = eventsc.wxMouseEvent_Dragging(self.this)
+    def Dragging(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_Dragging,(self,) + _args, _kwargs)
         return val
-    def Moving(self):
-        val = eventsc.wxMouseEvent_Moving(self.this)
+    def Moving(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_Moving,(self,) + _args, _kwargs)
         return val
-    def Entering(self):
-        val = eventsc.wxMouseEvent_Entering(self.this)
+    def Entering(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_Entering,(self,) + _args, _kwargs)
         return val
-    def Leaving(self):
-        val = eventsc.wxMouseEvent_Leaving(self.this)
+    def Leaving(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_Leaving,(self,) + _args, _kwargs)
         return val
-    def Position(self):
-        val = eventsc.wxMouseEvent_Position(self.this)
+    def Position(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_Position,(self,) + _args, _kwargs)
         return val
-    def GetPosition(self):
-        val = eventsc.wxMouseEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetPosition(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_GetPosition,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetLogicalPosition(self,arg0):
-        val = eventsc.wxMouseEvent_GetLogicalPosition(self.this,arg0.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetLogicalPosition(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_GetLogicalPosition,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetX(self):
-        val = eventsc.wxMouseEvent_GetX(self.this)
+    def GetX(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_GetX,(self,) + _args, _kwargs)
         return val
-    def GetY(self):
-        val = eventsc.wxMouseEvent_GetY(self.this)
+    def GetY(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMouseEvent_GetY,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxMouseEvent instance>"
+        return "<C wxMouseEvent instance at %s>" % (self.this,)
 class wxMouseEvent(wxMouseEventPtr):
     def __init__(self,this):
         self.this = this
@@ -271,23 +268,23 @@ class wxKeyEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def ControlDown(self):
-        val = eventsc.wxKeyEvent_ControlDown(self.this)
+    def ControlDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxKeyEvent_ControlDown,(self,) + _args, _kwargs)
         return val
-    def MetaDown(self):
-        val = eventsc.wxKeyEvent_MetaDown(self.this)
+    def MetaDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxKeyEvent_MetaDown,(self,) + _args, _kwargs)
         return val
-    def AltDown(self):
-        val = eventsc.wxKeyEvent_AltDown(self.this)
+    def AltDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxKeyEvent_AltDown,(self,) + _args, _kwargs)
         return val
-    def ShiftDown(self):
-        val = eventsc.wxKeyEvent_ShiftDown(self.this)
+    def ShiftDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxKeyEvent_ShiftDown,(self,) + _args, _kwargs)
         return val
-    def KeyCode(self):
-        val = eventsc.wxKeyEvent_KeyCode(self.this)
+    def KeyCode(self, *_args, **_kwargs):
+        val = apply(eventsc.wxKeyEvent_KeyCode,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxKeyEvent instance>"
+        return "<C wxKeyEvent instance at %s>" % (self.this,)
 class wxKeyEvent(wxKeyEventPtr):
     def __init__(self,this):
         self.this = this
@@ -299,13 +296,12 @@ class wxMoveEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetPosition(self):
-        val = eventsc.wxMoveEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetPosition(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMoveEvent_GetPosition,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
     def __repr__(self):
-        return "<C wxMoveEvent instance>"
+        return "<C wxMoveEvent instance at %s>" % (self.this,)
 class wxMoveEvent(wxMoveEventPtr):
     def __init__(self,this):
         self.this = this
@@ -318,7 +314,7 @@ class wxPaintEventPtr(wxEventPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxPaintEvent instance>"
+        return "<C wxPaintEvent instance at %s>" % (self.this,)
 class wxPaintEvent(wxPaintEventPtr):
     def __init__(self,this):
         self.this = this
@@ -330,12 +326,12 @@ class wxEraseEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetDC(self):
-        val = eventsc.wxEraseEvent_GetDC(self.this)
-        val = wxDCPtr(val)
+    def GetDC(self, *_args, **_kwargs):
+        val = apply(eventsc.wxEraseEvent_GetDC,(self,) + _args, _kwargs)
+        if val: val = wxDCPtr(val) 
         return val
     def __repr__(self):
-        return "<C wxEraseEvent instance>"
+        return "<C wxEraseEvent instance at %s>" % (self.this,)
 class wxEraseEvent(wxEraseEventPtr):
     def __init__(self,this):
         self.this = this
@@ -348,7 +344,7 @@ class wxFocusEventPtr(wxEventPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxFocusEvent instance>"
+        return "<C wxFocusEvent instance at %s>" % (self.this,)
 class wxFocusEvent(wxFocusEventPtr):
     def __init__(self,this):
         self.this = this
@@ -360,11 +356,11 @@ class wxActivateEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetActive(self):
-        val = eventsc.wxActivateEvent_GetActive(self.this)
+    def GetActive(self, *_args, **_kwargs):
+        val = apply(eventsc.wxActivateEvent_GetActive,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxActivateEvent instance>"
+        return "<C wxActivateEvent instance at %s>" % (self.this,)
 class wxActivateEvent(wxActivateEventPtr):
     def __init__(self,this):
         self.this = this
@@ -377,7 +373,7 @@ class wxInitDialogEventPtr(wxEventPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxInitDialogEvent instance>"
+        return "<C wxInitDialogEvent instance at %s>" % (self.this,)
 class wxInitDialogEvent(wxInitDialogEventPtr):
     def __init__(self,this):
         self.this = this
@@ -389,11 +385,11 @@ class wxMenuEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetMenuId(self):
-        val = eventsc.wxMenuEvent_GetMenuId(self.this)
+    def GetMenuId(self, *_args, **_kwargs):
+        val = apply(eventsc.wxMenuEvent_GetMenuId,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxMenuEvent instance>"
+        return "<C wxMenuEvent instance at %s>" % (self.this,)
 class wxMenuEvent(wxMenuEventPtr):
     def __init__(self,this):
         self.this = this
@@ -405,14 +401,14 @@ class wxShowEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def SetShow(self,arg0):
-        val = eventsc.wxShowEvent_SetShow(self.this,arg0)
+    def SetShow(self, *_args, **_kwargs):
+        val = apply(eventsc.wxShowEvent_SetShow,(self,) + _args, _kwargs)
         return val
-    def GetShow(self):
-        val = eventsc.wxShowEvent_GetShow(self.this)
+    def GetShow(self, *_args, **_kwargs):
+        val = apply(eventsc.wxShowEvent_GetShow,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxShowEvent instance>"
+        return "<C wxShowEvent instance at %s>" % (self.this,)
 class wxShowEvent(wxShowEventPtr):
     def __init__(self,this):
         self.this = this
@@ -425,7 +421,7 @@ class wxIconizeEventPtr(wxEventPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxIconizeEvent instance>"
+        return "<C wxIconizeEvent instance at %s>" % (self.this,)
 class wxIconizeEvent(wxIconizeEventPtr):
     def __init__(self,this):
         self.this = this
@@ -438,7 +434,7 @@ class wxMaximizeEventPtr(wxEventPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxMaximizeEvent instance>"
+        return "<C wxMaximizeEvent instance at %s>" % (self.this,)
 class wxMaximizeEvent(wxMaximizeEventPtr):
     def __init__(self,this):
         self.this = this
@@ -450,58 +446,57 @@ class wxJoystickEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetPosition(self):
-        val = eventsc.wxJoystickEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetPosition(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_GetPosition,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetZPosition(self):
-        val = eventsc.wxJoystickEvent_GetZPosition(self.this)
+    def GetZPosition(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_GetZPosition,(self,) + _args, _kwargs)
         return val
-    def GetButtonState(self):
-        val = eventsc.wxJoystickEvent_GetButtonState(self.this)
+    def GetButtonState(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_GetButtonState,(self,) + _args, _kwargs)
         return val
-    def GetButtonChange(self):
-        val = eventsc.wxJoystickEvent_GetButtonChange(self.this)
+    def GetButtonChange(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_GetButtonChange,(self,) + _args, _kwargs)
         return val
-    def GetJoystick(self):
-        val = eventsc.wxJoystickEvent_GetJoystick(self.this)
+    def GetJoystick(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_GetJoystick,(self,) + _args, _kwargs)
         return val
-    def SetJoystick(self,arg0):
-        val = eventsc.wxJoystickEvent_SetJoystick(self.this,arg0)
+    def SetJoystick(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_SetJoystick,(self,) + _args, _kwargs)
         return val
-    def SetButtonState(self,arg0):
-        val = eventsc.wxJoystickEvent_SetButtonState(self.this,arg0)
+    def SetButtonState(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_SetButtonState,(self,) + _args, _kwargs)
         return val
-    def SetButtonChange(self,arg0):
-        val = eventsc.wxJoystickEvent_SetButtonChange(self.this,arg0)
+    def SetButtonChange(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_SetButtonChange,(self,) + _args, _kwargs)
         return val
-    def SetPosition(self,arg0):
-        val = eventsc.wxJoystickEvent_SetPosition(self.this,arg0.this)
+    def SetPosition(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_SetPosition,(self,) + _args, _kwargs)
         return val
-    def SetZPosition(self,arg0):
-        val = eventsc.wxJoystickEvent_SetZPosition(self.this,arg0)
+    def SetZPosition(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_SetZPosition,(self,) + _args, _kwargs)
         return val
-    def IsButton(self):
-        val = eventsc.wxJoystickEvent_IsButton(self.this)
+    def IsButton(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_IsButton,(self,) + _args, _kwargs)
         return val
-    def IsMove(self):
-        val = eventsc.wxJoystickEvent_IsMove(self.this)
+    def IsMove(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_IsMove,(self,) + _args, _kwargs)
         return val
-    def IsZMove(self):
-        val = eventsc.wxJoystickEvent_IsZMove(self.this)
+    def IsZMove(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_IsZMove,(self,) + _args, _kwargs)
         return val
-    def ButtonDown(self,*args):
-        val = apply(eventsc.wxJoystickEvent_ButtonDown,(self.this,)+args)
+    def ButtonDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_ButtonDown,(self,) + _args, _kwargs)
         return val
-    def ButtonUp(self,*args):
-        val = apply(eventsc.wxJoystickEvent_ButtonUp,(self.this,)+args)
+    def ButtonUp(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_ButtonUp,(self,) + _args, _kwargs)
         return val
-    def ButtonIsDown(self,*args):
-        val = apply(eventsc.wxJoystickEvent_ButtonIsDown,(self.this,)+args)
+    def ButtonIsDown(self, *_args, **_kwargs):
+        val = apply(eventsc.wxJoystickEvent_ButtonIsDown,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxJoystickEvent instance>"
+        return "<C wxJoystickEvent instance at %s>" % (self.this,)
 class wxJoystickEvent(wxJoystickEventPtr):
     def __init__(self,this):
         self.this = this
@@ -513,19 +508,18 @@ class wxDropFilesEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetPosition(self):
-        val = eventsc.wxDropFilesEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetPosition(self, *_args, **_kwargs):
+        val = apply(eventsc.wxDropFilesEvent_GetPosition,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetNumberOfFiles(self):
-        val = eventsc.wxDropFilesEvent_GetNumberOfFiles(self.this)
+    def GetNumberOfFiles(self, *_args, **_kwargs):
+        val = apply(eventsc.wxDropFilesEvent_GetNumberOfFiles,(self,) + _args, _kwargs)
         return val
-    def GetFiles(self):
-        val = eventsc.wxDropFilesEvent_GetFiles(self.this)
+    def GetFiles(self, *_args, **_kwargs):
+        val = apply(eventsc.wxDropFilesEvent_GetFiles,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxDropFilesEvent instance>"
+        return "<C wxDropFilesEvent instance at %s>" % (self.this,)
 class wxDropFilesEvent(wxDropFilesEventPtr):
     def __init__(self,this):
         self.this = this
@@ -537,14 +531,14 @@ class wxIdleEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def RequestMore(self,*args):
-        val = apply(eventsc.wxIdleEvent_RequestMore,(self.this,)+args)
+    def RequestMore(self, *_args, **_kwargs):
+        val = apply(eventsc.wxIdleEvent_RequestMore,(self,) + _args, _kwargs)
         return val
-    def MoreRequested(self):
-        val = eventsc.wxIdleEvent_MoreRequested(self.this)
+    def MoreRequested(self, *_args, **_kwargs):
+        val = apply(eventsc.wxIdleEvent_MoreRequested,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxIdleEvent instance>"
+        return "<C wxIdleEvent instance at %s>" % (self.this,)
 class wxIdleEvent(wxIdleEventPtr):
     def __init__(self,this):
         self.this = this
@@ -556,35 +550,35 @@ class wxUpdateUIEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetChecked(self):
-        val = eventsc.wxUpdateUIEvent_GetChecked(self.this)
+    def GetChecked(self, *_args, **_kwargs):
+        val = apply(eventsc.wxUpdateUIEvent_GetChecked,(self,) + _args, _kwargs)
         return val
-    def GetEnabled(self):
-        val = eventsc.wxUpdateUIEvent_GetEnabled(self.this)
+    def GetEnabled(self, *_args, **_kwargs):
+        val = apply(eventsc.wxUpdateUIEvent_GetEnabled,(self,) + _args, _kwargs)
         return val
-    def GetText(self):
-        val = eventsc.wxUpdateUIEvent_GetText(self.this)
+    def GetText(self, *_args, **_kwargs):
+        val = apply(eventsc.wxUpdateUIEvent_GetText,(self,) + _args, _kwargs)
         return val
-    def GetSetText(self):
-        val = eventsc.wxUpdateUIEvent_GetSetText(self.this)
+    def GetSetText(self, *_args, **_kwargs):
+        val = apply(eventsc.wxUpdateUIEvent_GetSetText,(self,) + _args, _kwargs)
         return val
-    def GetSetChecked(self):
-        val = eventsc.wxUpdateUIEvent_GetSetChecked(self.this)
+    def GetSetChecked(self, *_args, **_kwargs):
+        val = apply(eventsc.wxUpdateUIEvent_GetSetChecked,(self,) + _args, _kwargs)
         return val
-    def GetSetEnabled(self):
-        val = eventsc.wxUpdateUIEvent_GetSetEnabled(self.this)
+    def GetSetEnabled(self, *_args, **_kwargs):
+        val = apply(eventsc.wxUpdateUIEvent_GetSetEnabled,(self,) + _args, _kwargs)
         return val
-    def Check(self,arg0):
-        val = eventsc.wxUpdateUIEvent_Check(self.this,arg0)
+    def Check(self, *_args, **_kwargs):
+        val = apply(eventsc.wxUpdateUIEvent_Check,(self,) + _args, _kwargs)
         return val
-    def Enable(self,arg0):
-        val = eventsc.wxUpdateUIEvent_Enable(self.this,arg0)
+    def Enable(self, *_args, **_kwargs):
+        val = apply(eventsc.wxUpdateUIEvent_Enable,(self,) + _args, _kwargs)
         return val
-    def SetText(self,arg0):
-        val = eventsc.wxUpdateUIEvent_SetText(self.this,arg0)
+    def SetText(self, *_args, **_kwargs):
+        val = apply(eventsc.wxUpdateUIEvent_SetText,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxUpdateUIEvent instance>"
+        return "<C wxUpdateUIEvent instance at %s>" % (self.this,)
 class wxUpdateUIEvent(wxUpdateUIEventPtr):
     def __init__(self,this):
         self.this = this
@@ -597,7 +591,7 @@ class wxSysColourChangedEventPtr(wxEventPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxSysColourChangedEvent instance>"
+        return "<C wxSysColourChangedEvent instance at %s>" % (self.this,)
 class wxSysColourChangedEvent(wxSysColourChangedEventPtr):
     def __init__(self,this):
         self.this = this
@@ -609,20 +603,20 @@ class wxPyEventPtr(wxCommandEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, eventsc=eventsc):
+    def __del__(self,eventsc=eventsc):
         if self.thisown == 1 :
-            eventsc.delete_wxPyEvent(self.this)
-    def SetUserData(self,arg0):
-        val = eventsc.wxPyEvent_SetUserData(self.this,arg0)
+            eventsc.delete_wxPyEvent(self)
+    def SetUserData(self, *_args, **_kwargs):
+        val = apply(eventsc.wxPyEvent_SetUserData,(self,) + _args, _kwargs)
         return val
-    def GetUserData(self):
-        val = eventsc.wxPyEvent_GetUserData(self.this)
+    def GetUserData(self, *_args, **_kwargs):
+        val = apply(eventsc.wxPyEvent_GetUserData,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPyEvent instance>"
+        return "<C wxPyEvent instance at %s>" % (self.this,)
 class wxPyEvent(wxPyEventPtr):
-    def __init__(self,*args) :
-        self.this = apply(eventsc.new_wxPyEvent,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(eventsc.new_wxPyEvent,_args,_kwargs)
         self.thisown = 1
 
 
@@ -632,14 +626,14 @@ class wxNotifyEventPtr(wxCommandEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def IsAllowed(self):
-        val = eventsc.wxNotifyEvent_IsAllowed(self.this)
+    def IsAllowed(self, *_args, **_kwargs):
+        val = apply(eventsc.wxNotifyEvent_IsAllowed,(self,) + _args, _kwargs)
         return val
-    def Veto(self):
-        val = eventsc.wxNotifyEvent_Veto(self.this)
+    def Veto(self, *_args, **_kwargs):
+        val = apply(eventsc.wxNotifyEvent_Veto,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxNotifyEvent instance>"
+        return "<C wxNotifyEvent instance at %s>" % (self.this,)
 class wxNotifyEvent(wxNotifyEventPtr):
     def __init__(self,this):
         self.this = this

utils/wxPython/src/gtk/frames.py

@@ -17,76 +17,70 @@ class wxFramePtr(wxWindowPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def Centre(self,*args):
-        val = apply(framesc.wxFrame_Centre,(self.this,)+args)
+    def Centre(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_Centre,(self,) + _args, _kwargs)
         return val
-    def CreateStatusBar(self,*args):
-        val = apply(framesc.wxFrame_CreateStatusBar,(self.this,)+args)
-        val = wxStatusBarPtr(val)
+    def CreateStatusBar(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_CreateStatusBar,(self,) + _args, _kwargs)
+        if val: val = wxStatusBarPtr(val) 
         return val
-    def CreateToolBar(self,*args):
-        val = apply(framesc.wxFrame_CreateToolBar,(self.this,)+args)
-        val = wxToolBarPtr(val)
+    def CreateToolBar(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_CreateToolBar,(self,) + _args, _kwargs)
+        if val: val = wxToolBarPtr(val) 
         return val
-    def GetMenuBar(self):
-        val = framesc.wxFrame_GetMenuBar(self.this)
-        val = wxMenuBarPtr(val)
+    def GetMenuBar(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_GetMenuBar,(self,) + _args, _kwargs)
+        if val: val = wxMenuBarPtr(val) 
         return val
-    def GetStatusBar(self):
-        val = framesc.wxFrame_GetStatusBar(self.this)
-        val = wxStatusBarPtr(val)
+    def GetStatusBar(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_GetStatusBar,(self,) + _args, _kwargs)
+        if val: val = wxStatusBarPtr(val) 
         return val
-    def GetTitle(self):
-        val = framesc.wxFrame_GetTitle(self.this)
+    def GetTitle(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_GetTitle,(self,) + _args, _kwargs)
         return val
-    def GetToolBar(self):
-        val = framesc.wxFrame_GetToolBar(self.this)
-        val = wxToolBarPtr(val)
+    def GetToolBar(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_GetToolBar,(self,) + _args, _kwargs)
+        if val: val = wxToolBarPtr(val) 
         return val
-    def Iconize(self,arg0):
-        val = framesc.wxFrame_Iconize(self.this,arg0)
+    def Iconize(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_Iconize,(self,) + _args, _kwargs)
         return val
-    def IsIconized(self):
-        val = framesc.wxFrame_IsIconized(self.this)
+    def IsIconized(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_IsIconized,(self,) + _args, _kwargs)
         return val
-    def Maximize(self,arg0):
-        val = framesc.wxFrame_Maximize(self.this,arg0)
+    def Maximize(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_Maximize,(self,) + _args, _kwargs)
         return val
-    def SetAcceleratorTable(self,arg0):
-        val = framesc.wxFrame_SetAcceleratorTable(self.this,arg0.this)
+    def SetAcceleratorTable(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_SetAcceleratorTable,(self,) + _args, _kwargs)
         return val
-    def SetIcon(self,arg0):
-        val = framesc.wxFrame_SetIcon(self.this,arg0.this)
+    def SetIcon(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_SetIcon,(self,) + _args, _kwargs)
         return val
-    def SetMenuBar(self,arg0):
-        val = framesc.wxFrame_SetMenuBar(self.this,arg0.this)
+    def SetMenuBar(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_SetMenuBar,(self,) + _args, _kwargs)
         return val
-    def SetStatusBar(self,arg0):
-        val = framesc.wxFrame_SetStatusBar(self.this,arg0.this)
+    def SetStatusBar(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_SetStatusBar,(self,) + _args, _kwargs)
         return val
-    def SetStatusText(self,arg0,*args):
-        val = apply(framesc.wxFrame_SetStatusText,(self.this,arg0,)+args)
+    def SetStatusText(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_SetStatusText,(self,) + _args, _kwargs)
         return val
-    def SetStatusWidths(self,arg0,*args):
-        val = apply(framesc.wxFrame_SetStatusWidths,(self.this,arg0,)+args)
+    def SetStatusWidths(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_SetStatusWidths,(self,) + _args, _kwargs)
         return val
-    def SetTitle(self,arg0):
-        val = framesc.wxFrame_SetTitle(self.this,arg0)
+    def SetTitle(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_SetTitle,(self,) + _args, _kwargs)
         return val
-    def SetToolBar(self,arg0):
-        val = framesc.wxFrame_SetToolBar(self.this,arg0.this)
+    def SetToolBar(self, *_args, **_kwargs):
+        val = apply(framesc.wxFrame_SetToolBar,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxFrame instance>"
+        return "<C wxFrame instance at %s>" % (self.this,)
 class wxFrame(wxFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(framesc.new_wxFrame,(arg0.this,arg1,arg2,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(framesc.new_wxFrame,_args,_kwargs)
         self.thisown = 1
         wx._StdFrameCallbacks(self)
 
@@ -98,16 +92,10 @@ class wxMiniFramePtr(wxFramePtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxMiniFrame instance>"
+        return "<C wxMiniFrame instance at %s>" % (self.this,)
 class wxMiniFrame(wxMiniFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(framesc.new_wxMiniFrame,(arg0.this,arg1,arg2,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(framesc.new_wxMiniFrame,_args,_kwargs)
         self.thisown = 1
         wx._StdFrameCallbacks(self)
 

utils/wxPython/src/gtk/glcanvas.py

@@ -35,46 +35,41 @@ class wxGLContextPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, glcanvasc=glcanvasc):
+    def __del__(self,glcanvasc=glcanvasc):
         if self.thisown == 1 :
-            glcanvasc.delete_wxGLContext(self.this)
-    def SetCurrent(self):
-        val = glcanvasc.wxGLContext_SetCurrent(self.this)
+            glcanvasc.delete_wxGLContext(self)
+    def SetCurrent(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLContext_SetCurrent,(self,) + _args, _kwargs)
         return val
-    def SetColour(self,arg0):
-        val = glcanvasc.wxGLContext_SetColour(self.this,arg0)
+    def SetColour(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLContext_SetColour,(self,) + _args, _kwargs)
         return val
-    def SwapBuffers(self):
-        val = glcanvasc.wxGLContext_SwapBuffers(self.this)
+    def SwapBuffers(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLContext_SwapBuffers,(self,) + _args, _kwargs)
         return val
-    def SetupPixelFormat(self):
-        val = glcanvasc.wxGLContext_SetupPixelFormat(self.this)
+    def SetupPixelFormat(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLContext_SetupPixelFormat,(self,) + _args, _kwargs)
         return val
-    def SetupPalette(self,arg0):
-        val = glcanvasc.wxGLContext_SetupPalette(self.this,arg0.this)
+    def SetupPalette(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLContext_SetupPalette,(self,) + _args, _kwargs)
         return val
-    def CreateDefaultPalette(self):
-        val = glcanvasc.wxGLContext_CreateDefaultPalette(self.this)
-        val = wxPalettePtr(val)
-        val.thisown = 1
+    def CreateDefaultPalette(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLContext_CreateDefaultPalette,(self,) + _args, _kwargs)
+        if val: val = wxPalettePtr(val) ; val.thisown = 1
         return val
-    def GetPalette(self):
-        val = glcanvasc.wxGLContext_GetPalette(self.this)
-        val = wxPalettePtr(val)
+    def GetPalette(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLContext_GetPalette,(self,) + _args, _kwargs)
+        if val: val = wxPalettePtr(val) 
         return val
-    def GetWindow(self):
-        val = glcanvasc.wxGLContext_GetWindow(self.this)
-        val = wxWindowPtr(val)
+    def GetWindow(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLContext_GetWindow,(self,) + _args, _kwargs)
+        if val: val = wxWindowPtr(val) 
         return val
     def __repr__(self):
-        return "<C wxGLContext instance>"
+        return "<C wxGLContext instance at %s>" % (self.this,)
 class wxGLContext(wxGLContextPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(glcanvasc.new_wxGLContext,(arg0,arg1.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(glcanvasc.new_wxGLContext,_args,_kwargs)
         self.thisown = 1
 
 
@@ -84,32 +79,24 @@ class wxGLCanvasPtr(wxScrolledWindowPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def SetCurrent(self):
-        val = glcanvasc.wxGLCanvas_SetCurrent(self.this)
+    def SetCurrent(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLCanvas_SetCurrent,(self,) + _args, _kwargs)
         return val
-    def SetColour(self,arg0):
-        val = glcanvasc.wxGLCanvas_SetColour(self.this,arg0)
+    def SetColour(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLCanvas_SetColour,(self,) + _args, _kwargs)
         return val
-    def SwapBuffers(self):
-        val = glcanvasc.wxGLCanvas_SwapBuffers(self.this)
+    def SwapBuffers(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLCanvas_SwapBuffers,(self,) + _args, _kwargs)
         return val
-    def GetContext(self):
-        val = glcanvasc.wxGLCanvas_GetContext(self.this)
-        val = wxGLContextPtr(val)
+    def GetContext(self, *_args, **_kwargs):
+        val = apply(glcanvasc.wxGLCanvas_GetContext,(self,) + _args, _kwargs)
+        if val: val = wxGLContextPtr(val) 
         return val
     def __repr__(self):
-        return "<C wxGLCanvas instance>"
+        return "<C wxGLCanvas instance at %s>" % (self.this,)
 class wxGLCanvas(wxGLCanvasPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        try: argl[6] = argl[6].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(glcanvasc.new_wxGLCanvas,(arg0.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(glcanvasc.new_wxGLCanvas,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
 

utils/wxPython/src/gtk/image.py

@@ -8,35 +8,35 @@ class wxImageHandlerPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetName(self):
-        val = imagec.wxImageHandler_GetName(self.this)
+    def GetName(self, *_args, **_kwargs):
+        val = apply(imagec.wxImageHandler_GetName,(self,) + _args, _kwargs)
         return val
-    def GetExtension(self):
-        val = imagec.wxImageHandler_GetExtension(self.this)
+    def GetExtension(self, *_args, **_kwargs):
+        val = apply(imagec.wxImageHandler_GetExtension,(self,) + _args, _kwargs)
         return val
-    def GetType(self):
-        val = imagec.wxImageHandler_GetType(self.this)
+    def GetType(self, *_args, **_kwargs):
+        val = apply(imagec.wxImageHandler_GetType,(self,) + _args, _kwargs)
         return val
-    def GetMimeType(self):
-        val = imagec.wxImageHandler_GetMimeType(self.this)
+    def GetMimeType(self, *_args, **_kwargs):
+        val = apply(imagec.wxImageHandler_GetMimeType,(self,) + _args, _kwargs)
         return val
-    def SetName(self,arg0):
-        val = imagec.wxImageHandler_SetName(self.this,arg0)
+    def SetName(self, *_args, **_kwargs):
+        val = apply(imagec.wxImageHandler_SetName,(self,) + _args, _kwargs)
         return val
-    def SetExtension(self,arg0):
-        val = imagec.wxImageHandler_SetExtension(self.this,arg0)
+    def SetExtension(self, *_args, **_kwargs):
+        val = apply(imagec.wxImageHandler_SetExtension,(self,) + _args, _kwargs)
         return val
-    def SetType(self,arg0):
-        val = imagec.wxImageHandler_SetType(self.this,arg0)
+    def SetType(self, *_args, **_kwargs):
+        val = apply(imagec.wxImageHandler_SetType,(self,) + _args, _kwargs)
         return val
-    def SetMimeType(self,arg0):
-        val = imagec.wxImageHandler_SetMimeType(self.this,arg0)
+    def SetMimeType(self, *_args, **_kwargs):
+        val = apply(imagec.wxImageHandler_SetMimeType,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxImageHandler instance>"
+        return "<C wxImageHandler instance at %s>" % (self.this,)
 class wxImageHandler(wxImageHandlerPtr):
-    def __init__(self) :
-        self.this = imagec.new_wxImageHandler()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(imagec.new_wxImageHandler,_args,_kwargs)
         self.thisown = 1
 
 
@@ -47,10 +47,10 @@ class wxPNGHandlerPtr(wxImageHandlerPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxPNGHandler instance>"
+        return "<C wxPNGHandler instance at %s>" % (self.this,)
 class wxPNGHandler(wxPNGHandlerPtr):
-    def __init__(self) :
-        self.this = imagec.new_wxPNGHandler()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(imagec.new_wxPNGHandler,_args,_kwargs)
         self.thisown = 1
 
 
@@ -61,10 +61,10 @@ class wxJPEGHandlerPtr(wxImageHandlerPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxJPEGHandler instance>"
+        return "<C wxJPEGHandler instance at %s>" % (self.this,)
 class wxJPEGHandler(wxJPEGHandlerPtr):
-    def __init__(self) :
-        self.this = imagec.new_wxJPEGHandler()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(imagec.new_wxJPEGHandler,_args,_kwargs)
         self.thisown = 1
 
 
@@ -75,10 +75,10 @@ class wxBMPHandlerPtr(wxImageHandlerPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxBMPHandler instance>"
+        return "<C wxBMPHandler instance at %s>" % (self.this,)
 class wxBMPHandler(wxBMPHandlerPtr):
-    def __init__(self) :
-        self.this = imagec.new_wxBMPHandler()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(imagec.new_wxBMPHandler,_args,_kwargs)
         self.thisown = 1
 
 
@@ -89,10 +89,10 @@ class wxGIFHandlerPtr(wxImageHandlerPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxGIFHandler instance>"
+        return "<C wxGIFHandler instance at %s>" % (self.this,)
 class wxGIFHandler(wxGIFHandlerPtr):
-    def __init__(self) :
-        self.this = imagec.new_wxGIFHandler()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(imagec.new_wxGIFHandler,_args,_kwargs)
         self.thisown = 1
 
 
@@ -102,90 +102,88 @@ class wxImagePtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, imagec=imagec):
+    def __del__(self,imagec=imagec):
         if self.thisown == 1 :
-            imagec.delete_wxImage(self.this)
-    def ConvertToBitmap(self):
-        val = imagec.wxImage_ConvertToBitmap(self.this)
-        val = wxBitmapPtr(val)
-        val.thisown = 1
+            imagec.delete_wxImage(self)
+    def ConvertToBitmap(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_ConvertToBitmap,(self,) + _args, _kwargs)
+        if val: val = wxBitmapPtr(val) ; val.thisown = 1
         return val
-    def Create(self,arg0,arg1):
-        val = imagec.wxImage_Create(self.this,arg0,arg1)
+    def Create(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_Create,(self,) + _args, _kwargs)
         return val
-    def Destroy(self):
-        val = imagec.wxImage_Destroy(self.this)
+    def Destroy(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_Destroy,(self,) + _args, _kwargs)
         return val
-    def Scale(self,arg0,arg1):
-        val = imagec.wxImage_Scale(self.this,arg0,arg1)
-        val = wxImagePtr(val)
-        val.thisown = 1
+    def Scale(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_Scale,(self,) + _args, _kwargs)
+        if val: val = wxImagePtr(val) ; val.thisown = 1
         return val
-    def Rescale(self,arg0,arg1):
-        val = imagec.wxImage_Rescale(self.this,arg0,arg1)
+    def Rescale(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_Rescale,(self,) + _args, _kwargs)
         return val
-    def SetRGB(self,arg0,arg1,arg2,arg3,arg4):
-        val = imagec.wxImage_SetRGB(self.this,arg0,arg1,arg2,arg3,arg4)
+    def SetRGB(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_SetRGB,(self,) + _args, _kwargs)
         return val
-    def GetRed(self,arg0,arg1):
-        val = imagec.wxImage_GetRed(self.this,arg0,arg1)
+    def GetRed(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_GetRed,(self,) + _args, _kwargs)
         return val
-    def GetGreen(self,arg0,arg1):
-        val = imagec.wxImage_GetGreen(self.this,arg0,arg1)
+    def GetGreen(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_GetGreen,(self,) + _args, _kwargs)
         return val
-    def GetBlue(self,arg0,arg1):
-        val = imagec.wxImage_GetBlue(self.this,arg0,arg1)
+    def GetBlue(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_GetBlue,(self,) + _args, _kwargs)
         return val
-    def LoadFile(self,arg0,*args):
-        val = apply(imagec.wxImage_LoadFile,(self.this,arg0,)+args)
+    def LoadFile(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_LoadFile,(self,) + _args, _kwargs)
         return val
-    def LoadMimeFile(self,arg0,arg1):
-        val = imagec.wxImage_LoadMimeFile(self.this,arg0,arg1)
+    def LoadMimeFile(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_LoadMimeFile,(self,) + _args, _kwargs)
         return val
-    def SaveFile(self,arg0,arg1):
-        val = imagec.wxImage_SaveFile(self.this,arg0,arg1)
+    def SaveFile(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_SaveFile,(self,) + _args, _kwargs)
         return val
-    def SaveMimeFile(self,arg0,arg1):
-        val = imagec.wxImage_SaveMimeFile(self.this,arg0,arg1)
+    def SaveMimeFile(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_SaveMimeFile,(self,) + _args, _kwargs)
         return val
-    def Ok(self):
-        val = imagec.wxImage_Ok(self.this)
+    def Ok(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_Ok,(self,) + _args, _kwargs)
         return val
-    def GetWidth(self):
-        val = imagec.wxImage_GetWidth(self.this)
+    def GetWidth(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_GetWidth,(self,) + _args, _kwargs)
         return val
-    def GetHeight(self):
-        val = imagec.wxImage_GetHeight(self.this)
+    def GetHeight(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_GetHeight,(self,) + _args, _kwargs)
         return val
-    def GetData(self):
-        val = imagec.wxImage_GetData(self.this)
+    def GetData(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_GetData,(self,) + _args, _kwargs)
         return val
-    def SetData(self,arg0):
-        val = imagec.wxImage_SetData(self.this,arg0)
+    def SetData(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_SetData,(self,) + _args, _kwargs)
         return val
-    def SetMaskColour(self,arg0,arg1,arg2):
-        val = imagec.wxImage_SetMaskColour(self.this,arg0,arg1,arg2)
+    def SetMaskColour(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_SetMaskColour,(self,) + _args, _kwargs)
         return val
-    def GetMaskRed(self):
-        val = imagec.wxImage_GetMaskRed(self.this)
+    def GetMaskRed(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_GetMaskRed,(self,) + _args, _kwargs)
         return val
-    def GetMaskGreen(self):
-        val = imagec.wxImage_GetMaskGreen(self.this)
+    def GetMaskGreen(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_GetMaskGreen,(self,) + _args, _kwargs)
         return val
-    def GetMaskBlue(self):
-        val = imagec.wxImage_GetMaskBlue(self.this)
+    def GetMaskBlue(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_GetMaskBlue,(self,) + _args, _kwargs)
         return val
-    def SetMask(self,*args):
-        val = apply(imagec.wxImage_SetMask,(self.this,)+args)
+    def SetMask(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_SetMask,(self,) + _args, _kwargs)
         return val
-    def HasMask(self):
-        val = imagec.wxImage_HasMask(self.this)
+    def HasMask(self, *_args, **_kwargs):
+        val = apply(imagec.wxImage_HasMask,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxImage instance>"
+        return "<C wxImage instance at %s>" % (self.this,)
 class wxImage(wxImagePtr):
-    def __init__(self,arg0,*args) :
-        self.this = apply(imagec.new_wxImage,(arg0,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(imagec.new_wxImage,_args,_kwargs)
         self.thisown = 1
 
 
@@ -195,33 +193,27 @@ class wxImage(wxImagePtr):
 
 #-------------- FUNCTION WRAPPERS ------------------
 
-def wxNullImage():
-    val = imagec.wxNullImage()
-    val = wxImagePtr(val)
-    val.thisown = 1
+def wxNullImage(*_args, **_kwargs):
+    val = apply(imagec.wxNullImage,_args,_kwargs)
+    if val: val = wxImagePtr(val); val.thisown = 1
     return val
 
-def wxEmptyImage(arg0,arg1):
-    val = imagec.wxEmptyImage(arg0,arg1)
-    val = wxImagePtr(val)
-    val.thisown = 1
+def wxEmptyImage(*_args, **_kwargs):
+    val = apply(imagec.wxEmptyImage,_args,_kwargs)
+    if val: val = wxImagePtr(val); val.thisown = 1
     return val
 
-def wxImageFromMime(arg0,arg1):
-    val = imagec.wxImageFromMime(arg0,arg1)
-    val = wxImagePtr(val)
-    val.thisown = 1
+def wxImageFromMime(*_args, **_kwargs):
+    val = apply(imagec.wxImageFromMime,_args,_kwargs)
+    if val: val = wxImagePtr(val); val.thisown = 1
     return val
 
-def wxImageFromBitmap(arg0):
-    val = imagec.wxImageFromBitmap(arg0.this)
-    val = wxImagePtr(val)
-    val.thisown = 1
+def wxImageFromBitmap(*_args, **_kwargs):
+    val = apply(imagec.wxImageFromBitmap,_args,_kwargs)
+    if val: val = wxImagePtr(val); val.thisown = 1
     return val
 
-def wxImage_AddHandler(arg0):
-    val = imagec.wxImage_AddHandler(arg0.this)
-    return val
+wxImage_AddHandler = imagec.wxImage_AddHandler
 
 
 

utils/wxPython/src/gtk/mdi.py

@@ -19,44 +19,38 @@ class wxMDIParentFramePtr(wxFramePtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def ActivateNext(self):
-        val = mdic.wxMDIParentFrame_ActivateNext(self.this)
+    def ActivateNext(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIParentFrame_ActivateNext,(self,) + _args, _kwargs)
         return val
-    def ActivatePrevious(self):
-        val = mdic.wxMDIParentFrame_ActivatePrevious(self.this)
+    def ActivatePrevious(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIParentFrame_ActivatePrevious,(self,) + _args, _kwargs)
         return val
-    def ArrangeIcons(self):
-        val = mdic.wxMDIParentFrame_ArrangeIcons(self.this)
+    def ArrangeIcons(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIParentFrame_ArrangeIcons,(self,) + _args, _kwargs)
         return val
-    def Cascade(self):
-        val = mdic.wxMDIParentFrame_Cascade(self.this)
+    def Cascade(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIParentFrame_Cascade,(self,) + _args, _kwargs)
         return val
-    def GetActiveChild(self):
-        val = mdic.wxMDIParentFrame_GetActiveChild(self.this)
-        val = wxMDIChildFramePtr(val)
+    def GetActiveChild(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIParentFrame_GetActiveChild,(self,) + _args, _kwargs)
+        if val: val = wxMDIChildFramePtr(val) 
         return val
-    def GetClientWindow(self):
-        val = mdic.wxMDIParentFrame_GetClientWindow(self.this)
-        val = wxMDIClientWindowPtr(val)
+    def GetClientWindow(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIParentFrame_GetClientWindow,(self,) + _args, _kwargs)
+        if val: val = wxMDIClientWindowPtr(val) 
         return val
-    def GetToolBar(self):
-        val = mdic.wxMDIParentFrame_GetToolBar(self.this)
-        val = wxWindowPtr(val)
+    def GetToolBar(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIParentFrame_GetToolBar,(self,) + _args, _kwargs)
+        if val: val = wxWindowPtr(val) 
         return val
-    def Tile(self):
-        val = mdic.wxMDIParentFrame_Tile(self.this)
+    def Tile(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIParentFrame_Tile,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxMDIParentFrame instance>"
+        return "<C wxMDIParentFrame instance at %s>" % (self.this,)
 class wxMDIParentFrame(wxMDIParentFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(mdic.new_wxMDIParentFrame,(arg0.this,arg1,arg2,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(mdic.new_wxMDIParentFrame,_args,_kwargs)
         self.thisown = 1
         wx._StdFrameCallbacks(self)
 
@@ -67,26 +61,20 @@ class wxMDIChildFramePtr(wxFramePtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def Activate(self):
-        val = mdic.wxMDIChildFrame_Activate(self.this)
+    def Activate(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIChildFrame_Activate,(self,) + _args, _kwargs)
         return val
-    def Maximize(self,arg0):
-        val = mdic.wxMDIChildFrame_Maximize(self.this,arg0)
+    def Maximize(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIChildFrame_Maximize,(self,) + _args, _kwargs)
         return val
-    def Restore(self):
-        val = mdic.wxMDIChildFrame_Restore(self.this)
+    def Restore(self, *_args, **_kwargs):
+        val = apply(mdic.wxMDIChildFrame_Restore,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxMDIChildFrame instance>"
+        return "<C wxMDIChildFrame instance at %s>" % (self.this,)
 class wxMDIChildFrame(wxMDIChildFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(mdic.new_wxMDIChildFrame,(arg0.this,arg1,arg2,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(mdic.new_wxMDIChildFrame,_args,_kwargs)
         self.thisown = 1
         wx._StdFrameCallbacks(self)
 
@@ -98,10 +86,10 @@ class wxMDIClientWindowPtr(wxWindowPtr):
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxMDIClientWindow instance>"
+        return "<C wxMDIClientWindow instance at %s>" % (self.this,)
 class wxMDIClientWindow(wxMDIClientWindowPtr):
-    def __init__(self,arg0,*args) :
-        self.this = apply(mdic.new_wxMDIClientWindow,(arg0.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(mdic.new_wxMDIClientWindow,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
         wx._StdOnScrollCallbacks(self)

utils/wxPython/src/gtk/misc.py

@@ -4,64 +4,64 @@ class wxSizePtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, miscc=miscc):
+    def __del__(self,miscc=miscc):
         if self.thisown == 1 :
-            miscc.delete_wxSize(self.this)
-    def Set(self,arg0,arg1):
-        val = miscc.wxSize_Set(self.this,arg0,arg1)
+            miscc.delete_wxSize(self)
+    def Set(self, *_args, **_kwargs):
+        val = apply(miscc.wxSize_Set,(self,) + _args, _kwargs)
         return val
-    def GetX(self):
-        val = miscc.wxSize_GetX(self.this)
+    def GetX(self, *_args, **_kwargs):
+        val = apply(miscc.wxSize_GetX,(self,) + _args, _kwargs)
         return val
-    def GetY(self):
-        val = miscc.wxSize_GetY(self.this)
+    def GetY(self, *_args, **_kwargs):
+        val = apply(miscc.wxSize_GetY,(self,) + _args, _kwargs)
         return val
-    def GetWidth(self):
-        val = miscc.wxSize_GetWidth(self.this)
+    def GetWidth(self, *_args, **_kwargs):
+        val = apply(miscc.wxSize_GetWidth,(self,) + _args, _kwargs)
         return val
-    def GetHeight(self):
-        val = miscc.wxSize_GetHeight(self.this)
+    def GetHeight(self, *_args, **_kwargs):
+        val = apply(miscc.wxSize_GetHeight,(self,) + _args, _kwargs)
         return val
-    def SetWidth(self,arg0):
-        val = miscc.wxSize_SetWidth(self.this,arg0)
+    def SetWidth(self, *_args, **_kwargs):
+        val = apply(miscc.wxSize_SetWidth,(self,) + _args, _kwargs)
         return val
-    def SetHeight(self,arg0):
-        val = miscc.wxSize_SetHeight(self.this,arg0)
+    def SetHeight(self, *_args, **_kwargs):
+        val = apply(miscc.wxSize_SetHeight,(self,) + _args, _kwargs)
         return val
-    def asTuple(self):
-        val = miscc.wxSize_asTuple(self.this)
+    def asTuple(self, *_args, **_kwargs):
+        val = apply(miscc.wxSize_asTuple,(self,) + _args, _kwargs)
         return val
     def __setattr__(self,name,value):
         if name == "x" :
-            miscc.wxSize_x_set(self.this,value)
+            miscc.wxSize_x_set(self,value)
             return
         if name == "y" :
-            miscc.wxSize_y_set(self.this,value)
+            miscc.wxSize_y_set(self,value)
             return
         if name == "width" :
-            miscc.wxSize_width_set(self.this,value)
+            miscc.wxSize_width_set(self,value)
             return
         if name == "height" :
-            miscc.wxSize_height_set(self.this,value)
+            miscc.wxSize_height_set(self,value)
             return
         self.__dict__[name] = value
     def __getattr__(self,name):
         if name == "x" : 
-            return miscc.wxSize_x_get(self.this)
+            return miscc.wxSize_x_get(self)
         if name == "y" : 
-            return miscc.wxSize_y_get(self.this)
+            return miscc.wxSize_y_get(self)
         if name == "width" : 
-            return miscc.wxSize_width_get(self.this)
+            return miscc.wxSize_width_get(self)
         if name == "height" : 
-            return miscc.wxSize_height_get(self.this)
+            return miscc.wxSize_height_get(self)
         raise AttributeError,name
     def __repr__(self):
-        return "<C wxSize instance>"
+        return "<C wxSize instance at %s>" % (self.this,)
     def __str__(self): return str(self.asTuple())
     def __repr__(self): return str(self.asTuple())
 class wxSize(wxSizePtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxSize,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxSize,_args,_kwargs)
         self.thisown = 1
 
 
@@ -71,28 +71,28 @@ class wxRealPointPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, miscc=miscc):
+    def __del__(self,miscc=miscc):
         if self.thisown == 1 :
-            miscc.delete_wxRealPoint(self.this)
+            miscc.delete_wxRealPoint(self)
     def __setattr__(self,name,value):
         if name == "x" :
-            miscc.wxRealPoint_x_set(self.this,value)
+            miscc.wxRealPoint_x_set(self,value)
             return
         if name == "y" :
-            miscc.wxRealPoint_y_set(self.this,value)
+            miscc.wxRealPoint_y_set(self,value)
             return
         self.__dict__[name] = value
     def __getattr__(self,name):
         if name == "x" : 
-            return miscc.wxRealPoint_x_get(self.this)
+            return miscc.wxRealPoint_x_get(self)
         if name == "y" : 
-            return miscc.wxRealPoint_y_get(self.this)
+            return miscc.wxRealPoint_y_get(self)
         raise AttributeError,name
     def __repr__(self):
-        return "<C wxRealPoint instance>"
+        return "<C wxRealPoint instance at %s>" % (self.this,)
 class wxRealPoint(wxRealPointPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxRealPoint,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxRealPoint,_args,_kwargs)
         self.thisown = 1
 
 
@@ -102,36 +102,36 @@ class wxPointPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, miscc=miscc):
+    def __del__(self,miscc=miscc):
         if self.thisown == 1 :
-            miscc.delete_wxPoint(self.this)
-    def Set(self,arg0,arg1):
-        val = miscc.wxPoint_Set(self.this,arg0,arg1)
+            miscc.delete_wxPoint(self)
+    def Set(self, *_args, **_kwargs):
+        val = apply(miscc.wxPoint_Set,(self,) + _args, _kwargs)
         return val
-    def asTuple(self):
-        val = miscc.wxPoint_asTuple(self.this)
+    def asTuple(self, *_args, **_kwargs):
+        val = apply(miscc.wxPoint_asTuple,(self,) + _args, _kwargs)
         return val
     def __setattr__(self,name,value):
         if name == "x" :
-            miscc.wxPoint_x_set(self.this,value)
+            miscc.wxPoint_x_set(self,value)
             return
         if name == "y" :
-            miscc.wxPoint_y_set(self.this,value)
+            miscc.wxPoint_y_set(self,value)
             return
         self.__dict__[name] = value
     def __getattr__(self,name):
         if name == "x" : 
-            return miscc.wxPoint_x_get(self.this)
+            return miscc.wxPoint_x_get(self)
         if name == "y" : 
-            return miscc.wxPoint_y_get(self.this)
+            return miscc.wxPoint_y_get(self)
         raise AttributeError,name
     def __repr__(self):
-        return "<C wxPoint instance>"
+        return "<C wxPoint instance at %s>" % (self.this,)
     def __str__(self): return str(self.asTuple())
     def __repr__(self): return str(self.asTuple())
 class wxPoint(wxPointPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxPoint,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxPoint,_args,_kwargs)
         self.thisown = 1
 
 
@@ -141,89 +141,87 @@ class wxRectPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, miscc=miscc):
+    def __del__(self,miscc=miscc):
         if self.thisown == 1 :
-            miscc.delete_wxRect(self.this)
-    def GetX(self):
-        val = miscc.wxRect_GetX(self.this)
+            miscc.delete_wxRect(self)
+    def GetX(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetX,(self,) + _args, _kwargs)
         return val
-    def SetX(self,arg0):
-        val = miscc.wxRect_SetX(self.this,arg0)
+    def SetX(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_SetX,(self,) + _args, _kwargs)
         return val
-    def GetY(self):
-        val = miscc.wxRect_GetY(self.this)
+    def GetY(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetY,(self,) + _args, _kwargs)
         return val
-    def SetY(self,arg0):
-        val = miscc.wxRect_SetY(self.this,arg0)
+    def SetY(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_SetY,(self,) + _args, _kwargs)
         return val
-    def GetWidth(self):
-        val = miscc.wxRect_GetWidth(self.this)
+    def GetWidth(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetWidth,(self,) + _args, _kwargs)
         return val
-    def SetWidth(self,arg0):
-        val = miscc.wxRect_SetWidth(self.this,arg0)
+    def SetWidth(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_SetWidth,(self,) + _args, _kwargs)
         return val
-    def GetHeight(self):
-        val = miscc.wxRect_GetHeight(self.this)
+    def GetHeight(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetHeight,(self,) + _args, _kwargs)
         return val
-    def SetHeight(self,arg0):
-        val = miscc.wxRect_SetHeight(self.this,arg0)
+    def SetHeight(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_SetHeight,(self,) + _args, _kwargs)
         return val
-    def GetPosition(self):
-        val = miscc.wxRect_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetPosition(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetPosition,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetSize(self):
-        val = miscc.wxRect_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
+    def GetSize(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetSize,(self,) + _args, _kwargs)
+        if val: val = wxSizePtr(val) ; val.thisown = 1
         return val
-    def GetLeft(self):
-        val = miscc.wxRect_GetLeft(self.this)
+    def GetLeft(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetLeft,(self,) + _args, _kwargs)
         return val
-    def GetTop(self):
-        val = miscc.wxRect_GetTop(self.this)
+    def GetTop(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetTop,(self,) + _args, _kwargs)
         return val
-    def GetBottom(self):
-        val = miscc.wxRect_GetBottom(self.this)
+    def GetBottom(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetBottom,(self,) + _args, _kwargs)
         return val
-    def GetRight(self):
-        val = miscc.wxRect_GetRight(self.this)
+    def GetRight(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_GetRight,(self,) + _args, _kwargs)
         return val
-    def asTuple(self):
-        val = miscc.wxRect_asTuple(self.this)
+    def asTuple(self, *_args, **_kwargs):
+        val = apply(miscc.wxRect_asTuple,(self,) + _args, _kwargs)
         return val
     def __setattr__(self,name,value):
         if name == "x" :
-            miscc.wxRect_x_set(self.this,value)
+            miscc.wxRect_x_set(self,value)
             return
         if name == "y" :
-            miscc.wxRect_y_set(self.this,value)
+            miscc.wxRect_y_set(self,value)
             return
         if name == "width" :
-            miscc.wxRect_width_set(self.this,value)
+            miscc.wxRect_width_set(self,value)
             return
         if name == "height" :
-            miscc.wxRect_height_set(self.this,value)
+            miscc.wxRect_height_set(self,value)
             return
         self.__dict__[name] = value
     def __getattr__(self,name):
         if name == "x" : 
-            return miscc.wxRect_x_get(self.this)
+            return miscc.wxRect_x_get(self)
         if name == "y" : 
-            return miscc.wxRect_y_get(self.this)
+            return miscc.wxRect_y_get(self)
         if name == "width" : 
-            return miscc.wxRect_width_get(self.this)
+            return miscc.wxRect_width_get(self)
         if name == "height" : 
-            return miscc.wxRect_height_get(self.this)
+            return miscc.wxRect_height_get(self)
         raise AttributeError,name
     def __repr__(self):
-        return "<C wxRect instance>"
+        return "<C wxRect instance at %s>" % (self.this,)
     def __str__(self): return str(self.asTuple())
     def __repr__(self): return str(self.asTuple())
 class wxRect(wxRectPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxRect,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxRect,_args,_kwargs)
         self.thisown = 1
 
 
@@ -233,23 +231,23 @@ class wxPyTimerPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, miscc=miscc):
+    def __del__(self,miscc=miscc):
         if self.thisown == 1 :
-            miscc.delete_wxPyTimer(self.this)
-    def Interval(self):
-        val = miscc.wxPyTimer_Interval(self.this)
+            miscc.delete_wxPyTimer(self)
+    def Interval(self, *_args, **_kwargs):
+        val = apply(miscc.wxPyTimer_Interval,(self,) + _args, _kwargs)
         return val
-    def Start(self,*args):
-        val = apply(miscc.wxPyTimer_Start,(self.this,)+args)
+    def Start(self, *_args, **_kwargs):
+        val = apply(miscc.wxPyTimer_Start,(self,) + _args, _kwargs)
         return val
-    def Stop(self):
-        val = miscc.wxPyTimer_Stop(self.this)
+    def Stop(self, *_args, **_kwargs):
+        val = apply(miscc.wxPyTimer_Stop,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPyTimer instance>"
+        return "<C wxPyTimer instance at %s>" % (self.this,)
 class wxPyTimer(wxPyTimerPtr):
-    def __init__(self,arg0) :
-        self.this = miscc.new_wxPyTimer(arg0)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxPyTimer,_args,_kwargs)
         self.thisown = 1
 
 
@@ -259,38 +257,38 @@ class wxIndividualLayoutConstraintPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def Above(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_Above,(self.this,arg0.this,)+args)
+    def Above(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_Above,(self,) + _args, _kwargs)
         return val
-    def Absolute(self,arg0):
-        val = miscc.wxIndividualLayoutConstraint_Absolute(self.this,arg0)
+    def Absolute(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_Absolute,(self,) + _args, _kwargs)
         return val
-    def AsIs(self):
-        val = miscc.wxIndividualLayoutConstraint_AsIs(self.this)
+    def AsIs(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_AsIs,(self,) + _args, _kwargs)
         return val
-    def Below(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_Below,(self.this,arg0.this,)+args)
+    def Below(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_Below,(self,) + _args, _kwargs)
         return val
-    def Unconstrained(self):
-        val = miscc.wxIndividualLayoutConstraint_Unconstrained(self.this)
+    def Unconstrained(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_Unconstrained,(self,) + _args, _kwargs)
         return val
-    def LeftOf(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_LeftOf,(self.this,arg0.this,)+args)
+    def LeftOf(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_LeftOf,(self,) + _args, _kwargs)
         return val
-    def PercentOf(self,arg0,arg1,arg2):
-        val = miscc.wxIndividualLayoutConstraint_PercentOf(self.this,arg0.this,arg1,arg2)
+    def PercentOf(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_PercentOf,(self,) + _args, _kwargs)
         return val
-    def RightOf(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_RightOf,(self.this,arg0.this,)+args)
+    def RightOf(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_RightOf,(self,) + _args, _kwargs)
         return val
-    def SameAs(self,arg0,arg1,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_SameAs,(self.this,arg0.this,arg1,)+args)
+    def SameAs(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_SameAs,(self,) + _args, _kwargs)
         return val
-    def Set(self,arg0,arg1,arg2,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_Set,(self.this,arg0,arg1.this,arg2,)+args)
+    def Set(self, *_args, **_kwargs):
+        val = apply(miscc.wxIndividualLayoutConstraint_Set,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxIndividualLayoutConstraint instance>"
+        return "<C wxIndividualLayoutConstraint instance at %s>" % (self.this,)
 class wxIndividualLayoutConstraint(wxIndividualLayoutConstraintPtr):
     def __init__(self,this):
         self.this = this
@@ -304,53 +302,53 @@ class wxLayoutConstraintsPtr :
         self.thisown = 0
     def __setattr__(self,name,value):
         if name == "bottom" :
-            miscc.wxLayoutConstraints_bottom_set(self.this,value.this)
+            miscc.wxLayoutConstraints_bottom_set(self,value.this)
             return
         if name == "centreX" :
-            miscc.wxLayoutConstraints_centreX_set(self.this,value.this)
+            miscc.wxLayoutConstraints_centreX_set(self,value.this)
             return
         if name == "centreY" :
-            miscc.wxLayoutConstraints_centreY_set(self.this,value.this)
+            miscc.wxLayoutConstraints_centreY_set(self,value.this)
             return
         if name == "height" :
-            miscc.wxLayoutConstraints_height_set(self.this,value.this)
+            miscc.wxLayoutConstraints_height_set(self,value.this)
             return
         if name == "left" :
-            miscc.wxLayoutConstraints_left_set(self.this,value.this)
+            miscc.wxLayoutConstraints_left_set(self,value.this)
             return
         if name == "right" :
-            miscc.wxLayoutConstraints_right_set(self.this,value.this)
+            miscc.wxLayoutConstraints_right_set(self,value.this)
             return
         if name == "top" :
-            miscc.wxLayoutConstraints_top_set(self.this,value.this)
+            miscc.wxLayoutConstraints_top_set(self,value.this)
             return
         if name == "width" :
-            miscc.wxLayoutConstraints_width_set(self.this,value.this)
+            miscc.wxLayoutConstraints_width_set(self,value.this)
             return
         self.__dict__[name] = value
     def __getattr__(self,name):
         if name == "bottom" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_bottom_get(self.this))
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_bottom_get(self))
         if name == "centreX" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreX_get(self.this))
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreX_get(self))
         if name == "centreY" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreY_get(self.this))
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreY_get(self))
         if name == "height" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_height_get(self.this))
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_height_get(self))
         if name == "left" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_left_get(self.this))
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_left_get(self))
         if name == "right" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_right_get(self.this))
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_right_get(self))
         if name == "top" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_top_get(self.this))
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_top_get(self))
         if name == "width" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_width_get(self.this))
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_width_get(self))
         raise AttributeError,name
     def __repr__(self):
-        return "<C wxLayoutConstraints instance>"
+        return "<C wxLayoutConstraints instance at %s>" % (self.this,)
 class wxLayoutConstraints(wxLayoutConstraintsPtr):
-    def __init__(self) :
-        self.this = miscc.new_wxLayoutConstraints()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxLayoutConstraints,_args,_kwargs)
         self.thisown = 1
 
 
@@ -360,43 +358,42 @@ class wxRegionPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, miscc=miscc):
+    def __del__(self,miscc=miscc):
         if self.thisown == 1 :
-            miscc.delete_wxRegion(self.this)
-    def Clear(self):
-        val = miscc.wxRegion_Clear(self.this)
+            miscc.delete_wxRegion(self)
+    def Clear(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegion_Clear,(self,) + _args, _kwargs)
         return val
-    def Contains(self,arg0,arg1):
-        val = miscc.wxRegion_Contains(self.this,arg0,arg1)
+    def Contains(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegion_Contains,(self,) + _args, _kwargs)
         return val
-    def ContainsPoint(self,arg0):
-        val = miscc.wxRegion_ContainsPoint(self.this,arg0.this)
+    def ContainsPoint(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegion_ContainsPoint,(self,) + _args, _kwargs)
         return val
-    def ContainsRect(self,arg0):
-        val = miscc.wxRegion_ContainsRect(self.this,arg0.this)
+    def ContainsRect(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegion_ContainsRect,(self,) + _args, _kwargs)
         return val
-    def GetBox(self):
-        val = miscc.wxRegion_GetBox(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
+    def GetBox(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegion_GetBox,(self,) + _args, _kwargs)
+        if val: val = wxRectPtr(val) ; val.thisown = 1
         return val
-    def Intersect(self,arg0):
-        val = miscc.wxRegion_Intersect(self.this,arg0.this)
+    def Intersect(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegion_Intersect,(self,) + _args, _kwargs)
         return val
-    def Subtract(self,arg0):
-        val = miscc.wxRegion_Subtract(self.this,arg0.this)
+    def Subtract(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegion_Subtract,(self,) + _args, _kwargs)
         return val
-    def Union(self,arg0):
-        val = miscc.wxRegion_Union(self.this,arg0.this)
+    def Union(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegion_Union,(self,) + _args, _kwargs)
         return val
-    def Xor(self,arg0):
-        val = miscc.wxRegion_Xor(self.this,arg0.this)
+    def Xor(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegion_Xor,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxRegion instance>"
+        return "<C wxRegion instance at %s>" % (self.this,)
 class wxRegion(wxRegionPtr):
-    def __init__(self) :
-        self.this = miscc.new_wxRegion()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxRegion,_args,_kwargs)
         self.thisown = 1
 
 
@@ -406,46 +403,45 @@ class wxRegionIteratorPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, miscc=miscc):
+    def __del__(self,miscc=miscc):
         if self.thisown == 1 :
-            miscc.delete_wxRegionIterator(self.this)
-    def GetX(self):
-        val = miscc.wxRegionIterator_GetX(self.this)
+            miscc.delete_wxRegionIterator(self)
+    def GetX(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_GetX,(self,) + _args, _kwargs)
         return val
-    def GetY(self):
-        val = miscc.wxRegionIterator_GetY(self.this)
+    def GetY(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_GetY,(self,) + _args, _kwargs)
         return val
-    def GetW(self):
-        val = miscc.wxRegionIterator_GetW(self.this)
+    def GetW(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_GetW,(self,) + _args, _kwargs)
         return val
-    def GetWidth(self):
-        val = miscc.wxRegionIterator_GetWidth(self.this)
+    def GetWidth(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_GetWidth,(self,) + _args, _kwargs)
         return val
-    def GetH(self):
-        val = miscc.wxRegionIterator_GetH(self.this)
+    def GetH(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_GetH,(self,) + _args, _kwargs)
         return val
-    def GetHeight(self):
-        val = miscc.wxRegionIterator_GetHeight(self.this)
+    def GetHeight(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_GetHeight,(self,) + _args, _kwargs)
         return val
-    def GetRect(self):
-        val = miscc.wxRegionIterator_GetRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
+    def GetRect(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_GetRect,(self,) + _args, _kwargs)
+        if val: val = wxRectPtr(val) ; val.thisown = 1
         return val
-    def HaveRects(self):
-        val = miscc.wxRegionIterator_HaveRects(self.this)
+    def HaveRects(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_HaveRects,(self,) + _args, _kwargs)
         return val
-    def Reset(self):
-        val = miscc.wxRegionIterator_Reset(self.this)
+    def Reset(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_Reset,(self,) + _args, _kwargs)
         return val
-    def Next(self):
-        val = miscc.wxRegionIterator_Next(self.this)
+    def Next(self, *_args, **_kwargs):
+        val = apply(miscc.wxRegionIterator_Next,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxRegionIterator instance>"
+        return "<C wxRegionIterator instance at %s>" % (self.this,)
 class wxRegionIterator(wxRegionIteratorPtr):
-    def __init__(self,arg0) :
-        self.this = miscc.new_wxRegionIterator(arg0.this)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxRegionIterator,_args,_kwargs)
         self.thisown = 1
 
 
@@ -455,23 +451,23 @@ class wxAcceleratorEntryPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def Set(self,arg0,arg1,arg2):
-        val = miscc.wxAcceleratorEntry_Set(self.this,arg0,arg1,arg2)
+    def Set(self, *_args, **_kwargs):
+        val = apply(miscc.wxAcceleratorEntry_Set,(self,) + _args, _kwargs)
         return val
-    def GetFlags(self):
-        val = miscc.wxAcceleratorEntry_GetFlags(self.this)
+    def GetFlags(self, *_args, **_kwargs):
+        val = apply(miscc.wxAcceleratorEntry_GetFlags,(self,) + _args, _kwargs)
         return val
-    def GetKeyCode(self):
-        val = miscc.wxAcceleratorEntry_GetKeyCode(self.this)
+    def GetKeyCode(self, *_args, **_kwargs):
+        val = apply(miscc.wxAcceleratorEntry_GetKeyCode,(self,) + _args, _kwargs)
         return val
-    def GetCommand(self):
-        val = miscc.wxAcceleratorEntry_GetCommand(self.this)
+    def GetCommand(self, *_args, **_kwargs):
+        val = apply(miscc.wxAcceleratorEntry_GetCommand,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxAcceleratorEntry instance>"
+        return "<C wxAcceleratorEntry instance at %s>" % (self.this,)
 class wxAcceleratorEntry(wxAcceleratorEntryPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxAcceleratorEntry,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxAcceleratorEntry,_args,_kwargs)
         self.thisown = 1
 
 
@@ -482,10 +478,10 @@ class wxAcceleratorTablePtr :
         self.this = this
         self.thisown = 0
     def __repr__(self):
-        return "<C wxAcceleratorTable instance>"
+        return "<C wxAcceleratorTable instance at %s>" % (self.this,)
 class wxAcceleratorTable(wxAcceleratorTablePtr):
-    def __init__(self,arg0) :
-        self.this = miscc.new_wxAcceleratorTable(arg0.this)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(miscc.new_wxAcceleratorTable,_args,_kwargs)
         self.thisown = 1
 
 
@@ -495,63 +491,23 @@ class wxAcceleratorTable(wxAcceleratorTablePtr):
 
 #-------------- FUNCTION WRAPPERS ------------------
 
-def wxFileSelector(arg0,*args):
-    argl = map(None,args)
-    try: argl[5] = argl[5].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxFileSelector,(arg0,)+args)
-    return val
+wxFileSelector = miscc.wxFileSelector
 
-def wxGetTextFromUser(arg0,*args):
-    argl = map(None,args)
-    try: argl[2] = argl[2].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetTextFromUser,(arg0,)+args)
-    return val
+wxGetTextFromUser = miscc.wxGetTextFromUser
 
-def wxGetSingleChoice(arg0,arg1,arg2,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetSingleChoice,(arg0,arg1,arg2,)+args)
-    return val
+wxGetSingleChoice = miscc.wxGetSingleChoice
 
-def wxGetSingleChoiceIndex(arg0,arg1,arg2,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetSingleChoiceIndex,(arg0,arg1,arg2,)+args)
-    return val
+wxGetSingleChoiceIndex = miscc.wxGetSingleChoiceIndex
 
-def wxMessageBox(arg0,*args):
-    argl = map(None,args)
-    try: argl[2] = argl[2].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxMessageBox,(arg0,)+args)
-    return val
+wxMessageBox = miscc.wxMessageBox
 
-def wxGetNumberFromUser(arg0,arg1,arg2,arg3,*args):
-    argl = map(None,args)
-    try: argl[2] = argl[2].this
-    except: pass
-    try: argl[3] = argl[3].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetNumberFromUser,(arg0,arg1,arg2,arg3,)+args)
-    return val
+wxGetNumberFromUser = miscc.wxGetNumberFromUser
 
 wxColourDisplay = miscc.wxColourDisplay
 
 wxDisplayDepth = miscc.wxDisplayDepth
 
-def wxSetCursor(arg0):
-    val = miscc.wxSetCursor(arg0.this)
-    return val
+wxSetCursor = miscc.wxSetCursor
 
 wxNewId = miscc.wxNewId
 
@@ -561,13 +517,7 @@ NewId = miscc.NewId
 
 RegisterId = miscc.RegisterId
 
-def wxBeginBusyCursor(*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxBeginBusyCursor,()+args)
-    return val
+wxBeginBusyCursor = miscc.wxBeginBusyCursor
 
 wxBell = miscc.wxBell
 
@@ -597,21 +547,19 @@ wxResourceAddIdentifier = miscc.wxResourceAddIdentifier
 
 wxResourceClear = miscc.wxResourceClear
 
-def wxResourceCreateBitmap(arg0):
-    val = miscc.wxResourceCreateBitmap(arg0)
-    val = wxBitmapPtr(val)
-    val.thisown = 1
+def wxResourceCreateBitmap(*_args, **_kwargs):
+    val = apply(miscc.wxResourceCreateBitmap,_args,_kwargs)
+    if val: val = wxBitmapPtr(val); val.thisown = 1
     return val
 
-def wxResourceCreateIcon(arg0):
-    val = miscc.wxResourceCreateIcon(arg0)
-    val = wxIconPtr(val)
-    val.thisown = 1
+def wxResourceCreateIcon(*_args, **_kwargs):
+    val = apply(miscc.wxResourceCreateIcon,_args,_kwargs)
+    if val: val = wxIconPtr(val); val.thisown = 1
     return val
 
-def wxResourceCreateMenuBar(arg0):
-    val = miscc.wxResourceCreateMenuBar(arg0)
-    val = wxMenuBarPtr(val)
+def wxResourceCreateMenuBar(*_args, **_kwargs):
+    val = apply(miscc.wxResourceCreateMenuBar,_args,_kwargs)
+    if val: val = wxMenuBarPtr(val)
     return val
 
 wxResourceGetIdentifier = miscc.wxResourceGetIdentifier
@@ -622,16 +570,14 @@ wxResourceParseFile = miscc.wxResourceParseFile
 
 wxResourceParseString = miscc.wxResourceParseString
 
-def wxSystemSettings_GetSystemColour(arg0):
-    val = miscc.wxSystemSettings_GetSystemColour(arg0)
-    val = wxColourPtr(val)
-    val.thisown = 1
+def wxSystemSettings_GetSystemColour(*_args, **_kwargs):
+    val = apply(miscc.wxSystemSettings_GetSystemColour,_args,_kwargs)
+    if val: val = wxColourPtr(val); val.thisown = 1
     return val
 
-def wxSystemSettings_GetSystemFont(arg0):
-    val = miscc.wxSystemSettings_GetSystemFont(arg0)
-    val = wxFontPtr(val)
-    val.thisown = 1
+def wxSystemSettings_GetSystemFont(*_args, **_kwargs):
+    val = apply(miscc.wxSystemSettings_GetSystemFont,_args,_kwargs)
+    if val: val = wxFontPtr(val); val.thisown = 1
     return val
 
 wxSystemSettings_GetSystemMetric = miscc.wxSystemSettings_GetSystemMetric

utils/wxPython/src/gtk/misc2.cpp

@@ -3,7 +3,7 @@
  * 
  * This file was automatically generated by :
  * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Patch 5)
+ * Version 1.1 (Patch 6)
  * 
  * Portions Copyright (c) 1995-1998
  * The University of Utah and The Regents of the University of California.
@@ -24,16 +24,16 @@
 /* Definitions for Windows/Unix exporting */
 #if defined(__WIN32__)
 #   if defined(_MSC_VER)
-#	define SWIGEXPORT(a,b) __declspec(dllexport) a b
+#	define SWIGEXPORT(a) __declspec(dllexport) a
 #   else
 #	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a,b) a _export b
+#	    define SWIGEXPORT(a) a _export 
 #	else
-#	    define SWIGEXPORT(a,b) a b
+#	    define SWIGEXPORT(a) a 
 #	endif
 #   endif
 #else
-#   define SWIGEXPORT(a,b) a b
+#   define SWIGEXPORT(a) a 
 #endif
 
 #ifdef __cplusplus
@@ -43,12 +43,12 @@ extern "C" {
 extern void SWIG_MakePtr(char *, void *, char *);
 extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
 extern char *SWIG_GetPtr(char *, void **, char *);
+extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
 extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
 extern PyObject *SWIG_newvarlink(void);
 #ifdef __cplusplus
 }
 #endif
-
 #define SWIG_init    initmisc2c
 
 #define SWIG_name    "misc2c"
@@ -124,17 +124,20 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     void wxToolTip_SetDelay(long milliseconds) {
         wxToolTip::SetDelay(milliseconds);
     }
+#ifdef __cplusplus
+extern "C" {
+#endif
 static PyObject *_wrap_wxFindWindowByLabel(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxWindow * _result;
     wxString * _arg0;
-    wxWindow * _arg1 = NULL;
+    wxWindow * _arg1 = (wxWindow *) NULL;
     PyObject * _obj0 = 0;
-    char * _argc1 = 0;
+    PyObject * _argo1 = 0;
     char _ptemp[128];
 
     self = self;
-    if(!PyArg_ParseTuple(args,"O|s:wxFindWindowByLabel",&_obj0,&_argc1)) 
+    if(!PyArg_ParseTuple(args,"O|O:wxFindWindowByLabel",&_obj0,&_argo1)) 
         return NULL;
 {
     if (!PyString_Check(_obj0)) {
@@ -143,8 +146,9 @@ static PyObject *_wrap_wxFindWindowByLabel(PyObject *self, PyObject *args) {
     }
     _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0));
 }
-    if (_argc1) {
-        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) {
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxFindWindowByLabel. Expected _wxWindow_p.");
         return NULL;
         }
@@ -154,8 +158,13 @@ static PyObject *_wrap_wxFindWindowByLabel(PyObject *self, PyObject *args) {
         _result = (wxWindow *)wxFindWindowByLabel(*_arg0,_arg1);
 
     wxPy_END_ALLOW_THREADS;
-}    SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
 {
     if (_obj0)
         delete _arg0;
@@ -167,13 +176,13 @@ static PyObject *_wrap_wxFindWindowByName(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxWindow * _result;
     wxString * _arg0;
-    wxWindow * _arg1 = NULL;
+    wxWindow * _arg1 = (wxWindow *) NULL;
     PyObject * _obj0 = 0;
-    char * _argc1 = 0;
+    PyObject * _argo1 = 0;
     char _ptemp[128];
 
     self = self;
-    if(!PyArg_ParseTuple(args,"O|s:wxFindWindowByName",&_obj0,&_argc1)) 
+    if(!PyArg_ParseTuple(args,"O|O:wxFindWindowByName",&_obj0,&_argo1)) 
         return NULL;
 {
     if (!PyString_Check(_obj0)) {
@@ -182,8 +191,9 @@ static PyObject *_wrap_wxFindWindowByName(PyObject *self, PyObject *args) {
     }
     _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0));
 }
-    if (_argc1) {
-        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) {
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxFindWindowByName. Expected _wxWindow_p.");
         return NULL;
         }
@@ -193,8 +203,13 @@ static PyObject *_wrap_wxFindWindowByName(PyObject *self, PyObject *args) {
         _result = (wxWindow *)wxFindWindowByName(*_arg0,_arg1);
 
     wxPy_END_ALLOW_THREADS;
-}    SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
 {
     if (_obj0)
         delete _arg0;
@@ -261,8 +276,13 @@ static PyObject *_wrap_new_wxToolTip(PyObject *self, PyObject *args) {
         _result = (wxToolTip *)new_wxToolTip(*_arg0);
 
     wxPy_END_ALLOW_THREADS;
-}    SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolTip_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolTip_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
 {
     if (_obj0)
         delete _arg0;
@@ -275,14 +295,15 @@ static PyObject *_wrap_wxToolTip_SetTip(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxToolTip * _arg0;
     wxString * _arg1;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO:wxToolTip_SetTip",&_argc0,&_obj1)) 
+    if(!PyArg_ParseTuple(args,"OO:wxToolTip_SetTip",&_argo0,&_obj1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxToolTip_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxToolTip_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxToolTip_SetTip. Expected _wxToolTip_p.");
         return NULL;
         }
@@ -313,13 +334,14 @@ static PyObject *_wrap_wxToolTip_GetTip(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxString * _result;
     wxToolTip * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxToolTip_GetTip",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxToolTip_GetTip",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxToolTip_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxToolTip_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxToolTip_GetTip. Expected _wxToolTip_p.");
         return NULL;
         }
@@ -343,14 +365,15 @@ static PyObject *_wrap_wxToolTip_GetWindow(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxWindow * _result;
     wxToolTip * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     char _ptemp[128];
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxToolTip_GetWindow",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxToolTip_GetWindow",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxToolTip_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxToolTip_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxToolTip_GetWindow. Expected _wxToolTip_p.");
         return NULL;
         }
@@ -360,171 +383,186 @@ static PyObject *_wrap_wxToolTip_GetWindow(PyObject *self, PyObject *args) {
         _result = (wxWindow *)wxToolTip_GetWindow(_arg0);
 
     wxPy_END_ALLOW_THREADS;
-}    SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
     return _resultobj;
 }
 
 static PyMethodDef misc2cMethods[] = {
-	 { "wxToolTip_GetWindow", _wrap_wxToolTip_GetWindow, 1 },
-	 { "wxToolTip_GetTip", _wrap_wxToolTip_GetTip, 1 },
-	 { "wxToolTip_SetTip", _wrap_wxToolTip_SetTip, 1 },
-	 { "new_wxToolTip", _wrap_new_wxToolTip, 1 },
-	 { "wxToolTip_SetDelay", _wrap_wxToolTip_SetDelay, 1 },
-	 { "wxToolTip_Enable", _wrap_wxToolTip_Enable, 1 },
-	 { "wxFindWindowByName", _wrap_wxFindWindowByName, 1 },
-	 { "wxFindWindowByLabel", _wrap_wxFindWindowByLabel, 1 },
+	 { "wxToolTip_GetWindow", _wrap_wxToolTip_GetWindow, METH_VARARGS },
+	 { "wxToolTip_GetTip", _wrap_wxToolTip_GetTip, METH_VARARGS },
+	 { "wxToolTip_SetTip", _wrap_wxToolTip_SetTip, METH_VARARGS },
+	 { "new_wxToolTip", _wrap_new_wxToolTip, METH_VARARGS },
+	 { "wxToolTip_SetDelay", _wrap_wxToolTip_SetDelay, METH_VARARGS },
+	 { "wxToolTip_Enable", _wrap_wxToolTip_Enable, METH_VARARGS },
+	 { "wxFindWindowByName", _wrap_wxFindWindowByName, METH_VARARGS },
+	 { "wxFindWindowByLabel", _wrap_wxFindWindowByLabel, METH_VARARGS },
 	 { NULL, NULL }
 };
+#ifdef __cplusplus
+}
+#endif
+/*
+ * This table is used by the pointer type-checker
+ */
+static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
+    { "_wxAcceleratorTable","_class_wxAcceleratorTable",0},
+    { "_signed_long","_long",0},
+    { "_wxPrintQuality","_int",0},
+    { "_wxPrintQuality","_signed_int",0},
+    { "_wxPrintQuality","_unsigned_int",0},
+    { "_wxPrintQuality","_wxWindowID",0},
+    { "_wxPrintQuality","_uint",0},
+    { "_wxPrintQuality","_EBool",0},
+    { "_wxPrintQuality","_size_t",0},
+    { "_class_wxRegionIterator","_wxRegionIterator",0},
+    { "_class_wxMenuBar","_wxMenuBar",0},
+    { "_class_wxEvtHandler","_wxEvtHandler",0},
+    { "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0},
+    { "_wxCursor","_class_wxCursor",0},
+    { "_wxMask","_class_wxMask",0},
+    { "_wxToolTip","_class_wxToolTip",0},
+    { "_wxPen","_class_wxPen",0},
+    { "_byte","_unsigned_char",0},
+    { "_long","_wxDash",0},
+    { "_long","_unsigned_long",0},
+    { "_long","_signed_long",0},
+    { "_wxImageList","_class_wxImageList",0},
+    { "_class_wxAcceleratorTable","_wxAcceleratorTable",0},
+    { "_wxDC","_class_wxDC",0},
+    { "_size_t","_wxPrintQuality",0},
+    { "_size_t","_unsigned_int",0},
+    { "_size_t","_int",0},
+    { "_size_t","_wxWindowID",0},
+    { "_size_t","_uint",0},
+    { "_class_wxRealPoint","_wxRealPoint",0},
+    { "_class_wxMenuItem","_wxMenuItem",0},
+    { "_class_wxPostScriptDC","_wxPostScriptDC",0},
+    { "_wxPanel","_class_wxPanel",0},
+    { "_class_wxMask","_wxMask",0},
+    { "_class_wxToolTip","_wxToolTip",0},
+    { "_wxColour","_class_wxColour",0},
+    { "_class_wxDialog","_wxDialog",0},
+    { "_wxBrush","_class_wxBrush",0},
+    { "_uint","_wxPrintQuality",0},
+    { "_uint","_size_t",0},
+    { "_uint","_unsigned_int",0},
+    { "_uint","_int",0},
+    { "_uint","_wxWindowID",0},
+    { "_wxRect","_class_wxRect",0},
+    { "_wxPoint","_class_wxPoint",0},
+    { "_wxBitmap","_class_wxBitmap",0},
+    { "_wxPyTimer","_class_wxPyTimer",0},
+    { "_wxWindowDC","_class_wxWindowDC",0},
+    { "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
+    { "_EBool","_wxPrintQuality",0},
+    { "_EBool","_signed_int",0},
+    { "_EBool","_int",0},
+    { "_EBool","_wxWindowID",0},
+    { "_class_wxRegion","_wxRegion",0},
+    { "_wxFont","_class_wxFont",0},
+    { "_unsigned_long","_wxDash",0},
+    { "_unsigned_long","_long",0},
+    { "_class_wxRect","_wxRect",0},
+    { "_class_wxDC","_wxDC",0},
+    { "_class_wxPyTimer","_wxPyTimer",0},
+    { "_wxAcceleratorEntry","_class_wxAcceleratorEntry",0},
+    { "_class_wxPanel","_wxPanel",0},
+    { "_signed_int","_wxPrintQuality",0},
+    { "_signed_int","_EBool",0},
+    { "_signed_int","_wxWindowID",0},
+    { "_signed_int","_int",0},
+    { "_wxLayoutConstraints","_class_wxLayoutConstraints",0},
+    { "_wxMenu","_class_wxMenu",0},
+    { "_wxScreenDC","_class_wxScreenDC",0},
+    { "_WXTYPE","_short",0},
+    { "_WXTYPE","_signed_short",0},
+    { "_WXTYPE","_unsigned_short",0},
+    { "_class_wxBrush","_wxBrush",0},
+    { "_unsigned_short","_WXTYPE",0},
+    { "_unsigned_short","_short",0},
+    { "_class_wxWindow","_wxWindow",0},
+    { "_class_wxFont","_wxFont",0},
+    { "_wxClientDC","_class_wxClientDC",0},
+    { "_class_wxPoint","_wxPoint",0},
+    { "_wxRealPoint","_class_wxRealPoint",0},
+    { "_signed_short","_WXTYPE",0},
+    { "_signed_short","_short",0},
+    { "_wxMemoryDC","_class_wxMemoryDC",0},
+    { "_wxPaintDC","_class_wxPaintDC",0},
+    { "_class_wxWindowDC","_wxWindowDC",0},
+    { "_class_wxAcceleratorEntry","_wxAcceleratorEntry",0},
+    { "_class_wxCursor","_wxCursor",0},
+    { "_wxPostScriptDC","_class_wxPostScriptDC",0},
+    { "_wxScrolledWindow","_class_wxScrolledWindow",0},
+    { "_unsigned_char","_byte",0},
+    { "_class_wxMenu","_wxMenu",0},
+    { "_unsigned_int","_wxPrintQuality",0},
+    { "_unsigned_int","_size_t",0},
+    { "_unsigned_int","_uint",0},
+    { "_unsigned_int","_wxWindowID",0},
+    { "_unsigned_int","_int",0},
+    { "_wxIcon","_class_wxIcon",0},
+    { "_wxDialog","_class_wxDialog",0},
+    { "_class_wxPen","_wxPen",0},
+    { "_short","_WXTYPE",0},
+    { "_short","_unsigned_short",0},
+    { "_short","_signed_short",0},
+    { "_class_wxImageList","_wxImageList",0},
+    { "_wxWindowID","_wxPrintQuality",0},
+    { "_wxWindowID","_size_t",0},
+    { "_wxWindowID","_EBool",0},
+    { "_wxWindowID","_uint",0},
+    { "_wxWindowID","_int",0},
+    { "_wxWindowID","_signed_int",0},
+    { "_wxWindowID","_unsigned_int",0},
+    { "_int","_wxPrintQuality",0},
+    { "_int","_size_t",0},
+    { "_int","_EBool",0},
+    { "_int","_uint",0},
+    { "_int","_wxWindowID",0},
+    { "_int","_unsigned_int",0},
+    { "_int","_signed_int",0},
+    { "_wxSize","_class_wxSize",0},
+    { "_wxRegionIterator","_class_wxRegionIterator",0},
+    { "_class_wxPaintDC","_wxPaintDC",0},
+    { "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
+    { "_class_wxIcon","_wxIcon",0},
+    { "_class_wxColour","_wxColour",0},
+    { "_class_wxScreenDC","_wxScreenDC",0},
+    { "_wxPalette","_class_wxPalette",0},
+    { "_wxRegion","_class_wxRegion",0},
+    { "_class_wxClientDC","_wxClientDC",0},
+    { "_class_wxSize","_wxSize",0},
+    { "_class_wxBitmap","_wxBitmap",0},
+    { "_class_wxMemoryDC","_wxMemoryDC",0},
+    { "_wxMenuBar","_class_wxMenuBar",0},
+    { "_wxEvtHandler","_class_wxEvtHandler",0},
+    { "_wxMenuItem","_class_wxMenuItem",0},
+    { "_wxDash","_unsigned_long",0},
+    { "_wxDash","_long",0},
+    { "_class_wxScrolledWindow","_wxScrolledWindow",0},
+    { "_class_wxPalette","_wxPalette",0},
+    { "_wxWindow","_class_wxWindow",0},
+{0,0,0}};
+
 static PyObject *SWIG_globals;
 #ifdef __cplusplus
 extern "C" 
 #endif
-SWIGEXPORT(void,initmisc2c)() {
+SWIGEXPORT(void) initmisc2c() {
 	 PyObject *m, *d;
 	 SWIG_globals = SWIG_newvarlink();
 	 m = Py_InitModule("misc2c", misc2cMethods);
 	 d = PyModule_GetDict(m);
-/*
- * These are the pointer type-equivalency mappings. 
- * (Used by the SWIG pointer type-checker).
- */
-	 SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
-	 SWIG_RegisterMapping("_signed_long","_long",0);
-	 SWIG_RegisterMapping("_wxPrintQuality","_int",0);
-	 SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
-	 SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
-	 SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
-	 SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
-	 SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
-	 SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
-	 SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
-	 SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0);
-	 SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
-	 SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
-	 SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
-	 SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
-	 SWIG_RegisterMapping("_wxPen","_class_wxPen",0);
-	 SWIG_RegisterMapping("_byte","_unsigned_char",0);
-	 SWIG_RegisterMapping("_long","_wxDash",0);
-	 SWIG_RegisterMapping("_long","_unsigned_long",0);
-	 SWIG_RegisterMapping("_long","_signed_long",0);
-	 SWIG_RegisterMapping("_wxImageList","_class_wxImageList",0);
-	 SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
-	 SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
-	 SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
-	 SWIG_RegisterMapping("_size_t","_unsigned_int",0);
-	 SWIG_RegisterMapping("_size_t","_int",0);
-	 SWIG_RegisterMapping("_size_t","_wxWindowID",0);
-	 SWIG_RegisterMapping("_size_t","_uint",0);
-	 SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
-	 SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
-	 SWIG_RegisterMapping("_class_wxPostScriptDC","_wxPostScriptDC",0);
-	 SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
-	 SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
-	 SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0);
-	 SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
-	 SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
-	 SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
-	 SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
-	 SWIG_RegisterMapping("_uint","_size_t",0);
-	 SWIG_RegisterMapping("_uint","_unsigned_int",0);
-	 SWIG_RegisterMapping("_uint","_int",0);
-	 SWIG_RegisterMapping("_uint","_wxWindowID",0);
-	 SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
-	 SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
-	 SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0);
-	 SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
-	 SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
-	 SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
-	 SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
-	 SWIG_RegisterMapping("_EBool","_signed_int",0);
-	 SWIG_RegisterMapping("_EBool","_int",0);
-	 SWIG_RegisterMapping("_EBool","_wxWindowID",0);
-	 SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0);
-	 SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
-	 SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
-	 SWIG_RegisterMapping("_unsigned_long","_long",0);
-	 SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
-	 SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
-	 SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
-	 SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
-	 SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
-	 SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
-	 SWIG_RegisterMapping("_signed_int","_EBool",0);
-	 SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
-	 SWIG_RegisterMapping("_signed_int","_int",0);
-	 SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0);
-	 SWIG_RegisterMapping("_wxMenu","_class_wxMenu",0);
-	 SWIG_RegisterMapping("_wxScreenDC","_class_wxScreenDC",0);
-	 SWIG_RegisterMapping("_WXTYPE","_short",0);
-	 SWIG_RegisterMapping("_WXTYPE","_signed_short",0);
-	 SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0);
-	 SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0);
-	 SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0);
-	 SWIG_RegisterMapping("_unsigned_short","_short",0);
-	 SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0);
-	 SWIG_RegisterMapping("_class_wxFont","_wxFont",0);
-	 SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0);
-	 SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0);
-	 SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",0);
-	 SWIG_RegisterMapping("_signed_short","_WXTYPE",0);
-	 SWIG_RegisterMapping("_signed_short","_short",0);
-	 SWIG_RegisterMapping("_wxMemoryDC","_class_wxMemoryDC",0);
-	 SWIG_RegisterMapping("_wxPaintDC","_class_wxPaintDC",0);
-	 SWIG_RegisterMapping("_class_wxWindowDC","_wxWindowDC",0);
-	 SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
-	 SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0);
-	 SWIG_RegisterMapping("_wxPostScriptDC","_class_wxPostScriptDC",0);
-	 SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0);
-	 SWIG_RegisterMapping("_unsigned_char","_byte",0);
-	 SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
-	 SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
-	 SWIG_RegisterMapping("_unsigned_int","_size_t",0);
-	 SWIG_RegisterMapping("_unsigned_int","_uint",0);
-	 SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
-	 SWIG_RegisterMapping("_unsigned_int","_int",0);
-	 SWIG_RegisterMapping("_wxIcon","_class_wxIcon",0);
-	 SWIG_RegisterMapping("_wxDialog","_class_wxDialog",0);
-	 SWIG_RegisterMapping("_class_wxPen","_wxPen",0);
-	 SWIG_RegisterMapping("_short","_WXTYPE",0);
-	 SWIG_RegisterMapping("_short","_unsigned_short",0);
-	 SWIG_RegisterMapping("_short","_signed_short",0);
-	 SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0);
-	 SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
-	 SWIG_RegisterMapping("_wxWindowID","_size_t",0);
-	 SWIG_RegisterMapping("_wxWindowID","_EBool",0);
-	 SWIG_RegisterMapping("_wxWindowID","_uint",0);
-	 SWIG_RegisterMapping("_wxWindowID","_int",0);
-	 SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
-	 SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
-	 SWIG_RegisterMapping("_int","_wxPrintQuality",0);
-	 SWIG_RegisterMapping("_int","_size_t",0);
-	 SWIG_RegisterMapping("_int","_EBool",0);
-	 SWIG_RegisterMapping("_int","_uint",0);
-	 SWIG_RegisterMapping("_int","_wxWindowID",0);
-	 SWIG_RegisterMapping("_int","_unsigned_int",0);
-	 SWIG_RegisterMapping("_int","_signed_int",0);
-	 SWIG_RegisterMapping("_wxSize","_class_wxSize",0);
-	 SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0);
-	 SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0);
-	 SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0);
-	 SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0);
-	 SWIG_RegisterMapping("_class_wxColour","_wxColour",0);
-	 SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0);
-	 SWIG_RegisterMapping("_wxPalette","_class_wxPalette",0);
-	 SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
-	 SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0);
-	 SWIG_RegisterMapping("_class_wxSize","_wxSize",0);
-	 SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0);
-	 SWIG_RegisterMapping("_class_wxMemoryDC","_wxMemoryDC",0);
-	 SWIG_RegisterMapping("_wxMenuBar","_class_wxMenuBar",0);
-	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0);
-	 SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0);
-	 SWIG_RegisterMapping("_wxDash","_unsigned_long",0);
-	 SWIG_RegisterMapping("_wxDash","_long",0);
-	 SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0);
-	 SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0);
-	 SWIG_RegisterMapping("_wxWindow","_class_wxWindow",0);
+{
+   int i;
+   for (i = 0; _swig_mapping[i].n1; i++)
+        SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
+}
 }

utils/wxPython/src/gtk/misc2.py

@@ -10,21 +10,21 @@ class wxToolTipPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def SetTip(self,arg0):
-        val = misc2c.wxToolTip_SetTip(self.this,arg0)
+    def SetTip(self, *_args, **_kwargs):
+        val = apply(misc2c.wxToolTip_SetTip,(self,) + _args, _kwargs)
         return val
-    def GetTip(self):
-        val = misc2c.wxToolTip_GetTip(self.this)
+    def GetTip(self, *_args, **_kwargs):
+        val = apply(misc2c.wxToolTip_GetTip,(self,) + _args, _kwargs)
         return val
-    def GetWindow(self):
-        val = misc2c.wxToolTip_GetWindow(self.this)
-        val = wxWindowPtr(val)
+    def GetWindow(self, *_args, **_kwargs):
+        val = apply(misc2c.wxToolTip_GetWindow,(self,) + _args, _kwargs)
+        if val: val = wxWindowPtr(val) 
         return val
     def __repr__(self):
-        return "<C wxToolTip instance>"
+        return "<C wxToolTip instance at %s>" % (self.this,)
 class wxToolTip(wxToolTipPtr):
-    def __init__(self,arg0) :
-        self.this = misc2c.new_wxToolTip(arg0)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(misc2c.new_wxToolTip,_args,_kwargs)
         self.thisown = 1
 
 
@@ -34,22 +34,14 @@ class wxToolTip(wxToolTipPtr):
 
 #-------------- FUNCTION WRAPPERS ------------------
 
-def wxFindWindowByLabel(arg0,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(misc2c.wxFindWindowByLabel,(arg0,)+args)
-    val = wxWindowPtr(val)
+def wxFindWindowByLabel(*_args, **_kwargs):
+    val = apply(misc2c.wxFindWindowByLabel,_args,_kwargs)
+    if val: val = wxWindowPtr(val)
     return val
 
-def wxFindWindowByName(arg0,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(misc2c.wxFindWindowByName,(arg0,)+args)
-    val = wxWindowPtr(val)
+def wxFindWindowByName(*_args, **_kwargs):
+    val = apply(misc2c.wxFindWindowByName,_args,_kwargs)
+    if val: val = wxWindowPtr(val)
     return val
 
 wxToolTip_Enable = misc2c.wxToolTip_Enable

utils/wxPython/src/gtk/printfw.py

@@ -21,69 +21,69 @@ class wxPrintDataPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, printfwc=printfwc):
+    def __del__(self,printfwc=printfwc):
         if self.thisown == 1 :
-            printfwc.delete_wxPrintData(self.this)
-    def GetNoCopies(self):
-        val = printfwc.wxPrintData_GetNoCopies(self.this)
+            printfwc.delete_wxPrintData(self)
+    def GetNoCopies(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_GetNoCopies,(self,) + _args, _kwargs)
         return val
-    def GetCollate(self):
-        val = printfwc.wxPrintData_GetCollate(self.this)
+    def GetCollate(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_GetCollate,(self,) + _args, _kwargs)
         return val
-    def GetOrientation(self):
-        val = printfwc.wxPrintData_GetOrientation(self.this)
+    def GetOrientation(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_GetOrientation,(self,) + _args, _kwargs)
         return val
-    def GetPrinterName(self):
-        val = printfwc.wxPrintData_GetPrinterName(self.this)
+    def GetPrinterName(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_GetPrinterName,(self,) + _args, _kwargs)
         return val
-    def GetColour(self):
-        val = printfwc.wxPrintData_GetColour(self.this)
+    def GetColour(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_GetColour,(self,) + _args, _kwargs)
         return val
-    def GetDuplex(self):
-        val = printfwc.wxPrintData_GetDuplex(self.this)
+    def GetDuplex(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_GetDuplex,(self,) + _args, _kwargs)
         return val
-    def GetPaperId(self):
-        val = printfwc.wxPrintData_GetPaperId(self.this)
+    def GetPaperId(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_GetPaperId,(self,) + _args, _kwargs)
         return val
-    def GetPaperSize(self):
-        val = printfwc.wxPrintData_GetPaperSize(self.this)
-        val = wxSizePtr(val)
+    def GetPaperSize(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_GetPaperSize,(self,) + _args, _kwargs)
+        if val: val = wxSizePtr(val) 
         return val
-    def GetQuality(self):
-        val = printfwc.wxPrintData_GetQuality(self.this)
+    def GetQuality(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_GetQuality,(self,) + _args, _kwargs)
         return val
-    def SetNoCopies(self,arg0):
-        val = printfwc.wxPrintData_SetNoCopies(self.this,arg0)
+    def SetNoCopies(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_SetNoCopies,(self,) + _args, _kwargs)
         return val
-    def SetCollate(self,arg0):
-        val = printfwc.wxPrintData_SetCollate(self.this,arg0)
+    def SetCollate(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_SetCollate,(self,) + _args, _kwargs)
         return val
-    def SetOrientation(self,arg0):
-        val = printfwc.wxPrintData_SetOrientation(self.this,arg0)
+    def SetOrientation(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_SetOrientation,(self,) + _args, _kwargs)
         return val
-    def SetPrinterName(self,arg0):
-        val = printfwc.wxPrintData_SetPrinterName(self.this,arg0)
+    def SetPrinterName(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_SetPrinterName,(self,) + _args, _kwargs)
         return val
-    def SetColour(self,arg0):
-        val = printfwc.wxPrintData_SetColour(self.this,arg0)
+    def SetColour(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_SetColour,(self,) + _args, _kwargs)
         return val
-    def SetDuplex(self,arg0):
-        val = printfwc.wxPrintData_SetDuplex(self.this,arg0)
+    def SetDuplex(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_SetDuplex,(self,) + _args, _kwargs)
         return val
-    def SetPaperId(self,arg0):
-        val = printfwc.wxPrintData_SetPaperId(self.this,arg0)
+    def SetPaperId(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_SetPaperId,(self,) + _args, _kwargs)
         return val
-    def SetPaperSize(self,arg0):
-        val = printfwc.wxPrintData_SetPaperSize(self.this,arg0.this)
+    def SetPaperSize(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_SetPaperSize,(self,) + _args, _kwargs)
         return val
-    def SetQuality(self,arg0):
-        val = printfwc.wxPrintData_SetQuality(self.this,arg0)
+    def SetQuality(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintData_SetQuality,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPrintData instance>"
+        return "<C wxPrintData instance at %s>" % (self.this,)
 class wxPrintData(wxPrintDataPtr):
-    def __init__(self) :
-        self.this = printfwc.new_wxPrintData()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(printfwc.new_wxPrintData,_args,_kwargs)
         self.thisown = 1
 
 
@@ -93,110 +93,104 @@ class wxPageSetupDialogDataPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, printfwc=printfwc):
+    def __del__(self,printfwc=printfwc):
         if self.thisown == 1 :
-            printfwc.delete_wxPageSetupDialogData(self.this)
-    def EnableHelp(self,arg0):
-        val = printfwc.wxPageSetupDialogData_EnableHelp(self.this,arg0)
+            printfwc.delete_wxPageSetupDialogData(self)
+    def EnableHelp(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_EnableHelp,(self,) + _args, _kwargs)
         return val
-    def EnableMargins(self,arg0):
-        val = printfwc.wxPageSetupDialogData_EnableMargins(self.this,arg0)
+    def EnableMargins(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_EnableMargins,(self,) + _args, _kwargs)
         return val
-    def EnableOrientation(self,arg0):
-        val = printfwc.wxPageSetupDialogData_EnableOrientation(self.this,arg0)
+    def EnableOrientation(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_EnableOrientation,(self,) + _args, _kwargs)
         return val
-    def EnablePaper(self,arg0):
-        val = printfwc.wxPageSetupDialogData_EnablePaper(self.this,arg0)
+    def EnablePaper(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_EnablePaper,(self,) + _args, _kwargs)
         return val
-    def EnablePrinter(self,arg0):
-        val = printfwc.wxPageSetupDialogData_EnablePrinter(self.this,arg0)
+    def EnablePrinter(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_EnablePrinter,(self,) + _args, _kwargs)
         return val
-    def GetDefaultMinMargins(self):
-        val = printfwc.wxPageSetupDialogData_GetDefaultMinMargins(self.this)
+    def GetDefaultMinMargins(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetDefaultMinMargins,(self,) + _args, _kwargs)
         return val
-    def GetEnableMargins(self):
-        val = printfwc.wxPageSetupDialogData_GetEnableMargins(self.this)
+    def GetEnableMargins(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetEnableMargins,(self,) + _args, _kwargs)
         return val
-    def GetEnableOrientation(self):
-        val = printfwc.wxPageSetupDialogData_GetEnableOrientation(self.this)
+    def GetEnableOrientation(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetEnableOrientation,(self,) + _args, _kwargs)
         return val
-    def GetEnablePaper(self):
-        val = printfwc.wxPageSetupDialogData_GetEnablePaper(self.this)
+    def GetEnablePaper(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetEnablePaper,(self,) + _args, _kwargs)
         return val
-    def GetEnablePrinter(self):
-        val = printfwc.wxPageSetupDialogData_GetEnablePrinter(self.this)
+    def GetEnablePrinter(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetEnablePrinter,(self,) + _args, _kwargs)
         return val
-    def GetEnableHelp(self):
-        val = printfwc.wxPageSetupDialogData_GetEnableHelp(self.this)
+    def GetEnableHelp(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetEnableHelp,(self,) + _args, _kwargs)
         return val
-    def GetDefaultInfo(self):
-        val = printfwc.wxPageSetupDialogData_GetDefaultInfo(self.this)
+    def GetDefaultInfo(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetDefaultInfo,(self,) + _args, _kwargs)
         return val
-    def GetMarginTopLeft(self):
-        val = printfwc.wxPageSetupDialogData_GetMarginTopLeft(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetMarginTopLeft(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetMarginTopLeft,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetMarginBottomRight(self):
-        val = printfwc.wxPageSetupDialogData_GetMarginBottomRight(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetMarginBottomRight(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetMarginBottomRight,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetMinMarginTopLeft(self):
-        val = printfwc.wxPageSetupDialogData_GetMinMarginTopLeft(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetMinMarginTopLeft(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetMinMarginTopLeft,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetMinMarginBottomRight(self):
-        val = printfwc.wxPageSetupDialogData_GetMinMarginBottomRight(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetMinMarginBottomRight(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetMinMarginBottomRight,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def GetPaperId(self):
-        val = printfwc.wxPageSetupDialogData_GetPaperId(self.this)
+    def GetPaperId(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetPaperId,(self,) + _args, _kwargs)
         return val
-    def GetPaperSize(self):
-        val = printfwc.wxPageSetupDialogData_GetPaperSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
+    def GetPaperSize(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetPaperSize,(self,) + _args, _kwargs)
+        if val: val = wxSizePtr(val) ; val.thisown = 1
         return val
-    def GetPrintData(self):
-        val = printfwc.wxPageSetupDialogData_GetPrintData(self.this)
-        val = wxPrintDataPtr(val)
-        val.thisown = 1
+    def GetPrintData(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_GetPrintData,(self,) + _args, _kwargs)
+        if val: val = wxPrintDataPtr(val) ; val.thisown = 1
         return val
-    def SetDefaultInfo(self,arg0):
-        val = printfwc.wxPageSetupDialogData_SetDefaultInfo(self.this,arg0)
+    def SetDefaultInfo(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_SetDefaultInfo,(self,) + _args, _kwargs)
         return val
-    def SetDefaultMinMargins(self,arg0):
-        val = printfwc.wxPageSetupDialogData_SetDefaultMinMargins(self.this,arg0)
+    def SetDefaultMinMargins(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_SetDefaultMinMargins,(self,) + _args, _kwargs)
         return val
-    def SetMarginTopLeft(self,arg0):
-        val = printfwc.wxPageSetupDialogData_SetMarginTopLeft(self.this,arg0.this)
+    def SetMarginTopLeft(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_SetMarginTopLeft,(self,) + _args, _kwargs)
         return val
-    def SetMarginBottomRight(self,arg0):
-        val = printfwc.wxPageSetupDialogData_SetMarginBottomRight(self.this,arg0.this)
+    def SetMarginBottomRight(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_SetMarginBottomRight,(self,) + _args, _kwargs)
         return val
-    def SetMinMarginTopLeft(self,arg0):
-        val = printfwc.wxPageSetupDialogData_SetMinMarginTopLeft(self.this,arg0.this)
+    def SetMinMarginTopLeft(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_SetMinMarginTopLeft,(self,) + _args, _kwargs)
         return val
-    def SetMinMarginBottomRight(self,arg0):
-        val = printfwc.wxPageSetupDialogData_SetMinMarginBottomRight(self.this,arg0.this)
+    def SetMinMarginBottomRight(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_SetMinMarginBottomRight,(self,) + _args, _kwargs)
         return val
-    def SetPaperId(self,arg0):
-        val = printfwc.wxPageSetupDialogData_SetPaperId(self.this,arg0)
+    def SetPaperId(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_SetPaperId,(self,) + _args, _kwargs)
         return val
-    def SetPaperSize(self,arg0):
-        val = printfwc.wxPageSetupDialogData_SetPaperSize(self.this,arg0.this)
+    def SetPaperSize(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_SetPaperSize,(self,) + _args, _kwargs)
         return val
-    def SetPrintData(self,arg0):
-        val = printfwc.wxPageSetupDialogData_SetPrintData(self.this,arg0.this)
+    def SetPrintData(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialogData_SetPrintData,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPageSetupDialogData instance>"
+        return "<C wxPageSetupDialogData instance at %s>" % (self.this,)
 class wxPageSetupDialogData(wxPageSetupDialogDataPtr):
-    def __init__(self) :
-        self.this = printfwc.new_wxPageSetupDialogData()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(printfwc.new_wxPageSetupDialogData,_args,_kwargs)
         self.thisown = 1
 
 
@@ -206,22 +200,18 @@ class wxPageSetupDialogPtr(wxDialogPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetPageSetupData(self):
-        val = printfwc.wxPageSetupDialog_GetPageSetupData(self.this)
-        val = wxPageSetupDialogDataPtr(val)
+    def GetPageSetupData(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialog_GetPageSetupData,(self,) + _args, _kwargs)
+        if val: val = wxPageSetupDialogDataPtr(val) 
         return val
-    def ShowModal(self):
-        val = printfwc.wxPageSetupDialog_ShowModal(self.this)
+    def ShowModal(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPageSetupDialog_ShowModal,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPageSetupDialog instance>"
+        return "<C wxPageSetupDialog instance at %s>" % (self.this,)
 class wxPageSetupDialog(wxPageSetupDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(printfwc.new_wxPageSetupDialog,(arg0.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(printfwc.new_wxPageSetupDialog,_args,_kwargs)
         self.thisown = 1
         wx._StdDialogCallbacks(self)
 
@@ -232,82 +222,81 @@ class wxPrintDialogDataPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, printfwc=printfwc):
+    def __del__(self,printfwc=printfwc):
         if self.thisown == 1 :
-            printfwc.delete_wxPrintDialogData(self.this)
-    def EnableHelp(self,arg0):
-        val = printfwc.wxPrintDialogData_EnableHelp(self.this,arg0)
+            printfwc.delete_wxPrintDialogData(self)
+    def EnableHelp(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_EnableHelp,(self,) + _args, _kwargs)
         return val
-    def EnablePageNumbers(self,arg0):
-        val = printfwc.wxPrintDialogData_EnablePageNumbers(self.this,arg0)
+    def EnablePageNumbers(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_EnablePageNumbers,(self,) + _args, _kwargs)
         return val
-    def EnablePrintToFile(self,arg0):
-        val = printfwc.wxPrintDialogData_EnablePrintToFile(self.this,arg0)
+    def EnablePrintToFile(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_EnablePrintToFile,(self,) + _args, _kwargs)
         return val
-    def EnableSelection(self,arg0):
-        val = printfwc.wxPrintDialogData_EnableSelection(self.this,arg0)
+    def EnableSelection(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_EnableSelection,(self,) + _args, _kwargs)
         return val
-    def GetAllPages(self):
-        val = printfwc.wxPrintDialogData_GetAllPages(self.this)
+    def GetAllPages(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_GetAllPages,(self,) + _args, _kwargs)
         return val
-    def GetCollate(self):
-        val = printfwc.wxPrintDialogData_GetCollate(self.this)
+    def GetCollate(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_GetCollate,(self,) + _args, _kwargs)
         return val
-    def GetFromPage(self):
-        val = printfwc.wxPrintDialogData_GetFromPage(self.this)
+    def GetFromPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_GetFromPage,(self,) + _args, _kwargs)
         return val
-    def GetMaxPage(self):
-        val = printfwc.wxPrintDialogData_GetMaxPage(self.this)
+    def GetMaxPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_GetMaxPage,(self,) + _args, _kwargs)
         return val
-    def GetMinPage(self):
-        val = printfwc.wxPrintDialogData_GetMinPage(self.this)
+    def GetMinPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_GetMinPage,(self,) + _args, _kwargs)
         return val
-    def GetNoCopies(self):
-        val = printfwc.wxPrintDialogData_GetNoCopies(self.this)
+    def GetNoCopies(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_GetNoCopies,(self,) + _args, _kwargs)
         return val
-    def GetPrintData(self):
-        val = printfwc.wxPrintDialogData_GetPrintData(self.this)
-        val = wxPrintDataPtr(val)
-        val.thisown = 1
+    def GetPrintData(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_GetPrintData,(self,) + _args, _kwargs)
+        if val: val = wxPrintDataPtr(val) ; val.thisown = 1
         return val
-    def GetPrintToFile(self):
-        val = printfwc.wxPrintDialogData_GetPrintToFile(self.this)
+    def GetPrintToFile(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_GetPrintToFile,(self,) + _args, _kwargs)
         return val
-    def GetToPage(self):
-        val = printfwc.wxPrintDialogData_GetToPage(self.this)
+    def GetToPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_GetToPage,(self,) + _args, _kwargs)
         return val
-    def SetCollate(self,arg0):
-        val = printfwc.wxPrintDialogData_SetCollate(self.this,arg0)
+    def SetCollate(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_SetCollate,(self,) + _args, _kwargs)
         return val
-    def SetFromPage(self,arg0):
-        val = printfwc.wxPrintDialogData_SetFromPage(self.this,arg0)
+    def SetFromPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_SetFromPage,(self,) + _args, _kwargs)
         return val
-    def SetMaxPage(self,arg0):
-        val = printfwc.wxPrintDialogData_SetMaxPage(self.this,arg0)
+    def SetMaxPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_SetMaxPage,(self,) + _args, _kwargs)
         return val
-    def SetMinPage(self,arg0):
-        val = printfwc.wxPrintDialogData_SetMinPage(self.this,arg0)
+    def SetMinPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_SetMinPage,(self,) + _args, _kwargs)
         return val
-    def SetNoCopies(self,arg0):
-        val = printfwc.wxPrintDialogData_SetNoCopies(self.this,arg0)
+    def SetNoCopies(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_SetNoCopies,(self,) + _args, _kwargs)
         return val
-    def SetPrintData(self,arg0):
-        val = printfwc.wxPrintDialogData_SetPrintData(self.this,arg0.this)
+    def SetPrintData(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_SetPrintData,(self,) + _args, _kwargs)
         return val
-    def SetPrintToFile(self,arg0):
-        val = printfwc.wxPrintDialogData_SetPrintToFile(self.this,arg0)
+    def SetPrintToFile(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_SetPrintToFile,(self,) + _args, _kwargs)
         return val
-    def SetSetupDialog(self,arg0):
-        val = printfwc.wxPrintDialogData_SetSetupDialog(self.this,arg0)
+    def SetSetupDialog(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_SetSetupDialog,(self,) + _args, _kwargs)
         return val
-    def SetToPage(self,arg0):
-        val = printfwc.wxPrintDialogData_SetToPage(self.this,arg0)
+    def SetToPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialogData_SetToPage,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPrintDialogData instance>"
+        return "<C wxPrintDialogData instance at %s>" % (self.this,)
 class wxPrintDialogData(wxPrintDialogDataPtr):
-    def __init__(self) :
-        self.this = printfwc.new_wxPrintDialogData()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(printfwc.new_wxPrintDialogData,_args,_kwargs)
         self.thisown = 1
 
 
@@ -317,27 +306,22 @@ class wxPrintDialogPtr(wxDialogPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetPrintDialogData(self):
-        val = printfwc.wxPrintDialog_GetPrintDialogData(self.this)
-        val = wxPrintDialogDataPtr(val)
+    def GetPrintDialogData(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialog_GetPrintDialogData,(self,) + _args, _kwargs)
+        if val: val = wxPrintDialogDataPtr(val) 
         return val
-    def GetPrintDC(self):
-        val = printfwc.wxPrintDialog_GetPrintDC(self.this)
-        val = wxDCPtr(val)
-        val.thisown = 1
+    def GetPrintDC(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialog_GetPrintDC,(self,) + _args, _kwargs)
+        if val: val = wxDCPtr(val) ; val.thisown = 1
         return val
-    def ShowModal(self):
-        val = printfwc.wxPrintDialog_ShowModal(self.this)
+    def ShowModal(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintDialog_ShowModal,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPrintDialog instance>"
+        return "<C wxPrintDialog instance at %s>" % (self.this,)
 class wxPrintDialog(wxPrintDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(printfwc.new_wxPrintDialog,(arg0.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(printfwc.new_wxPrintDialog,_args,_kwargs)
         self.thisown = 1
         wx._StdDialogCallbacks(self)
 
@@ -348,57 +332,57 @@ class wxPrintoutPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def _setSelf(self,arg0):
-        val = printfwc.wxPrintout__setSelf(self.this,arg0)
+    def _setSelf(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout__setSelf,(self,) + _args, _kwargs)
         return val
-    def Destroy(self):
-        val = printfwc.wxPrintout_Destroy(self.this)
+    def Destroy(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_Destroy,(self,) + _args, _kwargs)
         return val
-    def GetDC(self):
-        val = printfwc.wxPrintout_GetDC(self.this)
-        val = wxDCPtr(val)
+    def GetDC(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_GetDC,(self,) + _args, _kwargs)
+        if val: val = wxDCPtr(val) 
         return val
-    def GetPageSizeMM(self):
-        val = printfwc.wxPrintout_GetPageSizeMM(self.this)
+    def GetPageSizeMM(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_GetPageSizeMM,(self,) + _args, _kwargs)
         return val
-    def GetPageSizePixels(self):
-        val = printfwc.wxPrintout_GetPageSizePixels(self.this)
+    def GetPageSizePixels(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_GetPageSizePixels,(self,) + _args, _kwargs)
         return val
-    def GetPPIPrinter(self):
-        val = printfwc.wxPrintout_GetPPIPrinter(self.this)
+    def GetPPIPrinter(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_GetPPIPrinter,(self,) + _args, _kwargs)
         return val
-    def GetPPIScreen(self):
-        val = printfwc.wxPrintout_GetPPIScreen(self.this)
+    def GetPPIScreen(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_GetPPIScreen,(self,) + _args, _kwargs)
         return val
-    def IsPreview(self):
-        val = printfwc.wxPrintout_IsPreview(self.this)
+    def IsPreview(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_IsPreview,(self,) + _args, _kwargs)
         return val
-    def base_OnBeginDocument(self,arg0,arg1):
-        val = printfwc.wxPrintout_base_OnBeginDocument(self.this,arg0,arg1)
+    def base_OnBeginDocument(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_base_OnBeginDocument,(self,) + _args, _kwargs)
         return val
-    def base_OnEndDocument(self):
-        val = printfwc.wxPrintout_base_OnEndDocument(self.this)
+    def base_OnEndDocument(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_base_OnEndDocument,(self,) + _args, _kwargs)
         return val
-    def base_OnBeginPrinting(self):
-        val = printfwc.wxPrintout_base_OnBeginPrinting(self.this)
+    def base_OnBeginPrinting(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_base_OnBeginPrinting,(self,) + _args, _kwargs)
         return val
-    def base_OnEndPrinting(self):
-        val = printfwc.wxPrintout_base_OnEndPrinting(self.this)
+    def base_OnEndPrinting(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_base_OnEndPrinting,(self,) + _args, _kwargs)
         return val
-    def base_OnPreparePrinting(self):
-        val = printfwc.wxPrintout_base_OnPreparePrinting(self.this)
+    def base_OnPreparePrinting(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_base_OnPreparePrinting,(self,) + _args, _kwargs)
         return val
-    def base_GetPageInfo(self):
-        val = printfwc.wxPrintout_base_GetPageInfo(self.this)
+    def base_GetPageInfo(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_base_GetPageInfo,(self,) + _args, _kwargs)
         return val
-    def base_HasPage(self,arg0):
-        val = printfwc.wxPrintout_base_HasPage(self.this,arg0)
+    def base_HasPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintout_base_HasPage,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPrintout instance>"
+        return "<C wxPrintout instance at %s>" % (self.this,)
 class wxPrintout(wxPrintoutPtr):
-    def __init__(self,*args) :
-        self.this = apply(printfwc.new_wxPrintout,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(printfwc.new_wxPrintout,_args,_kwargs)
         self.thisown = 1
         self._setSelf(self)
 
@@ -409,38 +393,34 @@ class wxPrinterPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, printfwc=printfwc):
+    def __del__(self,printfwc=printfwc):
         if self.thisown == 1 :
-            printfwc.delete_wxPrinter(self.this)
-    def CreateAbortWindow(self,arg0,arg1):
-        val = printfwc.wxPrinter_CreateAbortWindow(self.this,arg0.this,arg1.this)
+            printfwc.delete_wxPrinter(self)
+    def CreateAbortWindow(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrinter_CreateAbortWindow,(self,) + _args, _kwargs)
         return val
-    def GetPrintDialogData(self):
-        val = printfwc.wxPrinter_GetPrintDialogData(self.this)
-        val = wxPrintDialogDataPtr(val)
+    def GetPrintDialogData(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrinter_GetPrintDialogData,(self,) + _args, _kwargs)
+        if val: val = wxPrintDialogDataPtr(val) 
         return val
-    def Print(self,arg0,arg1,*args):
-        val = apply(printfwc.wxPrinter_Print,(self.this,arg0.this,arg1.this,)+args)
+    def Print(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrinter_Print,(self,) + _args, _kwargs)
         return val
-    def PrintDialog(self,arg0):
-        val = printfwc.wxPrinter_PrintDialog(self.this,arg0.this)
-        val = wxDCPtr(val)
+    def PrintDialog(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrinter_PrintDialog,(self,) + _args, _kwargs)
+        if val: val = wxDCPtr(val) 
         return val
-    def ReportError(self,arg0,arg1,arg2):
-        val = printfwc.wxPrinter_ReportError(self.this,arg0.this,arg1.this,arg2)
+    def ReportError(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrinter_ReportError,(self,) + _args, _kwargs)
         return val
-    def Setup(self,arg0):
-        val = printfwc.wxPrinter_Setup(self.this,arg0.this)
+    def Setup(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrinter_Setup,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPrinter instance>"
+        return "<C wxPrinter instance at %s>" % (self.this,)
 class wxPrinter(wxPrinterPtr):
-    def __init__(self,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(printfwc.new_wxPrinter,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(printfwc.new_wxPrinter,_args,_kwargs)
         self.thisown = 1
 
 
@@ -450,68 +430,64 @@ class wxPrintPreviewPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetCanvas(self):
-        val = printfwc.wxPrintPreview_GetCanvas(self.this)
-        val = wxWindowPtr(val)
+    def GetCanvas(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_GetCanvas,(self,) + _args, _kwargs)
+        if val: val = wxWindowPtr(val) 
         return val
-    def GetCurrentPage(self):
-        val = printfwc.wxPrintPreview_GetCurrentPage(self.this)
+    def GetCurrentPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_GetCurrentPage,(self,) + _args, _kwargs)
         return val
-    def GetFrame(self):
-        val = printfwc.wxPrintPreview_GetFrame(self.this)
-        val = wxFramePtr(val)
+    def GetFrame(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_GetFrame,(self,) + _args, _kwargs)
+        if val: val = wxFramePtr(val) 
         return val
-    def GetMaxPage(self):
-        val = printfwc.wxPrintPreview_GetMaxPage(self.this)
+    def GetMaxPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_GetMaxPage,(self,) + _args, _kwargs)
         return val
-    def GetMinPage(self):
-        val = printfwc.wxPrintPreview_GetMinPage(self.this)
+    def GetMinPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_GetMinPage,(self,) + _args, _kwargs)
         return val
-    def GetPrintDialogData(self):
-        val = printfwc.wxPrintPreview_GetPrintDialogData(self.this)
-        val = wxPrintDialogDataPtr(val)
+    def GetPrintDialogData(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_GetPrintDialogData,(self,) + _args, _kwargs)
+        if val: val = wxPrintDialogDataPtr(val) 
         return val
-    def GetPrintout(self):
-        val = printfwc.wxPrintPreview_GetPrintout(self.this)
-        val = wxPrintoutPtr(val)
+    def GetPrintout(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_GetPrintout,(self,) + _args, _kwargs)
+        if val: val = wxPrintoutPtr(val) 
         return val
-    def GetPrintoutForPrinting(self):
-        val = printfwc.wxPrintPreview_GetPrintoutForPrinting(self.this)
-        val = wxPrintoutPtr(val)
+    def GetPrintoutForPrinting(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_GetPrintoutForPrinting,(self,) + _args, _kwargs)
+        if val: val = wxPrintoutPtr(val) 
         return val
-    def GetZoom(self):
-        val = printfwc.wxPrintPreview_GetZoom(self.this)
+    def GetZoom(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_GetZoom,(self,) + _args, _kwargs)
         return val
-    def Ok(self):
-        val = printfwc.wxPrintPreview_Ok(self.this)
+    def Ok(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_Ok,(self,) + _args, _kwargs)
         return val
-    def Print(self,arg0):
-        val = printfwc.wxPrintPreview_Print(self.this,arg0)
+    def Print(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_Print,(self,) + _args, _kwargs)
         return val
-    def SetCanvas(self,arg0):
-        val = printfwc.wxPrintPreview_SetCanvas(self.this,arg0.this)
+    def SetCanvas(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_SetCanvas,(self,) + _args, _kwargs)
         return val
-    def SetCurrentPage(self,arg0):
-        val = printfwc.wxPrintPreview_SetCurrentPage(self.this,arg0)
+    def SetCurrentPage(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_SetCurrentPage,(self,) + _args, _kwargs)
         return val
-    def SetFrame(self,arg0):
-        val = printfwc.wxPrintPreview_SetFrame(self.this,arg0.this)
+    def SetFrame(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_SetFrame,(self,) + _args, _kwargs)
         return val
-    def SetPrintout(self,arg0):
-        val = printfwc.wxPrintPreview_SetPrintout(self.this,arg0.this)
+    def SetPrintout(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_SetPrintout,(self,) + _args, _kwargs)
         return val
-    def SetZoom(self,arg0):
-        val = printfwc.wxPrintPreview_SetZoom(self.this,arg0)
+    def SetZoom(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPrintPreview_SetZoom,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPrintPreview instance>"
+        return "<C wxPrintPreview instance at %s>" % (self.this,)
 class wxPrintPreview(wxPrintPreviewPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(printfwc.new_wxPrintPreview,(arg0.this,arg1.this,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(printfwc.new_wxPrintPreview,_args,_kwargs)
         self.thisown = 1
 
 
@@ -521,20 +497,14 @@ class wxPreviewFramePtr(wxFramePtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def Initialize(self):
-        val = printfwc.wxPreviewFrame_Initialize(self.this)
+    def Initialize(self, *_args, **_kwargs):
+        val = apply(printfwc.wxPreviewFrame_Initialize,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxPreviewFrame instance>"
+        return "<C wxPreviewFrame instance at %s>" % (self.this,)
 class wxPreviewFrame(wxPreviewFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(printfwc.new_wxPreviewFrame,(arg0.this,arg1.this,arg2,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(printfwc.new_wxPreviewFrame,_args,_kwargs)
         self.thisown = 1
         wx._StdFrameCallbacks(self)
 

utils/wxPython/src/gtk/stattool.py

@@ -15,46 +15,39 @@ class wxStatusBarPtr(wxWindowPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetFieldRect(self,arg0):
-        val = stattoolc.wxStatusBar_GetFieldRect(self.this,arg0)
-        val = wxRectPtr(val)
-        val.thisown = 1
+    def GetFieldRect(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxStatusBar_GetFieldRect,(self,) + _args, _kwargs)
+        if val: val = wxRectPtr(val) ; val.thisown = 1
         return val
-    def GetFieldsCount(self):
-        val = stattoolc.wxStatusBar_GetFieldsCount(self.this)
+    def GetFieldsCount(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxStatusBar_GetFieldsCount,(self,) + _args, _kwargs)
         return val
-    def GetStatusText(self,*args):
-        val = apply(stattoolc.wxStatusBar_GetStatusText,(self.this,)+args)
+    def GetStatusText(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxStatusBar_GetStatusText,(self,) + _args, _kwargs)
         return val
-    def DrawField(self,arg0,arg1):
-        val = stattoolc.wxStatusBar_DrawField(self.this,arg0.this,arg1)
+    def DrawField(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxStatusBar_DrawField,(self,) + _args, _kwargs)
         return val
-    def DrawFieldText(self,arg0,arg1):
-        val = stattoolc.wxStatusBar_DrawFieldText(self.this,arg0.this,arg1)
+    def DrawFieldText(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxStatusBar_DrawFieldText,(self,) + _args, _kwargs)
         return val
-    def InitColours(self):
-        val = stattoolc.wxStatusBar_InitColours(self.this)
+    def InitColours(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxStatusBar_InitColours,(self,) + _args, _kwargs)
         return val
-    def SetFieldsCount(self,*args):
-        val = apply(stattoolc.wxStatusBar_SetFieldsCount,(self.this,)+args)
+    def SetFieldsCount(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxStatusBar_SetFieldsCount,(self,) + _args, _kwargs)
         return val
-    def SetStatusText(self,arg0,*args):
-        val = apply(stattoolc.wxStatusBar_SetStatusText,(self.this,arg0,)+args)
+    def SetStatusText(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxStatusBar_SetStatusText,(self,) + _args, _kwargs)
         return val
-    def SetStatusWidths(self,arg0,*args):
-        val = apply(stattoolc.wxStatusBar_SetStatusWidths,(self.this,arg0,)+args)
+    def SetStatusWidths(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxStatusBar_SetStatusWidths,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxStatusBar instance>"
+        return "<C wxStatusBar instance at %s>" % (self.this,)
 class wxStatusBar(wxStatusBarPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(stattoolc.new_wxStatusBar,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(stattoolc.new_wxStatusBar,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
 
@@ -65,78 +58,78 @@ class wxToolBarToolPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, stattoolc=stattoolc):
+    def __del__(self,stattoolc=stattoolc):
         if self.thisown == 1 :
-            stattoolc.delete_wxToolBarTool(self.this)
+            stattoolc.delete_wxToolBarTool(self)
     def __setattr__(self,name,value):
         if name == "m_toolStyle" :
-            stattoolc.wxToolBarTool_m_toolStyle_set(self.this,value)
+            stattoolc.wxToolBarTool_m_toolStyle_set(self,value)
             return
         if name == "m_clientData" :
-            stattoolc.wxToolBarTool_m_clientData_set(self.this,value)
+            stattoolc.wxToolBarTool_m_clientData_set(self,value)
             return
         if name == "m_index" :
-            stattoolc.wxToolBarTool_m_index_set(self.this,value)
+            stattoolc.wxToolBarTool_m_index_set(self,value)
             return
         if name == "m_toggleState" :
-            stattoolc.wxToolBarTool_m_toggleState_set(self.this,value)
+            stattoolc.wxToolBarTool_m_toggleState_set(self,value)
             return
         if name == "m_isToggle" :
-            stattoolc.wxToolBarTool_m_isToggle_set(self.this,value)
+            stattoolc.wxToolBarTool_m_isToggle_set(self,value)
             return
         if name == "m_deleteSecondBitmap" :
-            stattoolc.wxToolBarTool_m_deleteSecondBitmap_set(self.this,value)
+            stattoolc.wxToolBarTool_m_deleteSecondBitmap_set(self,value)
             return
         if name == "m_enabled" :
-            stattoolc.wxToolBarTool_m_enabled_set(self.this,value)
+            stattoolc.wxToolBarTool_m_enabled_set(self,value)
             return
         if name == "m_bitmap1" :
-            stattoolc.wxToolBarTool_m_bitmap1_set(self.this,value.this)
+            stattoolc.wxToolBarTool_m_bitmap1_set(self,value.this)
             return
         if name == "m_bitmap2" :
-            stattoolc.wxToolBarTool_m_bitmap2_set(self.this,value.this)
+            stattoolc.wxToolBarTool_m_bitmap2_set(self,value.this)
             return
         if name == "m_isMenuCommand" :
-            stattoolc.wxToolBarTool_m_isMenuCommand_set(self.this,value)
+            stattoolc.wxToolBarTool_m_isMenuCommand_set(self,value)
             return
         if name == "m_shortHelpString" :
-            stattoolc.wxToolBarTool_m_shortHelpString_set(self.this,value)
+            stattoolc.wxToolBarTool_m_shortHelpString_set(self,value)
             return
         if name == "m_longHelpString" :
-            stattoolc.wxToolBarTool_m_longHelpString_set(self.this,value)
+            stattoolc.wxToolBarTool_m_longHelpString_set(self,value)
             return
         self.__dict__[name] = value
     def __getattr__(self,name):
         if name == "m_toolStyle" : 
-            return stattoolc.wxToolBarTool_m_toolStyle_get(self.this)
+            return stattoolc.wxToolBarTool_m_toolStyle_get(self)
         if name == "m_clientData" : 
-            return stattoolc.wxToolBarTool_m_clientData_get(self.this)
+            return stattoolc.wxToolBarTool_m_clientData_get(self)
         if name == "m_index" : 
-            return stattoolc.wxToolBarTool_m_index_get(self.this)
+            return stattoolc.wxToolBarTool_m_index_get(self)
         if name == "m_toggleState" : 
-            return stattoolc.wxToolBarTool_m_toggleState_get(self.this)
+            return stattoolc.wxToolBarTool_m_toggleState_get(self)
         if name == "m_isToggle" : 
-            return stattoolc.wxToolBarTool_m_isToggle_get(self.this)
+            return stattoolc.wxToolBarTool_m_isToggle_get(self)
         if name == "m_deleteSecondBitmap" : 
-            return stattoolc.wxToolBarTool_m_deleteSecondBitmap_get(self.this)
+            return stattoolc.wxToolBarTool_m_deleteSecondBitmap_get(self)
         if name == "m_enabled" : 
-            return stattoolc.wxToolBarTool_m_enabled_get(self.this)
+            return stattoolc.wxToolBarTool_m_enabled_get(self)
         if name == "m_bitmap1" : 
-            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap1_get(self.this))
+            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap1_get(self))
         if name == "m_bitmap2" : 
-            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap2_get(self.this))
+            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap2_get(self))
         if name == "m_isMenuCommand" : 
-            return stattoolc.wxToolBarTool_m_isMenuCommand_get(self.this)
+            return stattoolc.wxToolBarTool_m_isMenuCommand_get(self)
         if name == "m_shortHelpString" : 
-            return stattoolc.wxToolBarTool_m_shortHelpString_get(self.this)
+            return stattoolc.wxToolBarTool_m_shortHelpString_get(self)
         if name == "m_longHelpString" : 
-            return stattoolc.wxToolBarTool_m_longHelpString_get(self.this)
+            return stattoolc.wxToolBarTool_m_longHelpString_get(self)
         raise AttributeError,name
     def __repr__(self):
-        return "<C wxToolBarTool instance>"
+        return "<C wxToolBarTool instance at %s>" % (self.this,)
 class wxToolBarTool(wxToolBarToolPtr):
-    def __init__(self) :
-        self.this = stattoolc.new_wxToolBarTool()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(stattoolc.new_wxToolBarTool,_args,_kwargs)
         self.thisown = 1
 
 
@@ -146,74 +139,64 @@ class wxToolBarPtr(wxControlPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def AddSeparator(self):
-        val = stattoolc.wxToolBar_AddSeparator(self.this)
+    def AddSeparator(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_AddSeparator,(self,) + _args, _kwargs)
         return val
-    def AddTool(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(stattoolc.wxToolBar_AddTool,(self.this,arg0,arg1.this,)+args)
-        val = wxToolBarToolPtr(val)
+    def AddTool(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_AddTool,(self,) + _args, _kwargs)
+        if val: val = wxToolBarToolPtr(val) 
         return val
-    def AddSimpleTool(self,arg0,arg1,*args):
-        val = apply(stattoolc.wxToolBar_AddSimpleTool,(self.this,arg0,arg1.this,)+args)
-        val = wxToolBarToolPtr(val)
+    def AddSimpleTool(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_AddSimpleTool,(self,) + _args, _kwargs)
+        if val: val = wxToolBarToolPtr(val) 
         return val
-    def EnableTool(self,arg0,arg1):
-        val = stattoolc.wxToolBar_EnableTool(self.this,arg0,arg1)
+    def EnableTool(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_EnableTool,(self,) + _args, _kwargs)
         return val
-    def GetToolEnabled(self,arg0):
-        val = stattoolc.wxToolBar_GetToolEnabled(self.this,arg0)
+    def GetToolEnabled(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_GetToolEnabled,(self,) + _args, _kwargs)
         return val
-    def GetToolLongHelp(self,arg0):
-        val = stattoolc.wxToolBar_GetToolLongHelp(self.this,arg0)
+    def GetToolLongHelp(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_GetToolLongHelp,(self,) + _args, _kwargs)
         return val
-    def GetToolPacking(self):
-        val = stattoolc.wxToolBar_GetToolPacking(self.this)
+    def GetToolPacking(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_GetToolPacking,(self,) + _args, _kwargs)
         return val
-    def GetToolSeparation(self):
-        val = stattoolc.wxToolBar_GetToolSeparation(self.this)
+    def GetToolSeparation(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_GetToolSeparation,(self,) + _args, _kwargs)
         return val
-    def GetToolShortHelp(self,arg0):
-        val = stattoolc.wxToolBar_GetToolShortHelp(self.this,arg0)
+    def GetToolShortHelp(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_GetToolShortHelp,(self,) + _args, _kwargs)
         return val
-    def GetToolState(self,arg0):
-        val = stattoolc.wxToolBar_GetToolState(self.this,arg0)
+    def GetToolState(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_GetToolState,(self,) + _args, _kwargs)
         return val
-    def Realize(self):
-        val = stattoolc.wxToolBar_Realize(self.this)
+    def Realize(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_Realize,(self,) + _args, _kwargs)
         return val
-    def SetToolLongHelp(self,arg0,arg1):
-        val = stattoolc.wxToolBar_SetToolLongHelp(self.this,arg0,arg1)
+    def SetToolLongHelp(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_SetToolLongHelp,(self,) + _args, _kwargs)
         return val
-    def SetToolShortHelp(self,arg0,arg1):
-        val = stattoolc.wxToolBar_SetToolShortHelp(self.this,arg0,arg1)
+    def SetToolShortHelp(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_SetToolShortHelp,(self,) + _args, _kwargs)
         return val
-    def SetMargins(self,arg0):
-        val = stattoolc.wxToolBar_SetMargins(self.this,arg0.this)
+    def SetMargins(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_SetMargins,(self,) + _args, _kwargs)
         return val
-    def SetToolPacking(self,arg0):
-        val = stattoolc.wxToolBar_SetToolPacking(self.this,arg0)
+    def SetToolPacking(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_SetToolPacking,(self,) + _args, _kwargs)
         return val
-    def SetToolSeparation(self,arg0):
-        val = stattoolc.wxToolBar_SetToolSeparation(self.this,arg0)
+    def SetToolSeparation(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_SetToolSeparation,(self,) + _args, _kwargs)
         return val
-    def ToggleTool(self,arg0,arg1):
-        val = stattoolc.wxToolBar_ToggleTool(self.this,arg0,arg1)
+    def ToggleTool(self, *_args, **_kwargs):
+        val = apply(stattoolc.wxToolBar_ToggleTool,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxToolBar instance>"
+        return "<C wxToolBar instance at %s>" % (self.this,)
 class wxToolBar(wxToolBarPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(stattoolc.new_wxToolBar,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(stattoolc.new_wxToolBar,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
 

utils/wxPython/src/gtk/utils.cpp

@@ -3,7 +3,7 @@
  * 
  * This file was automatically generated by :
  * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Patch 5)
+ * Version 1.1 (Patch 6)
  * 
  * Portions Copyright (c) 1995-1998
  * The University of Utah and The Regents of the University of California.
@@ -24,16 +24,16 @@
 /* Definitions for Windows/Unix exporting */
 #if defined(__WIN32__)
 #   if defined(_MSC_VER)
-#	define SWIGEXPORT(a,b) __declspec(dllexport) a b
+#	define SWIGEXPORT(a) __declspec(dllexport) a
 #   else
 #	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a,b) a _export b
+#	    define SWIGEXPORT(a) a _export 
 #	else
-#	    define SWIGEXPORT(a,b) a b
+#	    define SWIGEXPORT(a) a 
 #	endif
 #   endif
 #else
-#   define SWIGEXPORT(a,b) a b
+#   define SWIGEXPORT(a) a 
 #endif
 
 #ifdef __cplusplus
@@ -43,12 +43,12 @@ extern "C" {
 extern void SWIG_MakePtr(char *, void *, char *);
 extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
 extern char *SWIG_GetPtr(char *, void **, char *);
+extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
 extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
 extern PyObject *SWIG_newvarlink(void);
 #ifdef __cplusplus
 }
 #endif
-
 #define SWIG_init    initutilsc
 
 #define SWIG_name    "utilsc"
@@ -129,15 +129,18 @@ static char* wxStringErrorMsg = "string type is required for parameter";
         }
         return ret;
     }
+#ifdef __cplusplus
+extern "C" {
+#endif
 #define new_wxConfig(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (new wxConfig(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
 static PyObject *_wrap_new_wxConfig(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxConfig * _result;
-    wxString * _arg0 = &wxPyEmptyStr;
-    wxString * _arg1 = &wxPyEmptyStr;
-    wxString * _arg2 = &wxPyEmptyStr;
-    wxString * _arg3 = &wxPyEmptyStr;
-    long  _arg4 = 0;
+    wxString * _arg0 = (wxString *) &wxPyEmptyStr;
+    wxString * _arg1 = (wxString *) &wxPyEmptyStr;
+    wxString * _arg2 = (wxString *) &wxPyEmptyStr;
+    wxString * _arg3 = (wxString *) &wxPyEmptyStr;
+    long  _arg4 = (long ) 0;
     PyObject * _obj0 = 0;
     PyObject * _obj1 = 0;
     PyObject * _obj2 = 0;
@@ -184,8 +187,13 @@ static PyObject *_wrap_new_wxConfig(PyObject *self, PyObject *args) {
         _result = (wxConfig *)new_wxConfig(*_arg0,*_arg1,*_arg2,*_arg3,_arg4);
 
     wxPy_END_ALLOW_THREADS;
-}    SWIG_MakePtr(_ptemp, (char *) _result,"_wxConfig_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxConfig_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
 {
     if (_obj0)
         delete _arg0;
@@ -209,13 +217,14 @@ static PyObject *_wrap_new_wxConfig(PyObject *self, PyObject *args) {
 static PyObject *_wrap_delete_wxConfig(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:delete_wxConfig",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:delete_wxConfig",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxConfig. Expected _wxConfig_p.");
         return NULL;
         }
@@ -234,13 +243,14 @@ static PyObject *_wrap_delete_wxConfig(PyObject *self, PyObject *args) {
 static PyObject *_wrap_wxConfig_DontCreateOnDemand(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxConfig_DontCreateOnDemand",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxConfig_DontCreateOnDemand",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_DontCreateOnDemand. Expected _wxConfig_p.");
         return NULL;
         }
@@ -260,13 +270,14 @@ static PyObject *_wrap_wxConfig_DeleteAll(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     bool  _result;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxConfig_DeleteAll",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxConfig_DeleteAll",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_DeleteAll. Expected _wxConfig_p.");
         return NULL;
         }
@@ -286,16 +297,17 @@ static PyObject *_wrap_wxConfig_DeleteEntry(PyObject *self, PyObject *args) {
     bool  _result;
     wxConfig * _arg0;
     wxString * _arg1;
-    bool  _arg2 = TRUE;
-    char * _argc0 = 0;
+    bool  _arg2 = (bool ) TRUE;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
-    int tempbool2;
+    int tempbool2 = (int) TRUE;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO|i:wxConfig_DeleteEntry",&_argc0,&_obj1,&tempbool2)) 
+    if(!PyArg_ParseTuple(args,"OO|i:wxConfig_DeleteEntry",&_argo0,&_obj1,&tempbool2)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_DeleteEntry. Expected _wxConfig_p.");
         return NULL;
         }
@@ -327,14 +339,15 @@ static PyObject *_wrap_wxConfig_DeleteGroup(PyObject *self, PyObject *args) {
     bool  _result;
     wxConfig * _arg0;
     wxString * _arg1;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO:wxConfig_DeleteGroup",&_argc0,&_obj1)) 
+    if(!PyArg_ParseTuple(args,"OO:wxConfig_DeleteGroup",&_argo0,&_obj1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_DeleteGroup. Expected _wxConfig_p.");
         return NULL;
         }
@@ -365,14 +378,15 @@ static PyObject *_wrap_wxConfig_Exists(PyObject *self, PyObject *args) {
     bool  _result;
     wxConfig * _arg0;
     wxString * _arg1;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO:wxConfig_Exists",&_argc0,&_obj1)) 
+    if(!PyArg_ParseTuple(args,"OO:wxConfig_Exists",&_argo0,&_obj1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_Exists. Expected _wxConfig_p.");
         return NULL;
         }
@@ -402,15 +416,16 @@ static PyObject *_wrap_wxConfig_Flush(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     bool  _result;
     wxConfig * _arg0;
-    bool  _arg1 = FALSE;
-    char * _argc0 = 0;
-    int tempbool1;
+    bool  _arg1 = (bool ) FALSE;
+    PyObject * _argo0 = 0;
+    int tempbool1 = (int) FALSE;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s|i:wxConfig_Flush",&_argc0,&tempbool1)) 
+    if(!PyArg_ParseTuple(args,"O|i:wxConfig_Flush",&_argo0,&tempbool1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_Flush. Expected _wxConfig_p.");
         return NULL;
         }
@@ -430,13 +445,14 @@ static PyObject *_wrap_wxConfig_GetAppName(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxString * _result;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxConfig_GetAppName",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxConfig_GetAppName",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_GetAppName. Expected _wxConfig_p.");
         return NULL;
         }
@@ -467,13 +483,14 @@ static PyObject *_wrap_wxConfig_GetFirstGroup(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     PyObject * _result;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxConfig_GetFirstGroup",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxConfig_GetFirstGroup",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_GetFirstGroup. Expected _wxConfig_p.");
         return NULL;
         }
@@ -501,13 +518,14 @@ static PyObject *_wrap_wxConfig_GetFirstEntry(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     PyObject * _result;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxConfig_GetFirstEntry",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxConfig_GetFirstEntry",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_GetFirstEntry. Expected _wxConfig_p.");
         return NULL;
         }
@@ -535,13 +553,14 @@ static PyObject *_wrap_wxConfig_GetNextGroup(PyObject *self, PyObject *args) {
     PyObject * _result;
     wxConfig * _arg0;
     long  _arg1;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sl:wxConfig_GetNextGroup",&_argc0,&_arg1)) 
+    if(!PyArg_ParseTuple(args,"Ol:wxConfig_GetNextGroup",&_argo0,&_arg1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_GetNextGroup. Expected _wxConfig_p.");
         return NULL;
         }
@@ -569,13 +588,14 @@ static PyObject *_wrap_wxConfig_GetNextEntry(PyObject *self, PyObject *args) {
     PyObject * _result;
     wxConfig * _arg0;
     long  _arg1;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sl:wxConfig_GetNextEntry",&_argc0,&_arg1)) 
+    if(!PyArg_ParseTuple(args,"Ol:wxConfig_GetNextEntry",&_argo0,&_arg1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_GetNextEntry. Expected _wxConfig_p.");
         return NULL;
         }
@@ -596,15 +616,16 @@ static PyObject *_wrap_wxConfig_GetNumberOfEntries(PyObject *self, PyObject *arg
     PyObject * _resultobj;
     int  _result;
     wxConfig * _arg0;
-    bool  _arg1 = FALSE;
-    char * _argc0 = 0;
-    int tempbool1;
+    bool  _arg1 = (bool ) FALSE;
+    PyObject * _argo0 = 0;
+    int tempbool1 = (int) FALSE;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s|i:wxConfig_GetNumberOfEntries",&_argc0,&tempbool1)) 
+    if(!PyArg_ParseTuple(args,"O|i:wxConfig_GetNumberOfEntries",&_argo0,&tempbool1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_GetNumberOfEntries. Expected _wxConfig_p.");
         return NULL;
         }
@@ -624,15 +645,16 @@ static PyObject *_wrap_wxConfig_GetNumberOfGroups(PyObject *self, PyObject *args
     PyObject * _resultobj;
     int  _result;
     wxConfig * _arg0;
-    bool  _arg1 = FALSE;
-    char * _argc0 = 0;
-    int tempbool1;
+    bool  _arg1 = (bool ) FALSE;
+    PyObject * _argo0 = 0;
+    int tempbool1 = (int) FALSE;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s|i:wxConfig_GetNumberOfGroups",&_argc0,&tempbool1)) 
+    if(!PyArg_ParseTuple(args,"O|i:wxConfig_GetNumberOfGroups",&_argo0,&tempbool1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_GetNumberOfGroups. Expected _wxConfig_p.");
         return NULL;
         }
@@ -652,13 +674,14 @@ static PyObject *_wrap_wxConfig_GetPath(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxString * _result;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxConfig_GetPath",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxConfig_GetPath",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_GetPath. Expected _wxConfig_p.");
         return NULL;
         }
@@ -682,13 +705,14 @@ static PyObject *_wrap_wxConfig_GetVendorName(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxString * _result;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxConfig_GetVendorName",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxConfig_GetVendorName",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_GetVendorName. Expected _wxConfig_p.");
         return NULL;
         }
@@ -713,14 +737,15 @@ static PyObject *_wrap_wxConfig_HasEntry(PyObject *self, PyObject *args) {
     bool  _result;
     wxConfig * _arg0;
     wxString * _arg1;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO:wxConfig_HasEntry",&_argc0,&_obj1)) 
+    if(!PyArg_ParseTuple(args,"OO:wxConfig_HasEntry",&_argo0,&_obj1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_HasEntry. Expected _wxConfig_p.");
         return NULL;
         }
@@ -751,14 +776,15 @@ static PyObject *_wrap_wxConfig_HasGroup(PyObject *self, PyObject *args) {
     bool  _result;
     wxConfig * _arg0;
     wxString * _arg1;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO:wxConfig_HasGroup",&_argc0,&_obj1)) 
+    if(!PyArg_ParseTuple(args,"OO:wxConfig_HasGroup",&_argo0,&_obj1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_HasGroup. Expected _wxConfig_p.");
         return NULL;
         }
@@ -788,13 +814,14 @@ static PyObject *_wrap_wxConfig_IsExpandingEnvVars(PyObject *self, PyObject *arg
     PyObject * _resultobj;
     bool  _result;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxConfig_IsExpandingEnvVars",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxConfig_IsExpandingEnvVars",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_IsExpandingEnvVars. Expected _wxConfig_p.");
         return NULL;
         }
@@ -813,13 +840,14 @@ static PyObject *_wrap_wxConfig_IsRecordingDefaults(PyObject *self, PyObject *ar
     PyObject * _resultobj;
     bool  _result;
     wxConfig * _arg0;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s:wxConfig_IsRecordingDefaults",&_argc0)) 
+    if(!PyArg_ParseTuple(args,"O:wxConfig_IsRecordingDefaults",&_argo0)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_IsRecordingDefaults. Expected _wxConfig_p.");
         return NULL;
         }
@@ -839,16 +867,17 @@ static PyObject *_wrap_wxConfig_Read(PyObject *self, PyObject *args) {
     wxString * _result;
     wxConfig * _arg0;
     wxString * _arg1;
-    wxString * _arg2 = &wxPyEmptyStr;
-    char * _argc0 = 0;
+    wxString * _arg2 = (wxString *) &wxPyEmptyStr;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
     PyObject * _obj2 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO|O:wxConfig_Read",&_argc0,&_obj1,&_obj2)) 
+    if(!PyArg_ParseTuple(args,"OO|O:wxConfig_Read",&_argo0,&_obj1,&_obj2)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_Read. Expected _wxConfig_p.");
         return NULL;
         }
@@ -896,15 +925,16 @@ static PyObject *_wrap_wxConfig_ReadInt(PyObject *self, PyObject *args) {
     long  _result;
     wxConfig * _arg0;
     wxString * _arg1;
-    long  _arg2 = 0;
-    char * _argc0 = 0;
+    long  _arg2 = (long ) 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO|l:wxConfig_ReadInt",&_argc0,&_obj1,&_arg2)) 
+    if(!PyArg_ParseTuple(args,"OO|l:wxConfig_ReadInt",&_argo0,&_obj1,&_arg2)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_ReadInt. Expected _wxConfig_p.");
         return NULL;
         }
@@ -935,15 +965,16 @@ static PyObject *_wrap_wxConfig_ReadFloat(PyObject *self, PyObject *args) {
     double  _result;
     wxConfig * _arg0;
     wxString * _arg1;
-    double  _arg2 = 0.0;
-    char * _argc0 = 0;
+    double  _arg2 = (double ) 0.0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO|d:wxConfig_ReadFloat",&_argc0,&_obj1,&_arg2)) 
+    if(!PyArg_ParseTuple(args,"OO|d:wxConfig_ReadFloat",&_argo0,&_obj1,&_arg2)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_ReadFloat. Expected _wxConfig_p.");
         return NULL;
         }
@@ -972,15 +1003,16 @@ static PyObject *_wrap_wxConfig_ReadFloat(PyObject *self, PyObject *args) {
 static PyObject *_wrap_wxConfig_SetExpandEnvVars(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxConfig * _arg0;
-    bool  _arg1 = TRUE;
-    char * _argc0 = 0;
-    int tempbool1;
+    bool  _arg1 = (bool ) TRUE;
+    PyObject * _argo0 = 0;
+    int tempbool1 = (int) TRUE;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s|i:wxConfig_SetExpandEnvVars",&_argc0,&tempbool1)) 
+    if(!PyArg_ParseTuple(args,"O|i:wxConfig_SetExpandEnvVars",&_argo0,&tempbool1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_SetExpandEnvVars. Expected _wxConfig_p.");
         return NULL;
         }
@@ -1001,14 +1033,15 @@ static PyObject *_wrap_wxConfig_SetPath(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxConfig * _arg0;
     wxString * _arg1;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sO:wxConfig_SetPath",&_argc0,&_obj1)) 
+    if(!PyArg_ParseTuple(args,"OO:wxConfig_SetPath",&_argo0,&_obj1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_SetPath. Expected _wxConfig_p.");
         return NULL;
         }
@@ -1038,15 +1071,16 @@ static PyObject *_wrap_wxConfig_SetPath(PyObject *self, PyObject *args) {
 static PyObject *_wrap_wxConfig_SetRecordDefaults(PyObject *self, PyObject *args) {
     PyObject * _resultobj;
     wxConfig * _arg0;
-    bool  _arg1 = TRUE;
-    char * _argc0 = 0;
-    int tempbool1;
+    bool  _arg1 = (bool ) TRUE;
+    PyObject * _argo0 = 0;
+    int tempbool1 = (int) TRUE;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"s|i:wxConfig_SetRecordDefaults",&_argc0,&tempbool1)) 
+    if(!PyArg_ParseTuple(args,"O|i:wxConfig_SetRecordDefaults",&_argo0,&tempbool1)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_SetRecordDefaults. Expected _wxConfig_p.");
         return NULL;
         }
@@ -1069,15 +1103,16 @@ static PyObject *_wrap_wxConfig_Write(PyObject *self, PyObject *args) {
     wxConfig * _arg0;
     wxString * _arg1;
     wxString * _arg2;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
     PyObject * _obj2 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sOO:wxConfig_Write",&_argc0,&_obj1,&_obj2)) 
+    if(!PyArg_ParseTuple(args,"OOO:wxConfig_Write",&_argo0,&_obj1,&_obj2)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_Write. Expected _wxConfig_p.");
         return NULL;
         }
@@ -1120,14 +1155,15 @@ static PyObject *_wrap_wxConfig_WriteInt(PyObject *self, PyObject *args) {
     wxConfig * _arg0;
     wxString * _arg1;
     long  _arg2;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sOl:wxConfig_WriteInt",&_argc0,&_obj1,&_arg2)) 
+    if(!PyArg_ParseTuple(args,"OOl:wxConfig_WriteInt",&_argo0,&_obj1,&_arg2)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_WriteInt. Expected _wxConfig_p.");
         return NULL;
         }
@@ -1159,14 +1195,15 @@ static PyObject *_wrap_wxConfig_WriteFloat(PyObject *self, PyObject *args) {
     wxConfig * _arg0;
     wxString * _arg1;
     double  _arg2;
-    char * _argc0 = 0;
+    PyObject * _argo0 = 0;
     PyObject * _obj1 = 0;
 
     self = self;
-    if(!PyArg_ParseTuple(args,"sOd:wxConfig_WriteFloat",&_argc0,&_obj1,&_arg2)) 
+    if(!PyArg_ParseTuple(args,"OOd:wxConfig_WriteFloat",&_argo0,&_obj1,&_arg2)) 
         return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) {
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxConfig_p")) {
             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_WriteFloat. Expected _wxConfig_p.");
         return NULL;
         }
@@ -1192,43 +1229,66 @@ static PyObject *_wrap_wxConfig_WriteFloat(PyObject *self, PyObject *args) {
 }
 
 static PyMethodDef utilscMethods[] = {
-	 { "wxConfig_WriteFloat", _wrap_wxConfig_WriteFloat, 1 },
-	 { "wxConfig_WriteInt", _wrap_wxConfig_WriteInt, 1 },
-	 { "wxConfig_Write", _wrap_wxConfig_Write, 1 },
-	 { "wxConfig_SetRecordDefaults", _wrap_wxConfig_SetRecordDefaults, 1 },
-	 { "wxConfig_SetPath", _wrap_wxConfig_SetPath, 1 },
-	 { "wxConfig_SetExpandEnvVars", _wrap_wxConfig_SetExpandEnvVars, 1 },
-	 { "wxConfig_ReadFloat", _wrap_wxConfig_ReadFloat, 1 },
-	 { "wxConfig_ReadInt", _wrap_wxConfig_ReadInt, 1 },
-	 { "wxConfig_Read", _wrap_wxConfig_Read, 1 },
-	 { "wxConfig_IsRecordingDefaults", _wrap_wxConfig_IsRecordingDefaults, 1 },
-	 { "wxConfig_IsExpandingEnvVars", _wrap_wxConfig_IsExpandingEnvVars, 1 },
-	 { "wxConfig_HasGroup", _wrap_wxConfig_HasGroup, 1 },
-	 { "wxConfig_HasEntry", _wrap_wxConfig_HasEntry, 1 },
-	 { "wxConfig_GetVendorName", _wrap_wxConfig_GetVendorName, 1 },
-	 { "wxConfig_GetPath", _wrap_wxConfig_GetPath, 1 },
-	 { "wxConfig_GetNumberOfGroups", _wrap_wxConfig_GetNumberOfGroups, 1 },
-	 { "wxConfig_GetNumberOfEntries", _wrap_wxConfig_GetNumberOfEntries, 1 },
-	 { "wxConfig_GetNextEntry", _wrap_wxConfig_GetNextEntry, 1 },
-	 { "wxConfig_GetNextGroup", _wrap_wxConfig_GetNextGroup, 1 },
-	 { "wxConfig_GetFirstEntry", _wrap_wxConfig_GetFirstEntry, 1 },
-	 { "wxConfig_GetFirstGroup", _wrap_wxConfig_GetFirstGroup, 1 },
-	 { "wxConfig_GetAppName", _wrap_wxConfig_GetAppName, 1 },
-	 { "wxConfig_Flush", _wrap_wxConfig_Flush, 1 },
-	 { "wxConfig_Exists", _wrap_wxConfig_Exists, 1 },
-	 { "wxConfig_DeleteGroup", _wrap_wxConfig_DeleteGroup, 1 },
-	 { "wxConfig_DeleteEntry", _wrap_wxConfig_DeleteEntry, 1 },
-	 { "wxConfig_DeleteAll", _wrap_wxConfig_DeleteAll, 1 },
-	 { "wxConfig_DontCreateOnDemand", _wrap_wxConfig_DontCreateOnDemand, 1 },
-	 { "delete_wxConfig", _wrap_delete_wxConfig, 1 },
-	 { "new_wxConfig", _wrap_new_wxConfig, 1 },
+	 { "wxConfig_WriteFloat", _wrap_wxConfig_WriteFloat, METH_VARARGS },
+	 { "wxConfig_WriteInt", _wrap_wxConfig_WriteInt, METH_VARARGS },
+	 { "wxConfig_Write", _wrap_wxConfig_Write, METH_VARARGS },
+	 { "wxConfig_SetRecordDefaults", _wrap_wxConfig_SetRecordDefaults, METH_VARARGS },
+	 { "wxConfig_SetPath", _wrap_wxConfig_SetPath, METH_VARARGS },
+	 { "wxConfig_SetExpandEnvVars", _wrap_wxConfig_SetExpandEnvVars, METH_VARARGS },
+	 { "wxConfig_ReadFloat", _wrap_wxConfig_ReadFloat, METH_VARARGS },
+	 { "wxConfig_ReadInt", _wrap_wxConfig_ReadInt, METH_VARARGS },
+	 { "wxConfig_Read", _wrap_wxConfig_Read, METH_VARARGS },
+	 { "wxConfig_IsRecordingDefaults", _wrap_wxConfig_IsRecordingDefaults, METH_VARARGS },
+	 { "wxConfig_IsExpandingEnvVars", _wrap_wxConfig_IsExpandingEnvVars, METH_VARARGS },
+	 { "wxConfig_HasGroup", _wrap_wxConfig_HasGroup, METH_VARARGS },
+	 { "wxConfig_HasEntry", _wrap_wxConfig_HasEntry, METH_VARARGS },
+	 { "wxConfig_GetVendorName", _wrap_wxConfig_GetVendorName, METH_VARARGS },
+	 { "wxConfig_GetPath", _wrap_wxConfig_GetPath, METH_VARARGS },
+	 { "wxConfig_GetNumberOfGroups", _wrap_wxConfig_GetNumberOfGroups, METH_VARARGS },
+	 { "wxConfig_GetNumberOfEntries", _wrap_wxConfig_GetNumberOfEntries, METH_VARARGS },
+	 { "wxConfig_GetNextEntry", _wrap_wxConfig_GetNextEntry, METH_VARARGS },
+	 { "wxConfig_GetNextGroup", _wrap_wxConfig_GetNextGroup, METH_VARARGS },
+	 { "wxConfig_GetFirstEntry", _wrap_wxConfig_GetFirstEntry, METH_VARARGS },
+	 { "wxConfig_GetFirstGroup", _wrap_wxConfig_GetFirstGroup, METH_VARARGS },
+	 { "wxConfig_GetAppName", _wrap_wxConfig_GetAppName, METH_VARARGS },
+	 { "wxConfig_Flush", _wrap_wxConfig_Flush, METH_VARARGS },
+	 { "wxConfig_Exists", _wrap_wxConfig_Exists, METH_VARARGS },
+	 { "wxConfig_DeleteGroup", _wrap_wxConfig_DeleteGroup, METH_VARARGS },
+	 { "wxConfig_DeleteEntry", _wrap_wxConfig_DeleteEntry, METH_VARARGS },
+	 { "wxConfig_DeleteAll", _wrap_wxConfig_DeleteAll, METH_VARARGS },
+	 { "wxConfig_DontCreateOnDemand", _wrap_wxConfig_DontCreateOnDemand, METH_VARARGS },
+	 { "delete_wxConfig", _wrap_delete_wxConfig, METH_VARARGS },
+	 { "new_wxConfig", _wrap_new_wxConfig, METH_VARARGS },
 	 { NULL, NULL }
 };
+#ifdef __cplusplus
+}
+#endif
+/*
+ * This table is used by the pointer type-checker
+ */
+static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
+    { "_signed_long","_long",0},
+    { "_long","_unsigned_long",0},
+    { "_long","_signed_long",0},
+    { "_wxConfig","_class_wxConfig",0},
+    { "_unsigned_long","_long",0},
+    { "_signed_int","_int",0},
+    { "_unsigned_short","_short",0},
+    { "_signed_short","_short",0},
+    { "_unsigned_int","_int",0},
+    { "_short","_unsigned_short",0},
+    { "_short","_signed_short",0},
+    { "_int","_unsigned_int",0},
+    { "_int","_signed_int",0},
+    { "_class_wxConfig","_wxConfig",0},
+{0,0,0}};
+
 static PyObject *SWIG_globals;
 #ifdef __cplusplus
 extern "C" 
 #endif
-SWIGEXPORT(void,initutilsc)() {
+SWIGEXPORT(void) initutilsc() {
 	 PyObject *m, *d;
 	 SWIG_globals = SWIG_newvarlink();
 	 m = Py_InitModule("utilsc", utilscMethods);
@@ -1238,22 +1298,9 @@ SWIGEXPORT(void,initutilsc)() {
     wxClassInfo::CleanUpClasses();
     wxClassInfo::InitializeClasses();
 
-/*
- * These are the pointer type-equivalency mappings. 
- * (Used by the SWIG pointer type-checker).
- */
-	 SWIG_RegisterMapping("_signed_long","_long",0);
-	 SWIG_RegisterMapping("_long","_unsigned_long",0);
-	 SWIG_RegisterMapping("_long","_signed_long",0);
-	 SWIG_RegisterMapping("_wxConfig","_class_wxConfig",0);
-	 SWIG_RegisterMapping("_unsigned_long","_long",0);
-	 SWIG_RegisterMapping("_signed_int","_int",0);
-	 SWIG_RegisterMapping("_unsigned_short","_short",0);
-	 SWIG_RegisterMapping("_signed_short","_short",0);
-	 SWIG_RegisterMapping("_unsigned_int","_int",0);
-	 SWIG_RegisterMapping("_short","_unsigned_short",0);
-	 SWIG_RegisterMapping("_short","_signed_short",0);
-	 SWIG_RegisterMapping("_int","_unsigned_int",0);
-	 SWIG_RegisterMapping("_int","_signed_int",0);
-	 SWIG_RegisterMapping("_class_wxConfig","_wxConfig",0);
+{
+   int i;
+   for (i = 0; _swig_mapping[i].n1; i++)
+        SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
+}
 }

utils/wxPython/src/gtk/utils.py

@@ -4,98 +4,98 @@ class wxConfigPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, utilsc=utilsc):
+    def __del__(self,utilsc=utilsc):
         if self.thisown == 1 :
-            utilsc.delete_wxConfig(self.this)
-    def DontCreateOnDemand(self):
-        val = utilsc.wxConfig_DontCreateOnDemand(self.this)
+            utilsc.delete_wxConfig(self)
+    def DontCreateOnDemand(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_DontCreateOnDemand,(self,) + _args, _kwargs)
         return val
-    def DeleteAll(self):
-        val = utilsc.wxConfig_DeleteAll(self.this)
+    def DeleteAll(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_DeleteAll,(self,) + _args, _kwargs)
         return val
-    def DeleteEntry(self,arg0,*args):
-        val = apply(utilsc.wxConfig_DeleteEntry,(self.this,arg0,)+args)
+    def DeleteEntry(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_DeleteEntry,(self,) + _args, _kwargs)
         return val
-    def DeleteGroup(self,arg0):
-        val = utilsc.wxConfig_DeleteGroup(self.this,arg0)
+    def DeleteGroup(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_DeleteGroup,(self,) + _args, _kwargs)
         return val
-    def Exists(self,arg0):
-        val = utilsc.wxConfig_Exists(self.this,arg0)
+    def Exists(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_Exists,(self,) + _args, _kwargs)
         return val
-    def Flush(self,*args):
-        val = apply(utilsc.wxConfig_Flush,(self.this,)+args)
+    def Flush(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_Flush,(self,) + _args, _kwargs)
         return val
-    def GetAppName(self):
-        val = utilsc.wxConfig_GetAppName(self.this)
+    def GetAppName(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_GetAppName,(self,) + _args, _kwargs)
         return val
-    def GetFirstGroup(self):
-        val = utilsc.wxConfig_GetFirstGroup(self.this)
+    def GetFirstGroup(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_GetFirstGroup,(self,) + _args, _kwargs)
         return val
-    def GetFirstEntry(self):
-        val = utilsc.wxConfig_GetFirstEntry(self.this)
+    def GetFirstEntry(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_GetFirstEntry,(self,) + _args, _kwargs)
         return val
-    def GetNextGroup(self,arg0):
-        val = utilsc.wxConfig_GetNextGroup(self.this,arg0)
+    def GetNextGroup(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_GetNextGroup,(self,) + _args, _kwargs)
         return val
-    def GetNextEntry(self,arg0):
-        val = utilsc.wxConfig_GetNextEntry(self.this,arg0)
+    def GetNextEntry(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_GetNextEntry,(self,) + _args, _kwargs)
         return val
-    def GetNumberOfEntries(self,*args):
-        val = apply(utilsc.wxConfig_GetNumberOfEntries,(self.this,)+args)
+    def GetNumberOfEntries(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_GetNumberOfEntries,(self,) + _args, _kwargs)
         return val
-    def GetNumberOfGroups(self,*args):
-        val = apply(utilsc.wxConfig_GetNumberOfGroups,(self.this,)+args)
+    def GetNumberOfGroups(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_GetNumberOfGroups,(self,) + _args, _kwargs)
         return val
-    def GetPath(self):
-        val = utilsc.wxConfig_GetPath(self.this)
+    def GetPath(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_GetPath,(self,) + _args, _kwargs)
         return val
-    def GetVendorName(self):
-        val = utilsc.wxConfig_GetVendorName(self.this)
+    def GetVendorName(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_GetVendorName,(self,) + _args, _kwargs)
         return val
-    def HasEntry(self,arg0):
-        val = utilsc.wxConfig_HasEntry(self.this,arg0)
+    def HasEntry(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_HasEntry,(self,) + _args, _kwargs)
         return val
-    def HasGroup(self,arg0):
-        val = utilsc.wxConfig_HasGroup(self.this,arg0)
+    def HasGroup(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_HasGroup,(self,) + _args, _kwargs)
         return val
-    def IsExpandingEnvVars(self):
-        val = utilsc.wxConfig_IsExpandingEnvVars(self.this)
+    def IsExpandingEnvVars(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_IsExpandingEnvVars,(self,) + _args, _kwargs)
         return val
-    def IsRecordingDefaults(self):
-        val = utilsc.wxConfig_IsRecordingDefaults(self.this)
+    def IsRecordingDefaults(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_IsRecordingDefaults,(self,) + _args, _kwargs)
         return val
-    def Read(self,arg0,*args):
-        val = apply(utilsc.wxConfig_Read,(self.this,arg0,)+args)
+    def Read(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_Read,(self,) + _args, _kwargs)
         return val
-    def ReadInt(self,arg0,*args):
-        val = apply(utilsc.wxConfig_ReadInt,(self.this,arg0,)+args)
+    def ReadInt(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_ReadInt,(self,) + _args, _kwargs)
         return val
-    def ReadFloat(self,arg0,*args):
-        val = apply(utilsc.wxConfig_ReadFloat,(self.this,arg0,)+args)
+    def ReadFloat(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_ReadFloat,(self,) + _args, _kwargs)
         return val
-    def SetExpandEnvVars(self,*args):
-        val = apply(utilsc.wxConfig_SetExpandEnvVars,(self.this,)+args)
+    def SetExpandEnvVars(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_SetExpandEnvVars,(self,) + _args, _kwargs)
         return val
-    def SetPath(self,arg0):
-        val = utilsc.wxConfig_SetPath(self.this,arg0)
+    def SetPath(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_SetPath,(self,) + _args, _kwargs)
         return val
-    def SetRecordDefaults(self,*args):
-        val = apply(utilsc.wxConfig_SetRecordDefaults,(self.this,)+args)
+    def SetRecordDefaults(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_SetRecordDefaults,(self,) + _args, _kwargs)
         return val
-    def Write(self,arg0,arg1):
-        val = utilsc.wxConfig_Write(self.this,arg0,arg1)
+    def Write(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_Write,(self,) + _args, _kwargs)
         return val
-    def WriteInt(self,arg0,arg1):
-        val = utilsc.wxConfig_WriteInt(self.this,arg0,arg1)
+    def WriteInt(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_WriteInt,(self,) + _args, _kwargs)
         return val
-    def WriteFloat(self,arg0,arg1):
-        val = utilsc.wxConfig_WriteFloat(self.this,arg0,arg1)
+    def WriteFloat(self, *_args, **_kwargs):
+        val = apply(utilsc.wxConfig_WriteFloat,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxConfig instance>"
+        return "<C wxConfig instance at %s>" % (self.this,)
 class wxConfig(wxConfigPtr):
-    def __init__(self,*args) :
-        self.this = apply(utilsc.new_wxConfig,()+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(utilsc.new_wxConfig,_args,_kwargs)
         self.thisown = 1
 
 

utils/wxPython/src/gtk/windows2.py

@@ -15,58 +15,58 @@ class wxGridCellPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, windows2c=windows2c):
+    def __del__(self,windows2c=windows2c):
         if self.thisown == 1 :
-            windows2c.delete_wxGridCell(self.this)
-    def GetTextValue(self):
-        val = windows2c.wxGridCell_GetTextValue(self.this)
+            windows2c.delete_wxGridCell(self)
+    def GetTextValue(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_GetTextValue,(self,) + _args, _kwargs)
         return val
-    def SetTextValue(self,arg0):
-        val = windows2c.wxGridCell_SetTextValue(self.this,arg0)
+    def SetTextValue(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_SetTextValue,(self,) + _args, _kwargs)
         return val
-    def GetFont(self):
-        val = windows2c.wxGridCell_GetFont(self.this)
-        val = wxFontPtr(val)
+    def GetFont(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_GetFont,(self,) + _args, _kwargs)
+        if val: val = wxFontPtr(val) 
         return val
-    def SetFont(self,arg0):
-        val = windows2c.wxGridCell_SetFont(self.this,arg0.this)
+    def SetFont(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_SetFont,(self,) + _args, _kwargs)
         return val
-    def GetTextColour(self):
-        val = windows2c.wxGridCell_GetTextColour(self.this)
-        val = wxColourPtr(val)
+    def GetTextColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_GetTextColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def SetTextColour(self,arg0):
-        val = windows2c.wxGridCell_SetTextColour(self.this,arg0.this)
+    def SetTextColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_SetTextColour,(self,) + _args, _kwargs)
         return val
-    def GetBackgroundColour(self):
-        val = windows2c.wxGridCell_GetBackgroundColour(self.this)
-        val = wxColourPtr(val)
+    def GetBackgroundColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_GetBackgroundColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def SetBackgroundColour(self,arg0):
-        val = windows2c.wxGridCell_SetBackgroundColour(self.this,arg0.this)
+    def SetBackgroundColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_SetBackgroundColour,(self,) + _args, _kwargs)
         return val
-    def GetBackgroundBrush(self):
-        val = windows2c.wxGridCell_GetBackgroundBrush(self.this)
-        val = wxBrushPtr(val)
+    def GetBackgroundBrush(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_GetBackgroundBrush,(self,) + _args, _kwargs)
+        if val: val = wxBrushPtr(val) 
         return val
-    def GetAlignment(self):
-        val = windows2c.wxGridCell_GetAlignment(self.this)
+    def GetAlignment(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_GetAlignment,(self,) + _args, _kwargs)
         return val
-    def SetAlignment(self,arg0):
-        val = windows2c.wxGridCell_SetAlignment(self.this,arg0)
+    def SetAlignment(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_SetAlignment,(self,) + _args, _kwargs)
         return val
-    def GetCellBitmap(self):
-        val = windows2c.wxGridCell_GetCellBitmap(self.this)
-        val = wxBitmapPtr(val)
+    def GetCellBitmap(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_GetCellBitmap,(self,) + _args, _kwargs)
+        if val: val = wxBitmapPtr(val) 
         return val
-    def SetCellBitmap(self,arg0):
-        val = windows2c.wxGridCell_SetCellBitmap(self.this,arg0.this)
+    def SetCellBitmap(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridCell_SetCellBitmap,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxGridCell instance>"
+        return "<C wxGridCell instance at %s>" % (self.this,)
 class wxGridCell(wxGridCellPtr):
-    def __init__(self) :
-        self.this = windows2c.new_wxGridCell()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(windows2c.new_wxGridCell,_args,_kwargs)
         self.thisown = 1
 
 
@@ -76,233 +76,226 @@ class wxGridPtr(wxPanelPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def AdjustScrollbars(self):
-        val = windows2c.wxGrid_AdjustScrollbars(self.this)
+    def AdjustScrollbars(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_AdjustScrollbars,(self,) + _args, _kwargs)
         return val
-    def AppendCols(self,*args):
-        val = apply(windows2c.wxGrid_AppendCols,(self.this,)+args)
+    def AppendCols(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_AppendCols,(self,) + _args, _kwargs)
         return val
-    def AppendRows(self,*args):
-        val = apply(windows2c.wxGrid_AppendRows,(self.this,)+args)
+    def AppendRows(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_AppendRows,(self,) + _args, _kwargs)
         return val
-    def BeginBatch(self):
-        val = windows2c.wxGrid_BeginBatch(self.this)
+    def BeginBatch(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_BeginBatch,(self,) + _args, _kwargs)
         return val
-    def CellHitTest(self,arg0,arg1):
-        val = windows2c.wxGrid_CellHitTest(self.this,arg0,arg1)
+    def CellHitTest(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_CellHitTest,(self,) + _args, _kwargs)
         return val
-    def CreateGrid(self,arg0,arg1,*args):
-        val = apply(windows2c.wxGrid_CreateGrid,(self.this,arg0,arg1,)+args)
+    def CreateGrid(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_CreateGrid,(self,) + _args, _kwargs)
         return val
-    def CurrentCellVisible(self):
-        val = windows2c.wxGrid_CurrentCellVisible(self.this)
+    def CurrentCellVisible(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_CurrentCellVisible,(self,) + _args, _kwargs)
         return val
-    def DeleteCols(self,*args):
-        val = apply(windows2c.wxGrid_DeleteCols,(self.this,)+args)
+    def DeleteCols(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_DeleteCols,(self,) + _args, _kwargs)
         return val
-    def DeleteRows(self,*args):
-        val = apply(windows2c.wxGrid_DeleteRows,(self.this,)+args)
+    def DeleteRows(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_DeleteRows,(self,) + _args, _kwargs)
         return val
-    def EndBatch(self):
-        val = windows2c.wxGrid_EndBatch(self.this)
+    def EndBatch(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_EndBatch,(self,) + _args, _kwargs)
         return val
-    def GetBatchCount(self):
-        val = windows2c.wxGrid_GetBatchCount(self.this)
+    def GetBatchCount(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetBatchCount,(self,) + _args, _kwargs)
         return val
-    def GetCell(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCell(self.this,arg0,arg1)
-        val = wxGridCellPtr(val)
+    def GetCell(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCell,(self,) + _args, _kwargs)
+        if val: val = wxGridCellPtr(val) 
         return val
-    def GetCellAlignment(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellAlignment(self.this,arg0,arg1)
+    def GetCellAlignment(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCellAlignment,(self,) + _args, _kwargs)
         return val
-    def GetDefCellAlignment(self):
-        val = windows2c.wxGrid_GetDefCellAlignment(self.this)
+    def GetDefCellAlignment(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetDefCellAlignment,(self,) + _args, _kwargs)
         return val
-    def GetCellBackgroundColour(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellBackgroundColour(self.this,arg0,arg1)
-        val = wxColourPtr(val)
+    def GetCellBackgroundColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCellBackgroundColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def GetDefCellBackgroundColour(self):
-        val = windows2c.wxGrid_GetDefCellBackgroundColour(self.this)
-        val = wxColourPtr(val)
+    def GetDefCellBackgroundColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetDefCellBackgroundColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def GetCells(self):
-        val = windows2c.wxGrid_GetCells(self.this)
+    def GetCells(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCells,(self,) + _args, _kwargs)
         return val
-    def GetCellTextColour(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellTextColour(self.this,arg0,arg1)
-        val = wxColourPtr(val)
+    def GetCellTextColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCellTextColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def GetDefCellTextColour(self):
-        val = windows2c.wxGrid_GetDefCellTextColour(self.this)
-        val = wxColourPtr(val)
+    def GetDefCellTextColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetDefCellTextColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def GetCellTextFont(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellTextFont(self.this,arg0,arg1)
-        val = wxFontPtr(val)
+    def GetCellTextFont(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCellTextFont,(self,) + _args, _kwargs)
+        if val: val = wxFontPtr(val) 
         return val
-    def GetDefCellTextFont(self):
-        val = windows2c.wxGrid_GetDefCellTextFont(self.this)
-        val = wxFontPtr(val)
+    def GetDefCellTextFont(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetDefCellTextFont,(self,) + _args, _kwargs)
+        if val: val = wxFontPtr(val) 
         return val
-    def GetCellValue(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellValue(self.this,arg0,arg1)
+    def GetCellValue(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCellValue,(self,) + _args, _kwargs)
         return val
-    def GetCols(self):
-        val = windows2c.wxGrid_GetCols(self.this)
+    def GetCols(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCols,(self,) + _args, _kwargs)
         return val
-    def GetColumnWidth(self,arg0):
-        val = windows2c.wxGrid_GetColumnWidth(self.this,arg0)
+    def GetColumnWidth(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetColumnWidth,(self,) + _args, _kwargs)
         return val
-    def GetCurrentRect(self):
-        val = windows2c.wxGrid_GetCurrentRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
+    def GetCurrentRect(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCurrentRect,(self,) + _args, _kwargs)
+        if val: val = wxRectPtr(val) ; val.thisown = 1
         return val
-    def GetCursorColumn(self):
-        val = windows2c.wxGrid_GetCursorColumn(self.this)
+    def GetCursorColumn(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCursorColumn,(self,) + _args, _kwargs)
         return val
-    def GetCursorRow(self):
-        val = windows2c.wxGrid_GetCursorRow(self.this)
+    def GetCursorRow(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetCursorRow,(self,) + _args, _kwargs)
         return val
-    def GetEditable(self):
-        val = windows2c.wxGrid_GetEditable(self.this)
+    def GetEditable(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetEditable,(self,) + _args, _kwargs)
         return val
-    def GetHorizScrollBar(self):
-        val = windows2c.wxGrid_GetHorizScrollBar(self.this)
-        val = wxScrollBarPtr(val)
+    def GetHorizScrollBar(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetHorizScrollBar,(self,) + _args, _kwargs)
+        if val: val = wxScrollBarPtr(val) 
         return val
-    def GetLabelAlignment(self,arg0):
-        val = windows2c.wxGrid_GetLabelAlignment(self.this,arg0)
+    def GetLabelAlignment(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetLabelAlignment,(self,) + _args, _kwargs)
         return val
-    def GetLabelBackgroundColour(self):
-        val = windows2c.wxGrid_GetLabelBackgroundColour(self.this)
-        val = wxColourPtr(val)
+    def GetLabelBackgroundColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetLabelBackgroundColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def GetLabelSize(self,arg0):
-        val = windows2c.wxGrid_GetLabelSize(self.this,arg0)
+    def GetLabelSize(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetLabelSize,(self,) + _args, _kwargs)
         return val
-    def GetLabelTextColour(self):
-        val = windows2c.wxGrid_GetLabelTextColour(self.this)
-        val = wxColourPtr(val)
+    def GetLabelTextColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetLabelTextColour,(self,) + _args, _kwargs)
+        if val: val = wxColourPtr(val) 
         return val
-    def GetLabelTextFont(self):
-        val = windows2c.wxGrid_GetLabelTextFont(self.this)
-        val = wxFontPtr(val)
+    def GetLabelTextFont(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetLabelTextFont,(self,) + _args, _kwargs)
+        if val: val = wxFontPtr(val) 
         return val
-    def GetLabelValue(self,arg0,arg1):
-        val = windows2c.wxGrid_GetLabelValue(self.this,arg0,arg1)
+    def GetLabelValue(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetLabelValue,(self,) + _args, _kwargs)
         return val
-    def GetRowHeight(self,arg0):
-        val = windows2c.wxGrid_GetRowHeight(self.this,arg0)
+    def GetRowHeight(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetRowHeight,(self,) + _args, _kwargs)
         return val
-    def GetRows(self):
-        val = windows2c.wxGrid_GetRows(self.this)
+    def GetRows(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetRows,(self,) + _args, _kwargs)
         return val
-    def GetScrollPosX(self):
-        val = windows2c.wxGrid_GetScrollPosX(self.this)
+    def GetScrollPosX(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetScrollPosX,(self,) + _args, _kwargs)
         return val
-    def GetScrollPosY(self):
-        val = windows2c.wxGrid_GetScrollPosY(self.this)
+    def GetScrollPosY(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetScrollPosY,(self,) + _args, _kwargs)
         return val
-    def GetTextItem(self):
-        val = windows2c.wxGrid_GetTextItem(self.this)
-        val = wxTextCtrlPtr(val)
+    def GetTextItem(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetTextItem,(self,) + _args, _kwargs)
+        if val: val = wxTextCtrlPtr(val) 
         return val
-    def GetVertScrollBar(self):
-        val = windows2c.wxGrid_GetVertScrollBar(self.this)
-        val = wxScrollBarPtr(val)
+    def GetVertScrollBar(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetVertScrollBar,(self,) + _args, _kwargs)
+        if val: val = wxScrollBarPtr(val) 
         return val
-    def InsertCols(self,*args):
-        val = apply(windows2c.wxGrid_InsertCols,(self.this,)+args)
+    def InsertCols(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_InsertCols,(self,) + _args, _kwargs)
         return val
-    def InsertRows(self,*args):
-        val = apply(windows2c.wxGrid_InsertRows,(self.this,)+args)
+    def InsertRows(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_InsertRows,(self,) + _args, _kwargs)
         return val
-    def OnActivate(self,arg0):
-        val = windows2c.wxGrid_OnActivate(self.this,arg0)
+    def OnActivate(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_OnActivate,(self,) + _args, _kwargs)
         return val
-    def SetCellAlignment(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellAlignment(self.this,arg0,arg1,arg2)
+    def SetCellAlignment(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetCellAlignment,(self,) + _args, _kwargs)
         return val
-    def SetDefCellAlignment(self,arg0):
-        val = windows2c.wxGrid_SetDefCellAlignment(self.this,arg0)
+    def SetDefCellAlignment(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetDefCellAlignment,(self,) + _args, _kwargs)
         return val
-    def SetCellBackgroundColour(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellBackgroundColour(self.this,arg0.this,arg1,arg2)
+    def SetCellBackgroundColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetCellBackgroundColour,(self,) + _args, _kwargs)
         return val
-    def SetDefCellBackgroundColour(self,arg0):
-        val = windows2c.wxGrid_SetDefCellBackgroundColour(self.this,arg0.this)
+    def SetDefCellBackgroundColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetDefCellBackgroundColour,(self,) + _args, _kwargs)
         return val
-    def SetCellTextColour(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellTextColour(self.this,arg0.this,arg1,arg2)
+    def SetCellTextColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetCellTextColour,(self,) + _args, _kwargs)
         return val
-    def SetDefCellTextColour(self,arg0):
-        val = windows2c.wxGrid_SetDefCellTextColour(self.this,arg0.this)
+    def SetDefCellTextColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetDefCellTextColour,(self,) + _args, _kwargs)
         return val
-    def SetCellTextFont(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellTextFont(self.this,arg0.this,arg1,arg2)
+    def SetCellTextFont(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetCellTextFont,(self,) + _args, _kwargs)
         return val
-    def SetDefCellTextFont(self,arg0):
-        val = windows2c.wxGrid_SetDefCellTextFont(self.this,arg0.this)
+    def SetDefCellTextFont(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetDefCellTextFont,(self,) + _args, _kwargs)
         return val
-    def SetCellValue(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellValue(self.this,arg0,arg1,arg2)
+    def SetCellValue(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetCellValue,(self,) + _args, _kwargs)
         return val
-    def SetColumnWidth(self,arg0,arg1):
-        val = windows2c.wxGrid_SetColumnWidth(self.this,arg0,arg1)
+    def SetColumnWidth(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetColumnWidth,(self,) + _args, _kwargs)
         return val
-    def SetDividerPen(self,arg0):
-        val = windows2c.wxGrid_SetDividerPen(self.this,arg0.this)
+    def SetDividerPen(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetDividerPen,(self,) + _args, _kwargs)
         return val
-    def SetEditable(self,arg0):
-        val = windows2c.wxGrid_SetEditable(self.this,arg0)
+    def SetEditable(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetEditable,(self,) + _args, _kwargs)
         return val
-    def SetGridCursor(self,arg0,arg1):
-        val = windows2c.wxGrid_SetGridCursor(self.this,arg0,arg1)
+    def SetGridCursor(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetGridCursor,(self,) + _args, _kwargs)
         return val
-    def SetLabelAlignment(self,arg0,arg1):
-        val = windows2c.wxGrid_SetLabelAlignment(self.this,arg0,arg1)
+    def SetLabelAlignment(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetLabelAlignment,(self,) + _args, _kwargs)
         return val
-    def SetLabelBackgroundColour(self,arg0):
-        val = windows2c.wxGrid_SetLabelBackgroundColour(self.this,arg0.this)
+    def SetLabelBackgroundColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetLabelBackgroundColour,(self,) + _args, _kwargs)
         return val
-    def SetLabelSize(self,arg0,arg1):
-        val = windows2c.wxGrid_SetLabelSize(self.this,arg0,arg1)
+    def SetLabelSize(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetLabelSize,(self,) + _args, _kwargs)
         return val
-    def SetLabelTextColour(self,arg0):
-        val = windows2c.wxGrid_SetLabelTextColour(self.this,arg0.this)
+    def SetLabelTextColour(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetLabelTextColour,(self,) + _args, _kwargs)
         return val
-    def SetLabelTextFont(self,arg0):
-        val = windows2c.wxGrid_SetLabelTextFont(self.this,arg0.this)
+    def SetLabelTextFont(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetLabelTextFont,(self,) + _args, _kwargs)
         return val
-    def SetLabelValue(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetLabelValue(self.this,arg0,arg1,arg2)
+    def SetLabelValue(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetLabelValue,(self,) + _args, _kwargs)
         return val
-    def SetRowHeight(self,arg0,arg1):
-        val = windows2c.wxGrid_SetRowHeight(self.this,arg0,arg1)
+    def SetRowHeight(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetRowHeight,(self,) + _args, _kwargs)
         return val
-    def UpdateDimensions(self):
-        val = windows2c.wxGrid_UpdateDimensions(self.this)
+    def UpdateDimensions(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_UpdateDimensions,(self,) + _args, _kwargs)
         return val
-    def GetEditInPlace(self):
-        val = windows2c.wxGrid_GetEditInPlace(self.this)
+    def GetEditInPlace(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_GetEditInPlace,(self,) + _args, _kwargs)
         return val
-    def SetEditInPlace(self,*args):
-        val = apply(windows2c.wxGrid_SetEditInPlace,(self.this,)+args)
+    def SetEditInPlace(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGrid_SetEditInPlace,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxGrid instance>"
+        return "<C wxGrid instance at %s>" % (self.this,)
 class wxGrid(wxGridPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows2c.new_wxGrid,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(windows2c.new_wxGrid,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
         wx._checkForCallback(self, 'OnSelectCell',           wxEVT_GRID_SELECT_CELL)
@@ -322,68 +315,67 @@ class wxGridEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetRow(self):
-        val = windows2c.wxGridEvent_GetRow(self.this)
+    def GetRow(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridEvent_GetRow,(self,) + _args, _kwargs)
         return val
-    def GetCol(self):
-        val = windows2c.wxGridEvent_GetCol(self.this)
+    def GetCol(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridEvent_GetCol,(self,) + _args, _kwargs)
         return val
-    def GetPosition(self):
-        val = windows2c.wxGridEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
+    def GetPosition(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridEvent_GetPosition,(self,) + _args, _kwargs)
+        if val: val = wxPointPtr(val) ; val.thisown = 1
         return val
-    def ControlDown(self):
-        val = windows2c.wxGridEvent_ControlDown(self.this)
+    def ControlDown(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridEvent_ControlDown,(self,) + _args, _kwargs)
         return val
-    def ShiftDown(self):
-        val = windows2c.wxGridEvent_ShiftDown(self.this)
+    def ShiftDown(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridEvent_ShiftDown,(self,) + _args, _kwargs)
         return val
-    def GetCell(self):
-        val = windows2c.wxGridEvent_GetCell(self.this)
-        val = wxGridCellPtr(val)
+    def GetCell(self, *_args, **_kwargs):
+        val = apply(windows2c.wxGridEvent_GetCell,(self,) + _args, _kwargs)
+        if val: val = wxGridCellPtr(val) 
         return val
     def __setattr__(self,name,value):
         if name == "m_row" :
-            windows2c.wxGridEvent_m_row_set(self.this,value)
+            windows2c.wxGridEvent_m_row_set(self,value)
             return
         if name == "m_col" :
-            windows2c.wxGridEvent_m_col_set(self.this,value)
+            windows2c.wxGridEvent_m_col_set(self,value)
             return
         if name == "m_x" :
-            windows2c.wxGridEvent_m_x_set(self.this,value)
+            windows2c.wxGridEvent_m_x_set(self,value)
             return
         if name == "m_y" :
-            windows2c.wxGridEvent_m_y_set(self.this,value)
+            windows2c.wxGridEvent_m_y_set(self,value)
             return
         if name == "m_control" :
-            windows2c.wxGridEvent_m_control_set(self.this,value)
+            windows2c.wxGridEvent_m_control_set(self,value)
             return
         if name == "m_shift" :
-            windows2c.wxGridEvent_m_shift_set(self.this,value)
+            windows2c.wxGridEvent_m_shift_set(self,value)
             return
         if name == "m_cell" :
-            windows2c.wxGridEvent_m_cell_set(self.this,value.this)
+            windows2c.wxGridEvent_m_cell_set(self,value.this)
             return
         self.__dict__[name] = value
     def __getattr__(self,name):
         if name == "m_row" : 
-            return windows2c.wxGridEvent_m_row_get(self.this)
+            return windows2c.wxGridEvent_m_row_get(self)
         if name == "m_col" : 
-            return windows2c.wxGridEvent_m_col_get(self.this)
+            return windows2c.wxGridEvent_m_col_get(self)
         if name == "m_x" : 
-            return windows2c.wxGridEvent_m_x_get(self.this)
+            return windows2c.wxGridEvent_m_x_get(self)
         if name == "m_y" : 
-            return windows2c.wxGridEvent_m_y_get(self.this)
+            return windows2c.wxGridEvent_m_y_get(self)
         if name == "m_control" : 
-            return windows2c.wxGridEvent_m_control_get(self.this)
+            return windows2c.wxGridEvent_m_control_get(self)
         if name == "m_shift" : 
-            return windows2c.wxGridEvent_m_shift_get(self.this)
+            return windows2c.wxGridEvent_m_shift_get(self)
         if name == "m_cell" : 
-            return wxGridCellPtr(windows2c.wxGridEvent_m_cell_get(self.this))
+            return wxGridCellPtr(windows2c.wxGridEvent_m_cell_get(self))
         raise AttributeError,name
     def __repr__(self):
-        return "<C wxGridEvent instance>"
+        return "<C wxGridEvent instance at %s>" % (self.this,)
 class wxGridEvent(wxGridEventPtr):
     def __init__(self,this):
         self.this = this
@@ -395,20 +387,20 @@ class wxNotebookEventPtr(wxNotifyEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetSelection(self):
-        val = windows2c.wxNotebookEvent_GetSelection(self.this)
+    def GetSelection(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebookEvent_GetSelection,(self,) + _args, _kwargs)
         return val
-    def GetOldSelection(self):
-        val = windows2c.wxNotebookEvent_GetOldSelection(self.this)
+    def GetOldSelection(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebookEvent_GetOldSelection,(self,) + _args, _kwargs)
         return val
-    def SetOldSelection(self,arg0):
-        val = windows2c.wxNotebookEvent_SetOldSelection(self.this,arg0)
+    def SetOldSelection(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebookEvent_SetOldSelection,(self,) + _args, _kwargs)
         return val
-    def SetSelection(self,arg0):
-        val = windows2c.wxNotebookEvent_SetSelection(self.this,arg0)
+    def SetSelection(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebookEvent_SetSelection,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxNotebookEvent instance>"
+        return "<C wxNotebookEvent instance at %s>" % (self.this,)
 class wxNotebookEvent(wxNotebookEventPtr):
     def __init__(self,this):
         self.this = this
@@ -420,70 +412,64 @@ class wxNotebookPtr(wxControlPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetPageCount(self):
-        val = windows2c.wxNotebook_GetPageCount(self.this)
+    def GetPageCount(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_GetPageCount,(self,) + _args, _kwargs)
         return val
-    def SetSelection(self,arg0):
-        val = windows2c.wxNotebook_SetSelection(self.this,arg0)
+    def SetSelection(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_SetSelection,(self,) + _args, _kwargs)
         return val
-    def AdvanceSelection(self,*args):
-        val = apply(windows2c.wxNotebook_AdvanceSelection,(self.this,)+args)
+    def AdvanceSelection(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_AdvanceSelection,(self,) + _args, _kwargs)
         return val
-    def GetSelection(self):
-        val = windows2c.wxNotebook_GetSelection(self.this)
+    def GetSelection(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_GetSelection,(self,) + _args, _kwargs)
         return val
-    def SetPageText(self,arg0,arg1):
-        val = windows2c.wxNotebook_SetPageText(self.this,arg0,arg1)
+    def SetPageText(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_SetPageText,(self,) + _args, _kwargs)
         return val
-    def GetPageText(self,arg0):
-        val = windows2c.wxNotebook_GetPageText(self.this,arg0)
+    def GetPageText(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_GetPageText,(self,) + _args, _kwargs)
         return val
-    def SetImageList(self,arg0):
-        val = windows2c.wxNotebook_SetImageList(self.this,arg0.this)
+    def SetImageList(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_SetImageList,(self,) + _args, _kwargs)
         return val
-    def GetImageList(self):
-        val = windows2c.wxNotebook_GetImageList(self.this)
-        val = wxImageListPtr(val)
+    def GetImageList(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_GetImageList,(self,) + _args, _kwargs)
+        if val: val = wxImageListPtr(val) 
         return val
-    def GetPageImage(self,arg0):
-        val = windows2c.wxNotebook_GetPageImage(self.this,arg0)
+    def GetPageImage(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_GetPageImage,(self,) + _args, _kwargs)
         return val
-    def SetPageImage(self,arg0,arg1):
-        val = windows2c.wxNotebook_SetPageImage(self.this,arg0,arg1)
+    def SetPageImage(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_SetPageImage,(self,) + _args, _kwargs)
         return val
-    def GetRowCount(self):
-        val = windows2c.wxNotebook_GetRowCount(self.this)
+    def GetRowCount(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_GetRowCount,(self,) + _args, _kwargs)
         return val
-    def DeletePage(self,arg0):
-        val = windows2c.wxNotebook_DeletePage(self.this,arg0)
+    def DeletePage(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_DeletePage,(self,) + _args, _kwargs)
         return val
-    def RemovePage(self,arg0):
-        val = windows2c.wxNotebook_RemovePage(self.this,arg0)
+    def RemovePage(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_RemovePage,(self,) + _args, _kwargs)
         return val
-    def DeleteAllPages(self):
-        val = windows2c.wxNotebook_DeleteAllPages(self.this)
+    def DeleteAllPages(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_DeleteAllPages,(self,) + _args, _kwargs)
         return val
-    def AddPage(self,arg0,arg1,*args):
-        val = apply(windows2c.wxNotebook_AddPage,(self.this,arg0.this,arg1,)+args)
+    def AddPage(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_AddPage,(self,) + _args, _kwargs)
         return val
-    def GetPage(self,arg0):
-        val = windows2c.wxNotebook_GetPage(self.this,arg0)
-        val = wxWindowPtr(val)
+    def GetPage(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_GetPage,(self,) + _args, _kwargs)
+        if val: val = wxWindowPtr(val) 
         return val
-    def ResizeChildren(self):
-        val = windows2c.wxNotebook_ResizeChildren(self.this)
+    def ResizeChildren(self, *_args, **_kwargs):
+        val = apply(windows2c.wxNotebook_ResizeChildren,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxNotebook instance>"
+        return "<C wxNotebook instance at %s>" % (self.this,)
 class wxNotebook(wxNotebookPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows2c.new_wxNotebook,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(windows2c.new_wxNotebook,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
 
@@ -494,24 +480,24 @@ class wxSplitterEventPtr(wxCommandEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetSashPosition(self):
-        val = windows2c.wxSplitterEvent_GetSashPosition(self.this)
+    def GetSashPosition(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterEvent_GetSashPosition,(self,) + _args, _kwargs)
         return val
-    def GetX(self):
-        val = windows2c.wxSplitterEvent_GetX(self.this)
+    def GetX(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterEvent_GetX,(self,) + _args, _kwargs)
         return val
-    def GetY(self):
-        val = windows2c.wxSplitterEvent_GetY(self.this)
+    def GetY(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterEvent_GetY,(self,) + _args, _kwargs)
         return val
-    def GetWindowBeingRemoved(self):
-        val = windows2c.wxSplitterEvent_GetWindowBeingRemoved(self.this)
-        val = wxWindowPtr(val)
+    def GetWindowBeingRemoved(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterEvent_GetWindowBeingRemoved,(self,) + _args, _kwargs)
+        if val: val = wxWindowPtr(val) 
         return val
-    def SetSashPosition(self,arg0):
-        val = windows2c.wxSplitterEvent_SetSashPosition(self.this,arg0)
+    def SetSashPosition(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterEvent_SetSashPosition,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxSplitterEvent instance>"
+        return "<C wxSplitterEvent instance at %s>" % (self.this,)
 class wxSplitterEvent(wxSplitterEventPtr):
     def __init__(self,this):
         self.this = this
@@ -523,74 +509,64 @@ class wxSplitterWindowPtr(wxWindowPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetBorderSize(self):
-        val = windows2c.wxSplitterWindow_GetBorderSize(self.this)
+    def GetBorderSize(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_GetBorderSize,(self,) + _args, _kwargs)
         return val
-    def GetMinimumPaneSize(self):
-        val = windows2c.wxSplitterWindow_GetMinimumPaneSize(self.this)
+    def GetMinimumPaneSize(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_GetMinimumPaneSize,(self,) + _args, _kwargs)
         return val
-    def GetSashPosition(self):
-        val = windows2c.wxSplitterWindow_GetSashPosition(self.this)
+    def GetSashPosition(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_GetSashPosition,(self,) + _args, _kwargs)
         return val
-    def GetSashSize(self):
-        val = windows2c.wxSplitterWindow_GetSashSize(self.this)
+    def GetSashSize(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_GetSashSize,(self,) + _args, _kwargs)
         return val
-    def GetSplitMode(self):
-        val = windows2c.wxSplitterWindow_GetSplitMode(self.this)
+    def GetSplitMode(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_GetSplitMode,(self,) + _args, _kwargs)
         return val
-    def GetWindow1(self):
-        val = windows2c.wxSplitterWindow_GetWindow1(self.this)
-        val = wxWindowPtr(val)
+    def GetWindow1(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_GetWindow1,(self,) + _args, _kwargs)
+        if val: val = wxWindowPtr(val) 
         return val
-    def GetWindow2(self):
-        val = windows2c.wxSplitterWindow_GetWindow2(self.this)
-        val = wxWindowPtr(val)
+    def GetWindow2(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_GetWindow2,(self,) + _args, _kwargs)
+        if val: val = wxWindowPtr(val) 
         return val
-    def Initialize(self,arg0):
-        val = windows2c.wxSplitterWindow_Initialize(self.this,arg0.this)
+    def Initialize(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_Initialize,(self,) + _args, _kwargs)
         return val
-    def IsSplit(self):
-        val = windows2c.wxSplitterWindow_IsSplit(self.this)
+    def IsSplit(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_IsSplit,(self,) + _args, _kwargs)
         return val
-    def SetBorderSize(self,arg0):
-        val = windows2c.wxSplitterWindow_SetBorderSize(self.this,arg0)
+    def SetBorderSize(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_SetBorderSize,(self,) + _args, _kwargs)
         return val
-    def SetSashPosition(self,arg0,*args):
-        val = apply(windows2c.wxSplitterWindow_SetSashPosition,(self.this,arg0,)+args)
+    def SetSashPosition(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_SetSashPosition,(self,) + _args, _kwargs)
         return val
-    def SetSashSize(self,arg0):
-        val = windows2c.wxSplitterWindow_SetSashSize(self.this,arg0)
+    def SetSashSize(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_SetSashSize,(self,) + _args, _kwargs)
         return val
-    def SetMinimumPaneSize(self,arg0):
-        val = windows2c.wxSplitterWindow_SetMinimumPaneSize(self.this,arg0)
+    def SetMinimumPaneSize(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_SetMinimumPaneSize,(self,) + _args, _kwargs)
         return val
-    def SetSplitMode(self,arg0):
-        val = windows2c.wxSplitterWindow_SetSplitMode(self.this,arg0)
+    def SetSplitMode(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_SetSplitMode,(self,) + _args, _kwargs)
         return val
-    def SplitHorizontally(self,arg0,arg1,*args):
-        val = apply(windows2c.wxSplitterWindow_SplitHorizontally,(self.this,arg0.this,arg1.this,)+args)
+    def SplitHorizontally(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_SplitHorizontally,(self,) + _args, _kwargs)
         return val
-    def SplitVertically(self,arg0,arg1,*args):
-        val = apply(windows2c.wxSplitterWindow_SplitVertically,(self.this,arg0.this,arg1.this,)+args)
+    def SplitVertically(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_SplitVertically,(self,) + _args, _kwargs)
         return val
-    def Unsplit(self,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows2c.wxSplitterWindow_Unsplit,(self.this,)+args)
+    def Unsplit(self, *_args, **_kwargs):
+        val = apply(windows2c.wxSplitterWindow_Unsplit,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxSplitterWindow instance>"
+        return "<C wxSplitterWindow instance at %s>" % (self.this,)
 class wxSplitterWindow(wxSplitterWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows2c.new_wxSplitterWindow,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(windows2c.new_wxSplitterWindow,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
 

utils/wxPython/src/gtk/windows3.py

@@ -23,28 +23,27 @@ class wxSashEventPtr(wxCommandEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def SetEdge(self,arg0):
-        val = windows3c.wxSashEvent_SetEdge(self.this,arg0)
+    def SetEdge(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashEvent_SetEdge,(self,) + _args, _kwargs)
         return val
-    def GetEdge(self):
-        val = windows3c.wxSashEvent_GetEdge(self.this)
+    def GetEdge(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashEvent_GetEdge,(self,) + _args, _kwargs)
         return val
-    def SetDragRect(self,arg0):
-        val = windows3c.wxSashEvent_SetDragRect(self.this,arg0.this)
+    def SetDragRect(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashEvent_SetDragRect,(self,) + _args, _kwargs)
         return val
-    def GetDragRect(self):
-        val = windows3c.wxSashEvent_GetDragRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
+    def GetDragRect(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashEvent_GetDragRect,(self,) + _args, _kwargs)
+        if val: val = wxRectPtr(val) ; val.thisown = 1
         return val
-    def SetDragStatus(self,arg0):
-        val = windows3c.wxSashEvent_SetDragStatus(self.this,arg0)
+    def SetDragStatus(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashEvent_SetDragStatus,(self,) + _args, _kwargs)
         return val
-    def GetDragStatus(self):
-        val = windows3c.wxSashEvent_GetDragStatus(self.this)
+    def GetDragStatus(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashEvent_GetDragStatus,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxSashEvent instance>"
+        return "<C wxSashEvent instance at %s>" % (self.this,)
 class wxSashEvent(wxSashEventPtr):
     def __init__(self,this):
         self.this = this
@@ -56,68 +55,62 @@ class wxSashWindowPtr(wxWindowPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetSashVisible(self,arg0):
-        val = windows3c.wxSashWindow_GetSashVisible(self.this,arg0)
+    def GetSashVisible(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_GetSashVisible,(self,) + _args, _kwargs)
         return val
-    def GetDefaultBorderSize(self):
-        val = windows3c.wxSashWindow_GetDefaultBorderSize(self.this)
+    def GetDefaultBorderSize(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_GetDefaultBorderSize,(self,) + _args, _kwargs)
         return val
-    def GetEdgeMargin(self,arg0):
-        val = windows3c.wxSashWindow_GetEdgeMargin(self.this,arg0)
+    def GetEdgeMargin(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_GetEdgeMargin,(self,) + _args, _kwargs)
         return val
-    def GetExtraBorderSize(self):
-        val = windows3c.wxSashWindow_GetExtraBorderSize(self.this)
+    def GetExtraBorderSize(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_GetExtraBorderSize,(self,) + _args, _kwargs)
         return val
-    def GetMaximumSizeX(self):
-        val = windows3c.wxSashWindow_GetMaximumSizeX(self.this)
+    def GetMaximumSizeX(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_GetMaximumSizeX,(self,) + _args, _kwargs)
         return val
-    def GetMaximumSizeY(self):
-        val = windows3c.wxSashWindow_GetMaximumSizeY(self.this)
+    def GetMaximumSizeY(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_GetMaximumSizeY,(self,) + _args, _kwargs)
         return val
-    def GetMinimumSizeX(self):
-        val = windows3c.wxSashWindow_GetMinimumSizeX(self.this)
+    def GetMinimumSizeX(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_GetMinimumSizeX,(self,) + _args, _kwargs)
         return val
-    def GetMinimumSizeY(self):
-        val = windows3c.wxSashWindow_GetMinimumSizeY(self.this)
+    def GetMinimumSizeY(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_GetMinimumSizeY,(self,) + _args, _kwargs)
         return val
-    def HasBorder(self,arg0):
-        val = windows3c.wxSashWindow_HasBorder(self.this,arg0)
+    def HasBorder(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_HasBorder,(self,) + _args, _kwargs)
         return val
-    def SetDefaultBorderSize(self,arg0):
-        val = windows3c.wxSashWindow_SetDefaultBorderSize(self.this,arg0)
+    def SetDefaultBorderSize(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_SetDefaultBorderSize,(self,) + _args, _kwargs)
         return val
-    def SetExtraBorderSize(self,arg0):
-        val = windows3c.wxSashWindow_SetExtraBorderSize(self.this,arg0)
+    def SetExtraBorderSize(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_SetExtraBorderSize,(self,) + _args, _kwargs)
         return val
-    def SetMaximumSizeX(self,arg0):
-        val = windows3c.wxSashWindow_SetMaximumSizeX(self.this,arg0)
+    def SetMaximumSizeX(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_SetMaximumSizeX,(self,) + _args, _kwargs)
         return val
-    def SetMaximumSizeY(self,arg0):
-        val = windows3c.wxSashWindow_SetMaximumSizeY(self.this,arg0)
+    def SetMaximumSizeY(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_SetMaximumSizeY,(self,) + _args, _kwargs)
         return val
-    def SetMinimumSizeX(self,arg0):
-        val = windows3c.wxSashWindow_SetMinimumSizeX(self.this,arg0)
+    def SetMinimumSizeX(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_SetMinimumSizeX,(self,) + _args, _kwargs)
         return val
-    def SetMinimumSizeY(self,arg0):
-        val = windows3c.wxSashWindow_SetMinimumSizeY(self.this,arg0)
+    def SetMinimumSizeY(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_SetMinimumSizeY,(self,) + _args, _kwargs)
         return val
-    def SetSashVisible(self,arg0,arg1):
-        val = windows3c.wxSashWindow_SetSashVisible(self.this,arg0,arg1)
+    def SetSashVisible(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_SetSashVisible,(self,) + _args, _kwargs)
         return val
-    def SetSashBorder(self,arg0,arg1):
-        val = windows3c.wxSashWindow_SetSashBorder(self.this,arg0,arg1)
+    def SetSashBorder(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashWindow_SetSashBorder,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxSashWindow instance>"
+        return "<C wxSashWindow instance at %s>" % (self.this,)
 class wxSashWindow(wxSashWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows3c.new_wxSashWindow,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(windows3c.new_wxSashWindow,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
 
@@ -128,40 +121,39 @@ class wxQueryLayoutInfoEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def SetRequestedLength(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetRequestedLength(self.this,arg0)
+    def SetRequestedLength(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_SetRequestedLength,(self,) + _args, _kwargs)
         return val
-    def GetRequestedLength(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetRequestedLength(self.this)
+    def GetRequestedLength(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_GetRequestedLength,(self,) + _args, _kwargs)
         return val
-    def SetFlags(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetFlags(self.this,arg0)
+    def SetFlags(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_SetFlags,(self,) + _args, _kwargs)
         return val
-    def GetFlags(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetFlags(self.this)
+    def GetFlags(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_GetFlags,(self,) + _args, _kwargs)
         return val
-    def SetSize(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetSize(self.this,arg0.this)
+    def SetSize(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_SetSize,(self,) + _args, _kwargs)
         return val
-    def GetSize(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
+    def GetSize(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_GetSize,(self,) + _args, _kwargs)
+        if val: val = wxSizePtr(val) ; val.thisown = 1
         return val
-    def SetOrientation(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetOrientation(self.this,arg0)
+    def SetOrientation(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_SetOrientation,(self,) + _args, _kwargs)
         return val
-    def GetOrientation(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetOrientation(self.this)
+    def GetOrientation(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_GetOrientation,(self,) + _args, _kwargs)
         return val
-    def SetAlignment(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetAlignment(self.this,arg0)
+    def SetAlignment(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_SetAlignment,(self,) + _args, _kwargs)
         return val
-    def GetAlignment(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetAlignment(self.this)
+    def GetAlignment(self, *_args, **_kwargs):
+        val = apply(windows3c.wxQueryLayoutInfoEvent_GetAlignment,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxQueryLayoutInfoEvent instance>"
+        return "<C wxQueryLayoutInfoEvent instance at %s>" % (self.this,)
 class wxQueryLayoutInfoEvent(wxQueryLayoutInfoEventPtr):
     def __init__(self,this):
         self.this = this
@@ -173,22 +165,21 @@ class wxCalculateLayoutEventPtr(wxEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def SetFlags(self,arg0):
-        val = windows3c.wxCalculateLayoutEvent_SetFlags(self.this,arg0)
+    def SetFlags(self, *_args, **_kwargs):
+        val = apply(windows3c.wxCalculateLayoutEvent_SetFlags,(self,) + _args, _kwargs)
         return val
-    def GetFlags(self):
-        val = windows3c.wxCalculateLayoutEvent_GetFlags(self.this)
+    def GetFlags(self, *_args, **_kwargs):
+        val = apply(windows3c.wxCalculateLayoutEvent_GetFlags,(self,) + _args, _kwargs)
         return val
-    def SetRect(self,arg0):
-        val = windows3c.wxCalculateLayoutEvent_SetRect(self.this,arg0.this)
+    def SetRect(self, *_args, **_kwargs):
+        val = apply(windows3c.wxCalculateLayoutEvent_SetRect,(self,) + _args, _kwargs)
         return val
-    def GetRect(self):
-        val = windows3c.wxCalculateLayoutEvent_GetRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
+    def GetRect(self, *_args, **_kwargs):
+        val = apply(windows3c.wxCalculateLayoutEvent_GetRect,(self,) + _args, _kwargs)
+        if val: val = wxRectPtr(val) ; val.thisown = 1
         return val
     def __repr__(self):
-        return "<C wxCalculateLayoutEvent instance>"
+        return "<C wxCalculateLayoutEvent instance at %s>" % (self.this,)
 class wxCalculateLayoutEvent(wxCalculateLayoutEventPtr):
     def __init__(self,this):
         self.this = this
@@ -200,32 +191,26 @@ class wxSashLayoutWindowPtr(wxSashWindowPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetAlignment(self):
-        val = windows3c.wxSashLayoutWindow_GetAlignment(self.this)
+    def GetAlignment(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashLayoutWindow_GetAlignment,(self,) + _args, _kwargs)
         return val
-    def GetOrientation(self):
-        val = windows3c.wxSashLayoutWindow_GetOrientation(self.this)
+    def GetOrientation(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashLayoutWindow_GetOrientation,(self,) + _args, _kwargs)
         return val
-    def SetAlignment(self,arg0):
-        val = windows3c.wxSashLayoutWindow_SetAlignment(self.this,arg0)
+    def SetAlignment(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashLayoutWindow_SetAlignment,(self,) + _args, _kwargs)
         return val
-    def SetDefaultSize(self,arg0):
-        val = windows3c.wxSashLayoutWindow_SetDefaultSize(self.this,arg0.this)
+    def SetDefaultSize(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashLayoutWindow_SetDefaultSize,(self,) + _args, _kwargs)
         return val
-    def SetOrientation(self,arg0):
-        val = windows3c.wxSashLayoutWindow_SetOrientation(self.this,arg0)
+    def SetOrientation(self, *_args, **_kwargs):
+        val = apply(windows3c.wxSashLayoutWindow_SetOrientation,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxSashLayoutWindow instance>"
+        return "<C wxSashLayoutWindow instance at %s>" % (self.this,)
 class wxSashLayoutWindow(wxSashLayoutWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows3c.new_wxSashLayoutWindow,(arg0.this,arg1,)+args)
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(windows3c.new_wxSashLayoutWindow,_args,_kwargs)
         self.thisown = 1
         wx._StdWindowCallbacks(self)
         wx._checkForCallback(self, 'OnCalculateLayout',    wxEVT_CALCULATE_LAYOUT)
@@ -238,35 +223,23 @@ class wxLayoutAlgorithmPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, windows3c=windows3c):
+    def __del__(self,windows3c=windows3c):
         if self.thisown == 1 :
-            windows3c.delete_wxLayoutAlgorithm(self.this)
-    def LayoutMDIFrame(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows3c.wxLayoutAlgorithm_LayoutMDIFrame,(self.this,arg0.this,)+args)
+            windows3c.delete_wxLayoutAlgorithm(self)
+    def LayoutMDIFrame(self, *_args, **_kwargs):
+        val = apply(windows3c.wxLayoutAlgorithm_LayoutMDIFrame,(self,) + _args, _kwargs)
         return val
-    def LayoutFrame(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows3c.wxLayoutAlgorithm_LayoutFrame,(self.this,arg0.this,)+args)
+    def LayoutFrame(self, *_args, **_kwargs):
+        val = apply(windows3c.wxLayoutAlgorithm_LayoutFrame,(self,) + _args, _kwargs)
         return val
-    def LayoutWindow(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows3c.wxLayoutAlgorithm_LayoutWindow,(self.this,arg0.this,)+args)
+    def LayoutWindow(self, *_args, **_kwargs):
+        val = apply(windows3c.wxLayoutAlgorithm_LayoutWindow,(self,) + _args, _kwargs)
         return val
     def __repr__(self):
-        return "<C wxLayoutAlgorithm instance>"
+        return "<C wxLayoutAlgorithm instance at %s>" % (self.this,)
 class wxLayoutAlgorithm(wxLayoutAlgorithmPtr):
-    def __init__(self) :
-        self.this = windows3c.new_wxLayoutAlgorithm()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(windows3c.new_wxLayoutAlgorithm,_args,_kwargs)
         self.thisown = 1
 
 

utils/wxPython/src/gtk/wx.py

@@ -34,74 +34,73 @@ class wxPyAppPtr(wxEvtHandlerPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, wxc=wxc):
+    def __del__(self,wxc=wxc):
         if self.thisown == 1 :
-            wxc.delete_wxPyApp(self.this)
-    def GetAppName(self):
-        val = wxc.wxPyApp_GetAppName(self.this)
+            wxc.delete_wxPyApp(self)
+    def GetAppName(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_GetAppName,(self,) + _args, _kwargs)
         return val
-    def GetClassName(self):
-        val = wxc.wxPyApp_GetClassName(self.this)
+    def GetClassName(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_GetClassName,(self,) + _args, _kwargs)
         return val
-    def GetExitOnFrameDelete(self):
-        val = wxc.wxPyApp_GetExitOnFrameDelete(self.this)
+    def GetExitOnFrameDelete(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_GetExitOnFrameDelete,(self,) + _args, _kwargs)
         return val
-    def GetPrintMode(self):
-        val = wxc.wxPyApp_GetPrintMode(self.this)
+    def GetPrintMode(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_GetPrintMode,(self,) + _args, _kwargs)
         return val
-    def GetTopWindow(self):
-        val = wxc.wxPyApp_GetTopWindow(self.this)
-        val = wxWindowPtr(val)
+    def GetTopWindow(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_GetTopWindow,(self,) + _args, _kwargs)
+        if val: val = wxWindowPtr(val) 
         return val
-    def GetVendorName(self):
-        val = wxc.wxPyApp_GetVendorName(self.this)
+    def GetVendorName(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_GetVendorName,(self,) + _args, _kwargs)
         return val
-    def Dispatch(self):
-        val = wxc.wxPyApp_Dispatch(self.this)
+    def Dispatch(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_Dispatch,(self,) + _args, _kwargs)
         return val
-    def ExitMainLoop(self):
-        val = wxc.wxPyApp_ExitMainLoop(self.this)
+    def ExitMainLoop(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_ExitMainLoop,(self,) + _args, _kwargs)
         return val
-    def Initialized(self):
-        val = wxc.wxPyApp_Initialized(self.this)
+    def Initialized(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_Initialized,(self,) + _args, _kwargs)
         return val
-    def MainLoop(self):
-        val = wxc.wxPyApp_MainLoop(self.this)
+    def MainLoop(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_MainLoop,(self,) + _args, _kwargs)
         return val
-    def Pending(self):
-        val = wxc.wxPyApp_Pending(self.this)
+    def Pending(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_Pending,(self,) + _args, _kwargs)
         return val
-    def ProcessIdle(self):
-        val = wxc.wxPyApp_ProcessIdle(self.this)
+    def ProcessIdle(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_ProcessIdle,(self,) + _args, _kwargs)
         return val
-    def SetAppName(self,arg0):
-        val = wxc.wxPyApp_SetAppName(self.this,arg0)
+    def SetAppName(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_SetAppName,(self,) + _args, _kwargs)
         return val
-    def SetClassName(self,arg0):
-        val = wxc.wxPyApp_SetClassName(self.this,arg0)
+    def SetClassName(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_SetClassName,(self,) + _args, _kwargs)
         return val
-    def SetExitOnFrameDelete(self,arg0):
-        val = wxc.wxPyApp_SetExitOnFrameDelete(self.this,arg0)
+    def SetExitOnFrameDelete(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_SetExitOnFrameDelete,(self,) + _args, _kwargs)
         return val
-    def SetPrintMode(self,arg0):
-        val = wxc.wxPyApp_SetPrintMode(self.this,arg0)
+    def SetPrintMode(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_SetPrintMode,(self,) + _args, _kwargs)
         return val
-    def SetTopWindow(self,arg0):
-        val = wxc.wxPyApp_SetTopWindow(self.this,arg0.this)
+    def SetTopWindow(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_SetTopWindow,(self,) + _args, _kwargs)
         return val
-    def SetVendorName(self,arg0):
-        val = wxc.wxPyApp_SetVendorName(self.this,arg0)
+    def SetVendorName(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_SetVendorName,(self,) + _args, _kwargs)
         return val
-    def GetStdIcon(self,arg0):
-        val = wxc.wxPyApp_GetStdIcon(self.this,arg0)
-        val = wxIconPtr(val)
-        val.thisown = 1
+    def GetStdIcon(self, *_args, **_kwargs):
+        val = apply(wxc.wxPyApp_GetStdIcon,(self,) + _args, _kwargs)
+        if val: val = wxIconPtr(val) ; val.thisown = 1
         return val
     def __repr__(self):
-        return "<C wxPyApp instance>"
+        return "<C wxPyApp instance at %s>" % (self.this,)
 class wxPyApp(wxPyAppPtr):
-    def __init__(self) :
-        self.this = wxc.new_wxPyApp()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(wxc.new_wxPyApp,_args,_kwargs)
         self.thisown = 1
 
 
@@ -111,14 +110,14 @@ class __wxPyCleanupPtr :
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def __del__(self, wxc=wxc):
+    def __del__(self,wxc=wxc):
         if self.thisown == 1 :
-            wxc.delete___wxPyCleanup(self.this)
+            wxc.delete___wxPyCleanup(self)
     def __repr__(self):
-        return "<C __wxPyCleanup instance>"
+        return "<C __wxPyCleanup instance at %s>" % (self.this,)
 class __wxPyCleanup(__wxPyCleanupPtr):
-    def __init__(self) :
-        self.this = wxc.new___wxPyCleanup()
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(wxc.new___wxPyCleanup,_args,_kwargs)
         self.thisown = 1