+
+
+wxPyCBOutputStream::wxPyCBOutputStream(PyObject *w, PyObject *s, PyObject *t, bool block)
+ : wxOutputStream(), m_write(w), m_seek(s), m_tell(t), m_block(block)
+{}
+
+wxPyCBOutputStream::wxPyCBOutputStream(const wxPyCBOutputStream& other)
+{
+ m_write = other.m_write;
+ m_seek = other.m_seek;
+ m_tell = other.m_tell;
+ m_block = other.m_block;
+ Py_INCREF(m_write);
+ Py_INCREF(m_seek);
+ Py_INCREF(m_tell);
+}
+
+
+wxPyCBOutputStream::~wxPyCBOutputStream() {
+ wxPyBlock_t blocked = wxPyBlock_t_default;
+ if (m_block) blocked = wxPyBeginBlockThreads();
+ Py_XDECREF(m_write);
+ Py_XDECREF(m_seek);
+ Py_XDECREF(m_tell);
+ if (m_block) wxPyEndBlockThreads(blocked);
+}
+
+
+wxPyCBOutputStream* wxPyCBOutputStream::create(PyObject *py, bool block) {
+ wxPyBlock_t blocked = wxPyBlock_t_default;
+ if (block) blocked = wxPyBeginBlockThreads();
+
+ PyObject* write = wxPyGetMethod(py, "write");
+ PyObject* seek = wxPyGetMethod(py, "seek");
+ PyObject* tell = wxPyGetMethod(py, "tell");
+
+ if (!write) {
+ PyErr_SetString(PyExc_TypeError, "Not a file-like object");
+ Py_XDECREF(write);
+ Py_XDECREF(seek);
+ Py_XDECREF(tell);
+ if (block) wxPyEndBlockThreads(blocked);
+ return NULL;
+ }
+
+ if (block) wxPyEndBlockThreads(blocked);
+ return new wxPyCBOutputStream(write, seek, tell, block);
+}
+
+
+wxPyCBOutputStream* wxPyCBOutputStream_create(PyObject *py, bool block) {
+ return wxPyCBOutputStream::create(py, block);
+}
+
+wxPyCBOutputStream* wxPyCBOutputStream_copy(wxPyCBOutputStream* other) {
+ return new wxPyCBOutputStream(*other);
+}
+
+
+wxFileOffset wxPyCBOutputStream::GetLength() const {
+ wxPyCBOutputStream* self = (wxPyCBOutputStream*)this; // cast off const
+ if (m_seek && m_tell) {
+ wxFileOffset temp = self->OnSysTell();
+ wxFileOffset ret = self->OnSysSeek(0, wxFromEnd);
+ self->OnSysSeek(temp, wxFromStart);
+ return ret;
+ }
+ else
+ return wxInvalidOffset;
+}
+
+
+size_t wxPyCBOutputStream::OnSysRead(void *buffer, size_t bufsize) {
+ m_lasterror = wxSTREAM_READ_ERROR;
+ return 0;
+}
+
+size_t wxPyCBOutputStream::OnSysWrite(const void *buffer, size_t bufsize) {
+ if (bufsize == 0)
+ return 0;
+
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ PyObject* arglist = PyTuple_New(1);
+ PyTuple_SET_ITEM(arglist, 0, PyString_FromStringAndSize((char*)buffer, bufsize));
+
+ PyObject* result = PyEval_CallObject(m_write, arglist);
+ Py_DECREF(arglist);
+
+ if (result != NULL)
+ Py_DECREF(result);
+ else
+ m_lasterror = wxSTREAM_WRITE_ERROR;
+ wxPyEndBlockThreads(blocked);
+ return bufsize;
+}
+
+
+wxFileOffset wxPyCBOutputStream::OnSysSeek(wxFileOffset off, wxSeekMode mode) {
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ PyObject* arglist = PyTuple_New(2);
+
+ if (sizeof(wxFileOffset) > sizeof(long))
+ // wxFileOffset is a 64-bit value...
+ PyTuple_SET_ITEM(arglist, 0, PyLong_FromLongLong(off));
+ else
+ PyTuple_SET_ITEM(arglist, 0, PyInt_FromLong(off));
+
+ PyTuple_SET_ITEM(arglist, 1, PyInt_FromLong(mode));
+
+
+ PyObject* result = PyEval_CallObject(m_seek, arglist);
+ Py_DECREF(arglist);
+ Py_XDECREF(result);
+ wxPyEndBlockThreads(blocked);
+ return OnSysTell();
+}
+
+
+wxFileOffset wxPyCBOutputStream::OnSysTell() const {
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ PyObject* arglist = Py_BuildValue("()");
+ PyObject* result = PyEval_CallObject(m_tell, arglist);
+ Py_DECREF(arglist);
+ wxFileOffset o = 0;
+ if (result != NULL) {
+ if (PyLong_Check(result))
+ o = PyLong_AsLongLong(result);
+ else
+ o = PyInt_AsLong(result);
+ Py_DECREF(result);
+ };
+ wxPyEndBlockThreads(blocked);
+ return o;
+}
+
+
+
+//----------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject);
+
+wxPyCallback::wxPyCallback(PyObject* func) {
+ m_func = func;
+ Py_INCREF(m_func);
+}
+
+wxPyCallback::wxPyCallback(const wxPyCallback& other) {
+ m_func = other.m_func;
+ Py_INCREF(m_func);
+}
+
+wxPyCallback::~wxPyCallback() {
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ Py_DECREF(m_func);
+ wxPyEndBlockThreads(blocked);
+}
+
+
+#define wxPy_PRECALLINIT "_preCallInit"
+#define wxPy_POSTCALLCLEANUP "_postCallCleanup"
+
+// This function is used for all events destined for Python event handlers.
+void wxPyCallback::EventThunker(wxEvent& event) {
+ wxPyCallback* cb = (wxPyCallback*)event.m_callbackUserData;
+ PyObject* func = cb->m_func;
+ PyObject* result;
+ PyObject* arg;
+ PyObject* tuple;
+ bool checkSkip = false;
+
+ wxPyBlock_t blocked = wxPyBeginBlockThreads();
+ wxString className = event.GetClassInfo()->GetClassName();
+
+ // If the event is one of these types then pass the original
+ // event object instead of the one passed to us.
+ if ( className == wxT("wxPyEvent") ) {
+ arg = ((wxPyEvent*)&event)->GetSelf();
+ checkSkip = ((wxPyEvent*)&event)->GetCloned();
+ }
+ else if ( className == wxT("wxPyCommandEvent") ) {
+ arg = ((wxPyCommandEvent*)&event)->GetSelf();
+ checkSkip = ((wxPyCommandEvent*)&event)->GetCloned();
+ }
+ else {
+ arg = wxPyConstructObject((void*)&event, className);
+ }
+
+ if (!arg) {
+ PyErr_Print();
+ } else {
+ // "intern" the pre/post method names to speed up the HasAttr
+ static PyObject* s_preName = NULL;
+ static PyObject* s_postName = NULL;
+ if (s_preName == NULL) {
+ s_preName = PyString_FromString(wxPy_PRECALLINIT);
projects / wxWidgets.git / blobdiff