return _resultobj;
}
+#define wxTreeEvent_IsEditCancelled(_swigobj) (_swigobj->IsEditCancelled())
+static PyObject *_wrap_wxTreeEvent_IsEditCancelled(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxTreeEvent * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxTreeEvent_IsEditCancelled",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxTreeEvent_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeEvent_IsEditCancelled. Expected _wxTreeEvent_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxTreeEvent_IsEditCancelled(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
static void *SwigwxPyTreeCtrlTowxControl(void *ptr) {
wxPyTreeCtrl *src;
wxControl *dest;
{ "wxTreeCtrl_Create", (PyCFunction) _wrap_wxTreeCtrl_Create, METH_VARARGS | METH_KEYWORDS },
{ "new_wxPreTreeCtrl", (PyCFunction) _wrap_new_wxPreTreeCtrl, METH_VARARGS | METH_KEYWORDS },
{ "new_wxTreeCtrl", (PyCFunction) _wrap_new_wxTreeCtrl, METH_VARARGS | METH_KEYWORDS },
+ { "wxTreeEvent_IsEditCancelled", (PyCFunction) _wrap_wxTreeEvent_IsEditCancelled, METH_VARARGS | METH_KEYWORDS },
{ "wxTreeEvent_GetLabel", (PyCFunction) _wrap_wxTreeEvent_GetLabel, METH_VARARGS | METH_KEYWORDS },
{ "wxTreeEvent_GetKeyCode", (PyCFunction) _wrap_wxTreeEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS },
{ "wxTreeEvent_GetKeyEvent", (PyCFunction) _wrap_wxTreeEvent_GetKeyEvent, METH_VARARGS | METH_KEYWORDS },
def GetLabel(self, *_args, **_kwargs):
val = apply(controls2c.wxTreeEvent_GetLabel,(self,) + _args, _kwargs)
return val
+ def IsEditCancelled(self, *_args, **_kwargs):
+ val = apply(controls2c.wxTreeEvent_IsEditCancelled,(self,) + _args, _kwargs)
+ return val
def __repr__(self):
return "<C wxTreeEvent instance at %s>" % (self.this,)
GetCode = GetKeyCode
}
static PyObject * wxDC__DrawPointList(wxDC *self,PyObject * pyPoints,PyObject * pyPens) {
+ wxPyBeginBlockThreads();
+
bool isFastSeq = PyList_Check(pyPoints) || PyTuple_Check(pyPoints);
bool isFastPens = PyList_Check(pyPens) || PyTuple_Check(pyPens);
int numObjs = 0;
PyObject* obj;
int x1, y1;
int i = 0;
+ PyObject* retval;
if (!PySequence_Check(pyPoints)) {
goto err0;
Py_DECREF(obj);
goto err0;
}
+ if (PyErr_Occurred()) {
+ retval = NULL;
+ if (!isFastPens)
+ Py_DECREF(obj);
+ goto exit;
+ }
+
// Now draw the point
self->DrawPoint(x1, y1);
}
Py_INCREF(Py_None);
- return Py_None;
+ retval = Py_None;
+ goto exit;
err1:
PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens");
- return NULL;
+ retval = NULL;
+ goto exit;
err0:
PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y) sequences.");
- return NULL;
+ retval = NULL;
+ goto exit;
+
+ exit:
+ wxPyEndBlockThreads();
+ return retval;
}
static PyObject *_wrap_wxDC__DrawPointList(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
}
static PyObject * wxDC__DrawLineList(wxDC *self,PyObject * pyLines,PyObject * pyPens) {
+ wxPyBeginBlockThreads();
+
bool isFastSeq = PyList_Check(pyLines) || PyTuple_Check(pyLines);
bool isFastPens = PyList_Check(pyPens) || PyTuple_Check(pyPens);
int numObjs = 0;
PyObject* obj;
int x1, y1, x2, y2;
int i = 0;
+ PyObject* retval;
if (!PySequence_Check(pyLines)) {
goto err0;
Py_DECREF(obj);
goto err0;
}
+ if (PyErr_Occurred()) {
+ retval = NULL;
+ if (!isFastPens)
+ Py_DECREF(obj);
+ goto exit;
+ }
// Now draw the line
self->DrawLine(x1, y1, x2, y2);
}
Py_INCREF(Py_None);
- return Py_None;
+ retval = Py_None;
+ goto exit;
err1:
PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens");
- return NULL;
+ retval = NULL;
+ goto exit;
+
err0:
PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x1,y1, x2,y2) sequences.");
- return NULL;
+ retval = NULL;
+ goto exit;
+
+ exit:
+ wxPyEndBlockThreads();
+ return retval;
}
static PyObject *_wrap_wxDC__DrawLineList(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxGridCellAttr_SetSize(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxGridCellAttr_SetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxGridCellAttr * _arg0;
+ int _arg1;
+ int _arg2;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","num_rows","num_cols", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridCellAttr_SetSize",_kwnames,&_argo0,&_arg1,&_arg2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetSize. Expected _wxGridCellAttr_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxGridCellAttr_SetSize(_arg0,_arg1,_arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxGridCellAttr_SetOverflow(_swigobj,_swigarg0) (_swigobj->SetOverflow(_swigarg0))
+static PyObject *_wrap_wxGridCellAttr_SetOverflow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxGridCellAttr * _arg0;
+ bool _arg1;
+ PyObject * _argo0 = 0;
+ int tempbool1;
+ char *_kwnames[] = { "self","allow", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellAttr_SetOverflow",_kwnames,&_argo0,&tempbool1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetOverflow. Expected _wxGridCellAttr_p.");
+ return NULL;
+ }
+ }
+ _arg1 = (bool ) tempbool1;
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxGridCellAttr_SetOverflow(_arg0,_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
#define wxGridCellAttr_SetReadOnly(_swigobj,_swigarg0) (_swigobj->SetReadOnly(_swigarg0))
static PyObject *_wrap_wxGridCellAttr_SetReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxGridCellAttr_GetSize(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxGridCellAttr_GetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxGridCellAttr * _arg0;
+ int * _arg1;
+ int * _arg2;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _argo2 = 0;
+ char *_kwnames[] = { "self","num_rows","num_cols", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGridCellAttr_GetSize",_kwnames,&_argo0,&_argo1,&_argo2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetSize. Expected _wxGridCellAttr_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_int_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_GetSize. Expected _int_p.");
+ return NULL;
+ }
+ }
+ if (_argo2) {
+ if (_argo2 == Py_None) { _arg2 = NULL; }
+ else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_int_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGridCellAttr_GetSize. Expected _int_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxGridCellAttr_GetSize(_arg0,_arg1,_arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxGridCellAttr_GetOverflow(_swigobj) (_swigobj->GetOverflow())
+static PyObject *_wrap_wxGridCellAttr_GetOverflow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxGridCellAttr * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_GetOverflow",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetOverflow. Expected _wxGridCellAttr_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxGridCellAttr_GetOverflow(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
#define wxGridCellAttr_GetRenderer(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->GetRenderer(_swigarg0,_swigarg1,_swigarg2))
static PyObject *_wrap_wxGridCellAttr_GetRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxGrid_Refresh(_swigobj,_swigarg0,_swigarg1) (_swigobj->Refresh(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxGrid_Refresh(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxGrid * _arg0;
+ bool _arg1 = (bool ) TRUE;
+ wxRect * _arg2 = (wxRect *) NULL;
+ PyObject * _argo0 = 0;
+ int tempbool1 = (int) TRUE;
+ wxRect temp;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","eraseb","rect", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iO:wxGrid_Refresh",_kwnames,&_argo0,&tempbool1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_Refresh. Expected _wxGrid_p.");
+ return NULL;
+ }
+ }
+ _arg1 = (bool ) tempbool1;
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxRect_helper(_obj2, &_arg2))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxGrid_Refresh(_arg0,_arg1,_arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
#define wxGrid_IsEditable(_swigobj) (_swigobj->IsEditable())
static PyObject *_wrap_wxGrid_IsEditable(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxGrid_SetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->SetAttr(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_wxGrid_SetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxGrid * _arg0;
+ int _arg1;
+ int _arg2;
+ wxGridCellAttr * _arg3;
+ PyObject * _argo0 = 0;
+ PyObject * _argo3 = 0;
+ char *_kwnames[] = { "self","row","col","attr", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetAttr. Expected _wxGrid_p.");
+ return NULL;
+ }
+ }
+ if (_argo3) {
+ if (_argo3 == Py_None) { _arg3 = NULL; }
+ else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellAttr_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetAttr. Expected _wxGridCellAttr_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxGrid_SetAttr(_arg0,_arg1,_arg2,_arg3);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
#define wxGrid_SetRowAttr(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetRowAttr(_swigarg0,_swigarg1))
static PyObject *_wrap_wxGrid_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxGrid_GetDefaultCellOverflow(_swigobj) (_swigobj->GetDefaultCellOverflow())
+static PyObject *_wrap_wxGrid_GetDefaultCellOverflow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxGrid * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellOverflow",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellOverflow. Expected _wxGrid_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxGrid_GetDefaultCellOverflow(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxGrid_GetCellOverflow(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetCellOverflow(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxGrid_GetCellOverflow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxGrid * _arg0;
+ int _arg1;
+ int _arg2;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","row","col", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellOverflow",_kwnames,&_argo0,&_arg1,&_arg2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellOverflow. Expected _wxGrid_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxGrid_GetCellOverflow(_arg0,_arg1,_arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxGrid_GetCellSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3) (_swigobj->GetCellSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
+static PyObject *_wrap_wxGrid_GetCellSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxGrid * _arg0;
+ int _arg1;
+ int _arg2;
+ int * _arg3;
+ int temp;
+ int * _arg4;
+ int temp0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","row","col", NULL };
+
+ self = self;
+{
+ _arg3 = &temp;
+}
+{
+ _arg4 = &temp0;
+}
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellSize",_kwnames,&_argo0,&_arg1,&_arg2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellSize. Expected _wxGrid_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxGrid_GetCellSize(_arg0,_arg1,_arg2,_arg3,_arg4);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ PyObject *o;
+ o = PyInt_FromLong((long) (*_arg3));
+ _resultobj = t_output_helper(_resultobj, o);
+}
+{
+ PyObject *o;
+ o = PyInt_FromLong((long) (*_arg4));
+ _resultobj = t_output_helper(_resultobj, o);
+}
+ return _resultobj;
+}
+
#define wxGrid_SetDefaultRowSize(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetDefaultRowSize(_swigarg0,_swigarg1))
static PyObject *_wrap_wxGrid_SetDefaultRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxGrid_SetDefaultCellOverflow(_swigobj,_swigarg0) (_swigobj->SetDefaultCellOverflow(_swigarg0))
+static PyObject *_wrap_wxGrid_SetDefaultCellOverflow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxGrid * _arg0;
+ bool _arg1;
+ PyObject * _argo0 = 0;
+ int tempbool1;
+ char *_kwnames[] = { "self","allow", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetDefaultCellOverflow",_kwnames,&_argo0,&tempbool1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellOverflow. Expected _wxGrid_p.");
+ return NULL;
+ }
+ }
+ _arg1 = (bool ) tempbool1;
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxGrid_SetDefaultCellOverflow(_arg0,_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxGrid_SetCellOverflow(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->SetCellOverflow(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_wxGrid_SetCellOverflow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxGrid * _arg0;
+ int _arg1;
+ int _arg2;
+ bool _arg3;
+ PyObject * _argo0 = 0;
+ int tempbool3;
+ char *_kwnames[] = { "self","row","col","allow", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGrid_SetCellOverflow",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellOverflow. Expected _wxGrid_p.");
+ return NULL;
+ }
+ }
+ _arg3 = (bool ) tempbool3;
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxGrid_SetCellOverflow(_arg0,_arg1,_arg2,_arg3);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxGrid_SetCellSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3) (_swigobj->SetCellSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
+static PyObject *_wrap_wxGrid_SetCellSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxGrid * _arg0;
+ int _arg1;
+ int _arg2;
+ int _arg3;
+ int _arg4;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","row","col","num_rows","num_cols", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii:wxGrid_SetCellSize",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellSize. Expected _wxGrid_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxGrid_SetCellSize(_arg0,_arg1,_arg2,_arg3,_arg4);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
#define wxGrid_SetDefaultRenderer(_swigobj,_swigarg0) (_swigobj->SetDefaultRenderer(_swigarg0))
static PyObject *_wrap_wxGrid_SetDefaultRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
{ "wxGrid_GetDefaultRenderer", (PyCFunction) _wrap_wxGrid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetCellRenderer", (PyCFunction) _wrap_wxGrid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetDefaultRenderer", (PyCFunction) _wrap_wxGrid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS },
+ { "wxGrid_SetCellSize", (PyCFunction) _wrap_wxGrid_SetCellSize, METH_VARARGS | METH_KEYWORDS },
+ { "wxGrid_SetCellOverflow", (PyCFunction) _wrap_wxGrid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS },
+ { "wxGrid_SetDefaultCellOverflow", (PyCFunction) _wrap_wxGrid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetCellAlignment", (PyCFunction) _wrap_wxGrid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetDefaultCellAlignment", (PyCFunction) _wrap_wxGrid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetCellFont", (PyCFunction) _wrap_wxGrid_SetCellFont, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetDefaultColSize", (PyCFunction) _wrap_wxGrid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetRowSize", (PyCFunction) _wrap_wxGrid_SetRowSize, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetDefaultRowSize", (PyCFunction) _wrap_wxGrid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS },
+ { "wxGrid_GetCellSize", (PyCFunction) _wrap_wxGrid_GetCellSize, METH_VARARGS | METH_KEYWORDS },
+ { "wxGrid_GetCellOverflow", (PyCFunction) _wrap_wxGrid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS },
+ { "wxGrid_GetDefaultCellOverflow", (PyCFunction) _wrap_wxGrid_GetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_GetCellAlignment", (PyCFunction) _wrap_wxGrid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_GetDefaultCellAlignment", (PyCFunction) _wrap_wxGrid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_GetCellFont", (PyCFunction) _wrap_wxGrid_GetCellFont, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetColFormatBool", (PyCFunction) _wrap_wxGrid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetColAttr", (PyCFunction) _wrap_wxGrid_SetColAttr, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_SetRowAttr", (PyCFunction) _wrap_wxGrid_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
+ { "wxGrid_SetAttr", (PyCFunction) _wrap_wxGrid_SetAttr, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_CanDragGridSize", (PyCFunction) _wrap_wxGrid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_DisableDragGridSize", (PyCFunction) _wrap_wxGrid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_EnableDragGridSize", (PyCFunction) _wrap_wxGrid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_EnableCellEditControl", (PyCFunction) _wrap_wxGrid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_EnableEditing", (PyCFunction) _wrap_wxGrid_EnableEditing, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_IsEditable", (PyCFunction) _wrap_wxGrid_IsEditable, METH_VARARGS | METH_KEYWORDS },
+ { "wxGrid_Refresh", (PyCFunction) _wrap_wxGrid_Refresh, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_ForceRefresh", (PyCFunction) _wrap_wxGrid_ForceRefresh, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_GetBatchCount", (PyCFunction) _wrap_wxGrid_GetBatchCount, METH_VARARGS | METH_KEYWORDS },
{ "wxGrid_EndBatch", (PyCFunction) _wrap_wxGrid_EndBatch, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_IsReadOnly", (PyCFunction) _wrap_wxGridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_GetEditor", (PyCFunction) _wrap_wxGridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_GetRenderer", (PyCFunction) _wrap_wxGridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS },
+ { "wxGridCellAttr_GetOverflow", (PyCFunction) _wrap_wxGridCellAttr_GetOverflow, METH_VARARGS | METH_KEYWORDS },
+ { "wxGridCellAttr_GetSize", (PyCFunction) _wrap_wxGridCellAttr_GetSize, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_GetAlignment", (PyCFunction) _wrap_wxGridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_GetFont", (PyCFunction) _wrap_wxGridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_SetEditor", (PyCFunction) _wrap_wxGridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_SetRenderer", (PyCFunction) _wrap_wxGridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_SetReadOnly", (PyCFunction) _wrap_wxGridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS },
+ { "wxGridCellAttr_SetOverflow", (PyCFunction) _wrap_wxGridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS },
+ { "wxGridCellAttr_SetSize", (PyCFunction) _wrap_wxGridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_SetAlignment", (PyCFunction) _wrap_wxGridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_SetFont", (PyCFunction) _wrap_wxGridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS },
{ "wxGridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
def SetAlignment(self, *_args, **_kwargs):
val = apply(gridc.wxGridCellAttr_SetAlignment,(self,) + _args, _kwargs)
return val
+ def SetSize(self, *_args, **_kwargs):
+ val = apply(gridc.wxGridCellAttr_SetSize,(self,) + _args, _kwargs)
+ return val
+ def SetOverflow(self, *_args, **_kwargs):
+ val = apply(gridc.wxGridCellAttr_SetOverflow,(self,) + _args, _kwargs)
+ return val
def SetReadOnly(self, *_args, **_kwargs):
val = apply(gridc.wxGridCellAttr_SetReadOnly,(self,) + _args, _kwargs)
return val
def GetAlignment(self, *_args, **_kwargs):
val = apply(gridc.wxGridCellAttr_GetAlignment,(self,) + _args, _kwargs)
return val
+ def GetSize(self, *_args, **_kwargs):
+ val = apply(gridc.wxGridCellAttr_GetSize,(self,) + _args, _kwargs)
+ return val
+ def GetOverflow(self, *_args, **_kwargs):
+ val = apply(gridc.wxGridCellAttr_GetOverflow,(self,) + _args, _kwargs)
+ return val
def GetRenderer(self, *_args, **_kwargs):
val = apply(gridc.wxGridCellAttr_GetRenderer,(self,) + _args, _kwargs)
return val
def ForceRefresh(self, *_args, **_kwargs):
val = apply(gridc.wxGrid_ForceRefresh,(self,) + _args, _kwargs)
return val
+ def Refresh(self, *_args, **_kwargs):
+ val = apply(gridc.wxGrid_Refresh,(self,) + _args, _kwargs)
+ return val
def IsEditable(self, *_args, **_kwargs):
val = apply(gridc.wxGrid_IsEditable,(self,) + _args, _kwargs)
return val
def CanDragGridSize(self, *_args, **_kwargs):
val = apply(gridc.wxGrid_CanDragGridSize,(self,) + _args, _kwargs)
return val
+ def SetAttr(self, *_args, **_kwargs):
+ val = apply(gridc.wxGrid_SetAttr,(self,) + _args, _kwargs)
+ return val
def SetRowAttr(self, *_args, **_kwargs):
val = apply(gridc.wxGrid_SetRowAttr,(self,) + _args, _kwargs)
return val
def GetCellAlignment(self, *_args, **_kwargs):
val = apply(gridc.wxGrid_GetCellAlignment,(self,) + _args, _kwargs)
return val
+ def GetDefaultCellOverflow(self, *_args, **_kwargs):
+ val = apply(gridc.wxGrid_GetDefaultCellOverflow,(self,) + _args, _kwargs)
+ return val
+ def GetCellOverflow(self, *_args, **_kwargs):
+ val = apply(gridc.wxGrid_GetCellOverflow,(self,) + _args, _kwargs)
+ return val
+ def GetCellSize(self, *_args, **_kwargs):
+ val = apply(gridc.wxGrid_GetCellSize,(self,) + _args, _kwargs)
+ return val
def SetDefaultRowSize(self, *_args, **_kwargs):
val = apply(gridc.wxGrid_SetDefaultRowSize,(self,) + _args, _kwargs)
return val
def SetCellAlignment(self, *_args, **_kwargs):
val = apply(gridc.wxGrid_SetCellAlignment,(self,) + _args, _kwargs)
return val
+ def SetDefaultCellOverflow(self, *_args, **_kwargs):
+ val = apply(gridc.wxGrid_SetDefaultCellOverflow,(self,) + _args, _kwargs)
+ return val
+ def SetCellOverflow(self, *_args, **_kwargs):
+ val = apply(gridc.wxGrid_SetCellOverflow,(self,) + _args, _kwargs)
+ return val
+ def SetCellSize(self, *_args, **_kwargs):
+ val = apply(gridc.wxGrid_SetCellSize,(self,) + _args, _kwargs)
+ return val
def SetDefaultRenderer(self, *_args, **_kwargs):
val = apply(gridc.wxGrid_SetDefaultRenderer,(self,) + _args, _kwargs)
return val
#endif
#include <wx/mimetype.h>
+#include <wx/snglinst.h>
+#include <wx/effects.h>
+//#include <wx/spawnbrowser.h>
static PyObject* t_output_helper(PyObject* target, PyObject* o) {
: wxTipProvider(currentTip) {}
DEC_PYCALLBACK_STRING__pure(GetTip);
-
+ DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
PYPRIVATE;
};
IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
-
+IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
#include <wx/generic/dragimgg.h>
return _resultobj;
}
+#define wxTipProvider_PreprocessTip(_swigobj,_swigarg0) (_swigobj->PreprocessTip(_swigarg0))
+static PyObject *_wrap_wxTipProvider_PreprocessTip(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxTipProvider * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","tip", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxTipProvider_PreprocessTip",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxTipProvider_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTipProvider_PreprocessTip. Expected _wxTipProvider_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = wxString_in_helper(_obj1);
+ if (_arg1 == NULL)
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxString (wxTipProvider_PreprocessTip(_arg0,*_arg1));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+}{
+#if wxUSE_UNICODE
+ _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
+ _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
+}
+{
+ if (_obj1)
+ delete _arg1;
+}
+{
+ delete _result;
+}
+ return _resultobj;
+}
+
static void *SwigwxPyTipProviderTowxTipProvider(void *ptr) {
wxPyTipProvider *src;
wxTipProvider *dest;
return _resultobj;
}
+static PyObject *_wrap_wxLog_GetTraceMasks(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxArrayString * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxLog_GetTraceMasks",_kwnames))
+ return NULL;
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ const wxArrayString & _result_ref = wxLog::GetTraceMasks();
+ _result = (wxArrayString *) &_result_ref;
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxArrayString_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
static PyObject *_wrap_wxLog_SetTimestamp(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxString * _arg0;
return _resultobj;
}
+static void *SwigwxEffectsTowxObject(void *ptr) {
+ wxEffects *src;
+ wxObject *dest;
+ src = (wxEffects *) ptr;
+ dest = (wxObject *) src;
+ return (void *) dest;
+}
+
+#define new_wxEffects() (new wxEffects())
+static PyObject *_wrap_new_wxEffects(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEffects * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxEffects",_kwnames))
+ return NULL;
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxEffects *)new_wxEffects();
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxEffects_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxEffects_GetHighlightColour(_swigobj) (_swigobj->GetHighlightColour())
+static PyObject *_wrap_wxEffects_GetHighlightColour(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxColour * _result;
+ wxEffects * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxEffects_GetHighlightColour",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_GetHighlightColour. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxColour (wxEffects_GetHighlightColour(_arg0));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxEffects_GetLightShadow(_swigobj) (_swigobj->GetLightShadow())
+static PyObject *_wrap_wxEffects_GetLightShadow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxColour * _result;
+ wxEffects * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxEffects_GetLightShadow",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_GetLightShadow. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxColour (wxEffects_GetLightShadow(_arg0));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxEffects_GetFaceColour(_swigobj) (_swigobj->GetFaceColour())
+static PyObject *_wrap_wxEffects_GetFaceColour(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxColour * _result;
+ wxEffects * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxEffects_GetFaceColour",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_GetFaceColour. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxColour (wxEffects_GetFaceColour(_arg0));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxEffects_GetMediumShadow(_swigobj) (_swigobj->GetMediumShadow())
+static PyObject *_wrap_wxEffects_GetMediumShadow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxColour * _result;
+ wxEffects * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxEffects_GetMediumShadow",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_GetMediumShadow. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxColour (wxEffects_GetMediumShadow(_arg0));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxEffects_GetDarkShadow(_swigobj) (_swigobj->GetDarkShadow())
+static PyObject *_wrap_wxEffects_GetDarkShadow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxColour * _result;
+ wxEffects * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxEffects_GetDarkShadow",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_GetDarkShadow. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxColour (wxEffects_GetDarkShadow(_arg0));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxEffects_SetHighlightColour(_swigobj,_swigarg0) (_swigobj->SetHighlightColour(_swigarg0))
+static PyObject *_wrap_wxEffects_SetHighlightColour(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEffects * _arg0;
+ wxColour * _arg1;
+ PyObject * _argo0 = 0;
+ wxColour temp;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","c", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEffects_SetHighlightColour",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_SetHighlightColour. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = &temp;
+ if (! wxColour_helper(_obj1, &_arg1))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxEffects_SetHighlightColour(_arg0,*_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxEffects_SetLightShadow(_swigobj,_swigarg0) (_swigobj->SetLightShadow(_swigarg0))
+static PyObject *_wrap_wxEffects_SetLightShadow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEffects * _arg0;
+ wxColour * _arg1;
+ PyObject * _argo0 = 0;
+ wxColour temp;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","c", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEffects_SetLightShadow",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_SetLightShadow. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = &temp;
+ if (! wxColour_helper(_obj1, &_arg1))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxEffects_SetLightShadow(_arg0,*_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxEffects_SetFaceColour(_swigobj,_swigarg0) (_swigobj->SetFaceColour(_swigarg0))
+static PyObject *_wrap_wxEffects_SetFaceColour(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEffects * _arg0;
+ wxColour * _arg1;
+ PyObject * _argo0 = 0;
+ wxColour temp;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","c", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEffects_SetFaceColour",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_SetFaceColour. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = &temp;
+ if (! wxColour_helper(_obj1, &_arg1))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxEffects_SetFaceColour(_arg0,*_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxEffects_SetMediumShadow(_swigobj,_swigarg0) (_swigobj->SetMediumShadow(_swigarg0))
+static PyObject *_wrap_wxEffects_SetMediumShadow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEffects * _arg0;
+ wxColour * _arg1;
+ PyObject * _argo0 = 0;
+ wxColour temp;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","c", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEffects_SetMediumShadow",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_SetMediumShadow. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = &temp;
+ if (! wxColour_helper(_obj1, &_arg1))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxEffects_SetMediumShadow(_arg0,*_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxEffects_SetDarkShadow(_swigobj,_swigarg0) (_swigobj->SetDarkShadow(_swigarg0))
+static PyObject *_wrap_wxEffects_SetDarkShadow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEffects * _arg0;
+ wxColour * _arg1;
+ PyObject * _argo0 = 0;
+ wxColour temp;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","c", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEffects_SetDarkShadow",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_SetDarkShadow. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = &temp;
+ if (! wxColour_helper(_obj1, &_arg1))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxEffects_SetDarkShadow(_arg0,*_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxEffects_Set(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (_swigobj->Set(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_wxEffects_Set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEffects * _arg0;
+ wxColour * _arg1;
+ wxColour * _arg2;
+ wxColour * _arg3;
+ wxColour * _arg4;
+ wxColour * _arg5;
+ PyObject * _argo0 = 0;
+ wxColour temp;
+ PyObject * _obj1 = 0;
+ wxColour temp0;
+ PyObject * _obj2 = 0;
+ wxColour temp1;
+ PyObject * _obj3 = 0;
+ wxColour temp2;
+ PyObject * _obj4 = 0;
+ wxColour temp3;
+ PyObject * _obj5 = 0;
+ char *_kwnames[] = { "self","highlightColour","lightShadow","faceColour","mediumShadow","darkShadow", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOOOO:wxEffects_Set",_kwnames,&_argo0,&_obj1,&_obj2,&_obj3,&_obj4,&_obj5))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_Set. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = &temp;
+ if (! wxColour_helper(_obj1, &_arg1))
+ return NULL;
+}
+{
+ _arg2 = &temp0;
+ if (! wxColour_helper(_obj2, &_arg2))
+ return NULL;
+}
+{
+ _arg3 = &temp1;
+ if (! wxColour_helper(_obj3, &_arg3))
+ return NULL;
+}
+{
+ _arg4 = &temp2;
+ if (! wxColour_helper(_obj4, &_arg4))
+ return NULL;
+}
+{
+ _arg5 = &temp3;
+ if (! wxColour_helper(_obj5, &_arg5))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxEffects_Set(_arg0,*_arg1,*_arg2,*_arg3,*_arg4,*_arg5);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxEffects_DrawSunkenEdge(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->DrawSunkenEdge(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_wxEffects_DrawSunkenEdge(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEffects * _arg0;
+ wxDC * _arg1;
+ wxRect * _arg2;
+ int _arg3 = (int ) 1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ wxRect temp;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","dc","rect","borderSize", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|i:wxEffects_DrawSunkenEdge",_kwnames,&_argo0,&_argo1,&_obj2,&_arg3))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_DrawSunkenEdge. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxDC_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxEffects_DrawSunkenEdge. Expected _wxDC_p.");
+ return NULL;
+ }
+ }
+{
+ _arg2 = &temp;
+ if (! wxRect_helper(_obj2, &_arg2))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxEffects_DrawSunkenEdge(_arg0,*_arg1,*_arg2,_arg3);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxEffects_TileBitmap(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->TileBitmap(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_wxEffects_TileBitmap(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxEffects * _arg0;
+ wxRect * _arg1;
+ wxDC * _arg2;
+ wxBitmap * _arg3;
+ PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj1 = 0;
+ PyObject * _argo2 = 0;
+ PyObject * _argo3 = 0;
+ char *_kwnames[] = { "self","rect","dc","bitmap", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOO:wxEffects_TileBitmap",_kwnames,&_argo0,&_obj1,&_argo2,&_argo3))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEffects_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEffects_TileBitmap. Expected _wxEffects_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = &temp;
+ if (! wxRect_helper(_obj1, &_arg1))
+ return NULL;
+}
+ if (_argo2) {
+ if (_argo2 == Py_None) { _arg2 = NULL; }
+ else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxDC_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxEffects_TileBitmap. Expected _wxDC_p.");
+ return NULL;
+ }
+ }
+ if (_argo3) {
+ if (_argo3 == Py_None) { _arg3 = NULL; }
+ else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxBitmap_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxEffects_TileBitmap. Expected _wxBitmap_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxEffects_TileBitmap(_arg0,*_arg1,*_arg2,*_arg3);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define new_wxSingleInstanceChecker(_swigarg0,_swigarg1) (new wxSingleInstanceChecker(_swigarg0,_swigarg1))
+static PyObject *_wrap_new_wxSingleInstanceChecker(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSingleInstanceChecker * _result;
+ wxString * _arg0;
+ wxString * _arg1 = (wxString *) &wxPyEmptyString;
+ PyObject * _obj0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "name","path", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|O:new_wxSingleInstanceChecker",_kwnames,&_obj0,&_obj1))
+ return NULL;
+{
+ _arg0 = wxString_in_helper(_obj0);
+ if (_arg0 == NULL)
+ return NULL;
+}
+ if (_obj1)
+{
+ _arg1 = wxString_in_helper(_obj1);
+ if (_arg1 == NULL)
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxSingleInstanceChecker *)new_wxSingleInstanceChecker(*_arg0,*_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxSingleInstanceChecker_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+{
+ if (_obj0)
+ delete _arg0;
+}
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define new_wxPreSingleInstanceChecker() (new wxSingleInstanceChecker())
+static PyObject *_wrap_new_wxPreSingleInstanceChecker(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSingleInstanceChecker * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPreSingleInstanceChecker",_kwnames))
+ return NULL;
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxSingleInstanceChecker *)new_wxPreSingleInstanceChecker();
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxSingleInstanceChecker_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define delete_wxSingleInstanceChecker(_swigobj) (delete _swigobj)
+static PyObject *_wrap_delete_wxSingleInstanceChecker(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSingleInstanceChecker * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxSingleInstanceChecker",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSingleInstanceChecker_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxSingleInstanceChecker. Expected _wxSingleInstanceChecker_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ delete_wxSingleInstanceChecker(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxSingleInstanceChecker_Create(_swigobj,_swigarg0,_swigarg1) (_swigobj->Create(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxSingleInstanceChecker_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxSingleInstanceChecker * _arg0;
+ wxString * _arg1;
+ wxString * _arg2 = (wxString *) &wxPyEmptyString;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","name","path", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|O:wxSingleInstanceChecker_Create",_kwnames,&_argo0,&_obj1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSingleInstanceChecker_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSingleInstanceChecker_Create. Expected _wxSingleInstanceChecker_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = wxString_in_helper(_obj1);
+ if (_arg1 == NULL)
+ return NULL;
+}
+ if (_obj2)
+{
+ _arg2 = wxString_in_helper(_obj2);
+ if (_arg2 == NULL)
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxSingleInstanceChecker_Create(_arg0,*_arg1,*_arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+{
+ if (_obj1)
+ delete _arg1;
+}
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
+#define wxSingleInstanceChecker_IsAnotherRunning(_swigobj) (_swigobj->IsAnotherRunning())
+static PyObject *_wrap_wxSingleInstanceChecker_IsAnotherRunning(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxSingleInstanceChecker * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSingleInstanceChecker_IsAnotherRunning",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSingleInstanceChecker_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSingleInstanceChecker_IsAnotherRunning. Expected _wxSingleInstanceChecker_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxSingleInstanceChecker_IsAnotherRunning(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
static PyMethodDef misc2cMethods[] = {
+ { "wxSingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_wxSingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS },
+ { "wxSingleInstanceChecker_Create", (PyCFunction) _wrap_wxSingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS },
+ { "delete_wxSingleInstanceChecker", (PyCFunction) _wrap_delete_wxSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxPreSingleInstanceChecker", (PyCFunction) _wrap_new_wxPreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxSingleInstanceChecker", (PyCFunction) _wrap_new_wxSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_TileBitmap", (PyCFunction) _wrap_wxEffects_TileBitmap, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_DrawSunkenEdge", (PyCFunction) _wrap_wxEffects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_Set", (PyCFunction) _wrap_wxEffects_Set, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_SetDarkShadow", (PyCFunction) _wrap_wxEffects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_SetMediumShadow", (PyCFunction) _wrap_wxEffects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_SetFaceColour", (PyCFunction) _wrap_wxEffects_SetFaceColour, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_SetLightShadow", (PyCFunction) _wrap_wxEffects_SetLightShadow, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_SetHighlightColour", (PyCFunction) _wrap_wxEffects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_GetDarkShadow", (PyCFunction) _wrap_wxEffects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_GetMediumShadow", (PyCFunction) _wrap_wxEffects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_GetFaceColour", (PyCFunction) _wrap_wxEffects_GetFaceColour, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_GetLightShadow", (PyCFunction) _wrap_wxEffects_GetLightShadow, METH_VARARGS | METH_KEYWORDS },
+ { "wxEffects_GetHighlightColour", (PyCFunction) _wrap_wxEffects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxEffects", (PyCFunction) _wrap_new_wxEffects, METH_VARARGS | METH_KEYWORDS },
{ "wxFileHistory_GetNoHistoryFiles", (PyCFunction) _wrap_wxFileHistory_GetNoHistoryFiles, METH_VARARGS | METH_KEYWORDS },
{ "wxFileHistory_GetCount", (PyCFunction) _wrap_wxFileHistory_GetCount, METH_VARARGS | METH_KEYWORDS },
{ "wxFileHistory_GetHistoryFile", (PyCFunction) _wrap_wxFileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS },
{ "wxLog_GetVerbose", (PyCFunction) _wrap_wxLog_GetVerbose, METH_VARARGS | METH_KEYWORDS },
{ "wxLog_GetTimestamp", (PyCFunction) _wrap_wxLog_GetTimestamp, METH_VARARGS | METH_KEYWORDS },
{ "wxLog_SetTimestamp", (PyCFunction) _wrap_wxLog_SetTimestamp, METH_VARARGS | METH_KEYWORDS },
+ { "wxLog_GetTraceMasks", (PyCFunction) _wrap_wxLog_GetTraceMasks, METH_VARARGS | METH_KEYWORDS },
{ "wxLog_ClearTraceMasks", (PyCFunction) _wrap_wxLog_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS },
{ "wxLog_RemoveTraceMask", (PyCFunction) _wrap_wxLog_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS },
{ "wxLog_AddTraceMask", (PyCFunction) _wrap_wxLog_AddTraceMask, METH_VARARGS | METH_KEYWORDS },
{ "new_wxDragImage", (PyCFunction) _wrap_new_wxDragImage, METH_VARARGS | METH_KEYWORDS },
{ "wxPyTipProvider__setCallbackInfo", (PyCFunction) _wrap_wxPyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
{ "new_wxPyTipProvider", (PyCFunction) _wrap_new_wxPyTipProvider, METH_VARARGS | METH_KEYWORDS },
+ { "wxTipProvider_PreprocessTip", (PyCFunction) _wrap_wxTipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS },
{ "wxTipProvider_GetCurrentTip", (PyCFunction) _wrap_wxTipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS },
{ "wxTipProvider_GetTip", (PyCFunction) _wrap_wxTipProvider_GetTip, METH_VARARGS | METH_KEYWORDS },
{ "delete_wxTipProvider", (PyCFunction) _wrap_delete_wxTipProvider, METH_VARARGS | METH_KEYWORDS },
{ "_unsigned_short","_wxDateTime_t",0},
{ "_unsigned_short","_WXTYPE",0},
{ "_unsigned_short","_short",0},
+ { "_wxObject","_wxEffects",SwigwxEffectsTowxObject},
{ "_wxObject","_wxFileHistory",SwigwxFileHistoryTowxObject},
{ "_wxObject","_wxPyArtProvider",SwigwxPyArtProviderTowxObject},
{ "_wxObject","_wxWave",SwigwxWaveTowxObject},
def GetCurrentTip(self, *_args, **_kwargs):
val = apply(misc2c.wxTipProvider_GetCurrentTip,(self,) + _args, _kwargs)
return val
+ def PreprocessTip(self, *_args, **_kwargs):
+ val = apply(misc2c.wxTipProvider_PreprocessTip,(self,) + _args, _kwargs)
+ return val
def __repr__(self):
return "<C wxTipProvider instance at %s>" % (self.this,)
class wxTipProvider(wxTipProviderPtr):
+class wxEffectsPtr(wxObjectPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def GetHighlightColour(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_GetHighlightColour,(self,) + _args, _kwargs)
+ if val: val = wxColourPtr(val) ; val.thisown = 1
+ return val
+ def GetLightShadow(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_GetLightShadow,(self,) + _args, _kwargs)
+ if val: val = wxColourPtr(val) ; val.thisown = 1
+ return val
+ def GetFaceColour(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_GetFaceColour,(self,) + _args, _kwargs)
+ if val: val = wxColourPtr(val) ; val.thisown = 1
+ return val
+ def GetMediumShadow(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_GetMediumShadow,(self,) + _args, _kwargs)
+ if val: val = wxColourPtr(val) ; val.thisown = 1
+ return val
+ def GetDarkShadow(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_GetDarkShadow,(self,) + _args, _kwargs)
+ if val: val = wxColourPtr(val) ; val.thisown = 1
+ return val
+ def SetHighlightColour(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_SetHighlightColour,(self,) + _args, _kwargs)
+ return val
+ def SetLightShadow(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_SetLightShadow,(self,) + _args, _kwargs)
+ return val
+ def SetFaceColour(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_SetFaceColour,(self,) + _args, _kwargs)
+ return val
+ def SetMediumShadow(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_SetMediumShadow,(self,) + _args, _kwargs)
+ return val
+ def SetDarkShadow(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_SetDarkShadow,(self,) + _args, _kwargs)
+ return val
+ def Set(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_Set,(self,) + _args, _kwargs)
+ return val
+ def DrawSunkenEdge(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_DrawSunkenEdge,(self,) + _args, _kwargs)
+ return val
+ def TileBitmap(self, *_args, **_kwargs):
+ val = apply(misc2c.wxEffects_TileBitmap,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxEffects instance at %s>" % (self.this,)
+class wxEffects(wxEffectsPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(misc2c.new_wxEffects,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+class wxSingleInstanceCheckerPtr :
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def __del__(self,misc2c=misc2c):
+ if self.thisown == 1 :
+ misc2c.delete_wxSingleInstanceChecker(self)
+ def Create(self, *_args, **_kwargs):
+ val = apply(misc2c.wxSingleInstanceChecker_Create,(self,) + _args, _kwargs)
+ return val
+ def IsAnotherRunning(self, *_args, **_kwargs):
+ val = apply(misc2c.wxSingleInstanceChecker_IsAnotherRunning,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxSingleInstanceChecker instance at %s>" % (self.this,)
+class wxSingleInstanceChecker(wxSingleInstanceCheckerPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(misc2c.new_wxSingleInstanceChecker,_args,_kwargs)
+ self.thisown = 1
+
+
+
+def wxPreSingleInstanceChecker(*_args,**_kwargs):
+ val = wxSingleInstanceCheckerPtr(apply(misc2c.new_wxPreSingleInstanceChecker,_args,_kwargs))
+ val.thisown = 1
+ return val
+
+
#-------------- FUNCTION WRAPPERS ------------------
wxLog_ClearTraceMasks = misc2c.wxLog_ClearTraceMasks
+wxLog_GetTraceMasks = misc2c.wxLog_GetTraceMasks
+
wxLog_SetTimestamp = misc2c.wxLog_SetTimestamp
wxLog_GetTimestamp = misc2c.wxLog_GetTimestamp
return _resultobj;
}
+#define wxPyApp_Yield(_swigobj,_swigarg0) (_swigobj->Yield(_swigarg0))
+static PyObject *_wrap_wxPyApp_Yield(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxPyApp * _arg0;
+ bool _arg1 = (bool ) (0);
+ PyObject * _argo0 = 0;
+ int tempbool1 = (int) (0);
+ char *_kwnames[] = { "self","onlyIfNeeded", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxPyApp_Yield",_kwnames,&_argo0,&tempbool1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyApp_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyApp_Yield. Expected _wxPyApp_p.");
+ return NULL;
+ }
+ }
+ _arg1 = (bool ) tempbool1;
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxPyApp_Yield(_arg0,_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
#define wxPyApp_SetAppName(_swigobj,_swigarg0) (_swigobj->SetAppName(_swigarg0))
static PyObject *_wrap_wxPyApp_SetAppName(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
{ "wxPyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_wxPyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS },
{ "wxPyApp_SetClassName", (PyCFunction) _wrap_wxPyApp_SetClassName, METH_VARARGS | METH_KEYWORDS },
{ "wxPyApp_SetAppName", (PyCFunction) _wrap_wxPyApp_SetAppName, METH_VARARGS | METH_KEYWORDS },
+ { "wxPyApp_Yield", (PyCFunction) _wrap_wxPyApp_Yield, METH_VARARGS | METH_KEYWORDS },
{ "wxPyApp_ProcessIdle", (PyCFunction) _wrap_wxPyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS },
{ "wxPyApp_Pending", (PyCFunction) _wrap_wxPyApp_Pending, METH_VARARGS | METH_KEYWORDS },
{ "wxPyApp_MainLoop", (PyCFunction) _wrap_wxPyApp_MainLoop, METH_VARARGS | METH_KEYWORDS },
PyDict_SetItemString(d,"wxTE_DONTWRAP", PyInt_FromLong((long) wxTE_DONTWRAP));
PyDict_SetItemString(d,"wxTE_LINEWRAP", PyInt_FromLong((long) wxTE_LINEWRAP));
PyDict_SetItemString(d,"wxTE_WORDWRAP", PyInt_FromLong((long) wxTE_WORDWRAP));
+ PyDict_SetItemString(d,"wxTE_LEFT", PyInt_FromLong((long) wxTE_LEFT));
+ PyDict_SetItemString(d,"wxTE_RIGHT", PyInt_FromLong((long) wxTE_RIGHT));
+ PyDict_SetItemString(d,"wxTE_CENTER", PyInt_FromLong((long) wxTE_CENTER));
+ PyDict_SetItemString(d,"wxTE_CENTRE", PyInt_FromLong((long) wxTE_CENTRE));
PyDict_SetItemString(d,"wxCB_SIMPLE", PyInt_FromLong((long) wxCB_SIMPLE));
PyDict_SetItemString(d,"wxCB_DROPDOWN", PyInt_FromLong((long) wxCB_DROPDOWN));
PyDict_SetItemString(d,"wxCB_SORT", PyInt_FromLong((long) wxCB_SORT));
def ProcessIdle(self, *_args, **_kwargs):
val = apply(wxc.wxPyApp_ProcessIdle,(self,) + _args, _kwargs)
return val
+ def Yield(self, *_args, **_kwargs):
+ val = apply(wxc.wxPyApp_Yield,(self,) + _args, _kwargs)
+ return val
def SetAppName(self, *_args, **_kwargs):
val = apply(wxc.wxPyApp_SetAppName,(self,) + _args, _kwargs)
return val
wxTE_DONTWRAP = wxc.wxTE_DONTWRAP
wxTE_LINEWRAP = wxc.wxTE_LINEWRAP
wxTE_WORDWRAP = wxc.wxTE_WORDWRAP
+wxTE_LEFT = wxc.wxTE_LEFT
+wxTE_RIGHT = wxc.wxTE_RIGHT
+wxTE_CENTER = wxc.wxTE_CENTER
+wxTE_CENTRE = wxc.wxTE_CENTRE
wxCB_SIMPLE = wxc.wxCB_SIMPLE
wxCB_DROPDOWN = wxc.wxCB_DROPDOWN
wxCB_SORT = wxc.wxCB_SORT
projects / wxWidgets.git / commitdiff
