diff --git a/wxPython/CHANGES.txt b/wxPython/CHANGES.txt index da2b1f0198..e49519f938 100644 --- a/wxPython/CHANGES.txt +++ b/wxPython/CHANGES.txt @@ -7,7 +7,7 @@ New in 2.2.0 Added wxLog and friends. -Added wxFrame.ShowFullScreen. +Added wxFrame.ShowFullScreen for MSW. diff --git a/wxPython/src/frames.i b/wxPython/src/frames.i index 86d11375d9..cf4ee91b1b 100644 --- a/wxPython/src/frames.i +++ b/wxPython/src/frames.i @@ -85,8 +85,9 @@ public: wxPoint GetClientAreaOrigin() const; bool Command(int id); bool ProcessCommand(int id); - +#ifdef __WXMSW__ bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL); +#endif }; //--------------------------------------------------------------------------- diff --git a/wxPython/src/gtk/events.cpp b/wxPython/src/gtk/events.cpp index 6a9b8df560..6f136bae90 100644 --- a/wxPython/src/gtk/events.cpp +++ b/wxPython/src/gtk/events.cpp @@ -2345,6 +2345,60 @@ static PyObject *_wrap_wxKeyEvent_KeyCode(PyObject *self, PyObject *args, PyObje return _resultobj; } +#define wxKeyEvent_GetKeyCode(_swigobj) (_swigobj->GetKeyCode()) +static PyObject *_wrap_wxKeyEvent_GetKeyCode(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + long _result; + wxKeyEvent * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxKeyEvent_GetKeyCode",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxKeyEvent_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxKeyEvent_GetKeyCode. Expected _wxKeyEvent_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxKeyEvent_GetKeyCode(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); + return _resultobj; +} + +#define wxKeyEvent_HasModifiers(_swigobj) (_swigobj->HasModifiers()) +static PyObject *_wrap_wxKeyEvent_HasModifiers(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + bool _result; + wxKeyEvent * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxKeyEvent_HasModifiers",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxKeyEvent_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxKeyEvent_HasModifiers. Expected _wxKeyEvent_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxKeyEvent_HasModifiers(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + #define wxKeyEvent_GetX(_swigobj) (_swigobj->GetX()) static PyObject *_wrap_wxKeyEvent_GetX(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; @@ -5105,6 +5159,8 @@ static PyMethodDef eventscMethods[] = { { "wxKeyEvent_GetPosition", (PyCFunction) _wrap_wxKeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS }, { "wxKeyEvent_GetY", (PyCFunction) _wrap_wxKeyEvent_GetY, METH_VARARGS | METH_KEYWORDS }, { "wxKeyEvent_GetX", (PyCFunction) _wrap_wxKeyEvent_GetX, METH_VARARGS | METH_KEYWORDS }, + { "wxKeyEvent_HasModifiers", (PyCFunction) _wrap_wxKeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS }, + { "wxKeyEvent_GetKeyCode", (PyCFunction) _wrap_wxKeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS }, { "wxKeyEvent_KeyCode", (PyCFunction) _wrap_wxKeyEvent_KeyCode, METH_VARARGS | METH_KEYWORDS }, { "wxKeyEvent_ShiftDown", (PyCFunction) _wrap_wxKeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS }, { "wxKeyEvent_AltDown", (PyCFunction) _wrap_wxKeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS }, diff --git a/wxPython/src/gtk/events.py b/wxPython/src/gtk/events.py index 26fc37001f..e5ca31ceb0 100644 --- a/wxPython/src/gtk/events.py +++ b/wxPython/src/gtk/events.py @@ -324,6 +324,12 @@ class wxKeyEventPtr(wxEventPtr): def KeyCode(self, *_args, **_kwargs): val = apply(eventsc.wxKeyEvent_KeyCode,(self,) + _args, _kwargs) return val + def GetKeyCode(self, *_args, **_kwargs): + val = apply(eventsc.wxKeyEvent_GetKeyCode,(self,) + _args, _kwargs) + return val + def HasModifiers(self, *_args, **_kwargs): + val = apply(eventsc.wxKeyEvent_HasModifiers,(self,) + _args, _kwargs) + return val def GetX(self, *_args, **_kwargs): val = apply(eventsc.wxKeyEvent_GetX,(self,) + _args, _kwargs) return val diff --git a/wxPython/src/gtk/frames.cpp b/wxPython/src/gtk/frames.cpp index 5b4e4c8ac8..499118ba6a 100644 --- a/wxPython/src/gtk/frames.cpp +++ b/wxPython/src/gtk/frames.cpp @@ -1174,6 +1174,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_wxPrintQuality","_EBool",0}, { "_wxPrintQuality","_size_t",0}, { "_class_wxCustomDataObject","_wxCustomDataObject",0}, + { "_wxSpinCtrl","_class_wxSpinCtrl",0}, { "_class_wxRegionIterator","_wxRegionIterator",0}, { "_class_wxPyTextDropTarget","_wxPyTextDropTarget",0}, { "_class_wxMenuBar","_wxMenuBar",0}, @@ -1260,6 +1261,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_wxPoint","_class_wxPoint",0}, { "_class_wxButton","_wxButton",0}, { "_wxRadioBox","_class_wxRadioBox",0}, + { "_class_wxSpinCtrl","_wxSpinCtrl",0}, { "_char","_wxChar",0}, { "_wxBitmap","_class_wxBitmap",0}, { "_wxWindowDC","_class_wxWindowDC",0}, @@ -1494,6 +1496,12 @@ SWIGEXPORT(void) initframesc() { SWIG_globals = SWIG_newvarlink(); m = Py_InitModule("framesc", framescMethods); d = PyModule_GetDict(m); + PyDict_SetItemString(d,"wxFULLSCREEN_NOMENUBAR", PyInt_FromLong((long) wxFULLSCREEN_NOMENUBAR)); + PyDict_SetItemString(d,"wxFULLSCREEN_NOTOOLBAR", PyInt_FromLong((long) wxFULLSCREEN_NOTOOLBAR)); + PyDict_SetItemString(d,"wxFULLSCREEN_NOSTATUSBAR", PyInt_FromLong((long) wxFULLSCREEN_NOSTATUSBAR)); + PyDict_SetItemString(d,"wxFULLSCREEN_NOBORDER", PyInt_FromLong((long) wxFULLSCREEN_NOBORDER)); + PyDict_SetItemString(d,"wxFULLSCREEN_NOCAPTION", PyInt_FromLong((long) wxFULLSCREEN_NOCAPTION)); + PyDict_SetItemString(d,"wxFULLSCREEN_ALL", PyInt_FromLong((long) wxFULLSCREEN_ALL)); { int i; for (i = 0; _swig_mapping[i].n1; i++) diff --git a/wxPython/src/gtk/frames.py b/wxPython/src/gtk/frames.py index e97dd119a9..33ec02f388 100644 --- a/wxPython/src/gtk/frames.py +++ b/wxPython/src/gtk/frames.py @@ -135,3 +135,9 @@ class wxMiniFrame(wxMiniFramePtr): #-------------- VARIABLE WRAPPERS ------------------ +wxFULLSCREEN_NOMENUBAR = framesc.wxFULLSCREEN_NOMENUBAR +wxFULLSCREEN_NOTOOLBAR = framesc.wxFULLSCREEN_NOTOOLBAR +wxFULLSCREEN_NOSTATUSBAR = framesc.wxFULLSCREEN_NOSTATUSBAR +wxFULLSCREEN_NOBORDER = framesc.wxFULLSCREEN_NOBORDER +wxFULLSCREEN_NOCAPTION = framesc.wxFULLSCREEN_NOCAPTION +wxFULLSCREEN_ALL = framesc.wxFULLSCREEN_ALL diff --git a/wxPython/src/gtk/gdi.cpp b/wxPython/src/gtk/gdi.cpp index b8bc7f77cf..e46c1a0c3f 100644 --- a/wxPython/src/gtk/gdi.cpp +++ b/wxPython/src/gtk/gdi.cpp @@ -7213,7 +7213,56 @@ static PyObject *_wrap_wxImageList_RemoveAll(PyObject *self, PyObject *args, PyO return _resultobj; } +#define wxImageList_GetSize(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->GetSize(_swigarg0,_swigarg1,_swigarg2)) +static PyObject *_wrap_wxImageList_GetSize(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxImageList * _arg0; + int _arg1; + int * _arg2; + int temp; + int * _arg3; + int temp0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self","index", NULL }; + + self = self; +{ + _arg2 = &temp; +} +{ + _arg3 = &temp0; +} + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxImageList_GetSize",_kwnames,&_argo0,&_arg1)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageList_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageList_GetSize. Expected _wxImageList_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImageList_GetSize(_arg0,_arg1,*_arg2,*_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; +{ + PyObject *o; + o = PyInt_FromLong((long) (*_arg2)); + _resultobj = t_output_helper(_resultobj, o); +} +{ + PyObject *o; + o = PyInt_FromLong((long) (*_arg3)); + _resultobj = t_output_helper(_resultobj, o); +} + return _resultobj; +} + static PyMethodDef gdicMethods[] = { + { "wxImageList_GetSize", (PyCFunction) _wrap_wxImageList_GetSize, METH_VARARGS | METH_KEYWORDS }, { "wxImageList_RemoveAll", (PyCFunction) _wrap_wxImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS }, { "wxImageList_Remove", (PyCFunction) _wrap_wxImageList_Remove, METH_VARARGS | METH_KEYWORDS }, { "wxImageList_GetImageCount", (PyCFunction) _wrap_wxImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS }, diff --git a/wxPython/src/gtk/gdi.py b/wxPython/src/gtk/gdi.py index 76a3988a86..cd1d2386c7 100644 --- a/wxPython/src/gtk/gdi.py +++ b/wxPython/src/gtk/gdi.py @@ -779,6 +779,9 @@ class wxImageListPtr : def RemoveAll(self, *_args, **_kwargs): val = apply(gdic.wxImageList_RemoveAll,(self,) + _args, _kwargs) return val + def GetSize(self, *_args, **_kwargs): + val = apply(gdic.wxImageList_GetSize,(self,) + _args, _kwargs) + return val def __repr__(self): return "" % (self.this,) class wxImageList(wxImageListPtr): diff --git a/wxPython/src/gtk/grid.cpp b/wxPython/src/gtk/grid.cpp index b1141a155f..fba92308fd 100644 --- a/wxPython/src/gtk/grid.cpp +++ b/wxPython/src/gtk/grid.cpp @@ -646,6 +646,7 @@ public: DEC_PYCALLBACK___pure(Reset); DEC_PYCALLBACK__constany(SetSize, wxRect); + DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent); DEC_PYCALLBACK__any(StartingKey, wxKeyEvent); DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent); DEC_PYCALLBACK__(StartingClick); @@ -659,6 +660,7 @@ public: IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters); IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset); IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect); +IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent); IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent); IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent); IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick); @@ -898,6 +900,60 @@ static PyObject *_wrap_wxGridCellRenderer_SetParameters(PyObject *self, PyObject return _resultobj; } +#define wxGridCellRenderer_IncRef(_swigobj) (_swigobj->IncRef()) +static PyObject *_wrap_wxGridCellRenderer_IncRef(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxGridCellRenderer * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_IncRef",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_IncRef. Expected _wxGridCellRenderer_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCellRenderer_IncRef(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGridCellRenderer_DecRef(_swigobj) (_swigobj->DecRef()) +static PyObject *_wrap_wxGridCellRenderer_DecRef(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxGridCellRenderer * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_DecRef",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_DecRef. Expected _wxGridCellRenderer_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCellRenderer_DecRef(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + #define wxGridCellRenderer_Draw(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (_swigobj->Draw(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6)) static PyObject *_wrap_wxGridCellRenderer_Draw(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; @@ -1564,6 +1620,60 @@ static PyObject *_wrap_wxGridCellEditor_SetParameters(PyObject *self, PyObject * return _resultobj; } +#define wxGridCellEditor_IncRef(_swigobj) (_swigobj->IncRef()) +static PyObject *_wrap_wxGridCellEditor_IncRef(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxGridCellEditor * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_IncRef",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_IncRef. Expected _wxGridCellEditor_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCellEditor_IncRef(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGridCellEditor_DecRef(_swigobj) (_swigobj->DecRef()) +static PyObject *_wrap_wxGridCellEditor_DecRef(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxGridCellEditor * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_DecRef",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_DecRef. Expected _wxGridCellEditor_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCellEditor_DecRef(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + #define wxGridCellEditor_Create(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->Create(_swigarg0,_swigarg1,_swigarg2)) static PyObject *_wrap_wxGridCellEditor_Create(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; @@ -1865,6 +1975,42 @@ static PyObject *_wrap_wxGridCellEditor_PaintBackground(PyObject *self, PyObject return _resultobj; } +#define wxGridCellEditor_IsAcceptedKey(_swigobj,_swigarg0) (_swigobj->IsAcceptedKey(_swigarg0)) +static PyObject *_wrap_wxGridCellEditor_IsAcceptedKey(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + bool _result; + wxGridCellEditor * _arg0; + wxKeyEvent * _arg1; + PyObject * _argo0 = 0; + PyObject * _argo1 = 0; + char *_kwnames[] = { "self","event", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_IsAcceptedKey",_kwnames,&_argo0,&_argo1)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_IsAcceptedKey. Expected _wxGridCellEditor_p."); + return NULL; + } + } + if (_argo1) { + if (_argo1 == Py_None) { _arg1 = NULL; } + else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_IsAcceptedKey. Expected _wxKeyEvent_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGridCellEditor_IsAcceptedKey(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + #define wxGridCellEditor_StartingKey(_swigobj,_swigarg0) (_swigobj->StartingKey(_swigarg0)) static PyObject *_wrap_wxGridCellEditor_StartingKey(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; @@ -12603,6 +12749,7 @@ static PyMethodDef gridcMethods[] = { { "wxGridCellEditor_HandleReturn", (PyCFunction) _wrap_wxGridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_StartingClick", (PyCFunction) _wrap_wxGridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_StartingKey", (PyCFunction) _wrap_wxGridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS }, + { "wxGridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_wxGridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_PaintBackground", (PyCFunction) _wrap_wxGridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_Show", (PyCFunction) _wrap_wxGridCellEditor_Show, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_SetSize", (PyCFunction) _wrap_wxGridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS }, @@ -12611,6 +12758,8 @@ static PyMethodDef gridcMethods[] = { { "wxGridCellEditor_EndEdit", (PyCFunction) _wrap_wxGridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_BeginEdit", (PyCFunction) _wrap_wxGridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_Create", (PyCFunction) _wrap_wxGridCellEditor_Create, METH_VARARGS | METH_KEYWORDS }, + { "wxGridCellEditor_DecRef", (PyCFunction) _wrap_wxGridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS }, + { "wxGridCellEditor_IncRef", (PyCFunction) _wrap_wxGridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_SetParameters", (PyCFunction) _wrap_wxGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_SetControl", (PyCFunction) _wrap_wxGridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellEditor_GetControl", (PyCFunction) _wrap_wxGridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS }, @@ -12629,6 +12778,8 @@ static PyMethodDef gridcMethods[] = { { "wxGridCellRenderer_Clone", (PyCFunction) _wrap_wxGridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellRenderer_GetBestSize", (PyCFunction) _wrap_wxGridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellRenderer_Draw", (PyCFunction) _wrap_wxGridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS }, + { "wxGridCellRenderer_DecRef", (PyCFunction) _wrap_wxGridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS }, + { "wxGridCellRenderer_IncRef", (PyCFunction) _wrap_wxGridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS }, { "wxGridCellRenderer_SetParameters", (PyCFunction) _wrap_wxGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS }, { NULL, NULL } }; @@ -12676,6 +12827,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_wxPrintQuality","_EBool",0}, { "_wxPrintQuality","_size_t",0}, { "_class_wxCustomDataObject","_wxCustomDataObject",0}, + { "_wxSpinCtrl","_class_wxSpinCtrl",0}, { "_class_wxRegionIterator","_wxRegionIterator",0}, { "_class_wxPyTextDropTarget","_wxPyTextDropTarget",0}, { "_class_wxMenuBar","_wxMenuBar",0}, @@ -12793,6 +12945,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_wxPoint","_class_wxPoint",0}, { "_class_wxButton","_wxButton",0}, { "_wxRadioBox","_class_wxRadioBox",0}, + { "_class_wxSpinCtrl","_wxSpinCtrl",0}, { "_char","_wxChar",0}, { "_wxBitmap","_class_wxBitmap",0}, { "_wxGridCellStringRenderer","_class_wxGridCellFloatRenderer",SwigwxGridCellFloatRendererTowxGridCellStringRenderer}, diff --git a/wxPython/src/gtk/grid.py b/wxPython/src/gtk/grid.py index f4067138f1..d45de410e5 100644 --- a/wxPython/src/gtk/grid.py +++ b/wxPython/src/gtk/grid.py @@ -67,6 +67,12 @@ class wxGridCellRendererPtr : def SetParameters(self, *_args, **_kwargs): val = apply(gridc.wxGridCellRenderer_SetParameters,(self,) + _args, _kwargs) return val + def IncRef(self, *_args, **_kwargs): + val = apply(gridc.wxGridCellRenderer_IncRef,(self,) + _args, _kwargs) + return val + def DecRef(self, *_args, **_kwargs): + val = apply(gridc.wxGridCellRenderer_DecRef,(self,) + _args, _kwargs) + return val def Draw(self, *_args, **_kwargs): val = apply(gridc.wxGridCellRenderer_Draw,(self,) + _args, _kwargs) return val @@ -193,6 +199,12 @@ class wxGridCellEditorPtr : def SetParameters(self, *_args, **_kwargs): val = apply(gridc.wxGridCellEditor_SetParameters,(self,) + _args, _kwargs) return val + def IncRef(self, *_args, **_kwargs): + val = apply(gridc.wxGridCellEditor_IncRef,(self,) + _args, _kwargs) + return val + def DecRef(self, *_args, **_kwargs): + val = apply(gridc.wxGridCellEditor_DecRef,(self,) + _args, _kwargs) + return val def Create(self, *_args, **_kwargs): val = apply(gridc.wxGridCellEditor_Create,(self,) + _args, _kwargs) return val @@ -218,6 +230,9 @@ class wxGridCellEditorPtr : def PaintBackground(self, *_args, **_kwargs): val = apply(gridc.wxGridCellEditor_PaintBackground,(self,) + _args, _kwargs) return val + def IsAcceptedKey(self, *_args, **_kwargs): + val = apply(gridc.wxGridCellEditor_IsAcceptedKey,(self,) + _args, _kwargs) + return val def StartingKey(self, *_args, **_kwargs): val = apply(gridc.wxGridCellEditor_StartingKey,(self,) + _args, _kwargs) return val diff --git a/wxPython/src/gtk/misc2.cpp b/wxPython/src/gtk/misc2.cpp index 354ad1b5aa..b4add9d916 100644 --- a/wxPython/src/gtk/misc2.cpp +++ b/wxPython/src/gtk/misc2.cpp @@ -1450,6 +1450,212 @@ static PyObject *_wrap_wxDragListItem(PyObject *self, PyObject *args, PyObject * return _resultobj; } +static PyObject *_wrap_wxSysErrorCode(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + unsigned long _result; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxSysErrorCode",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned long )wxSysErrorCode(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); + return _resultobj; +} + +static PyObject *_wrap_wxSysErrorMsg(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char * _result; + unsigned long _arg0 = (unsigned long ) 0; + char *_kwnames[] = { "nErrCode", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|l:wxSysErrorMsg",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (char *)wxSysErrorMsg(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("s", _result); + return _resultobj; +} + +static PyObject *_wrap_wxLogFatalError(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char * _arg0; + char *_kwnames[] = { "szFormat", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"s:wxLogFatalError",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogFatalError(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLogError(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char * _arg0; + char *_kwnames[] = { "szFormat", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"s:wxLogError",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogError(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLogWarning(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char * _arg0; + char *_kwnames[] = { "szFormat", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"s:wxLogWarning",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogWarning(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLogMessage(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char * _arg0; + char *_kwnames[] = { "szFormat", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"s:wxLogMessage",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogMessage(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLogInfo(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char * _arg0; + char *_kwnames[] = { "szFormat", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"s:wxLogInfo",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogInfo(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLogVerbose(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char * _arg0; + char *_kwnames[] = { "szFormat", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"s:wxLogVerbose",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogVerbose(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLogStatus(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char * _arg0; + char *_kwnames[] = { "szFormat", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"s:wxLogStatus",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogStatus(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLogStatusFrame(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxFrame * _arg0; + char * _arg1; + PyObject * _argo0 = 0; + char *_kwnames[] = { "pFrame","szFormat", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os:wxLogStatusFrame",_kwnames,&_argo0,&_arg1)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFrame_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLogStatusFrame. Expected _wxFrame_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogStatus(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLogSysError(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char * _arg0; + char *_kwnames[] = { "szFormat", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"s:wxLogSysError",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogSysError(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + #define new_wxToolTip(_swigarg0) (new wxToolTip(_swigarg0)) static PyObject *_wrap_new_wxToolTip(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; @@ -3106,7 +3312,850 @@ static PyObject *_wrap_wxPyTimer_Stop(PyObject *self, PyObject *args, PyObject * return _resultobj; } +#define new_wxLog() (new wxLog()) +static PyObject *_wrap_new_wxLog(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLog * _result; + char *_kwnames[] = { NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxLog",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLog *)new_wxLog(); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxLog_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +static PyObject *_wrap_wxLog_IsEnabled(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + bool _result; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxLog_IsEnabled",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxLog::IsEnabled(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyObject *_wrap_wxLog_EnableLogging(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + bool _result; + bool _arg0 = (bool ) TRUE; + int tempbool0 = (int) TRUE; + char *_kwnames[] = { "doIt", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|i:wxLog_EnableLogging",_kwnames,&tempbool0)) + return NULL; + _arg0 = (bool ) tempbool0; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxLog::EnableLogging(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyObject *_wrap_wxLog_OnLog(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLogLevel * _arg0; + char * _arg1; + int _arg2 = (int ) 0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "level","szString","t", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os|i:wxLog_OnLog",_kwnames,&_argo0,&_arg1,&_arg2)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLogLevel_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLog_OnLog. Expected _wxLogLevel_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog::OnLog(*_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxLog_Flush(_swigobj) (_swigobj->Flush()) +static PyObject *_wrap_wxLog_Flush(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLog * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLog_Flush",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLog_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLog_Flush. Expected _wxLog_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog_Flush(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxLog_HasPendingMessages(_swigobj) (_swigobj->HasPendingMessages()) +static PyObject *_wrap_wxLog_HasPendingMessages(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + bool _result; + wxLog * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLog_HasPendingMessages",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLog_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLog_HasPendingMessages. Expected _wxLog_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxLog_HasPendingMessages(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyObject *_wrap_wxLog_FlushActive(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxLog_FlushActive",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog::FlushActive(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLog_GetActiveTarget(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLog * _result; + char *_kwnames[] = { NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxLog_GetActiveTarget",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLog *)wxLog::GetActiveTarget(); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxLog_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +static PyObject *_wrap_wxLog_SetActiveTarget(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLog * _result; + wxLog * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "pLogger", NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLog_SetActiveTarget",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLog_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLog_SetActiveTarget. Expected _wxLog_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLog *)wxLog::SetActiveTarget(_arg0); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxLog_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +static PyObject *_wrap_wxLog_Suspend(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxLog_Suspend",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog::Suspend(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLog_Resume(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxLog_Resume",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog::Resume(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxLog_SetVerbose(_swigobj,_swigarg0) (_swigobj->SetVerbose(_swigarg0)) +static PyObject *_wrap_wxLog_SetVerbose(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLog * _arg0; + bool _arg1 = (bool ) TRUE; + PyObject * _argo0 = 0; + int tempbool1 = (int) TRUE; + char *_kwnames[] = { "self","bVerbose", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxLog_SetVerbose",_kwnames,&_argo0,&tempbool1)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLog_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLog_SetVerbose. Expected _wxLog_p."); + return NULL; + } + } + _arg1 = (bool ) tempbool1; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog_SetVerbose(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLog_DontCreateOnDemand(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxLog_DontCreateOnDemand",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog::DontCreateOnDemand(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLog_SetTraceMask(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxTraceMask * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "ulMask", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLog_SetTraceMask",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxTraceMask_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLog_SetTraceMask. Expected _wxTraceMask_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog::SetTraceMask(*_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxLog_AddTraceMask(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxString * _arg0; + PyObject * _obj0 = 0; + char *_kwnames[] = { "str", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLog_AddTraceMask",_kwnames,&_obj0)) + return NULL; +{ + if (!PyString_Check(_obj0)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog::AddTraceMask(*_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; +{ + if (_obj0) + delete _arg0; +} + return _resultobj; +} + +static PyObject *_wrap_wxLog_RemoveTraceMask(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxString * _arg0; + PyObject * _obj0 = 0; + char *_kwnames[] = { "str", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLog_RemoveTraceMask",_kwnames,&_obj0)) + return NULL; +{ + if (!PyString_Check(_obj0)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLog::RemoveTraceMask(*_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; +{ + if (_obj0) + delete _arg0; +} + return _resultobj; +} + +#define wxLog_GetVerbose(_swigobj) (_swigobj->GetVerbose()) +static PyObject *_wrap_wxLog_GetVerbose(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + bool _result; + wxLog * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLog_GetVerbose",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLog_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLog_GetVerbose. Expected _wxLog_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxLog_GetVerbose(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyObject *_wrap_wxLog_GetTraceMask(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxTraceMask * _result; + char *_kwnames[] = { NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxLog_GetTraceMask",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTraceMask (wxLog::GetTraceMask()); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTraceMask_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static PyObject *_wrap_wxLog_IsAllowedTraceMask(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + bool _result; + char * _arg0; + char *_kwnames[] = { "mask", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"s:wxLog_IsAllowedTraceMask",_kwnames,&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxLog::IsAllowedTraceMask(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static void *SwigwxLogStderrTowxLog(void *ptr) { + wxLogStderr *src; + wxLog *dest; + src = (wxLogStderr *) ptr; + dest = (wxLog *) src; + return (void *) dest; +} + +#define new_wxLogStderr() (new wxLogStderr()) +static PyObject *_wrap_new_wxLogStderr(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLogStderr * _result; + char *_kwnames[] = { NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxLogStderr",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLogStderr *)new_wxLogStderr(); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxLogStderr_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +static void *SwigwxLogTextCtrlTowxLog(void *ptr) { + wxLogTextCtrl *src; + wxLog *dest; + src = (wxLogTextCtrl *) ptr; + dest = (wxLog *) src; + return (void *) dest; +} + +#define new_wxLogTextCtrl(_swigarg0) (new wxLogTextCtrl(_swigarg0)) +static PyObject *_wrap_new_wxLogTextCtrl(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLogTextCtrl * _result; + wxTextCtrl * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "pTextCtrl", NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:new_wxLogTextCtrl",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxTextCtrl_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxLogTextCtrl. Expected _wxTextCtrl_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLogTextCtrl *)new_wxLogTextCtrl(_arg0); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxLogTextCtrl_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +static void *SwigwxLogGuiTowxLog(void *ptr) { + wxLogGui *src; + wxLog *dest; + src = (wxLogGui *) ptr; + dest = (wxLog *) src; + return (void *) dest; +} + +#define new_wxLogGui() (new wxLogGui()) +static PyObject *_wrap_new_wxLogGui(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLogGui * _result; + char *_kwnames[] = { NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxLogGui",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLogGui *)new_wxLogGui(); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxLogGui_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +static void *SwigwxLogWindowTowxLog(void *ptr) { + wxLogWindow *src; + wxLog *dest; + src = (wxLogWindow *) ptr; + dest = (wxLog *) src; + return (void *) dest; +} + +#define new_wxLogWindow(_swigarg0,_swigarg1,_swigarg2,_swigarg3) (new wxLogWindow(_swigarg0,_swigarg1,_swigarg2,_swigarg3)) +static PyObject *_wrap_new_wxLogWindow(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLogWindow * _result; + wxFrame * _arg0; + char * _arg1; + bool _arg2 = (bool ) TRUE; + bool _arg3 = (bool ) TRUE; + PyObject * _argo0 = 0; + int tempbool2 = (int) TRUE; + int tempbool3 = (int) TRUE; + char *_kwnames[] = { "pParent","szTitle","bShow","bPassToOld", NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os|ii:new_wxLogWindow",_kwnames,&_argo0,&_arg1,&tempbool2,&tempbool3)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFrame_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxLogWindow. Expected _wxFrame_p."); + return NULL; + } + } + _arg2 = (bool ) tempbool2; + _arg3 = (bool ) tempbool3; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLogWindow *)new_wxLogWindow(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxLogWindow_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +#define wxLogWindow_Show(_swigobj,_swigarg0) (_swigobj->Show(_swigarg0)) +static PyObject *_wrap_wxLogWindow_Show(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLogWindow * _arg0; + bool _arg1 = (bool ) TRUE; + PyObject * _argo0 = 0; + int tempbool1 = (int) TRUE; + char *_kwnames[] = { "self","bShow", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxLogWindow_Show",_kwnames,&_argo0,&tempbool1)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLogWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLogWindow_Show. Expected _wxLogWindow_p."); + return NULL; + } + } + _arg1 = (bool ) tempbool1; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogWindow_Show(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxLogWindow_GetFrame(_swigobj) (_swigobj->GetFrame()) +static PyObject *_wrap_wxLogWindow_GetFrame(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxFrame * _result; + wxLogWindow * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLogWindow_GetFrame",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLogWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLogWindow_GetFrame. Expected _wxLogWindow_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxFrame *)wxLogWindow_GetFrame(_arg0); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxFrame_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +#define wxLogWindow_GetOldLog(_swigobj) (_swigobj->GetOldLog()) +static PyObject *_wrap_wxLogWindow_GetOldLog(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLog * _result; + wxLogWindow * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLogWindow_GetOldLog",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLogWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLogWindow_GetOldLog. Expected _wxLogWindow_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLog *)wxLogWindow_GetOldLog(_arg0); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxLog_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +#define wxLogWindow_IsPassingMessages(_swigobj) (_swigobj->IsPassingMessages()) +static PyObject *_wrap_wxLogWindow_IsPassingMessages(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + bool _result; + wxLogWindow * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxLogWindow_IsPassingMessages",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLogWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLogWindow_IsPassingMessages. Expected _wxLogWindow_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxLogWindow_IsPassingMessages(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxLogWindow_PassMessages(_swigobj,_swigarg0) (_swigobj->PassMessages(_swigarg0)) +static PyObject *_wrap_wxLogWindow_PassMessages(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLogWindow * _arg0; + bool _arg1; + PyObject * _argo0 = 0; + int tempbool1; + char *_kwnames[] = { "self","bDoPass", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxLogWindow_PassMessages",_kwnames,&_argo0,&tempbool1)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLogWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLogWindow_PassMessages. Expected _wxLogWindow_p."); + return NULL; + } + } + _arg1 = (bool ) tempbool1; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxLogWindow_PassMessages(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define new_wxLogNull() (new wxLogNull()) +static PyObject *_wrap_new_wxLogNull(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLogNull * _result; + char *_kwnames[] = { NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxLogNull",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLogNull *)new_wxLogNull(); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxLogNull_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + +#define delete_wxLogNull(_swigobj) (delete _swigobj) +static PyObject *_wrap_delete_wxLogNull(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLogNull * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxLogNull",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxLogNull_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxLogNull. Expected _wxLogNull_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxLogNull(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + static PyMethodDef misc2cMethods[] = { + { "delete_wxLogNull", (PyCFunction) _wrap_delete_wxLogNull, METH_VARARGS | METH_KEYWORDS }, + { "new_wxLogNull", (PyCFunction) _wrap_new_wxLogNull, METH_VARARGS | METH_KEYWORDS }, + { "wxLogWindow_PassMessages", (PyCFunction) _wrap_wxLogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS }, + { "wxLogWindow_IsPassingMessages", (PyCFunction) _wrap_wxLogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS }, + { "wxLogWindow_GetOldLog", (PyCFunction) _wrap_wxLogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS }, + { "wxLogWindow_GetFrame", (PyCFunction) _wrap_wxLogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS }, + { "wxLogWindow_Show", (PyCFunction) _wrap_wxLogWindow_Show, METH_VARARGS | METH_KEYWORDS }, + { "new_wxLogWindow", (PyCFunction) _wrap_new_wxLogWindow, METH_VARARGS | METH_KEYWORDS }, + { "new_wxLogGui", (PyCFunction) _wrap_new_wxLogGui, METH_VARARGS | METH_KEYWORDS }, + { "new_wxLogTextCtrl", (PyCFunction) _wrap_new_wxLogTextCtrl, METH_VARARGS | METH_KEYWORDS }, + { "new_wxLogStderr", (PyCFunction) _wrap_new_wxLogStderr, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_IsAllowedTraceMask", (PyCFunction) _wrap_wxLog_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_GetTraceMask", (PyCFunction) _wrap_wxLog_GetTraceMask, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_GetVerbose", (PyCFunction) _wrap_wxLog_GetVerbose, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_RemoveTraceMask", (PyCFunction) _wrap_wxLog_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_AddTraceMask", (PyCFunction) _wrap_wxLog_AddTraceMask, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_SetTraceMask", (PyCFunction) _wrap_wxLog_SetTraceMask, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_DontCreateOnDemand", (PyCFunction) _wrap_wxLog_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_SetVerbose", (PyCFunction) _wrap_wxLog_SetVerbose, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_Resume", (PyCFunction) _wrap_wxLog_Resume, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_Suspend", (PyCFunction) _wrap_wxLog_Suspend, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_SetActiveTarget", (PyCFunction) _wrap_wxLog_SetActiveTarget, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_GetActiveTarget", (PyCFunction) _wrap_wxLog_GetActiveTarget, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_FlushActive", (PyCFunction) _wrap_wxLog_FlushActive, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_HasPendingMessages", (PyCFunction) _wrap_wxLog_HasPendingMessages, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_Flush", (PyCFunction) _wrap_wxLog_Flush, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_OnLog", (PyCFunction) _wrap_wxLog_OnLog, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_EnableLogging", (PyCFunction) _wrap_wxLog_EnableLogging, METH_VARARGS | METH_KEYWORDS }, + { "wxLog_IsEnabled", (PyCFunction) _wrap_wxLog_IsEnabled, METH_VARARGS | METH_KEYWORDS }, + { "new_wxLog", (PyCFunction) _wrap_new_wxLog, METH_VARARGS | METH_KEYWORDS }, { "wxPyTimer_Stop", (PyCFunction) _wrap_wxPyTimer_Stop, METH_VARARGS | METH_KEYWORDS }, { "wxPyTimer_Start", (PyCFunction) _wrap_wxPyTimer_Start, METH_VARARGS | METH_KEYWORDS }, { "wxPyTimer_SetOwner", (PyCFunction) _wrap_wxPyTimer_SetOwner, METH_VARARGS | METH_KEYWORDS }, @@ -3157,6 +4206,17 @@ static PyMethodDef misc2cMethods[] = { { "wxToolTip_GetTip", (PyCFunction) _wrap_wxToolTip_GetTip, METH_VARARGS | METH_KEYWORDS }, { "wxToolTip_SetTip", (PyCFunction) _wrap_wxToolTip_SetTip, METH_VARARGS | METH_KEYWORDS }, { "new_wxToolTip", (PyCFunction) _wrap_new_wxToolTip, METH_VARARGS | METH_KEYWORDS }, + { "wxLogSysError", (PyCFunction) _wrap_wxLogSysError, METH_VARARGS | METH_KEYWORDS }, + { "wxLogStatusFrame", (PyCFunction) _wrap_wxLogStatusFrame, METH_VARARGS | METH_KEYWORDS }, + { "wxLogStatus", (PyCFunction) _wrap_wxLogStatus, METH_VARARGS | METH_KEYWORDS }, + { "wxLogVerbose", (PyCFunction) _wrap_wxLogVerbose, METH_VARARGS | METH_KEYWORDS }, + { "wxLogInfo", (PyCFunction) _wrap_wxLogInfo, METH_VARARGS | METH_KEYWORDS }, + { "wxLogMessage", (PyCFunction) _wrap_wxLogMessage, METH_VARARGS | METH_KEYWORDS }, + { "wxLogWarning", (PyCFunction) _wrap_wxLogWarning, METH_VARARGS | METH_KEYWORDS }, + { "wxLogError", (PyCFunction) _wrap_wxLogError, METH_VARARGS | METH_KEYWORDS }, + { "wxLogFatalError", (PyCFunction) _wrap_wxLogFatalError, METH_VARARGS | METH_KEYWORDS }, + { "wxSysErrorMsg", (PyCFunction) _wrap_wxSysErrorMsg, METH_VARARGS | METH_KEYWORDS }, + { "wxSysErrorCode", (PyCFunction) _wrap_wxSysErrorCode, METH_VARARGS | METH_KEYWORDS }, { "wxDragListItem", (PyCFunction) _wrap_wxDragListItem, METH_VARARGS | METH_KEYWORDS }, { "wxDragTreeItem", (PyCFunction) _wrap_wxDragTreeItem, METH_VARARGS | METH_KEYWORDS }, { "wxDragString", (PyCFunction) _wrap_wxDragString, METH_VARARGS | METH_KEYWORDS }, @@ -3228,6 +4288,15 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0}, { "_wxCursor","_class_wxCursor",0}, { "_wxNotifyEvent","_class_wxNotifyEvent",0}, + { "_wxLog","_class_wxLogWindow",SwigwxLogWindowTowxLog}, + { "_wxLog","_wxLogWindow",SwigwxLogWindowTowxLog}, + { "_wxLog","_class_wxLogGui",SwigwxLogGuiTowxLog}, + { "_wxLog","_wxLogGui",SwigwxLogGuiTowxLog}, + { "_wxLog","_class_wxLogTextCtrl",SwigwxLogTextCtrlTowxLog}, + { "_wxLog","_wxLogTextCtrl",SwigwxLogTextCtrlTowxLog}, + { "_wxLog","_class_wxLogStderr",SwigwxLogStderrTowxLog}, + { "_wxLog","_wxLogStderr",SwigwxLogStderrTowxLog}, + { "_wxLog","_class_wxLog",0}, { "_wxMask","_class_wxMask",0}, { "_wxToolTip","_class_wxToolTip",0}, { "_wxPen","_class_wxPen",0}, @@ -3256,6 +4325,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_class_wxRealPoint","_wxRealPoint",0}, { "_wxNavigationKeyEvent","_class_wxNavigationKeyEvent",0}, { "_wxWindowCreateEvent","_class_wxWindowCreateEvent",0}, + { "_wxLogGui","_class_wxLogGui",0}, { "_class_wxMenuItem","_wxMenuItem",0}, { "_class_wxPaintEvent","_wxPaintEvent",0}, { "_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0}, @@ -3291,6 +4361,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_wxRect","_class_wxRect",0}, { "_wxCommandEvent","_class_wxCommandEvent",0}, { "_wxSizeEvent","_class_wxSizeEvent",0}, + { "_class_wxLogWindow","_wxLogWindow",0}, { "_wxPoint","_class_wxPoint",0}, { "_char","_wxChar",0}, { "_wxBitmap","_class_wxBitmap",0}, @@ -3324,6 +4395,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_wxGenericDragImage","_class_wxGenericDragImage",0}, { "_wxQueryNewPaletteEvent","_class_wxQueryNewPaletteEvent",0}, { "_class_wxWindowCreateEvent","_wxWindowCreateEvent",0}, + { "_wxLogTextCtrl","_class_wxLogTextCtrl",0}, { "_wxFocusEvent","_class_wxFocusEvent",0}, { "_wxMaximizeEvent","_class_wxMaximizeEvent",0}, { "_class_wxTimerEvent","_wxTimerEvent",0}, @@ -3352,6 +4424,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_unsigned_short","_WXTYPE",0}, { "_unsigned_short","_short",0}, { "_class_wxWindow","_wxWindow",0}, + { "_class_wxLogStderr","_wxLogStderr",0}, { "_class_wxFont","_wxFont",0}, { "_wxClipboard","_class_wxClipboard",0}, { "_class_wxPyValidator","_wxPyValidator",0}, @@ -3378,6 +4451,15 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_wxPostScriptDC","_class_wxPostScriptDC",0}, { "_wxPyFileDropTarget","_class_wxPyFileDropTarget",0}, { "_wxScrolledWindow","_class_wxScrolledWindow",0}, + { "_class_wxLog","_class_wxLogWindow",SwigwxLogWindowTowxLog}, + { "_class_wxLog","_wxLogWindow",SwigwxLogWindowTowxLog}, + { "_class_wxLog","_class_wxLogGui",SwigwxLogGuiTowxLog}, + { "_class_wxLog","_wxLogGui",SwigwxLogGuiTowxLog}, + { "_class_wxLog","_class_wxLogTextCtrl",SwigwxLogTextCtrlTowxLog}, + { "_class_wxLog","_wxLogTextCtrl",SwigwxLogTextCtrlTowxLog}, + { "_class_wxLog","_class_wxLogStderr",SwigwxLogStderrTowxLog}, + { "_class_wxLog","_wxLogStderr",SwigwxLogStderrTowxLog}, + { "_class_wxLog","_wxLog",0}, { "_unsigned_char","_byte",0}, { "_class_wxMenu","_wxMenu",0}, { "_unsigned_int","_wxCoord",0}, @@ -3418,12 +4500,16 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_int","_signed_int",0}, { "_class_wxMouseEvent","_wxMouseEvent",0}, { "_wxPyCommandEvent","_class_wxPyCommandEvent",0}, + { "_wxLogWindow","_class_wxLogWindow",0}, { "_class_wxSpinEvent","_wxSpinEvent",0}, { "_class_wxQueryNewPaletteEvent","_wxQueryNewPaletteEvent",0}, { "_class_wxNavigationKeyEvent","_wxNavigationKeyEvent",0}, + { "_wxLogNull","_class_wxLogNull",0}, { "_wxSize","_class_wxSize",0}, { "_wxRegionIterator","_class_wxRegionIterator",0}, { "_class_wxPyTextDataObject","_wxPyTextDataObject",0}, + { "_class_wxLogTextCtrl","_wxLogTextCtrl",0}, + { "_class_wxLogGui","_wxLogGui",0}, { "_class_wxPaintDC","_wxPaintDC",0}, { "_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0}, { "_class_wxPyFileDropTarget","_wxPyFileDropTarget",0}, @@ -3460,6 +4546,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_class_wxClientDC","_wxClientDC",0}, { "_class_wxSizeEvent","_wxSizeEvent",0}, { "_wxCustomDataObject","_class_wxCustomDataObject",0}, + { "_class_wxLogNull","_wxLogNull",0}, { "_class_wxSize","_wxSize",0}, { "_class_wxBitmap","_wxBitmap",0}, { "_class_wxMemoryDC","_wxMemoryDC",0}, @@ -3477,6 +4564,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = { { "_class_wxDataObjectComposite","_wxDataObjectComposite",0}, { "_wxWindow","_class_wxWindow",0}, { "_class_wxWindowDestroyEvent","_wxWindowDestroyEvent",0}, + { "_wxLogStderr","_class_wxLogStderr",0}, {0,0,0}}; static PyObject *SWIG_globals; @@ -3574,6 +4662,16 @@ SWIGEXPORT(void) initmisc2c() { PyDict_SetItemString(d,"wxSYS_PENWINDOWS_PRESENT", PyInt_FromLong((long) wxSYS_PENWINDOWS_PRESENT)); PyDict_SetItemString(d,"wxSYS_SHOW_SOUNDS", PyInt_FromLong((long) wxSYS_SHOW_SOUNDS)); PyDict_SetItemString(d,"wxSYS_SWAP_BUTTONS", PyInt_FromLong((long) wxSYS_SWAP_BUTTONS)); + PyDict_SetItemString(d,"wxLOG_FatalError", PyInt_FromLong((long) wxLOG_FatalError)); + PyDict_SetItemString(d,"wxLOG_Error", PyInt_FromLong((long) wxLOG_Error)); + PyDict_SetItemString(d,"wxLOG_Warning", PyInt_FromLong((long) wxLOG_Warning)); + PyDict_SetItemString(d,"wxLOG_Message", PyInt_FromLong((long) wxLOG_Message)); + PyDict_SetItemString(d,"wxLOG_Info", PyInt_FromLong((long) wxLOG_Info)); + PyDict_SetItemString(d,"wxLOG_Status", PyInt_FromLong((long) wxLOG_Status)); + PyDict_SetItemString(d,"wxLOG_Debug", PyInt_FromLong((long) wxLOG_Debug)); + PyDict_SetItemString(d,"wxLOG_Trace", PyInt_FromLong((long) wxLOG_Trace)); + PyDict_SetItemString(d,"wxLOG_Progress", PyInt_FromLong((long) wxLOG_Progress)); + PyDict_SetItemString(d,"wxLOG_User", PyInt_FromLong((long) wxLOG_User)); { int i; for (i = 0; _swig_mapping[i].n1; i++) diff --git a/wxPython/src/gtk/misc2.py b/wxPython/src/gtk/misc2.py index 8f95fa3168..60be26b567 100644 --- a/wxPython/src/gtk/misc2.py +++ b/wxPython/src/gtk/misc2.py @@ -256,6 +256,122 @@ class wxPyTimer(wxPyTimerPtr): +class wxLogPtr : + def __init__(self,this): + self.this = this + self.thisown = 0 + def Flush(self, *_args, **_kwargs): + val = apply(misc2c.wxLog_Flush,(self,) + _args, _kwargs) + return val + def HasPendingMessages(self, *_args, **_kwargs): + val = apply(misc2c.wxLog_HasPendingMessages,(self,) + _args, _kwargs) + return val + def SetVerbose(self, *_args, **_kwargs): + val = apply(misc2c.wxLog_SetVerbose,(self,) + _args, _kwargs) + return val + def GetVerbose(self, *_args, **_kwargs): + val = apply(misc2c.wxLog_GetVerbose,(self,) + _args, _kwargs) + return val + def __repr__(self): + return "" % (self.this,) +class wxLog(wxLogPtr): + def __init__(self,*_args,**_kwargs): + self.this = apply(misc2c.new_wxLog,_args,_kwargs) + self.thisown = 1 + + + + +class wxLogStderrPtr(wxLogPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def __repr__(self): + return "" % (self.this,) +class wxLogStderr(wxLogStderrPtr): + def __init__(self,*_args,**_kwargs): + self.this = apply(misc2c.new_wxLogStderr,_args,_kwargs) + self.thisown = 1 + + + + +class wxLogTextCtrlPtr(wxLogPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def __repr__(self): + return "" % (self.this,) +class wxLogTextCtrl(wxLogTextCtrlPtr): + def __init__(self,*_args,**_kwargs): + self.this = apply(misc2c.new_wxLogTextCtrl,_args,_kwargs) + self.thisown = 1 + + + + +class wxLogGuiPtr(wxLogPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def __repr__(self): + return "" % (self.this,) +class wxLogGui(wxLogGuiPtr): + def __init__(self,*_args,**_kwargs): + self.this = apply(misc2c.new_wxLogGui,_args,_kwargs) + self.thisown = 1 + + + + +class wxLogWindowPtr(wxLogPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def Show(self, *_args, **_kwargs): + val = apply(misc2c.wxLogWindow_Show,(self,) + _args, _kwargs) + return val + def GetFrame(self, *_args, **_kwargs): + val = apply(misc2c.wxLogWindow_GetFrame,(self,) + _args, _kwargs) + if val: val = wxFramePtr(val) + return val + def GetOldLog(self, *_args, **_kwargs): + val = apply(misc2c.wxLogWindow_GetOldLog,(self,) + _args, _kwargs) + if val: val = wxLogPtr(val) + return val + def IsPassingMessages(self, *_args, **_kwargs): + val = apply(misc2c.wxLogWindow_IsPassingMessages,(self,) + _args, _kwargs) + return val + def PassMessages(self, *_args, **_kwargs): + val = apply(misc2c.wxLogWindow_PassMessages,(self,) + _args, _kwargs) + return val + def __repr__(self): + return "" % (self.this,) +class wxLogWindow(wxLogWindowPtr): + def __init__(self,*_args,**_kwargs): + self.this = apply(misc2c.new_wxLogWindow,_args,_kwargs) + self.thisown = 1 + + + + +class wxLogNullPtr : + def __init__(self,this): + self.this = this + self.thisown = 0 + def __del__(self,misc2c=misc2c): + if self.thisown == 1 : + misc2c.delete_wxLogNull(self) + def __repr__(self): + return "" % (self.this,) +class wxLogNull(wxLogNullPtr): + def __init__(self,*_args,**_kwargs): + self.this = apply(misc2c.new_wxLogNull,_args,_kwargs) + self.thisown = 1 + + + + #-------------- FUNCTION WRAPPERS ------------------ @@ -373,6 +489,62 @@ def wxDragListItem(*_args, **_kwargs): if val: val = wxDragImagePtr(val); val.thisown = 1 return val +wxSysErrorCode = misc2c.wxSysErrorCode + +wxSysErrorMsg = misc2c.wxSysErrorMsg + +wxLogFatalError = misc2c.wxLogFatalError + +wxLogError = misc2c.wxLogError + +wxLogWarning = misc2c.wxLogWarning + +wxLogMessage = misc2c.wxLogMessage + +wxLogInfo = misc2c.wxLogInfo + +wxLogVerbose = misc2c.wxLogVerbose + +wxLogStatus = misc2c.wxLogStatus + +wxLogStatusFrame = misc2c.wxLogStatusFrame + +wxLogSysError = misc2c.wxLogSysError + +wxLog_IsEnabled = misc2c.wxLog_IsEnabled + +wxLog_EnableLogging = misc2c.wxLog_EnableLogging + +wxLog_OnLog = misc2c.wxLog_OnLog + +wxLog_FlushActive = misc2c.wxLog_FlushActive + +def wxLog_GetActiveTarget(*_args, **_kwargs): + val = apply(misc2c.wxLog_GetActiveTarget,_args,_kwargs) + if val: val = wxLogPtr(val) + return val + +def wxLog_SetActiveTarget(*_args, **_kwargs): + val = apply(misc2c.wxLog_SetActiveTarget,_args,_kwargs) + if val: val = wxLogPtr(val) + return val + +wxLog_Suspend = misc2c.wxLog_Suspend + +wxLog_Resume = misc2c.wxLog_Resume + +wxLog_DontCreateOnDemand = misc2c.wxLog_DontCreateOnDemand + +wxLog_SetTraceMask = misc2c.wxLog_SetTraceMask + +wxLog_AddTraceMask = misc2c.wxLog_AddTraceMask + +wxLog_RemoveTraceMask = misc2c.wxLog_RemoveTraceMask + +wxLog_GetTraceMask = misc2c.wxLog_GetTraceMask + +wxLog_IsAllowedTraceMask = misc2c.wxLog_IsAllowedTraceMask + #-------------- VARIABLE WRAPPERS ------------------ @@ -463,3 +635,13 @@ wxSYS_NETWORK_PRESENT = misc2c.wxSYS_NETWORK_PRESENT wxSYS_PENWINDOWS_PRESENT = misc2c.wxSYS_PENWINDOWS_PRESENT wxSYS_SHOW_SOUNDS = misc2c.wxSYS_SHOW_SOUNDS wxSYS_SWAP_BUTTONS = misc2c.wxSYS_SWAP_BUTTONS +wxLOG_FatalError = misc2c.wxLOG_FatalError +wxLOG_Error = misc2c.wxLOG_Error +wxLOG_Warning = misc2c.wxLOG_Warning +wxLOG_Message = misc2c.wxLOG_Message +wxLOG_Info = misc2c.wxLOG_Info +wxLOG_Status = misc2c.wxLOG_Status +wxLOG_Debug = misc2c.wxLOG_Debug +wxLOG_Trace = misc2c.wxLOG_Trace +wxLOG_Progress = misc2c.wxLOG_Progress +wxLOG_User = misc2c.wxLOG_User diff --git a/wxPython/src/gtk/utils.cpp b/wxPython/src/gtk/utils.cpp index ab6e72156a..26d573d9de 100644 --- a/wxPython/src/gtk/utils.cpp +++ b/wxPython/src/gtk/utils.cpp @@ -121,6 +121,85 @@ static char* wxStringErrorMsg = "string type is required for parameter"; #ifdef __cplusplus extern "C" { #endif +static PyObject *_wrap_wxGetLocalTime(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + long _result; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxGetLocalTime",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxGetLocalTime(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); + return _resultobj; +} + +static PyObject *_wrap_wxGetUTCTime(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + long _result; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxGetUTCTime",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxGetUTCTime(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); + return _resultobj; +} + +static PyObject *_wrap_wxGetCurrentTime(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + long _result; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxGetCurrentTime",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxGetCurrentTime(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); + return _resultobj; +} + +static PyObject *_wrap_wxGetLocalTimeMillis(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxLongLong * _result; + char *_kwnames[] = { NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxGetLocalTimeMillis",_kwnames)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxLongLong (wxGetLocalTimeMillis()); + + wxPy_END_ALLOW_THREADS; +}{ + PyObject *hi, *lo, *shifter, *shifted; + hi = PyLong_FromLong(_result->GetHi()); + lo = PyLong_FromLong(_result->GetLo()); + shifter = PyLong_FromLong(32); + shifted = PyNumber_Lshift(hi, shifter); + _resultobj = PyNumber_Or(shifted, lo); + Py_DECREF(hi); + Py_DECREF(lo); + Py_DECREF(shifter); + Py_DECREF(shifted); +} + return _resultobj; +} + #define delete_wxConfigBase(_swigobj) (delete _swigobj) static PyObject *_wrap_delete_wxConfigBase(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; @@ -6240,70 +6319,6 @@ static PyObject *_wrap_wxTimeSpan_Format(PyObject *self, PyObject *args, PyObjec return _resultobj; } -#define wxTimeSpan_FormatDate(_swigobj) (_swigobj->FormatDate()) -static PyObject *_wrap_wxTimeSpan_FormatDate(PyObject *self, PyObject *args, PyObject *kwargs) { - PyObject * _resultobj; - wxString * _result; - wxTimeSpan * _arg0; - PyObject * _argo0 = 0; - char *_kwnames[] = { "self", NULL }; - - self = self; - if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxTimeSpan_FormatDate",_kwnames,&_argo0)) - return NULL; - if (_argo0) { - if (_argo0 == Py_None) { _arg0 = NULL; } - else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxTimeSpan_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTimeSpan_FormatDate. Expected _wxTimeSpan_p."); - return NULL; - } - } -{ - wxPy_BEGIN_ALLOW_THREADS; - _result = new wxString (wxTimeSpan_FormatDate(_arg0)); - - wxPy_END_ALLOW_THREADS; -}{ - _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len()); -} -{ - delete _result; -} - return _resultobj; -} - -#define wxTimeSpan_FormatTime(_swigobj) (_swigobj->FormatTime()) -static PyObject *_wrap_wxTimeSpan_FormatTime(PyObject *self, PyObject *args, PyObject *kwargs) { - PyObject * _resultobj; - wxString * _result; - wxTimeSpan * _arg0; - PyObject * _argo0 = 0; - char *_kwnames[] = { "self", NULL }; - - self = self; - if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxTimeSpan_FormatTime",_kwnames,&_argo0)) - return NULL; - if (_argo0) { - if (_argo0 == Py_None) { _arg0 = NULL; } - else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxTimeSpan_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTimeSpan_FormatTime. Expected _wxTimeSpan_p."); - return NULL; - } - } -{ - wxPy_BEGIN_ALLOW_THREADS; - _result = new wxString (wxTimeSpan_FormatTime(_arg0)); - - wxPy_END_ALLOW_THREADS; -}{ - _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len()); -} -{ - delete _result; -} - return _resultobj; -} - #define new_wxDateSpan(_swigarg0,_swigarg1,_swigarg2,_swigarg3) (new wxDateSpan(_swigarg0,_swigarg1,_swigarg2,_swigarg3)) static PyObject *_wrap_new_wxDateSpan(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; @@ -7148,8 +7163,6 @@ static PyMethodDef utilscMethods[] = { { "wxDateSpan_Days", (PyCFunction) _wrap_wxDateSpan_Days, METH_VARARGS | METH_KEYWORDS }, { "delete_wxDateSpan", (PyCFunction) _wrap_delete_wxDateSpan, METH_VARARGS | METH_KEYWORDS }, { "new_wxDateSpan", (PyCFunction) _wrap_new_wxDateSpan, METH_VARARGS | METH_KEYWORDS }, - { "wxTimeSpan_FormatTime", (PyCFunction) _wrap_wxTimeSpan_FormatTime, METH_VARARGS | METH_KEYWORDS }, - { "wxTimeSpan_FormatDate", (PyCFunction) _wrap_wxTimeSpan_FormatDate, METH_VARARGS | METH_KEYWORDS }, { "wxTimeSpan_Format", (PyCFunction) _wrap_wxTimeSpan_Format, METH_VARARGS | METH_KEYWORDS }, { "wxTimeSpan_GetMilliseconds", (PyCFunction) _wrap_wxTimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS }, { "wxTimeSpan_GetSeconds", (PyCFunction) _wrap_wxTimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS }, @@ -7335,6 +7348,10 @@ static PyMethodDef utilscMethods[] = { { "wxConfigBase_Get", (PyCFunction) _wrap_wxConfigBase_Get, METH_VARARGS | METH_KEYWORDS }, { "wxConfigBase_Set", (PyCFunction) _wrap_wxConfigBase_Set, METH_VARARGS | METH_KEYWORDS }, { "delete_wxConfigBase", (PyCFunction) _wrap_delete_wxConfigBase, METH_VARARGS | METH_KEYWORDS }, + { "wxGetLocalTimeMillis", (PyCFunction) _wrap_wxGetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS }, + { "wxGetCurrentTime", (PyCFunction) _wrap_wxGetCurrentTime, METH_VARARGS | METH_KEYWORDS }, + { "wxGetUTCTime", (PyCFunction) _wrap_wxGetUTCTime, METH_VARARGS | METH_KEYWORDS }, + { "wxGetLocalTime", (PyCFunction) _wrap_wxGetLocalTime, METH_VARARGS | METH_KEYWORDS }, { NULL, NULL } }; #ifdef __cplusplus diff --git a/wxPython/src/gtk/utils.py b/wxPython/src/gtk/utils.py index 87d8880369..be380ee5a4 100644 --- a/wxPython/src/gtk/utils.py +++ b/wxPython/src/gtk/utils.py @@ -683,12 +683,6 @@ class wxTimeSpanPtr : def Format(self, *_args, **_kwargs): val = apply(utilsc.wxTimeSpan_Format,(self,) + _args, _kwargs) return val - def FormatDate(self, *_args, **_kwargs): - val = apply(utilsc.wxTimeSpan_FormatDate,(self,) + _args, _kwargs) - return val - def FormatTime(self, *_args, **_kwargs): - val = apply(utilsc.wxTimeSpan_FormatTime,(self,) + _args, _kwargs) - return val def __repr__(self): return "" % (self.this,) class wxTimeSpan(wxTimeSpanPtr): @@ -787,6 +781,14 @@ class wxDateSpan(wxDateSpanPtr): #-------------- FUNCTION WRAPPERS ------------------ +wxGetLocalTime = utilsc.wxGetLocalTime + +wxGetUTCTime = utilsc.wxGetUTCTime + +wxGetCurrentTime = utilsc.wxGetCurrentTime + +wxGetLocalTimeMillis = utilsc.wxGetLocalTimeMillis + def wxConfigBase_Set(*_args, **_kwargs): val = apply(utilsc.wxConfigBase_Set,_args,_kwargs) if val: val = wxConfigBasePtr(val) diff --git a/wxPython/src/gtk/windows.cpp b/wxPython/src/gtk/windows.cpp index 0a8ad644a4..dc72e45fee 100644 --- a/wxPython/src/gtk/windows.cpp +++ b/wxPython/src/gtk/windows.cpp @@ -297,6 +297,42 @@ static PyObject *_wrap_wxEvtHandler_ProcessEvent(PyObject *self, PyObject *args, return _resultobj; } +#define wxEvtHandler_AddPendingEvent(_swigobj,_swigarg0) (_swigobj->AddPendingEvent(_swigarg0)) +static PyObject *_wrap_wxEvtHandler_AddPendingEvent(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxEvtHandler * _arg0; + wxEvent * _arg1; + PyObject * _argo0 = 0; + PyObject * _argo1 = 0; + char *_kwnames[] = { "self","event", NULL }; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEvtHandler_AddPendingEvent",_kwnames,&_argo0,&_argo1)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_AddPendingEvent. Expected _wxEvtHandler_p."); + return NULL; + } + } + if (_argo1) { + if (_argo1 == Py_None) { _arg1 = NULL; } + else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxEvent_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxEvtHandler_AddPendingEvent. Expected _wxEvent_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxEvtHandler_AddPendingEvent(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + #define wxEvtHandler_GetEvtHandlerEnabled(_swigobj) (_swigobj->GetEvtHandlerEnabled()) static PyObject *_wrap_wxEvtHandler_GetEvtHandlerEnabled(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; @@ -4553,6 +4589,40 @@ static PyObject *_wrap_wxWindow_SetSizer(PyObject *self, PyObject *args, PyObjec return _resultobj; } +#define wxWindow_GetSizer(_swigobj) (_swigobj->GetSizer()) +static PyObject *_wrap_wxWindow_GetSizer(PyObject *self, PyObject *args, PyObject *kwargs) { + PyObject * _resultobj; + wxSizer * _result; + wxWindow * _arg0; + PyObject * _argo0 = 0; + char *_kwnames[] = { "self", NULL }; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWindow_GetSizer",_kwnames,&_argo0)) + return NULL; + if (_argo0) { + if (_argo0 == Py_None) { _arg0 = NULL; } + else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_GetSizer. Expected _wxWindow_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSizer *)wxWindow_GetSizer(_arg0); + + wxPy_END_ALLOW_THREADS; +} if (_result) { + SWIG_MakePtr(_ptemp, (char *) _result,"_wxSizer_p"); + _resultobj = Py_BuildValue("s",_ptemp); + } else { + Py_INCREF(Py_None); + _resultobj = Py_None; + } + return _resultobj; +} + #define wxWindow_GetValidator(_swigobj) (_swigobj->GetValidator()) static PyObject *_wrap_wxWindow_GetValidator(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; @@ -5766,7 +5836,7 @@ static PyObject *_wrap_wxScrolledWindow_Scroll(PyObject *self, PyObject *args, P return _resultobj; } -#define wxScrolledWindow_SetScrollbars(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5) (_swigobj->SetScrollbars(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5)) +#define wxScrolledWindow_SetScrollbars(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (_swigobj->SetScrollbars(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6)) static PyObject *_wrap_wxScrolledWindow_SetScrollbars(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject * _resultobj; wxScrolledWindow * _arg0; @@ -5776,11 +5846,12 @@ static PyObject *_wrap_wxScrolledWindow_SetScrollbars(PyObject *self, PyObject * int _arg4; int _arg5 = (int ) 0; int _arg6 = (int ) 0; + int _arg7 = (int ) FALSE; PyObject * _argo0 = 0; - char *_kwnames[] = { "self","pixelsPerUnitX","pixelsPerUnitY","noUnitsX","noUnitsY","xPos","yPos", NULL }; + char *_kwnames[] = { "self","pixelsPerUnitX","pixelsPerUnitY","noUnitsX","noUnitsY","xPos","yPos","noRefresh", NULL }; self = self; - if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii|ii:wxScrolledWindow_SetScrollbars",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6)) + if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii|iii:wxScrolledWindow_SetScrollbars",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7)) return NULL; if (_argo0) { if (_argo0 == Py_None) { _arg0 = NULL; } @@ -5791,7 +5862,7 @@ static PyObject *_wrap_wxScrolledWindow_SetScrollbars(PyObject *self, PyObject * } { wxPy_BEGIN_ALLOW_THREADS; - wxScrolledWindow_SetScrollbars(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + wxScrolledWindow_SetScrollbars(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7); wxPy_END_ALLOW_THREADS; } Py_INCREF(Py_None); @@ -8957,6 +9028,7 @@ static PyMethodDef windowscMethods[] = { { "wxWindow_SetDropTarget", (PyCFunction) _wrap_wxWindow_SetDropTarget, METH_VARARGS | METH_KEYWORDS }, { "wxWindow_SetValidator", (PyCFunction) _wrap_wxWindow_SetValidator, METH_VARARGS | METH_KEYWORDS }, { "wxWindow_GetValidator", (PyCFunction) _wrap_wxWindow_GetValidator, METH_VARARGS | METH_KEYWORDS }, + { "wxWindow_GetSizer", (PyCFunction) _wrap_wxWindow_GetSizer, METH_VARARGS | METH_KEYWORDS }, { "wxWindow_SetSizer", (PyCFunction) _wrap_wxWindow_SetSizer, METH_VARARGS | METH_KEYWORDS }, { "wxWindow_GetToolTip", (PyCFunction) _wrap_wxWindow_GetToolTip, METH_VARARGS | METH_KEYWORDS }, { "wxWindow_SetToolTip", (PyCFunction) _wrap_wxWindow_SetToolTip, METH_VARARGS | METH_KEYWORDS }, @@ -9084,6 +9156,7 @@ static PyMethodDef windowscMethods[] = { { "wxEvtHandler_GetNextHandler", (PyCFunction) _wrap_wxEvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS }, { "wxEvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_wxEvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS }, { "wxEvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_wxEvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS }, + { "wxEvtHandler_AddPendingEvent", (PyCFunction) _wrap_wxEvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS }, { "wxEvtHandler_ProcessEvent", (PyCFunction) _wrap_wxEvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS }, { "wxWindow_PrevControlId", (PyCFunction) _wrap_wxWindow_PrevControlId, METH_VARARGS | METH_KEYWORDS }, { "wxWindow_NextControlId", (PyCFunction) _wrap_wxWindow_NextControlId, METH_VARARGS | METH_KEYWORDS }, diff --git a/wxPython/src/gtk/windows.py b/wxPython/src/gtk/windows.py index a8cb065cdf..3a5d0580af 100644 --- a/wxPython/src/gtk/windows.py +++ b/wxPython/src/gtk/windows.py @@ -27,6 +27,9 @@ class wxEvtHandlerPtr : def ProcessEvent(self, *_args, **_kwargs): val = apply(windowsc.wxEvtHandler_ProcessEvent,(self,) + _args, _kwargs) return val + def AddPendingEvent(self, *_args, **_kwargs): + val = apply(windowsc.wxEvtHandler_AddPendingEvent,(self,) + _args, _kwargs) + return val def GetEvtHandlerEnabled(self, *_args, **_kwargs): val = apply(windowsc.wxEvtHandler_GetEvtHandlerEnabled,(self,) + _args, _kwargs) return val @@ -55,6 +58,9 @@ class wxEvtHandlerPtr : return val def __repr__(self): return "" % (self.this,) + + _prop_list_ = {} + class wxEvtHandler(wxEvtHandlerPtr): def __init__(self,this): self.this = this @@ -79,6 +85,12 @@ class wxValidatorPtr(wxEvtHandlerPtr): return val def __repr__(self): return "" % (self.this,) + + _prop_list_ = { + 'window' : ('GetWindow', 'SetWindow'), + } + _prop_list_.update(wxEvtHandler._prop_list_) + class wxValidator(wxValidatorPtr): def __init__(self,*_args,**_kwargs): self.this = apply(windowsc.new_wxValidator,_args,_kwargs) @@ -469,6 +481,10 @@ class wxWindowPtr(wxEvtHandlerPtr): def SetSizer(self, *_args, **_kwargs): val = apply(windowsc.wxWindow_SetSizer,(self,) + _args, _kwargs) return val + def GetSizer(self, *_args, **_kwargs): + val = apply(windowsc.wxWindow_GetSizer,(self,) + _args, _kwargs) + if val: val = wxSizerPtr(val) + return val def GetValidator(self, *_args, **_kwargs): val = apply(windowsc.wxWindow_GetValidator,(self,) + _args, _kwargs) if val: val = wxValidatorPtr(val) @@ -503,7 +519,38 @@ class wxWindowPtr(wxEvtHandlerPtr): val = apply(windowsc.wxWindow_GetCaret,(self,) + _args, _kwargs) if val: val = wxCaretPtr(val) return val + + + _prop_list_ = { + 'size' : ('GetSize', 'SetSize'), + 'enabled' : ('IsEnabled', 'Enable'), + 'background' : ('GetBackgroundColour', 'SetBackgroundColour'), + 'foreground' : ('GetForegroundColour', 'SetForegroundColour'), + 'children' : ('GetChildren', None), + 'charHeight' : ('GetCharHeight', None), + 'charWidth' : ('GetCharWidth', None), + 'clientSize' : ('GetClientSize', 'SetClientSize'), + 'font' : ('GetFont', 'SetFont'), + 'grandParent' : ('GetGrandParent', None), + 'handle' : ('GetHandle', None), + 'label' : ('GetLabel', 'SetLabel'), + 'name' : ('GetName', 'SetName'), + 'parent' : ('GetParent', None), + 'position' : ('GetPosition', 'SetPosition'), + 'title' : ('GetTitle', 'SetTitle'), + 'style' : ('GetWindowStyleFlag', 'SetWindowStyleFlag'), + 'visible' : ('IsShown', 'Show'), + 'toolTip' : ('GetToolTip', 'SetToolTip'), + 'sizer' : ('GetSizer', 'SetSizer'), + 'validator' : ('GetValidator', 'SetValidator'), + 'dropTarget' : ('GetDropTarget', 'SetDropTarget'), + 'caret' : ('GetCaret', 'SetCaret'), + 'autoLayout' : ('GetAutoLayout', 'SetAutoLayout'), + 'constraints' : ('GetConstraints', 'SetConstraints'), + } + _prop_list_.update(wxEvtHandler._prop_list_) + class wxWindow(wxWindowPtr): def __init__(self,*_args,**_kwargs): self.this = apply(windowsc.new_wxWindow,_args,_kwargs) diff --git a/wxPython/src/gtk/wx.py b/wxPython/src/gtk/wx.py index 936d2e688f..1c1f08c9c8 100644 --- a/wxPython/src/gtk/wx.py +++ b/wxPython/src/gtk/wx.py @@ -852,10 +852,10 @@ _wxSetDictionary(vars()) # Helper function to link python methods to wxWindows virtual # functions by name. -## def _checkForCallback(obj, name, event, theID=-1): -## try: cb = getattr(obj, name) -## except: pass -## else: obj.Connect(theID, -1, event, cb) +def _checkForCallback(obj, name, event, theID=-1): + try: cb = getattr(obj, name) + except: pass + else: obj.Connect(theID, -1, event, cb) ## def _StdWindowCallbacks(win): ## _checkForCallback(win, "OnChar", wxEVT_CHAR)