1--- pyobjc-framework-Quartz/Modules/_callbacks.m.orig 2009-06-23 15:35:35.000000000 -0700 2+++ pyobjc-framework-Quartz/Modules/_callbacks.m 2011-10-20 11:26:12.000000000 -0700 3@@ -209,23 +209,6 @@ m_CGDataProviderGetBytesCallback( 4 } 5 6 static void 7-m_CGDataProviderSkipBytesCallback(void* _info, size_t count) 8-{ 9- PyObject* info = (PyObject*)_info; 10- 11- PyGILState_STATE state = PyGILState_Ensure(); 12- 13- PyObject* result = PyObject_CallFunction(PyTuple_GET_ITEM(info, 2), 14- "Ol", PyTuple_GET_ITEM(info, 0), count); 15- if (result == NULL) { 16- PyObjCErr_ToObjCWithGILState(&state); 17- } 18- Py_DECREF(result); 19- 20- PyGILState_Release(state); 21-} 22- 23-static void 24 m_CGDataProviderRewindCallback(void* _info) 25 { 26 PyObject* info = (PyObject*)_info; 27@@ -264,131 +247,6 @@ m_CGDataProviderReleaseInfoCallback(void 28 PyGILState_Release(state); 29 } 30 31-static CGDataProviderCallbacks m_CGDataProviderCallbacks = { 32- m_CGDataProviderGetBytesCallback, /* getBytes */ 33- m_CGDataProviderSkipBytesCallback, /* skipBytes */ 34- m_CGDataProviderRewindCallback, /* rewind */ 35- m_CGDataProviderReleaseInfoCallback /* releaseProvider */ 36-}; 37- 38-static const void* 39-m_CGDataProviderGetBytePointerCallback(void* _info) 40-{ 41- PyObject* info = (PyObject*)_info; 42- 43- PyGILState_STATE state = PyGILState_Ensure(); 44- 45- PyObject* result = PyObject_CallFunction( 46- PyTuple_GET_ITEM(info, 1), 47- "O", PyTuple_GET_ITEM(info, 0)); 48- if (result == NULL) { 49- PyObjCErr_ToObjCWithGILState(&state); 50- } 51- if (result == PyObjC_NULL || result == Py_None) { 52- Py_DECREF(result); 53- PyGILState_Release(state); 54- return NULL; 55- } 56- 57- const void* b; 58- Py_ssize_t c; 59- 60- if (PyObject_AsReadBuffer(PyTuple_GET_ITEM(result, 1), 61- &b, &c) < 0) { 62- Py_DECREF(result); 63- PyObjCErr_ToObjCWithGILState(&state); 64- } 65- 66- PyGILState_Release(state); 67- return b; 68-} 69- 70-static void 71-m_CGDataProviderReleaseBytePointerCallback(void* _info, const void* pointer) 72-{ 73- /* FIXME: have to store enough info to recover the right PyObject* */ 74-} 75- 76-static size_t 77-m_CGDataProviderGetBytesAtOffsetCallback(void* _info, void* buffer, 78- size_t offset, size_t count) 79-{ 80- PyObject* info = (PyObject*)_info; 81- 82- PyGILState_STATE state = PyGILState_Ensure(); 83- 84- PyObject* buf = PyBuffer_FromReadWriteMemory(buffer, count); 85- if (buf == NULL) { 86- PyObjCErr_ToObjCWithGILState(&state); 87- } 88- 89- PyObject* result = PyObject_CallFunction( 90- PyTuple_GET_ITEM(info, 3), 91- "OOll", 92- PyTuple_GET_ITEM(info, 0), 93- buf, 94- offset, 95- count); 96- if (result == NULL) { 97- Py_DECREF(buf); 98- PyObjCErr_ToObjCWithGILState(&state); 99- } 100- 101- if (!PyTuple_Check(result) || PyTuple_GET_SIZE(result) != 2) { 102- PyErr_Format(PyExc_TypeError, 103- "Expecting result of type tuple of 2, got %s", 104- result->ob_type->tp_name); 105- Py_DECREF(result); 106- Py_DECREF(buf); 107- PyObjCErr_ToObjCWithGILState(&state); 108- } 109- 110- size_t c_result; 111- if (PyObjC_PythonToObjC(@encode(size_t), PyTuple_GET_ITEM(result, 0), &c_result) < 0) { 112- Py_DECREF(result); 113- Py_DECREF(buf); 114- PyObjCErr_ToObjCWithGILState(&state); 115- } 116- 117- if (PyTuple_GET_ITEM(result, 1) != buf) { 118- const void* b; 119- Py_ssize_t c; 120- 121- if (PyObject_AsReadBuffer(PyTuple_GET_ITEM(result, 1), 122- &b, &c) < 0) { 123- Py_DECREF(result); 124- Py_DECREF(buf); 125- PyObjCErr_ToObjCWithGILState(&state); 126- } 127- 128- if (c < c_result || c > count) { 129- PyErr_SetString(PyExc_ValueError, 130- "Inconsistent size"); 131- Py_DECREF(result); 132- Py_DECREF(buf); 133- PyObjCErr_ToObjCWithGILState(&state); 134- } 135- memcpy(buffer, b, c_result); 136- } else { 137- /* Assume that the user knows what he's doing and has 138- * filled the right bit of the buffer. 139- */ 140- } 141- 142- Py_DECREF(buf); 143- Py_DECREF(result); 144- 145- PyGILState_Release(state); 146- return c_result; 147-} 148- 149-static CGDataProviderDirectAccessCallbacks m_CGDataProviderDirectAccessCallbacks = { 150- m_CGDataProviderGetBytePointerCallback, /* getBytePointer */ 151- m_CGDataProviderReleaseBytePointerCallback, /* releaseBytePointer */ 152- m_CGDataProviderGetBytesAtOffsetCallback, /* getBytes */ 153- m_CGDataProviderReleaseInfoCallback /* releaseProvider */ 154-}; 155- 156 157 158 159@@ -500,161 +358,6 @@ m_CGDataProviderCreateSequential(PyObjec 160 161 #endif 162 163- 164-PyDoc_STRVAR(doc_CGDataProviderCreate, 165- "CGDataConsumerCreate(info, (getBytes, skipBytes, rewind, releaseProvider)) -> object\n" 166- "\n" 167- "getBytes, skipBytes, rewind and release are callback functions. Release may be None"); 168-static PyObject* 169-m_CGDataProviderCreate(PyObject* self __attribute__((__unused__)), 170- PyObject* args) 171-{ 172- PyObject* info; 173- PyObject* getBytes; 174- PyObject* skipBytes; 175- PyObject* rewind; 176- PyObject* release; 177- 178- if (!PyArg_ParseTuple(args, "O(OOOO)", &info, &getBytes, &skipBytes, &rewind, &release)) { 179- return NULL; 180- } 181- 182- if (!PyCallable_Check(getBytes)) { 183- PyErr_SetString(PyExc_TypeError, "getBytes is not callable"); 184- return NULL; 185- } 186- if (!PyCallable_Check(skipBytes)) { 187- PyErr_SetString(PyExc_TypeError, "skipBytes is not callable"); 188- return NULL; 189- } 190- if (!PyCallable_Check(rewind)) { 191- PyErr_SetString(PyExc_TypeError, "rewind is not callable"); 192- return NULL; 193- } 194- if (release != Py_None && !PyCallable_Check(release)) { 195- PyErr_SetString(PyExc_TypeError, "release is not callable"); 196- return NULL; 197- } 198- 199- PyObject* real_info = Py_BuildValue("OOOOO", info, getBytes, skipBytes, rewind, release); 200- if (real_info == NULL) { 201- return NULL; 202- } 203- 204- CGDataProviderRef result; 205- PyObjC_DURING 206- result = CGDataProviderCreate(real_info, 207- &m_CGDataProviderCallbacks); 208- 209- PyObjC_HANDLER 210- result = NULL; 211- PyObjCErr_FromObjC(localException); 212- PyObjC_ENDHANDLER 213- 214- if (result == NULL && PyErr_Occurred()) { 215- Py_DECREF(real_info); 216- return NULL; 217- } 218- 219- if (result == NULL) { 220- Py_DECREF(real_info); 221- Py_INCREF(Py_None); 222- return Py_None; 223- } 224- 225- PyObject* retval = PyObjC_ObjCToPython( 226- @encode(CGDataProviderRef), &result); 227- /* CGDataProviderCreate donated a reference, we therefore now have 228- * one too many, release a reference. 229- */ 230- CGDataProviderRelease(result); 231- return retval; 232-} 233- 234-PyDoc_STRVAR(doc_CGDataProviderCreateDirectAccess, 235- "CGDataConsumerCreateDirectAccess(info, (getBytePointer, releaseBytePointer, getBytes, release)) -> object\n" 236- "\n" 237- "getBytePointer, releaseBytePointer, getBytes and release are callback functions. Release may be None"); 238-static PyObject* 239-m_CGDataProviderCreateDirectAccess(PyObject* self __attribute__((__unused__)), 240- PyObject* args) 241-{ 242- PyObject* info; 243- PyObject* getBytePointer; 244- PyObject* releaseBytePointer; 245- PyObject* getBytes; 246- PyObject* release; 247- long size; 248- 249- CGDataProviderDirectAccessCallbacks callbacks = m_CGDataProviderDirectAccessCallbacks; 250- 251- if (!PyArg_ParseTuple(args, "Ol(OOOO)", &info, &size, &getBytePointer, &releaseBytePointer, &getBytes, &release)) { 252- return NULL; 253- } 254- 255- if (getBytePointer == Py_None) { 256- callbacks.getBytePointer = NULL; 257- } else if (!PyCallable_Check(getBytePointer)) { 258- PyErr_SetString(PyExc_TypeError, "getBytePointer is not callable"); 259- return NULL; 260- } 261- 262- if (releaseBytePointer == Py_None) { 263- callbacks.releaseBytePointer = NULL; 264- } else if (!PyCallable_Check(releaseBytePointer)) { 265- PyErr_SetString(PyExc_TypeError, "releaseBytePointer is not callable"); 266- return NULL; 267- } 268- 269- if (getBytes == Py_None) { 270- callbacks.getBytes = NULL; 271- 272- } else if (!PyCallable_Check(getBytes)) { 273- PyErr_SetString(PyExc_TypeError, "getBytes is not callable"); 274- return NULL; 275- } 276- 277- if (release != Py_None && !PyCallable_Check(release)) { 278- PyErr_SetString(PyExc_TypeError, "release is not callable"); 279- return NULL; 280- } 281- 282- PyObject* real_info = Py_BuildValue("OOOOO", info, getBytePointer, releaseBytePointer, getBytes, release); 283- if (real_info == NULL) { 284- return NULL; 285- } 286- 287- CGDataProviderRef result; 288- PyObjC_DURING 289- result = CGDataProviderCreateDirectAccess(real_info, 290- size, 291- &callbacks); 292- 293- PyObjC_HANDLER 294- result = NULL; 295- PyObjCErr_FromObjC(localException); 296- PyObjC_ENDHANDLER 297- 298- if (result == NULL && PyErr_Occurred()) { 299- Py_DECREF(real_info); 300- return NULL; 301- } 302- 303- if (result == NULL) { 304- Py_DECREF(real_info); 305- Py_INCREF(Py_None); 306- return Py_None; 307- } 308- 309- PyObject* retval = PyObjC_ObjCToPython( 310- @encode(CGDataProviderRef), &result); 311- /* CGDataProviderCreate donated a reference, we therefore now have 312- * one too many, release a reference. 313- */ 314- CGDataProviderRelease(result); 315- return retval; 316-} 317- 318 /* 319 * CGDataProviderCreateWithData 320 */ 321@@ -2002,20 +1705,6 @@ static PyMethodDef m_methods[] = { 322 doc_CGDataConsumerCreate 323 }, 324 325- { 326- "CGDataProviderCreate", 327- (PyCFunction)m_CGDataProviderCreate, 328- METH_VARARGS, 329- doc_CGDataProviderCreate 330- }, 331- 332- { 333- "CGDataProviderCreateDirectAccess", 334- (PyCFunction)m_CGDataProviderCreateDirectAccess, 335- METH_VARARGS, 336- doc_CGDataProviderCreateDirectAccess 337- }, 338- 339 #ifndef OS_TIGER 340 341 { 342