/Mac/Modules/scrap/_Scrapmodule.c

http://unladen-swallow.googlecode.com/ · C · 365 lines · 308 code · 50 blank · 7 comment · 61 complexity · 246fbb0181d44d99f4570585617e5a80 MD5 · raw file

  1. /* ========================= Module _Scrap ========================== */
  2. #include "Python.h"
  3. #ifndef __LP64__
  4. #include "pymactoolbox.h"
  5. /* Macro to test whether a weak-loaded CFM function exists */
  6. #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
  7. PyErr_SetString(PyExc_NotImplementedError, \
  8. "Not available in this shared library/OS version"); \
  9. return NULL; \
  10. }} while(0)
  11. #include <Carbon/Carbon.h>
  12. static PyObject *Scrap_Error;
  13. /* ----------------------- Object type Scrap ------------------------ */
  14. PyTypeObject Scrap_Type;
  15. #define ScrapObj_Check(x) ((x)->ob_type == &Scrap_Type || PyObject_TypeCheck((x), &Scrap_Type))
  16. typedef struct ScrapObject {
  17. PyObject_HEAD
  18. ScrapRef ob_itself;
  19. } ScrapObject;
  20. PyObject *ScrapObj_New(ScrapRef itself)
  21. {
  22. ScrapObject *it;
  23. it = PyObject_NEW(ScrapObject, &Scrap_Type);
  24. if (it == NULL) return NULL;
  25. it->ob_itself = itself;
  26. return (PyObject *)it;
  27. }
  28. int ScrapObj_Convert(PyObject *v, ScrapRef *p_itself)
  29. {
  30. if (!ScrapObj_Check(v))
  31. {
  32. PyErr_SetString(PyExc_TypeError, "Scrap required");
  33. return 0;
  34. }
  35. *p_itself = ((ScrapObject *)v)->ob_itself;
  36. return 1;
  37. }
  38. static void ScrapObj_dealloc(ScrapObject *self)
  39. {
  40. /* Cleanup of self->ob_itself goes here */
  41. self->ob_type->tp_free((PyObject *)self);
  42. }
  43. static PyObject *ScrapObj_GetScrapFlavorFlags(ScrapObject *_self, PyObject *_args)
  44. {
  45. PyObject *_res = NULL;
  46. OSStatus _err;
  47. ScrapFlavorType flavorType;
  48. ScrapFlavorFlags flavorFlags;
  49. if (!PyArg_ParseTuple(_args, "O&",
  50. PyMac_GetOSType, &flavorType))
  51. return NULL;
  52. _err = GetScrapFlavorFlags(_self->ob_itself,
  53. flavorType,
  54. &flavorFlags);
  55. if (_err != noErr) return PyMac_Error(_err);
  56. _res = Py_BuildValue("l",
  57. flavorFlags);
  58. return _res;
  59. }
  60. static PyObject *ScrapObj_GetScrapFlavorSize(ScrapObject *_self, PyObject *_args)
  61. {
  62. PyObject *_res = NULL;
  63. OSStatus _err;
  64. ScrapFlavorType flavorType;
  65. Size byteCount;
  66. if (!PyArg_ParseTuple(_args, "O&",
  67. PyMac_GetOSType, &flavorType))
  68. return NULL;
  69. _err = GetScrapFlavorSize(_self->ob_itself,
  70. flavorType,
  71. &byteCount);
  72. if (_err != noErr) return PyMac_Error(_err);
  73. _res = Py_BuildValue("l",
  74. byteCount);
  75. return _res;
  76. }
  77. static PyObject *ScrapObj_GetScrapFlavorData(ScrapObject *_self, PyObject *_args)
  78. {
  79. PyObject *_res = NULL;
  80. OSStatus _err;
  81. ScrapFlavorType flavorType;
  82. Size byteCount;
  83. if (!PyArg_ParseTuple(_args, "O&",
  84. PyMac_GetOSType, &flavorType))
  85. return NULL;
  86. _err = GetScrapFlavorSize(_self->ob_itself,
  87. flavorType,
  88. &byteCount);
  89. if (_err != noErr) return PyMac_Error(_err);
  90. _res = PyString_FromStringAndSize(NULL, (int)byteCount);
  91. if ( _res == NULL ) return NULL;
  92. _err = GetScrapFlavorData(_self->ob_itself,
  93. flavorType,
  94. &byteCount,
  95. PyString_AS_STRING(_res));
  96. if (_err != noErr) {
  97. Py_XDECREF(_res);
  98. return PyMac_Error(_err);
  99. }
  100. return _res;
  101. }
  102. static PyObject *ScrapObj_PutScrapFlavor(ScrapObject *_self, PyObject *_args)
  103. {
  104. PyObject *_res = NULL;
  105. OSStatus _err;
  106. ScrapFlavorType flavorType;
  107. ScrapFlavorFlags flavorFlags;
  108. char *flavorData__in__;
  109. int flavorData__in_len__;
  110. if (!PyArg_ParseTuple(_args, "O&Ks#",
  111. PyMac_GetOSType, &flavorType,
  112. &flavorFlags,
  113. &flavorData__in__, &flavorData__in_len__))
  114. return NULL;
  115. _err = PutScrapFlavor(_self->ob_itself,
  116. flavorType,
  117. flavorFlags,
  118. (Size)flavorData__in_len__,
  119. flavorData__in__);
  120. if (_err != noErr) return PyMac_Error(_err);
  121. Py_INCREF(Py_None);
  122. _res = Py_None;
  123. return _res;
  124. }
  125. static PyObject *ScrapObj_GetScrapFlavorCount(ScrapObject *_self, PyObject *_args)
  126. {
  127. PyObject *_res = NULL;
  128. OSStatus _err;
  129. UInt32 infoCount;
  130. if (!PyArg_ParseTuple(_args, ""))
  131. return NULL;
  132. _err = GetScrapFlavorCount(_self->ob_itself,
  133. &infoCount);
  134. if (_err != noErr) return PyMac_Error(_err);
  135. _res = Py_BuildValue("l",
  136. infoCount);
  137. return _res;
  138. }
  139. static PyObject *ScrapObj_GetScrapFlavorInfoList(ScrapObject *_self, PyObject *_args)
  140. {
  141. PyObject *_res = NULL;
  142. PyObject *item;
  143. OSStatus _err;
  144. UInt32 infoCount;
  145. ScrapFlavorInfo *infolist = NULL;
  146. int i;
  147. if (!PyArg_ParseTuple(_args, ""))
  148. return NULL;
  149. _err = GetScrapFlavorCount(_self->ob_itself,
  150. &infoCount);
  151. if (_err != noErr) return PyMac_Error(_err);
  152. if (infoCount == 0) return Py_BuildValue("[]");
  153. if ((infolist = (ScrapFlavorInfo *)malloc(infoCount*sizeof(ScrapFlavorInfo))) == NULL )
  154. return PyErr_NoMemory();
  155. _err = GetScrapFlavorInfoList(_self->ob_itself, &infoCount, infolist);
  156. if (_err != noErr) {
  157. free(infolist);
  158. return NULL;
  159. }
  160. if ((_res = PyList_New(infoCount)) == NULL ) {
  161. free(infolist);
  162. return NULL;
  163. }
  164. for(i=0; i<infoCount; i++) {
  165. item = Py_BuildValue("O&l", PyMac_BuildOSType, infolist[i].flavorType,
  166. infolist[i].flavorFlags);
  167. if ( !item || PyList_SetItem(_res, i, item) < 0 ) {
  168. Py_DECREF(_res);
  169. free(infolist);
  170. return NULL;
  171. }
  172. }
  173. free(infolist);
  174. return _res;
  175. }
  176. static PyMethodDef ScrapObj_methods[] = {
  177. {"GetScrapFlavorFlags", (PyCFunction)ScrapObj_GetScrapFlavorFlags, 1,
  178. PyDoc_STR("(ScrapFlavorType flavorType) -> (ScrapFlavorFlags flavorFlags)")},
  179. {"GetScrapFlavorSize", (PyCFunction)ScrapObj_GetScrapFlavorSize, 1,
  180. PyDoc_STR("(ScrapFlavorType flavorType) -> (Size byteCount)")},
  181. {"GetScrapFlavorData", (PyCFunction)ScrapObj_GetScrapFlavorData, 1,
  182. PyDoc_STR("(ScrapFlavorType flavorType, Buffer destination) -> (Size byteCount)")},
  183. {"PutScrapFlavor", (PyCFunction)ScrapObj_PutScrapFlavor, 1,
  184. PyDoc_STR("(ScrapFlavorType flavorType, ScrapFlavorFlags flavorFlags, Size flavorSize, Buffer flavorData) -> None")},
  185. {"GetScrapFlavorCount", (PyCFunction)ScrapObj_GetScrapFlavorCount, 1,
  186. PyDoc_STR("() -> (UInt32 infoCount)")},
  187. {"GetScrapFlavorInfoList", (PyCFunction)ScrapObj_GetScrapFlavorInfoList, 1,
  188. PyDoc_STR("() -> ([(ScrapFlavorType, ScrapFlavorInfo), ...])")},
  189. {NULL, NULL, 0}
  190. };
  191. PyMethodChain ScrapObj_chain = { ScrapObj_methods, NULL };
  192. static PyObject *ScrapObj_getattr(ScrapObject *self, char *name)
  193. {
  194. return Py_FindMethodInChain(&ScrapObj_chain, (PyObject *)self, name);
  195. }
  196. #define ScrapObj_setattr NULL
  197. #define ScrapObj_compare NULL
  198. #define ScrapObj_repr NULL
  199. #define ScrapObj_hash NULL
  200. PyTypeObject Scrap_Type = {
  201. PyObject_HEAD_INIT(NULL)
  202. 0, /*ob_size*/
  203. "_Scrap.Scrap", /*tp_name*/
  204. sizeof(ScrapObject), /*tp_basicsize*/
  205. 0, /*tp_itemsize*/
  206. /* methods */
  207. (destructor) ScrapObj_dealloc, /*tp_dealloc*/
  208. 0, /*tp_print*/
  209. (getattrfunc) ScrapObj_getattr, /*tp_getattr*/
  210. (setattrfunc) ScrapObj_setattr, /*tp_setattr*/
  211. (cmpfunc) ScrapObj_compare, /*tp_compare*/
  212. (reprfunc) ScrapObj_repr, /*tp_repr*/
  213. (PyNumberMethods *)0, /* tp_as_number */
  214. (PySequenceMethods *)0, /* tp_as_sequence */
  215. (PyMappingMethods *)0, /* tp_as_mapping */
  216. (hashfunc) ScrapObj_hash, /*tp_hash*/
  217. };
  218. /* --------------------- End object type Scrap ---------------------- */
  219. static PyObject *Scrap_LoadScrap(PyObject *_self, PyObject *_args)
  220. {
  221. PyObject *_res = NULL;
  222. OSStatus _err;
  223. if (!PyArg_ParseTuple(_args, ""))
  224. return NULL;
  225. _err = LoadScrap();
  226. if (_err != noErr) return PyMac_Error(_err);
  227. Py_INCREF(Py_None);
  228. _res = Py_None;
  229. return _res;
  230. }
  231. static PyObject *Scrap_UnloadScrap(PyObject *_self, PyObject *_args)
  232. {
  233. PyObject *_res = NULL;
  234. OSStatus _err;
  235. if (!PyArg_ParseTuple(_args, ""))
  236. return NULL;
  237. _err = UnloadScrap();
  238. if (_err != noErr) return PyMac_Error(_err);
  239. Py_INCREF(Py_None);
  240. _res = Py_None;
  241. return _res;
  242. }
  243. static PyObject *Scrap_GetCurrentScrap(PyObject *_self, PyObject *_args)
  244. {
  245. PyObject *_res = NULL;
  246. OSStatus _err;
  247. ScrapRef scrap;
  248. if (!PyArg_ParseTuple(_args, ""))
  249. return NULL;
  250. _err = GetCurrentScrap(&scrap);
  251. if (_err != noErr) return PyMac_Error(_err);
  252. _res = Py_BuildValue("O&",
  253. ScrapObj_New, scrap);
  254. return _res;
  255. }
  256. static PyObject *Scrap_ClearCurrentScrap(PyObject *_self, PyObject *_args)
  257. {
  258. PyObject *_res = NULL;
  259. OSStatus _err;
  260. if (!PyArg_ParseTuple(_args, ""))
  261. return NULL;
  262. _err = ClearCurrentScrap();
  263. if (_err != noErr) return PyMac_Error(_err);
  264. Py_INCREF(Py_None);
  265. _res = Py_None;
  266. return _res;
  267. }
  268. static PyObject *Scrap_CallInScrapPromises(PyObject *_self, PyObject *_args)
  269. {
  270. PyObject *_res = NULL;
  271. OSStatus _err;
  272. if (!PyArg_ParseTuple(_args, ""))
  273. return NULL;
  274. _err = CallInScrapPromises();
  275. if (_err != noErr) return PyMac_Error(_err);
  276. Py_INCREF(Py_None);
  277. _res = Py_None;
  278. return _res;
  279. }
  280. #endif /* __LP64__ */
  281. static PyMethodDef Scrap_methods[] = {
  282. #ifndef __LP64__
  283. {"LoadScrap", (PyCFunction)Scrap_LoadScrap, 1,
  284. PyDoc_STR("() -> None")},
  285. {"UnloadScrap", (PyCFunction)Scrap_UnloadScrap, 1,
  286. PyDoc_STR("() -> None")},
  287. {"GetCurrentScrap", (PyCFunction)Scrap_GetCurrentScrap, 1,
  288. PyDoc_STR("() -> (ScrapRef scrap)")},
  289. {"ClearCurrentScrap", (PyCFunction)Scrap_ClearCurrentScrap, 1,
  290. PyDoc_STR("() -> None")},
  291. {"CallInScrapPromises", (PyCFunction)Scrap_CallInScrapPromises, 1,
  292. PyDoc_STR("() -> None")},
  293. #endif /* __LP64__ */
  294. {NULL, NULL, 0}
  295. };
  296. void init_Scrap(void)
  297. {
  298. PyObject *m;
  299. #ifndef __LP64__
  300. PyObject *d;
  301. #endif /* __LP64__ */
  302. m = Py_InitModule("_Scrap", Scrap_methods);
  303. #ifndef __LP64__
  304. d = PyModule_GetDict(m);
  305. Scrap_Error = PyMac_GetOSErrException();
  306. if (Scrap_Error == NULL ||
  307. PyDict_SetItemString(d, "Error", Scrap_Error) != 0)
  308. return;
  309. Scrap_Type.ob_type = &PyType_Type;
  310. Py_INCREF(&Scrap_Type);
  311. if (PyDict_SetItemString(d, "ScrapType", (PyObject *)&Scrap_Type) != 0)
  312. Py_FatalError("can't initialize ScrapType");
  313. #endif /* __LP64__ */
  314. }
  315. /* ======================= End module _Scrap ======================== */