return _resultobj;
}
-#define wxListCtrl_GetColumn(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetColumn(_swigarg0,_swigarg1))
+static wxListItem * wxPyListCtrl_GetColumn(wxPyListCtrl *self,int col) {
+ wxListItem item;
+ if (self->GetColumn(col, item))
+ return new wxListItem(item);
+ else
+ return NULL;
+ }
static PyObject *_wrap_wxListCtrl_GetColumn(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
- bool _result;
+ wxListItem * _result;
wxPyListCtrl * _arg0;
int _arg1;
- wxListItem * _arg2;
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- char *_kwnames[] = { "self","col","item", NULL };
+ char *_kwnames[] = { "self","col", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxListCtrl_GetColumn",_kwnames,&_argo0,&_arg1,&_argo2))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxListCtrl_GetColumn",_kwnames,&_argo0,&_arg1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxListItem_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxListCtrl_GetColumn. Expected _wxListItem_p.");
- return NULL;
- }
- }
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
- _result = (bool )wxListCtrl_GetColumn(_arg0,_arg1,*_arg2);
+ _result = (wxListItem *)wxPyListCtrl_GetColumn(_arg0,_arg1);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) return NULL;
-} _resultobj = Py_BuildValue("i",_result);
+}{ _resultobj = wxPyMake_wxObject(_result); }
return _resultobj;
}
def __repr__(self):
return "<C wxListCtrl instance at %s>" % (self.this,)
+ def GetItem(self, *_args, **_kwargs):
+ val = apply(controls2c.wxListCtrl_GetColumn,(self,) + _args, _kwargs)
+ if val is not None: val.thisown = 1
+ return val
+
+
def GetItem(self, *_args, **_kwargs):
val = apply(controls2c.wxListCtrl_GetItem,(self,) + _args, _kwargs)
val.thisown = 1
return _resultobj;
}
+static void *SwigwxDisplayChangedEventTowxEvent(void *ptr) {
+ wxDisplayChangedEvent *src;
+ wxEvent *dest;
+ src = (wxDisplayChangedEvent *) ptr;
+ dest = (wxEvent *) src;
+ return (void *) dest;
+}
+
+static void *SwigwxDisplayChangedEventTowxObject(void *ptr) {
+ wxDisplayChangedEvent *src;
+ wxObject *dest;
+ src = (wxDisplayChangedEvent *) ptr;
+ dest = (wxObject *) src;
+ return (void *) dest;
+}
+
+#define new_wxDisplayChangedEvent() (new wxDisplayChangedEvent())
+static PyObject *_wrap_new_wxDisplayChangedEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxDisplayChangedEvent * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxDisplayChangedEvent",_kwnames))
+ return NULL;
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxDisplayChangedEvent *)new_wxDisplayChangedEvent();
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxDisplayChangedEvent_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
static void *SwigwxPaletteChangedEventTowxEvent(void *ptr) {
wxPaletteChangedEvent *src;
wxEvent *dest;
{ "wxPaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_wxPaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS },
{ "wxPaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_wxPaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS },
{ "new_wxPaletteChangedEvent", (PyCFunction) _wrap_new_wxPaletteChangedEvent, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxDisplayChangedEvent", (PyCFunction) _wrap_new_wxDisplayChangedEvent, METH_VARARGS | METH_KEYWORDS },
{ "wxNotifyEvent_Veto", (PyCFunction) _wrap_wxNotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS },
{ "wxNotifyEvent_Allow", (PyCFunction) _wrap_wxNotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS },
{ "wxNotifyEvent_IsAllowed", (PyCFunction) _wrap_wxNotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS },
{ "_wxEvent","_wxWindowCreateEvent",SwigwxWindowCreateEventTowxEvent},
{ "_wxEvent","_wxQueryNewPaletteEvent",SwigwxQueryNewPaletteEventTowxEvent},
{ "_wxEvent","_wxPaletteChangedEvent",SwigwxPaletteChangedEventTowxEvent},
+ { "_wxEvent","_wxDisplayChangedEvent",SwigwxDisplayChangedEventTowxEvent},
{ "_wxEvent","_wxNotifyEvent",SwigwxNotifyEventTowxEvent},
{ "_wxEvent","_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent},
{ "_wxEvent","_wxUpdateUIEvent",SwigwxUpdateUIEventTowxEvent},
{ "_wxObject","_wxWindowCreateEvent",SwigwxWindowCreateEventTowxObject},
{ "_wxObject","_wxQueryNewPaletteEvent",SwigwxQueryNewPaletteEventTowxObject},
{ "_wxObject","_wxPaletteChangedEvent",SwigwxPaletteChangedEventTowxObject},
+ { "_wxObject","_wxDisplayChangedEvent",SwigwxDisplayChangedEventTowxObject},
{ "_wxObject","_wxNotifyEvent",SwigwxNotifyEventTowxObject},
{ "_wxObject","_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxObject},
{ "_wxObject","_wxUpdateUIEvent",SwigwxUpdateUIEventTowxObject},
+class wxDisplayChangedEventPtr(wxEventPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def __repr__(self):
+ return "<C wxDisplayChangedEvent instance at %s>" % (self.this,)
+class wxDisplayChangedEvent(wxDisplayChangedEventPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(eventsc.new_wxDisplayChangedEvent,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
class wxPaletteChangedEventPtr(wxEventPtr):
def __init__(self,this):
self.this = this
wxString * _arg2;
wxString * _arg3;
wxDateTime * _arg4;
+ wxPyInputStream * temp;
+ bool created;
PyObject * _obj0 = 0;
PyObject * _obj1 = 0;
PyObject * _obj2 = 0;
if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOOO:new_wxFSFile",_kwnames,&_obj0,&_obj1,&_obj2,&_obj3,&_argo4))
return NULL;
{
- if (PyInstance_Check(_obj0)) {
- wxPyInputStream* ptr;
- if (SWIG_GetPtrObj(_obj0, (void **) &ptr,"_wxPyInputStream_p")) {
- PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p.");
+ if (SWIG_GetPtrObj(_obj0, (void **) &temp, "_wxPyInputStream_p") == 0) {
+ _arg0 = temp->m_wxis;
+ created = FALSE;
+ } else {
+ _arg0 = wxPyCBInputStream::create(_obj0, FALSE);
+ if (_arg0 == NULL) {
+ PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object.");
return NULL;
}
- _arg0 = ptr->wxi;
- } else {
- PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p.");
- return NULL;
+ created = TRUE;
}
}
{
Py_INCREF(Py_None);
_resultobj = Py_None;
}
+{
+ if (created)
+ delete _arg0;
+}
{
if (_obj1)
delete _arg1;
#else
static char* wxStringErrorMsg = "String type required";
#endif
-
- static wxString wxPyEmptyStr("");
// Implementations of some alternate "constructors"
wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
return new wxMemoryDC(oldDC);
}
+#include <wx/metafile.h>
+
#if 0
extern wxFont * wxNORMAL_FONT;
extern wxFont * wxSMALL_FONT;
}
static void wxColourDatabase_Append(wxColourDatabase *self,const wxString & name,int red,int green,int blue) {
+ // first see if the name is already there
+ wxString cName = name;
+ cName.MakeUpper();
+ wxString cName2 = cName;
+ if ( !cName2.Replace("GRAY", "GREY") )
+ cName2.clear();
+
+ wxNode *node = self->First();
+ while ( node ) {
+ const wxChar *key = node->GetKeyString();
+ if ( cName == key || cName2 == key ) {
+ wxColour* c = (wxColour *)node->Data();
+ c->Set(red, green, blue);
+ return;
+ }
+ node = node->Next();
+ }
+
+ // otherwise append the new colour
self->Append(name.c_str(), new wxColour(red, green, blue));
}
static PyObject *_wrap_wxColourDatabase_Append(PyObject *self, PyObject *args, PyObject *kwargs) {
return _resultobj;
}
+#define wxDC_DrawLabel(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3) (_swigobj->DrawLabel(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
+static PyObject *_wrap_wxDC_DrawLabel(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxDC * _arg0;
+ wxString * _arg1;
+ wxRect * _arg2;
+ int _arg3 = (int ) wxALIGN_LEFT|wxALIGN_TOP;
+ int _arg4 = (int ) -1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ wxRect temp;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","text","rect","alignment","indexAccel", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|ii:wxDC_DrawLabel",_kwnames,&_argo0,&_obj1,&_obj2,&_arg3,&_arg4))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxDC_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDC_DrawLabel. Expected _wxDC_p.");
+ return NULL;
+ }
+ }
+{
+#if PYTHON_API_VERSION >= 1009
+ char* tmpPtr; int tmpSize;
+ if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+ return NULL;
+ _arg1 = new wxString(tmpPtr, tmpSize);
+#else
+ if (!PyString_Check(_obj1)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
+}
+{
+ _arg2 = &temp;
+ if (! wxRect_helper(_obj2, &_arg2))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxDC_DrawLabel(_arg0,*_arg1,*_arg2,_arg3,_arg4);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+static wxRect wxDC_DrawImageLabel(wxDC *self,const wxString & text,const wxBitmap & image,const wxRect & rect,int alignment,int indexAccel) {
+ wxRect rv;
+ self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
+ return rv;
+ }
+static PyObject *_wrap_wxDC_DrawImageLabel(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxRect * _result;
+ wxDC * _arg0;
+ wxString * _arg1;
+ wxBitmap * _arg2;
+ wxRect * _arg3;
+ int _arg4 = (int ) wxALIGN_LEFT|wxALIGN_TOP;
+ int _arg5 = (int ) -1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ PyObject * _argo2 = 0;
+ wxRect temp;
+ PyObject * _obj3 = 0;
+ char *_kwnames[] = { "self","text","image","rect","alignment","indexAccel", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOO|ii:wxDC_DrawImageLabel",_kwnames,&_argo0,&_obj1,&_argo2,&_obj3,&_arg4,&_arg5))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxDC_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDC_DrawImageLabel. Expected _wxDC_p.");
+ return NULL;
+ }
+ }
+{
+#if PYTHON_API_VERSION >= 1009
+ char* tmpPtr; int tmpSize;
+ if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+ return NULL;
+ _arg1 = new wxString(tmpPtr, tmpSize);
+#else
+ if (!PyString_Check(_obj1)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
+}
+ if (_argo2) {
+ if (_argo2 == Py_None) { _arg2 = NULL; }
+ else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxBitmap_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxDC_DrawImageLabel. Expected _wxBitmap_p.");
+ return NULL;
+ }
+ }
+{
+ _arg3 = &temp;
+ if (! wxRect_helper(_obj3, &_arg3))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxRect (wxDC_DrawImageLabel(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
#define wxDC_DrawLine(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3) (_swigobj->DrawLine(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
static PyObject *_wrap_wxDC_DrawLine(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+static void *SwigwxMetaFileTowxObject(void *ptr) {
+ wxMetaFile *src;
+ wxObject *dest;
+ src = (wxMetaFile *) ptr;
+ dest = (wxObject *) src;
+ return (void *) dest;
+}
+
+#define new_wxMetaFile(_swigarg0) (new wxMetaFile(_swigarg0))
+static PyObject *_wrap_new_wxMetaFile(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxMetaFile * _result;
+ wxString * _arg0 = (wxString *) &wxEmptyString;
+ PyObject * _obj0 = 0;
+ char *_kwnames[] = { "filename", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|O:new_wxMetaFile",_kwnames,&_obj0))
+ return NULL;
+ if (_obj0)
+{
+#if PYTHON_API_VERSION >= 1009
+ char* tmpPtr; int tmpSize;
+ if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
+ return NULL;
+ _arg0 = new wxString(tmpPtr, tmpSize);
+#else
+ if (!PyString_Check(_obj0)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
+#endif
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxMetaFile *)new_wxMetaFile(*_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxMetaFile_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+{
+ if (_obj0)
+ delete _arg0;
+}
+ return _resultobj;
+}
+
+#define delete_wxMetaFile(_swigobj) (delete _swigobj)
+static PyObject *_wrap_delete_wxMetaFile(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxMetaFile * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxMetaFile",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMetaFile_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxMetaFile. Expected _wxMetaFile_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ delete_wxMetaFile(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxMetaFile_Ok(_swigobj) (_swigobj->Ok())
+static PyObject *_wrap_wxMetaFile_Ok(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxMetaFile * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMetaFile_Ok",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMetaFile_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMetaFile_Ok. Expected _wxMetaFile_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxMetaFile_Ok(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxMetaFile_SetClipboard(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetClipboard(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMetaFile_SetClipboard(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxMetaFile * _arg0;
+ int _arg1 = (int ) 0;
+ int _arg2 = (int ) 0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","width","height", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxMetaFile_SetClipboard",_kwnames,&_argo0,&_arg1,&_arg2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMetaFile_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMetaFile_SetClipboard. Expected _wxMetaFile_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxMetaFile_SetClipboard(_arg0,_arg1,_arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxMetaFile_GetSize(_swigobj) (_swigobj->GetSize())
+static PyObject *_wrap_wxMetaFile_GetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSize * _result;
+ wxMetaFile * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMetaFile_GetSize",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMetaFile_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMetaFile_GetSize. Expected _wxMetaFile_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxSize (wxMetaFile_GetSize(_arg0));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxMetaFile_GetWidth(_swigobj) (_swigobj->GetWidth())
+static PyObject *_wrap_wxMetaFile_GetWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxMetaFile * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMetaFile_GetWidth",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMetaFile_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMetaFile_GetWidth. Expected _wxMetaFile_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (int )wxMetaFile_GetWidth(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxMetaFile_GetHeight(_swigobj) (_swigobj->GetHeight())
+static PyObject *_wrap_wxMetaFile_GetHeight(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxMetaFile * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMetaFile_GetHeight",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMetaFile_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMetaFile_GetHeight. Expected _wxMetaFile_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (int )wxMetaFile_GetHeight(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxMetaFile_GetFileName(_swigobj) (_swigobj->GetFileName())
+static PyObject *_wrap_wxMetaFile_GetFileName(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxMetaFile * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMetaFile_GetFileName",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMetaFile_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMetaFile_GetFileName. Expected _wxMetaFile_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ const wxString & _result_ref = wxMetaFile_GetFileName(_arg0);
+ _result = (wxString *) &_result_ref;
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+}{
+ _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+}
+ return _resultobj;
+}
+
+static void *SwigwxMetaFileDCTowxDC(void *ptr) {
+ wxMetaFileDC *src;
+ wxDC *dest;
+ src = (wxMetaFileDC *) ptr;
+ dest = (wxDC *) src;
+ return (void *) dest;
+}
+
+static void *SwigwxMetaFileDCTowxObject(void *ptr) {
+ wxMetaFileDC *src;
+ wxObject *dest;
+ src = (wxMetaFileDC *) ptr;
+ dest = (wxObject *) src;
+ return (void *) dest;
+}
+
+#define new_wxMetaFileDC(_swigarg0,_swigarg1,_swigarg2,_swigarg3) (new wxMetaFileDC(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
+static PyObject *_wrap_new_wxMetaFileDC(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxMetaFileDC * _result;
+ wxString * _arg0 = (wxString *) &wxEmptyString;
+ int _arg1 = (int ) 0;
+ int _arg2 = (int ) 0;
+ wxString * _arg3 = (wxString *) &wxEmptyString;
+ PyObject * _obj0 = 0;
+ PyObject * _obj3 = 0;
+ char *_kwnames[] = { "filename","width","height","description", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|OiiO:new_wxMetaFileDC",_kwnames,&_obj0,&_arg1,&_arg2,&_obj3))
+ return NULL;
+ if (_obj0)
+{
+#if PYTHON_API_VERSION >= 1009
+ char* tmpPtr; int tmpSize;
+ if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
+ return NULL;
+ _arg0 = new wxString(tmpPtr, tmpSize);
+#else
+ if (!PyString_Check(_obj0)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
+#endif
+}
+ if (_obj3)
+{
+#if PYTHON_API_VERSION >= 1009
+ char* tmpPtr; int tmpSize;
+ if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
+ return NULL;
+ _arg3 = new wxString(tmpPtr, tmpSize);
+#else
+ if (!PyString_Check(_obj3)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
+#endif
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxMetaFileDC *)new_wxMetaFileDC(*_arg0,_arg1,_arg2,*_arg3);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxMetaFileDC_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+{
+ if (_obj0)
+ delete _arg0;
+}
+{
+ if (_obj3)
+ delete _arg3;
+}
+ return _resultobj;
+}
+
+#define wxMetaFileDC_Close(_swigobj) (_swigobj->Close())
+static PyObject *_wrap_wxMetaFileDC_Close(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxMetaFile * _result;
+ wxMetaFileDC * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMetaFileDC_Close",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMetaFileDC_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMetaFileDC_Close. Expected _wxMetaFileDC_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxMetaFile *)wxMetaFileDC_Close(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxMetaFile_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
static void *SwigwxPaletteTowxGDIObject(void *ptr) {
wxPalette *src;
wxGDIObject *dest;
wxPalette * _arg0;
int _arg1;
byte * _arg2;
+ int temp;
byte * _arg3;
+ int temp0;
byte * _arg4;
+ int temp1;
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
- char *_kwnames[] = { "self","pixel","OUTPUT","OUTPUT","OUTPUT", NULL };
+ char *_kwnames[] = { "self","pixel", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiOOO:wxPalette_GetRGB",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_argo4))
+{
+ _arg2 = (byte*)&temp;
+}
+{
+ _arg3 = (byte*)&temp0;
+}
+{
+ _arg4 = (byte*)&temp1;
+}
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxPalette_GetRGB",_kwnames,&_argo0,&_arg1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_byte_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxPalette_GetRGB. Expected _byte_p.");
- return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_byte_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxPalette_GetRGB. Expected _byte_p.");
- return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_byte_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of wxPalette_GetRGB. Expected _byte_p.");
- return NULL;
- }
- }
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
_result = (bool )wxPalette_GetRGB(_arg0,_arg1,_arg2,_arg3,_arg4);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) return NULL;
} _resultobj = Py_BuildValue("i",_result);
+{
+ 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);
+}
+{
+ PyObject *o;
+ o = PyInt_FromLong((long) (*_arg4));
+ _resultobj = t_output_helper(_resultobj, o);
+}
return _resultobj;
}
return _resultobj;
}
+#define wxRegion_Offset(_swigobj,_swigarg0,_swigarg1) (_swigobj->Offset(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxRegion_Offset(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxRegion * _arg0;
+ wxCoord _arg1;
+ wxCoord _arg2;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","x","y", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxRegion_Offset",_kwnames,&_argo0,&_arg1,&_arg2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRegion_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRegion_Offset. Expected _wxRegion_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxRegion_Offset(_arg0,_arg1,_arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
#define wxRegion_Contains(_swigobj,_swigarg0,_swigarg1) (_swigobj->Contains(_swigarg0,_swigarg1))
static PyObject *_wrap_wxRegion_Contains(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
{ "wxRegion_ContainsRect", (PyCFunction) _wrap_wxRegion_ContainsRect, METH_VARARGS | METH_KEYWORDS },
{ "wxRegion_ContainsPoint", (PyCFunction) _wrap_wxRegion_ContainsPoint, METH_VARARGS | METH_KEYWORDS },
{ "wxRegion_Contains", (PyCFunction) _wrap_wxRegion_Contains, METH_VARARGS | METH_KEYWORDS },
+ { "wxRegion_Offset", (PyCFunction) _wrap_wxRegion_Offset, METH_VARARGS | METH_KEYWORDS },
{ "wxRegion_Clear", (PyCFunction) _wrap_wxRegion_Clear, METH_VARARGS | METH_KEYWORDS },
{ "delete_wxRegion", (PyCFunction) _wrap_delete_wxRegion, METH_VARARGS | METH_KEYWORDS },
{ "new_wxRegion", (PyCFunction) _wrap_new_wxRegion, METH_VARARGS | METH_KEYWORDS },
{ "wxPalette_GetPixel", (PyCFunction) _wrap_wxPalette_GetPixel, METH_VARARGS | METH_KEYWORDS },
{ "delete_wxPalette", (PyCFunction) _wrap_delete_wxPalette, METH_VARARGS | METH_KEYWORDS },
{ "new_wxPalette", (PyCFunction) _wrap_new_wxPalette, METH_VARARGS | METH_KEYWORDS },
+ { "wxMetaFileDC_Close", (PyCFunction) _wrap_wxMetaFileDC_Close, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxMetaFileDC", (PyCFunction) _wrap_new_wxMetaFileDC, METH_VARARGS | METH_KEYWORDS },
+ { "wxMetaFile_GetFileName", (PyCFunction) _wrap_wxMetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS },
+ { "wxMetaFile_GetHeight", (PyCFunction) _wrap_wxMetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS },
+ { "wxMetaFile_GetWidth", (PyCFunction) _wrap_wxMetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS },
+ { "wxMetaFile_GetSize", (PyCFunction) _wrap_wxMetaFile_GetSize, METH_VARARGS | METH_KEYWORDS },
+ { "wxMetaFile_SetClipboard", (PyCFunction) _wrap_wxMetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS },
+ { "wxMetaFile_Ok", (PyCFunction) _wrap_wxMetaFile_Ok, METH_VARARGS | METH_KEYWORDS },
+ { "delete_wxMetaFile", (PyCFunction) _wrap_delete_wxMetaFile, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxMetaFile", (PyCFunction) _wrap_new_wxMetaFile, METH_VARARGS | METH_KEYWORDS },
{ "new_wxWindowDC", (PyCFunction) _wrap_new_wxWindowDC, METH_VARARGS | METH_KEYWORDS },
{ "new_wxPaintDC", (PyCFunction) _wrap_new_wxPaintDC, METH_VARARGS | METH_KEYWORDS },
{ "new_wxClientDC", (PyCFunction) _wrap_new_wxClientDC, METH_VARARGS | METH_KEYWORDS },
{ "wxDC_DrawPolygon", (PyCFunction) _wrap_wxDC_DrawPolygon, METH_VARARGS | METH_KEYWORDS },
{ "wxDC_DrawLines", (PyCFunction) _wrap_wxDC_DrawLines, METH_VARARGS | METH_KEYWORDS },
{ "wxDC_DrawLine", (PyCFunction) _wrap_wxDC_DrawLine, METH_VARARGS | METH_KEYWORDS },
+ { "wxDC_DrawImageLabel", (PyCFunction) _wrap_wxDC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS },
+ { "wxDC_DrawLabel", (PyCFunction) _wrap_wxDC_DrawLabel, METH_VARARGS | METH_KEYWORDS },
{ "wxDC_DrawIcon", (PyCFunction) _wrap_wxDC_DrawIcon, METH_VARARGS | METH_KEYWORDS },
{ "wxDC_DrawEllipticArc", (PyCFunction) _wrap_wxDC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS },
{ "wxDC_DrawEllipse", (PyCFunction) _wrap_wxDC_DrawEllipse, METH_VARARGS | METH_KEYWORDS },
{ "_wxGDIObject","_wxCursor",SwigwxCursorTowxGDIObject},
{ "_wxGDIObject","_wxIcon",SwigwxIconTowxGDIObject},
{ "_wxGDIObject","_wxBitmap",SwigwxBitmapTowxGDIObject},
+ { "_wxDC","_wxMetaFileDC",SwigwxMetaFileDCTowxDC},
{ "_wxDC","_wxWindowDC",SwigwxWindowDCTowxDC},
{ "_wxDC","_wxPaintDC",SwigwxPaintDCTowxDC},
{ "_wxDC","_wxClientDC",SwigwxClientDCTowxDC},
{ "_wxObject","_wxRegion",SwigwxRegionTowxObject},
{ "_wxObject","_wxImageList",SwigwxImageListTowxObject},
{ "_wxObject","_wxPalette",SwigwxPaletteTowxObject},
+ { "_wxObject","_wxMetaFileDC",SwigwxMetaFileDCTowxObject},
+ { "_wxObject","_wxMetaFile",SwigwxMetaFileTowxObject},
{ "_wxObject","_wxWindowDC",SwigwxWindowDCTowxObject},
{ "_wxObject","_wxPaintDC",SwigwxPaintDCTowxObject},
{ "_wxObject","_wxClientDC",SwigwxClientDCTowxObject},
def DrawIcon(self, *_args, **_kwargs):
val = apply(gdic.wxDC_DrawIcon,(self,) + _args, _kwargs)
return val
+ def DrawLabel(self, *_args, **_kwargs):
+ val = apply(gdic.wxDC_DrawLabel,(self,) + _args, _kwargs)
+ return val
+ def DrawImageLabel(self, *_args, **_kwargs):
+ val = apply(gdic.wxDC_DrawImageLabel,(self,) + _args, _kwargs)
+ if val: val = wxRectPtr(val) ; val.thisown = 1
+ return val
def DrawLine(self, *_args, **_kwargs):
val = apply(gdic.wxDC_DrawLine,(self,) + _args, _kwargs)
return val
+class wxMetaFilePtr(wxObjectPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def __del__(self,gdic=gdic):
+ if self.thisown == 1 :
+ gdic.delete_wxMetaFile(self)
+ def Ok(self, *_args, **_kwargs):
+ val = apply(gdic.wxMetaFile_Ok,(self,) + _args, _kwargs)
+ return val
+ def SetClipboard(self, *_args, **_kwargs):
+ val = apply(gdic.wxMetaFile_SetClipboard,(self,) + _args, _kwargs)
+ return val
+ def GetSize(self, *_args, **_kwargs):
+ val = apply(gdic.wxMetaFile_GetSize,(self,) + _args, _kwargs)
+ if val: val = wxSizePtr(val) ; val.thisown = 1
+ return val
+ def GetWidth(self, *_args, **_kwargs):
+ val = apply(gdic.wxMetaFile_GetWidth,(self,) + _args, _kwargs)
+ return val
+ def GetHeight(self, *_args, **_kwargs):
+ val = apply(gdic.wxMetaFile_GetHeight,(self,) + _args, _kwargs)
+ return val
+ def GetFileName(self, *_args, **_kwargs):
+ val = apply(gdic.wxMetaFile_GetFileName,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxMetaFile instance at %s>" % (self.this,)
+class wxMetaFile(wxMetaFilePtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(gdic.new_wxMetaFile,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+class wxMetaFileDCPtr(wxDCPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def Close(self, *_args, **_kwargs):
+ val = apply(gdic.wxMetaFileDC_Close,(self,) + _args, _kwargs)
+ if val: val = wxMetaFilePtr(val)
+ return val
+ def __repr__(self):
+ return "<C wxMetaFileDC instance at %s>" % (self.this,)
+class wxMetaFileDC(wxMetaFileDCPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(gdic.new_wxMetaFileDC,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
class wxPalettePtr(wxGDIObjectPtr):
def __init__(self,this):
self.this = this
def Clear(self, *_args, **_kwargs):
val = apply(gdic.wxRegion_Clear,(self,) + _args, _kwargs)
return val
+ def Offset(self, *_args, **_kwargs):
+ val = apply(gdic.wxRegion_Offset,(self,) + _args, _kwargs)
+ return val
def Contains(self, *_args, **_kwargs):
val = apply(gdic.wxRegion_Contains,(self,) + _args, _kwargs)
return val
return new wxImage(width, height);
}
+
wxImage* wxImageFromMime(const wxString& name, const wxString& mimetype, int index) {
return new wxImage(name, mimetype, index);
}
+
wxImage* wxImageFromBitmap(const wxBitmap &bitmap) {
return new wxImage(bitmap);
}
+
wxImage* wxImageFromData(int width, int height, unsigned char* data) {
// Copy the source data so the wxImage can clean it up later
unsigned char* copy = (unsigned char*)malloc(width*height*3);
return new wxImage(width, height, copy, FALSE);
}
+
+ wxImage* wxImageFromStream(wxInputStream& stream,
+ long type = wxBITMAP_TYPE_ANY, int index = -1) {
+ return new wxImage(stream, type, index);
+ }
+
+
+ wxImage* wxImageFromStreamMime(wxInputStream& stream,
+ const wxString& mimetype, int index = -1 ) {
+ return new wxImage(stream, mimetype, index);
+ }
+
#if 0
extern wxImage wxNullImage;
return _resultobj;
}
+static PyObject *_wrap_wxImageFromStream(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxImage * _result;
+ wxInputStream * _arg0;
+ long _arg1 = (long ) wxBITMAP_TYPE_ANY;
+ int _arg2 = (int ) -1;
+ wxPyInputStream * temp;
+ bool created;
+ PyObject * _obj0 = 0;
+ char *_kwnames[] = { "stream","type","index", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|li:wxImageFromStream",_kwnames,&_obj0,&_arg1,&_arg2))
+ return NULL;
+{
+ if (SWIG_GetPtrObj(_obj0, (void **) &temp, "_wxPyInputStream_p") == 0) {
+ _arg0 = temp->m_wxis;
+ created = FALSE;
+ } else {
+ _arg0 = wxPyCBInputStream::create(_obj0, FALSE);
+ if (_arg0 == NULL) {
+ PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object.");
+ return NULL;
+ }
+ created = TRUE;
+ }
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxImage *)wxImageFromStream(*_arg0,_arg1,_arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+{
+ if (created)
+ delete _arg0;
+}
+ return _resultobj;
+}
+
+static PyObject *_wrap_wxImageFromStreamMime(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxImage * _result;
+ wxInputStream * _arg0;
+ wxString * _arg1;
+ int _arg2 = (int ) -1;
+ wxPyInputStream * temp;
+ bool created;
+ PyObject * _obj0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "stream","mimetype","index", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxImageFromStreamMime",_kwnames,&_obj0,&_obj1,&_arg2))
+ return NULL;
+{
+ if (SWIG_GetPtrObj(_obj0, (void **) &temp, "_wxPyInputStream_p") == 0) {
+ _arg0 = temp->m_wxis;
+ created = FALSE;
+ } else {
+ _arg0 = wxPyCBInputStream::create(_obj0, FALSE);
+ if (_arg0 == NULL) {
+ PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object.");
+ return NULL;
+ }
+ created = TRUE;
+ }
+}
+{
+#if PYTHON_API_VERSION >= 1009
+ char* tmpPtr; int tmpSize;
+ if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+ return NULL;
+ _arg1 = new wxString(tmpPtr, tmpSize);
+#else
+ if (!PyString_Check(_obj1)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxImage *)wxImageFromStreamMime(*_arg0,*_arg1,_arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+{
+ if (created)
+ delete _arg0;
+}
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
static PyObject *_wrap_wxInitAllImageHandlers(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
char *_kwnames[] = { NULL };
return _resultobj;
}
+static PyObject *_wrap_wxImage_CanReadStream(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxInputStream * _arg0;
+ wxPyInputStream * temp;
+ bool created;
+ PyObject * _obj0 = 0;
+ char *_kwnames[] = { "stream", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_CanReadStream",_kwnames,&_obj0))
+ return NULL;
+{
+ if (SWIG_GetPtrObj(_obj0, (void **) &temp, "_wxPyInputStream_p") == 0) {
+ _arg0 = temp->m_wxis;
+ created = FALSE;
+ } else {
+ _arg0 = wxPyCBInputStream::create(_obj0, FALSE);
+ if (_arg0 == NULL) {
+ PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object.");
+ return NULL;
+ }
+ created = TRUE;
+ }
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxImage::CanRead(*_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+{
+ if (created)
+ delete _arg0;
+}
+ return _resultobj;
+}
+
+#define wxImage_LoadStream(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_wxImage_LoadStream(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxImage * _arg0;
+ wxInputStream * _arg1;
+ long _arg2 = (long ) wxBITMAP_TYPE_ANY;
+ int _arg3 = (int ) -1;
+ PyObject * _argo0 = 0;
+ wxPyInputStream * temp;
+ bool created;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","stream","type","index", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|li:wxImage_LoadStream",_kwnames,&_argo0,&_obj1,&_arg2,&_arg3))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadStream. Expected _wxImage_p.");
+ return NULL;
+ }
+ }
+{
+ if (SWIG_GetPtrObj(_obj1, (void **) &temp, "_wxPyInputStream_p") == 0) {
+ _arg1 = temp->m_wxis;
+ created = FALSE;
+ } else {
+ _arg1 = wxPyCBInputStream::create(_obj1, FALSE);
+ if (_arg1 == NULL) {
+ PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object.");
+ return NULL;
+ }
+ created = TRUE;
+ }
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxImage_LoadStream(_arg0,*_arg1,_arg2,_arg3);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+{
+ if (created)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxImage_LoadMimeStream(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->LoadFile(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_wxImage_LoadMimeStream(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxImage * _arg0;
+ wxInputStream * _arg1;
+ wxString * _arg2;
+ int _arg3 = (int ) -1;
+ PyObject * _argo0 = 0;
+ wxPyInputStream * temp;
+ bool created;
+ PyObject * _obj1 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","stream","mimetype","index", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|i:wxImage_LoadMimeStream",_kwnames,&_argo0,&_obj1,&_obj2,&_arg3))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadMimeStream. Expected _wxImage_p.");
+ return NULL;
+ }
+ }
+{
+ if (SWIG_GetPtrObj(_obj1, (void **) &temp, "_wxPyInputStream_p") == 0) {
+ _arg1 = temp->m_wxis;
+ created = FALSE;
+ } else {
+ _arg1 = wxPyCBInputStream::create(_obj1, FALSE);
+ if (_arg1 == NULL) {
+ PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object.");
+ return NULL;
+ }
+ created = TRUE;
+ }
+}
+{
+#if PYTHON_API_VERSION >= 1009
+ char* tmpPtr; int tmpSize;
+ if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+ return NULL;
+ _arg2 = new wxString(tmpPtr, tmpSize);
+#else
+ if (!PyString_Check(_obj2)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
+#endif
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxImage_LoadMimeStream(_arg0,*_arg1,*_arg2,_arg3);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+{
+ if (created)
+ delete _arg1;
+}
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
#define wxImage_Ok(_swigobj) (_swigobj->Ok())
static PyObject *_wrap_wxImage_Ok(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
{ "wxImage_GetHeight", (PyCFunction) _wrap_wxImage_GetHeight, METH_VARARGS | METH_KEYWORDS },
{ "wxImage_GetWidth", (PyCFunction) _wrap_wxImage_GetWidth, METH_VARARGS | METH_KEYWORDS },
{ "wxImage_Ok", (PyCFunction) _wrap_wxImage_Ok, METH_VARARGS | METH_KEYWORDS },
+ { "wxImage_LoadMimeStream", (PyCFunction) _wrap_wxImage_LoadMimeStream, METH_VARARGS | METH_KEYWORDS },
+ { "wxImage_LoadStream", (PyCFunction) _wrap_wxImage_LoadStream, METH_VARARGS | METH_KEYWORDS },
+ { "wxImage_CanReadStream", (PyCFunction) _wrap_wxImage_CanReadStream, METH_VARARGS | METH_KEYWORDS },
{ "wxImage_SaveMimeFile", (PyCFunction) _wrap_wxImage_SaveMimeFile, METH_VARARGS | METH_KEYWORDS },
{ "wxImage_SaveFile", (PyCFunction) _wrap_wxImage_SaveFile, METH_VARARGS | METH_KEYWORDS },
{ "wxImage_LoadMimeFile", (PyCFunction) _wrap_wxImage_LoadMimeFile, METH_VARARGS | METH_KEYWORDS },
{ "wxImageHandler_GetName", (PyCFunction) _wrap_wxImageHandler_GetName, METH_VARARGS | METH_KEYWORDS },
{ "wxBitmapFromImage", (PyCFunction) _wrap_wxBitmapFromImage, METH_VARARGS | METH_KEYWORDS },
{ "wxInitAllImageHandlers", (PyCFunction) _wrap_wxInitAllImageHandlers, METH_VARARGS | METH_KEYWORDS },
+ { "wxImageFromStreamMime", (PyCFunction) _wrap_wxImageFromStreamMime, METH_VARARGS | METH_KEYWORDS },
+ { "wxImageFromStream", (PyCFunction) _wrap_wxImageFromStream, METH_VARARGS | METH_KEYWORDS },
{ "wxImageFromData", (PyCFunction) _wrap_wxImageFromData, METH_VARARGS | METH_KEYWORDS },
{ "wxImageFromBitmap", (PyCFunction) _wrap_wxImageFromBitmap, METH_VARARGS | METH_KEYWORDS },
{ "wxImageFromMime", (PyCFunction) _wrap_wxImageFromMime, METH_VARARGS | METH_KEYWORDS },
from misc import *
from gdi import *
+
+from streams import *
class wxImageHandlerPtr(wxObjectPtr):
def __init__(self,this):
self.this = this
def SaveMimeFile(self, *_args, **_kwargs):
val = apply(imagec.wxImage_SaveMimeFile,(self,) + _args, _kwargs)
return val
+ def LoadStream(self, *_args, **_kwargs):
+ val = apply(imagec.wxImage_LoadStream,(self,) + _args, _kwargs)
+ return val
+ def LoadMimeStream(self, *_args, **_kwargs):
+ val = apply(imagec.wxImage_LoadMimeStream,(self,) + _args, _kwargs)
+ return val
def Ok(self, *_args, **_kwargs):
val = apply(imagec.wxImage_Ok,(self,) + _args, _kwargs)
return val
if val: val = wxImagePtr(val); val.thisown = 1
return val
+def wxImageFromStream(*_args, **_kwargs):
+ val = apply(imagec.wxImageFromStream,_args,_kwargs)
+ if val: val = wxImagePtr(val); val.thisown = 1
+ return val
+
+def wxImageFromStreamMime(*_args, **_kwargs):
+ val = apply(imagec.wxImageFromStreamMime,_args,_kwargs)
+ if val: val = wxImagePtr(val); val.thisown = 1
+ return val
+
wxInitAllImageHandlers = imagec.wxInitAllImageHandlers
def wxBitmapFromImage(*_args, **_kwargs):
wxImage_GetImageCount = imagec.wxImage_GetImageCount
+wxImage_CanReadStream = imagec.wxImage_CanReadStream
+
wxImage_AddHandler = imagec.wxImage_AddHandler
wxImage_InsertHandler = imagec.wxImage_InsertHandler
static char* wxStringErrorMsg = "String type required";
#endif
- static wxString wxPyEmptyStr("");
-
PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
wxRegion reg1(*r1);
wxRegion reg2(*r2);
static PyObject *_wrap_wxShell(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
bool _result;
- wxString * _arg0 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg0 = (wxString *) &wxEmptyString;
PyObject * _obj0 = 0;
char *_kwnames[] = { "command", NULL };
static char* wxStringErrorMsg = "String type required";
#endif
- static wxString wxPyEmptyStr("");
-
int wxCaret_GetBlinkTime() {
return wxCaret::GetBlinkTime();
}
PyObject * _resultobj;
wxString * _result;
wxString * _arg0;
- wxString * _arg1 = (wxString *) &wxPyEmptyStr;
- wxString * _arg2 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg1 = (wxString *) &wxEmptyString;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
wxWindow * _arg3 = (wxWindow *) NULL;
int _arg4 = (int ) -1;
int _arg5 = (int ) -1;
PyObject * _resultobj;
wxString * _result;
wxString * _arg0;
- wxString * _arg1 = (wxString *) &wxPyEmptyStr;
- wxString * _arg2 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg1 = (wxString *) &wxEmptyString;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
wxWindow * _arg3 = (wxWindow *) NULL;
PyObject * _obj0 = 0;
PyObject * _obj1 = 0;
PyObject * _resultobj;
int _result;
wxString * _arg0;
- wxString * _arg1 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg1 = (wxString *) &wxEmptyString;
int _arg2 = (int ) wxOK|wxCENTRE;
wxWindow * _arg3 = (wxWindow *) NULL;
int _arg4 = (int ) -1;
PyObject * _result;
wxFileType * _arg0;
wxString * _arg1;
- wxString * _arg2 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
PyObject * _argo0 = 0;
PyObject * _obj1 = 0;
PyObject * _obj2 = 0;
PyObject * _result;
wxFileType * _arg0;
wxString * _arg1;
- wxString * _arg2 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
PyObject * _argo0 = 0;
PyObject * _obj1 = 0;
PyObject * _obj2 = 0;
PyObject * _result;
wxFileType * _arg0;
wxString * _arg1;
- wxString * _arg2 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
PyObject * _argo0 = 0;
PyObject * _obj1 = 0;
PyObject * _obj2 = 0;
#else
static char* wxStringErrorMsg = "String type required";
#endif
-
- static wxString wxPyEmptyStr("");
#ifdef __cplusplus
extern "C" {
#endif
wxBitmap * _arg3 = (wxBitmap *) &wxNullBitmap;
int _arg4 = (int ) FALSE;
PyObject * _arg5 = (PyObject *) NULL;
- wxString * _arg6 = (wxString *) &wxPyEmptyStr;
- wxString * _arg7 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg6 = (wxString *) &wxEmptyString;
+ wxString * _arg7 = (wxString *) &wxEmptyString;
PyObject * _argo0 = 0;
PyObject * _argo2 = 0;
PyObject * _argo3 = 0;
wxToolBarBase * _arg0;
int _arg1;
wxBitmap * _arg2;
- wxString * _arg3 = (wxString *) &wxPyEmptyStr;
- wxString * _arg4 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg3 = (wxString *) &wxEmptyString;
+ wxString * _arg4 = (wxString *) &wxEmptyString;
int _arg5 = (int ) FALSE;
PyObject * _argo0 = 0;
PyObject * _argo2 = 0;
wxBitmap * _arg4 = (wxBitmap *) &wxNullBitmap;
int _arg5 = (int ) FALSE;
PyObject * _arg6 = (PyObject *) NULL;
- wxString * _arg7 = (wxString *) &wxPyEmptyStr;
- wxString * _arg8 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg7 = (wxString *) &wxEmptyString;
+ wxString * _arg8 = (wxString *) &wxEmptyString;
PyObject * _argo0 = 0;
PyObject * _argo3 = 0;
PyObject * _argo4 = 0;
size_t _arg1;
int _arg2;
wxBitmap * _arg3;
- wxString * _arg4 = (wxString *) &wxPyEmptyStr;
- wxString * _arg5 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg4 = (wxString *) &wxEmptyString;
+ wxString * _arg5 = (wxString *) &wxEmptyString;
int _arg6 = (int ) FALSE;
PyObject * _argo0 = 0;
PyObject * _argo3 = 0;
#else
static char* wxStringErrorMsg = "String type required";
#endif
- // C++
-// definitions of wxStringPtrList and wxPyInputStream
-#include <wx/listimpl.cpp>
-WX_DEFINE_LIST(wxStringPtrList);
-
-
-void wxPyInputStream::close() {
- /* do nothing */
-}
-
-void wxPyInputStream::flush() {
- /*do nothing*/
-}
-
-bool wxPyInputStream::eof() {
- if (wxi)
- return wxi->Eof();
- else
- return TRUE;
-}
-
-wxPyInputStream::~wxPyInputStream() {
- /*do nothing*/
-}
-
-wxString* wxPyInputStream::read(int size) {
- wxString* s = NULL;
- const int BUFSIZE = 1024;
-
- // check if we have a real wxInputStream to work with
- if (!wxi) {
- PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream below");
- return NULL;
- }
-
- if (size < 0) {
- // init buffers
- char * buf = new char[BUFSIZE];
- if (!buf) {
- PyErr_NoMemory();
- return NULL;
- }
-
- s = new wxString();
- if (!s) {
- delete buf;
- PyErr_NoMemory();
- return NULL;
- }
-
- // read until EOF
- while (! wxi->Eof()) {
- wxi->Read(buf, BUFSIZE);
- //*s += wxString(buf, wxi->LastRead());
- s->Append(buf, wxi->LastRead());
- }
- delete buf;
-
- // error check
- if (wxi->LastError() == wxSTREAM_READ_ERROR) {
- delete s;
- PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
- return NULL;
- }
-
- } else { // Read only size number of characters
- s = new wxString;
- if (!s) {
- PyErr_NoMemory();
- return NULL;
- }
-
- // read size bytes
- wxi->Read(s->GetWriteBuf(size+1), size);
- s->UngetWriteBuf(wxi->LastRead());
-
- // error check
- if (wxi->LastError() == wxSTREAM_READ_ERROR) {
- delete s;
- PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
- return NULL;
- }
- }
- return s;
-}
-
-
-wxString* wxPyInputStream::readline (int size) {
- // check if we have a real wxInputStream to work with
- if (!wxi) {
- PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream below");
- return NULL;
- }
-
- // init buffer
- int i;
- char ch;
- wxString* s = new wxString;
- if (!s) {
- PyErr_NoMemory();
- return NULL;
- }
-
- // read until \n or byte limit reached
- for (i=ch=0; (ch != '\n') && (!wxi->Eof()) && ((size < 0) || (i < size)); i++) {
- *s += ch = wxi->GetC();
- }
-
- // errorcheck
- if (wxi->LastError() == wxSTREAM_READ_ERROR) {
- delete s;
- PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
- return NULL;
- }
- return s;
-}
-
-
-wxStringPtrList* wxPyInputStream::readlines (int sizehint) {
- // check if we have a real wxInputStream to work with
- if (!wxi) {
- PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream below");
- return NULL;
- }
-
- // init list
- wxStringPtrList* l = new wxStringPtrList();
- if (!l) {
- PyErr_NoMemory();
- return NULL;
- }
-
- // read sizehint bytes or until EOF
- int i;
- for (i=0; (!wxi->Eof()) && ((sizehint < 0) || (i < sizehint));) {
- wxString* s = readline();
- if (s == NULL) {
- l->DeleteContents(TRUE);
- l->Clear();
- return NULL;
- }
- l->Append(s);
- i = i + s->Length();
- }
-
- // error check
- if (wxi->LastError() == wxSTREAM_READ_ERROR) {
- l->DeleteContents(TRUE);
- l->Clear();
- PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
- return NULL;
- }
- return l;
-}
-
-
-void wxPyInputStream::seek(int offset, int whence) {
- if (wxi)
- wxi->SeekI(offset, wxSeekMode(whence));
-}
-
-int wxPyInputStream::tell(){
- if (wxi)
- return wxi->TellI();
-}
-
-
-
-// wxInputStream which operates on a Python file-like object
-class wxPyCBInputStream : public wxInputStream {
-protected:
- PyObject* read;
- PyObject* seek;
- PyObject* tell;
- PyObject* py;
-
- virtual size_t OnSysRead(void *buffer, size_t bufsize) {
- if (bufsize == 0)
- return 0;
-
- wxPyBeginBlockThreads();
- PyObject* arglist = Py_BuildValue("(i)", bufsize);
- PyObject* result = PyEval_CallObject(read, arglist);
- Py_DECREF(arglist);
-
- size_t o = 0;
- if ((result != NULL) && PyString_Check(result)) {
- o = PyString_Size(result);
- if (o == 0)
- m_lasterror = wxSTREAM_EOF;
- if (o > bufsize)
- o = bufsize;
- strncpy((char*)buffer, PyString_AsString(result), o);
- Py_DECREF(result);
-
- }
- else
- m_lasterror = wxSTREAM_READ_ERROR;
- wxPyEndBlockThreads();
- m_lastcount = o;
- return o;
- }
-
- virtual size_t OnSysWrite(const void *buffer, size_t bufsize){
- m_lasterror = wxSTREAM_WRITE_ERROR;
- return 0;
- }
-
- virtual off_t OnSysSeek(off_t off, wxSeekMode mode){
- wxPyBeginBlockThreads();
- PyObject*arglist = Py_BuildValue("(ii)", off, mode);
- PyObject*result = PyEval_CallObject(seek, arglist);
- Py_DECREF(arglist);
- Py_XDECREF(result);
- wxPyEndBlockThreads();
- return OnSysTell();
- }
-
- virtual off_t OnSysTell() const{
- wxPyBeginBlockThreads();
- PyObject* arglist = Py_BuildValue("()");
- PyObject* result = PyEval_CallObject(tell, arglist);
- Py_DECREF(arglist);
- off_t o = 0;
- if (result != NULL) {
- o = PyInt_AsLong(result);
- Py_DECREF(result);
- };
- wxPyEndBlockThreads();
- return o;
- }
-
- wxPyCBInputStream(PyObject *p, PyObject *r, PyObject *s, PyObject *t)
- : py(p), read(r), seek(s), tell(t)
- {}
-
-public:
- ~wxPyCBInputStream() {
- wxPyBeginBlockThreads();
- Py_XDECREF(py);
- Py_XDECREF(read);
- Py_XDECREF(seek);
- Py_XDECREF(tell);
- wxPyEndBlockThreads();
- }
-
- virtual size_t GetSize() {
- if (seek && tell) {
- off_t temp = OnSysTell();
- off_t ret = OnSysSeek(0, wxFromEnd);
- OnSysSeek(temp, wxFromStart);
- return ret;
- }
- else
- return 0;
- }
-
- static wxPyCBInputStream* create(PyObject *py) {
- PyObject* read;
- PyObject* seek;
- PyObject* tell;
-
- if (!PyInstance_Check(py) && !PyFile_Check(py)) {
- PyErr_SetString(PyExc_TypeError, "Not a file-like object");
- Py_XDECREF(py);
- return NULL;
- }
- read = getMethod(py, "read");
- seek = getMethod(py, "seek");
- tell = getMethod(py, "tell");
-
- if (!read) {
- PyErr_SetString(PyExc_TypeError, "Not a file-like object");
- Py_XDECREF(py);
- Py_XDECREF(read);
- Py_XDECREF(seek);
- Py_XDECREF(tell);
- return NULL;
- }
- return new wxPyCBInputStream(py, read, seek, tell);
- }
-
- static PyObject* getMethod(PyObject* py, char* name) {
- if (!PyObject_HasAttrString(py, name))
- return NULL;
- PyObject* o = PyObject_GetAttrString(py, name);
- if (!PyMethod_Check(o) && !PyCFunction_Check(o)) {
- Py_DECREF(o);
- return NULL;
- }
- return o;
- }
-
-protected:
-
-};
-
#ifdef __cplusplus
extern "C" {
#endif
static wxPyInputStream *new_wxPyInputStream(PyObject *p) {
- wxInputStream* wxi = wxPyCBInputStream::create(p);
- if (wxi)
- return new wxPyInputStream(wxi);
+ wxInputStream* wxis = wxPyCBInputStream::create(p);
+ if (wxis)
+ return new wxPyInputStream(wxis);
else
return NULL;
}
static char* wxStringErrorMsg = "String type required";
#endif
- static wxString wxPyEmptyStr("");
-
static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
PyObject* ret = PyTuple_New(3);
if (ret) {
wxString * _result;
wxConfigBase * _arg0;
wxString * _arg1;
- wxString * _arg2 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
PyObject * _argo0 = 0;
PyObject * _obj1 = 0;
PyObject * _obj2 = 0;
static PyObject *_wrap_new_wxConfig(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxConfig * _result;
- wxString * _arg0 = (wxString *) &wxPyEmptyStr;
- wxString * _arg1 = (wxString *) &wxPyEmptyStr;
- wxString * _arg2 = (wxString *) &wxPyEmptyStr;
- wxString * _arg3 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg0 = (wxString *) &wxEmptyString;
+ wxString * _arg1 = (wxString *) &wxEmptyString;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ wxString * _arg3 = (wxString *) &wxEmptyString;
long _arg4 = (long ) 0;
PyObject * _obj0 = 0;
PyObject * _obj1 = 0;
static PyObject *_wrap_new_wxFileConfig(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxFileConfig * _result;
- wxString * _arg0 = (wxString *) &wxPyEmptyStr;
- wxString * _arg1 = (wxString *) &wxPyEmptyStr;
- wxString * _arg2 = (wxString *) &wxPyEmptyStr;
- wxString * _arg3 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg0 = (wxString *) &wxEmptyString;
+ wxString * _arg1 = (wxString *) &wxEmptyString;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ wxString * _arg3 = (wxString *) &wxEmptyString;
long _arg4 = (long ) 0;
PyObject * _obj0 = 0;
PyObject * _obj1 = 0;
static char* wxStringErrorMsg = "String type required";
#endif
- static wxString wxPyEmptyStr("");
-
class wxPyValidator : public wxValidator {
DECLARE_DYNAMIC_CLASS(wxPyValidator);
public:
return _resultobj;
}
+#define wxWindow_GetBorder(_swigobj) (_swigobj->GetBorder())
+static PyObject *_wrap_wxWindow_GetBorder(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxBorder _result;
+ wxWindow * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWindow_GetBorder",_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_GetBorder. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxBorder )wxWindow_GetBorder(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
static PyObject * wxWindow_GetChildren(wxWindow *self) {
wxWindowList& list = self->GetChildren();
return wxPy_ConvertList(&list, "wxWindow");
return _resultobj;
}
+#define wxWindow_GetClientAreaOrigin(_swigobj) (_swigobj->GetClientAreaOrigin())
+static PyObject *_wrap_wxWindow_GetClientAreaOrigin(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxPoint * _result;
+ wxWindow * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWindow_GetClientAreaOrigin",_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_GetClientAreaOrigin. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxPoint (wxWindow_GetClientAreaOrigin(_arg0));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxWindow_GetClientRect(_swigobj) (_swigobj->GetClientRect())
+static PyObject *_wrap_wxWindow_GetClientRect(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxRect * _result;
+ wxWindow * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWindow_GetClientRect",_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_GetClientRect. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = new wxRect (wxWindow_GetClientRect(_arg0));
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
#define wxWindow_GetConstraints(_swigobj) (_swigobj->GetConstraints())
static PyObject *_wrap_wxWindow_GetConstraints(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxWindow_HasScrollbar(_swigobj,_swigarg0) (_swigobj->HasScrollbar(_swigarg0))
+static PyObject *_wrap_wxWindow_HasScrollbar(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxWindow * _arg0;
+ int _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","orient", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxWindow_HasScrollbar",_kwnames,&_argo0,&_arg1))
+ 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_HasScrollbar. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (bool )wxWindow_HasScrollbar(_arg0,_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
#define wxWindow_Hide(_swigobj) (_swigobj->Hide())
static PyObject *_wrap_wxWindow_Hide(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxWindow_HitTest(_swigobj,_swigarg0) (_swigobj->HitTest(_swigarg0))
+static PyObject *_wrap_wxWindow_HitTest(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHitTest _result;
+ wxWindow * _arg0;
+ wxPoint * _arg1;
+ PyObject * _argo0 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","pt", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_HitTest",_kwnames,&_argo0,&_obj1))
+ 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_HitTest. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
+ return NULL;
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxHitTest )wxWindow_HitTest(_arg0,*_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
#define wxWindow_InitDialog(_swigobj) (_swigobj->InitDialog())
static PyObject *_wrap_wxWindow_InitDialog(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
-#define wxWindow_MoveXY(_swigobj,_swigarg0,_swigarg1) (_swigobj->Move(_swigarg0,_swigarg1))
+#define wxWindow_MoveXY(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->Move(_swigarg0,_swigarg1,_swigarg2))
static PyObject *_wrap_wxWindow_MoveXY(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxWindow * _arg0;
int _arg1;
int _arg2;
+ int _arg3 = (int ) wxSIZE_USE_EXISTING;
PyObject * _argo0 = 0;
- char *_kwnames[] = { "self","x","y", NULL };
+ char *_kwnames[] = { "self","x","y","flags", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxWindow_MoveXY",_kwnames,&_argo0,&_arg1,&_arg2))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|i:wxWindow_MoveXY",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
- wxWindow_MoveXY(_arg0,_arg1,_arg2);
+ wxWindow_MoveXY(_arg0,_arg1,_arg2,_arg3);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) return NULL;
return _resultobj;
}
-#define wxWindow_Move(_swigobj,_swigarg0) (_swigobj->Move(_swigarg0))
+#define wxWindow_Move(_swigobj,_swigarg0,_swigarg1) (_swigobj->Move(_swigarg0,_swigarg1))
static PyObject *_wrap_wxWindow_Move(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxWindow * _arg0;
wxPoint * _arg1;
+ int _arg2 = (int ) wxSIZE_USE_EXISTING;
PyObject * _argo0 = 0;
wxPoint temp;
PyObject * _obj1 = 0;
- char *_kwnames[] = { "self","point", NULL };
+ char *_kwnames[] = { "self","point","flags", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_Move",_kwnames,&_argo0,&_obj1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxWindow_Move",_kwnames,&_argo0,&_obj1,&_arg2))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
- wxWindow_Move(_arg0,*_arg1);
+ wxWindow_Move(_arg0,*_arg1,_arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) return NULL;
return _resultobj;
}
-static void wxWindow_SetPosition(wxWindow *self,const wxPoint & pos) {
- self->Move(pos);
+static void wxWindow_SetPosition(wxWindow *self,const wxPoint & pos,int flags) {
+ self->Move(pos, flags);
}
static PyObject *_wrap_wxWindow_SetPosition(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxWindow * _arg0;
wxPoint * _arg1;
+ int _arg2 = (int ) wxSIZE_USE_EXISTING;
PyObject * _argo0 = 0;
wxPoint temp;
PyObject * _obj1 = 0;
- char *_kwnames[] = { "self","pos", NULL };
+ char *_kwnames[] = { "self","pos","flags", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetPosition",_kwnames,&_argo0,&_obj1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxWindow_SetPosition",_kwnames,&_argo0,&_obj1,&_arg2))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
- wxWindow_SetPosition(_arg0,*_arg1);
+ wxWindow_SetPosition(_arg0,*_arg1,_arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) return NULL;
return _resultobj;
}
+#define wxWindow_UpdateWindowUI(_swigobj) (_swigobj->UpdateWindowUI())
+static PyObject *_wrap_wxWindow_UpdateWindowUI(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxWindow * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWindow_UpdateWindowUI",_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_UpdateWindowUI. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxWindow_UpdateWindowUI(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
#define wxWindow_Validate(_swigobj) (_swigobj->Validate())
static PyObject *_wrap_wxWindow_Validate(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxWindow_SetContainingSizer(_swigobj,_swigarg0) (_swigobj->SetContainingSizer(_swigarg0))
+static PyObject *_wrap_wxWindow_SetContainingSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxWindow * _arg0;
+ wxSizer * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","sizer", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetContainingSizer",_kwnames,&_argo0,&_argo1))
+ 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_SetContainingSizer. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_SetContainingSizer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxWindow_SetContainingSizer(_arg0,_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxWindow_GetContainingSizer(_swigobj) (_swigobj->GetContainingSizer())
+static PyObject *_wrap_wxWindow_GetContainingSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _result;
+ wxWindow * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWindow_GetContainingSizer",_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_GetContainingSizer. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ _result = (wxSizer *)wxWindow_GetContainingSizer(_arg0);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+}{ _resultobj = wxPyMake_wxSizer(_result); }
+ return _resultobj;
+}
+
#define wxWindow_GetValidator(_swigobj) (_swigobj->GetValidator())
static PyObject *_wrap_wxWindow_GetValidator(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxWindow_SetHelpTextForId(_swigobj,_swigarg0) (_swigobj->SetHelpTextForId(_swigarg0))
+static PyObject *_wrap_wxWindow_SetHelpTextForId(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxWindow * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","text", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetHelpTextForId",_kwnames,&_argo0,&_obj1))
+ 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_SetHelpTextForId. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+#if PYTHON_API_VERSION >= 1009
+ char* tmpPtr; int tmpSize;
+ if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+ return NULL;
+ _arg1 = new wxString(tmpPtr, tmpSize);
+#else
+ if (!PyString_Check(_obj1)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
+}
+{
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ wxWindow_SetHelpTextForId(_arg0,*_arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) return NULL;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
#define wxWindow_ScrollLines(_swigobj,_swigarg0) (_swigobj->ScrollLines(_swigarg0))
static PyObject *_wrap_wxWindow_ScrollLines(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
static PyObject *_wrap_new_wxMenu(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxMenu * _result;
- wxString * _arg0 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg0 = (wxString *) &wxEmptyString;
long _arg1 = (long ) 0;
PyObject * _obj0 = 0;
char *_kwnames[] = { "title","style", NULL };
wxMenu * _arg0;
int _arg1;
wxString * _arg2;
- wxString * _arg3 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg3 = (wxString *) &wxEmptyString;
int _arg4 = (int ) FALSE;
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
int _arg1;
wxString * _arg2;
wxMenu * _arg3;
- wxString * _arg4 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg4 = (wxString *) &wxEmptyString;
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
PyObject * _argo3 = 0;
wxMenuItem * _result;
wxMenu * _arg0 = (wxMenu *) NULL;
int _arg1 = (int ) wxID_SEPARATOR;
- wxString * _arg2 = (wxString *) &wxPyEmptyStr;
- wxString * _arg3 = (wxString *) &wxPyEmptyStr;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ wxString * _arg3 = (wxString *) &wxEmptyString;
bool _arg4 = (bool ) FALSE;
wxMenu * _arg5 = (wxMenu *) NULL;
PyObject * _argo0 = 0;
{ "wxWindow_LineUp", (PyCFunction) _wrap_wxWindow_LineUp, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_ScrollPages", (PyCFunction) _wrap_wxWindow_ScrollPages, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_ScrollLines", (PyCFunction) _wrap_wxWindow_ScrollLines, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_SetHelpTextForId", (PyCFunction) _wrap_wxWindow_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetHelpText", (PyCFunction) _wrap_wxWindow_SetHelpText, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetHelpText", (PyCFunction) _wrap_wxWindow_GetHelpText, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_Update", (PyCFunction) _wrap_wxWindow_Update, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetBestSize", (PyCFunction) _wrap_wxWindow_GetBestSize, 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_GetContainingSizer", (PyCFunction) _wrap_wxWindow_GetContainingSizer, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_SetContainingSizer", (PyCFunction) _wrap_wxWindow_SetContainingSizer, 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_ConvertDialogPointToPixels", (PyCFunction) _wrap_wxWindow_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_WarpPointer", (PyCFunction) _wrap_wxWindow_WarpPointer, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_Validate", (PyCFunction) _wrap_wxWindow_Validate, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_UpdateWindowUI", (PyCFunction) _wrap_wxWindow_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_TransferDataToWindow", (PyCFunction) _wrap_wxWindow_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_TransferDataFromWindow", (PyCFunction) _wrap_wxWindow_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_Show", (PyCFunction) _wrap_wxWindow_Show, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_IsExposed", (PyCFunction) _wrap_wxWindow_IsExposed, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_IsEnabled", (PyCFunction) _wrap_wxWindow_IsEnabled, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_InitDialog", (PyCFunction) _wrap_wxWindow_InitDialog, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_HitTest", (PyCFunction) _wrap_wxWindow_HitTest, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_Hide", (PyCFunction) _wrap_wxWindow_Hide, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_HasScrollbar", (PyCFunction) _wrap_wxWindow_HasScrollbar, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetWindowStyle", (PyCFunction) _wrap_wxWindow_SetWindowStyle, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetWindowStyleFlag", (PyCFunction) _wrap_wxWindow_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetWindowStyleFlag", (PyCFunction) _wrap_wxWindow_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetFont", (PyCFunction) _wrap_wxWindow_GetFont, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetEventHandler", (PyCFunction) _wrap_wxWindow_GetEventHandler, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetConstraints", (PyCFunction) _wrap_wxWindow_GetConstraints, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_GetClientRect", (PyCFunction) _wrap_wxWindow_GetClientRect, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_GetClientAreaOrigin", (PyCFunction) _wrap_wxWindow_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetClientSize", (PyCFunction) _wrap_wxWindow_GetClientSize, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetClientSizeTuple", (PyCFunction) _wrap_wxWindow_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetCharWidth", (PyCFunction) _wrap_wxWindow_GetCharWidth, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetCharHeight", (PyCFunction) _wrap_wxWindow_GetCharHeight, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetChildren", (PyCFunction) _wrap_wxWindow_GetChildren, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_GetBorder", (PyCFunction) _wrap_wxWindow_GetBorder, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetBackgroundColour", (PyCFunction) _wrap_wxWindow_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_Fit", (PyCFunction) _wrap_wxWindow_Fit, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_FindWindowByName", (PyCFunction) _wrap_wxWindow_FindWindowByName, METH_VARARGS | METH_KEYWORDS },
val = apply(windowsc.wxWindow_GetBackgroundColour,(self,) + _args, _kwargs)
if val: val = wxColourPtr(val) ; val.thisown = 1
return val
+ def GetBorder(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_GetBorder,(self,) + _args, _kwargs)
+ return val
def GetChildren(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_GetChildren,(self,) + _args, _kwargs)
return val
val = apply(windowsc.wxWindow_GetClientSize,(self,) + _args, _kwargs)
if val: val = wxSizePtr(val) ; val.thisown = 1
return val
+ def GetClientAreaOrigin(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_GetClientAreaOrigin,(self,) + _args, _kwargs)
+ if val: val = wxPointPtr(val) ; val.thisown = 1
+ return val
+ def GetClientRect(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_GetClientRect,(self,) + _args, _kwargs)
+ if val: val = wxRectPtr(val) ; val.thisown = 1
+ return val
def GetConstraints(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_GetConstraints,(self,) + _args, _kwargs)
if val: val = wxLayoutConstraintsPtr(val)
def SetWindowStyle(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_SetWindowStyle,(self,) + _args, _kwargs)
return val
+ def HasScrollbar(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_HasScrollbar,(self,) + _args, _kwargs)
+ return val
def Hide(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_Hide,(self,) + _args, _kwargs)
return val
+ def HitTest(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_HitTest,(self,) + _args, _kwargs)
+ return val
def InitDialog(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_InitDialog,(self,) + _args, _kwargs)
return val
def TransferDataToWindow(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_TransferDataToWindow,(self,) + _args, _kwargs)
return val
+ def UpdateWindowUI(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_UpdateWindowUI,(self,) + _args, _kwargs)
+ return val
def Validate(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_Validate,(self,) + _args, _kwargs)
return val
def GetSizer(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_GetSizer,(self,) + _args, _kwargs)
return val
+ def SetContainingSizer(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_SetContainingSizer,(self,) + _args, _kwargs)
+ return val
+ def GetContainingSizer(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_GetContainingSizer,(self,) + _args, _kwargs)
+ return val
def GetValidator(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_GetValidator,(self,) + _args, _kwargs)
return val
def SetHelpText(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_SetHelpText,(self,) + _args, _kwargs)
return val
+ def SetHelpTextForId(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_SetHelpTextForId,(self,) + _args, _kwargs)
+ return val
def ScrollLines(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_ScrollLines,(self,) + _args, _kwargs)
return val
extern "C" SWIGEXPORT(void) initclip_dndc();
extern "C" SWIGEXPORT(void) initstreamsc();
extern "C" SWIGEXPORT(void) initfilesysc();
+extern "C" SWIGEXPORT(void) initutilsc();
PyDict_SetItemString(d,"wxDUPLEX_SIMPLEX", PyInt_FromLong((long) wxDUPLEX_SIMPLEX));
PyDict_SetItemString(d,"wxDUPLEX_HORIZONTAL", PyInt_FromLong((long) wxDUPLEX_HORIZONTAL));
PyDict_SetItemString(d,"wxDUPLEX_VERTICAL", PyInt_FromLong((long) wxDUPLEX_VERTICAL));
+ PyDict_SetItemString(d,"wxHT_NOWHERE", PyInt_FromLong((long) wxHT_NOWHERE));
+ PyDict_SetItemString(d,"wxHT_SCROLLBAR_FIRST", PyInt_FromLong((long) wxHT_SCROLLBAR_FIRST));
+ PyDict_SetItemString(d,"wxHT_SCROLLBAR_ARROW_LINE_1", PyInt_FromLong((long) wxHT_SCROLLBAR_ARROW_LINE_1));
+ PyDict_SetItemString(d,"wxHT_SCROLLBAR_ARROW_LINE_2", PyInt_FromLong((long) wxHT_SCROLLBAR_ARROW_LINE_2));
+ PyDict_SetItemString(d,"wxHT_SCROLLBAR_ARROW_PAGE_1", PyInt_FromLong((long) wxHT_SCROLLBAR_ARROW_PAGE_1));
+ PyDict_SetItemString(d,"wxHT_SCROLLBAR_ARROW_PAGE_2", PyInt_FromLong((long) wxHT_SCROLLBAR_ARROW_PAGE_2));
+ PyDict_SetItemString(d,"wxHT_SCROLLBAR_THUMB", PyInt_FromLong((long) wxHT_SCROLLBAR_THUMB));
+ PyDict_SetItemString(d,"wxHT_SCROLLBAR_BAR_1", PyInt_FromLong((long) wxHT_SCROLLBAR_BAR_1));
+ PyDict_SetItemString(d,"wxHT_SCROLLBAR_BAR_2", PyInt_FromLong((long) wxHT_SCROLLBAR_BAR_2));
+ PyDict_SetItemString(d,"wxHT_SCROLLBAR_LAST", PyInt_FromLong((long) wxHT_SCROLLBAR_LAST));
+ PyDict_SetItemString(d,"wxHT_WINDOW_OUTSIDE", PyInt_FromLong((long) wxHT_WINDOW_OUTSIDE));
+ PyDict_SetItemString(d,"wxHT_WINDOW_INSIDE", PyInt_FromLong((long) wxHT_WINDOW_INSIDE));
+ PyDict_SetItemString(d,"wxHT_WINDOW_VERT_SCROLLBAR", PyInt_FromLong((long) wxHT_WINDOW_VERT_SCROLLBAR));
+ PyDict_SetItemString(d,"wxHT_WINDOW_HORZ_SCROLLBAR", PyInt_FromLong((long) wxHT_WINDOW_HORZ_SCROLLBAR));
+ PyDict_SetItemString(d,"wxHT_WINDOW_CORNER", PyInt_FromLong((long) wxHT_WINDOW_CORNER));
+ PyDict_SetItemString(d,"wxHT_MAX", PyInt_FromLong((long) wxHT_MAX));
PyDict_SetItemString(d,"FALSE", PyInt_FromLong((long) 0));
PyDict_SetItemString(d,"false", PyInt_FromLong((long) 0));
PyDict_SetItemString(d,"TRUE", PyInt_FromLong((long) 1));
PyDict_SetItemString(d,"wxEVT_MENU_HIGHLIGHT", PyInt_FromLong((long) wxEVT_MENU_HIGHLIGHT));
PyDict_SetItemString(d,"wxEVT_POPUP_MENU_INIT", PyInt_FromLong((long) wxEVT_POPUP_MENU_INIT));
PyDict_SetItemString(d,"wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong((long) wxEVT_SYS_COLOUR_CHANGED));
+ PyDict_SetItemString(d,"wxEVT_DISPLAY_CHANGED", PyInt_FromLong((long) wxEVT_DISPLAY_CHANGED));
PyDict_SetItemString(d,"wxEVT_SETTING_CHANGED", PyInt_FromLong((long) wxEVT_SETTING_CHANGED));
PyDict_SetItemString(d,"wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong((long) wxEVT_QUERY_NEW_PALETTE));
PyDict_SetItemString(d,"wxEVT_PALETTE_CHANGED", PyInt_FromLong((long) wxEVT_PALETTE_CHANGED));
initclip_dndc();
initstreamsc();
initfilesysc();
+ initutilsc();
PyDict_SetItemString(d,"wxMAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
wxDUPLEX_SIMPLEX = wxc.wxDUPLEX_SIMPLEX
wxDUPLEX_HORIZONTAL = wxc.wxDUPLEX_HORIZONTAL
wxDUPLEX_VERTICAL = wxc.wxDUPLEX_VERTICAL
+wxHT_NOWHERE = wxc.wxHT_NOWHERE
+wxHT_SCROLLBAR_FIRST = wxc.wxHT_SCROLLBAR_FIRST
+wxHT_SCROLLBAR_ARROW_LINE_1 = wxc.wxHT_SCROLLBAR_ARROW_LINE_1
+wxHT_SCROLLBAR_ARROW_LINE_2 = wxc.wxHT_SCROLLBAR_ARROW_LINE_2
+wxHT_SCROLLBAR_ARROW_PAGE_1 = wxc.wxHT_SCROLLBAR_ARROW_PAGE_1
+wxHT_SCROLLBAR_ARROW_PAGE_2 = wxc.wxHT_SCROLLBAR_ARROW_PAGE_2
+wxHT_SCROLLBAR_THUMB = wxc.wxHT_SCROLLBAR_THUMB
+wxHT_SCROLLBAR_BAR_1 = wxc.wxHT_SCROLLBAR_BAR_1
+wxHT_SCROLLBAR_BAR_2 = wxc.wxHT_SCROLLBAR_BAR_2
+wxHT_SCROLLBAR_LAST = wxc.wxHT_SCROLLBAR_LAST
+wxHT_WINDOW_OUTSIDE = wxc.wxHT_WINDOW_OUTSIDE
+wxHT_WINDOW_INSIDE = wxc.wxHT_WINDOW_INSIDE
+wxHT_WINDOW_VERT_SCROLLBAR = wxc.wxHT_WINDOW_VERT_SCROLLBAR
+wxHT_WINDOW_HORZ_SCROLLBAR = wxc.wxHT_WINDOW_HORZ_SCROLLBAR
+wxHT_WINDOW_CORNER = wxc.wxHT_WINDOW_CORNER
+wxHT_MAX = wxc.wxHT_MAX
FALSE = wxc.FALSE
false = wxc.false
TRUE = wxc.TRUE
wxEVT_MENU_HIGHLIGHT = wxc.wxEVT_MENU_HIGHLIGHT
wxEVT_POPUP_MENU_INIT = wxc.wxEVT_POPUP_MENU_INIT
wxEVT_SYS_COLOUR_CHANGED = wxc.wxEVT_SYS_COLOUR_CHANGED
+wxEVT_DISPLAY_CHANGED = wxc.wxEVT_DISPLAY_CHANGED
wxEVT_SETTING_CHANGED = wxc.wxEVT_SETTING_CHANGED
wxEVT_QUERY_NEW_PALETTE = wxc.wxEVT_QUERY_NEW_PALETTE
wxEVT_PALETTE_CHANGED = wxc.wxEVT_PALETTE_CHANGED
def EVT_SYS_COLOUR_CHANGED(win, func):
win.Connect(-1, -1, wxEVT_SYS_COLOUR_CHANGED, func)
+def EVT_DISPLAY_CHANGED(win, func):
+ win.Connect(-1, -1, wxEVT_DISPLAY_CHANGED, func)
+
def EVT_SHOW(win, func):
win.Connect(-1, -1, wxEVT_SHOW, func)
def __del__(self):
self.cleanup()
-__cleanMeUp = __wxPyCleanup()
+sys.__wxPythonCleanup = __wxPyCleanup()
+
+## # another possible solution, but it gets called too early...
+## if sys.version[0] == '2':
+## import atexit
+## atexit.register(wxc.wxApp_CleanUp)
+## else:
+## sys.exitfunc = wxc.wxApp_CleanUp
+
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
projects / wxWidgets.git / commitdiff
