1 2/* ========================= Module _Qdoffs ========================= */ 3 4#include "Python.h" 5 6 7#include <Carbon/Carbon.h> 8#if !defined(__LP64__) && !defined(MAC_OS_X_VERSION_10_7) 9 10#include "pymactoolbox.h" 11 12/* Macro to test whether a weak-loaded CFM function exists */ 13#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ 14 PyErr_SetString(PyExc_NotImplementedError, \ 15 "Not available in this shared library/OS version"); \ 16 return NULL; \ 17 }} while(0) 18 19 20 21#ifdef USE_TOOLBOX_OBJECT_GLUE 22extern PyObject *_GWorldObj_New(GWorldPtr); 23extern int _GWorldObj_Convert(PyObject *, GWorldPtr *); 24 25#define GWorldObj_New _GWorldObj_New 26#define GWorldObj_Convert _GWorldObj_Convert 27#endif 28 29#define as_GrafPtr(gworld) ((GrafPtr)(gworld)) 30 31 32static PyObject *Qdoffs_Error; 33 34/* ----------------------- Object type GWorld ----------------------- */ 35 36PyTypeObject GWorld_Type; 37 38#define GWorldObj_Check(x) ((x)->ob_type == &GWorld_Type || PyObject_TypeCheck((x), &GWorld_Type)) 39 40typedef struct GWorldObject { 41 PyObject_HEAD 42 GWorldPtr ob_itself; 43} GWorldObject; 44 45PyObject *GWorldObj_New(GWorldPtr itself) 46{ 47 GWorldObject *it; 48 if (itself == NULL) return PyMac_Error(resNotFound); 49 it = PyObject_NEW(GWorldObject, &GWorld_Type); 50 if (it == NULL) return NULL; 51 it->ob_itself = itself; 52 return (PyObject *)it; 53} 54 55int GWorldObj_Convert(PyObject *v, GWorldPtr *p_itself) 56{ 57 if (!GWorldObj_Check(v)) 58 { 59 PyErr_SetString(PyExc_TypeError, "GWorld required"); 60 return 0; 61 } 62 *p_itself = ((GWorldObject *)v)->ob_itself; 63 return 1; 64} 65 66static void GWorldObj_dealloc(GWorldObject *self) 67{ 68 DisposeGWorld(self->ob_itself); 69 self->ob_type->tp_free((PyObject *)self); 70} 71 72static PyObject *GWorldObj_GetGWorldDevice(GWorldObject *_self, PyObject *_args) 73{ 74 PyObject *_res = NULL; 75 GDHandle _rv; 76#ifndef GetGWorldDevice 77 PyMac_PRECHECK(GetGWorldDevice); 78#endif 79 if (!PyArg_ParseTuple(_args, "")) 80 return NULL; 81 _rv = GetGWorldDevice(_self->ob_itself); 82 _res = Py_BuildValue("O&", 83 ResObj_New, _rv); 84 return _res; 85} 86 87static PyObject *GWorldObj_GetGWorldPixMap(GWorldObject *_self, PyObject *_args) 88{ 89 PyObject *_res = NULL; 90 PixMapHandle _rv; 91#ifndef GetGWorldPixMap 92 PyMac_PRECHECK(GetGWorldPixMap); 93#endif 94 if (!PyArg_ParseTuple(_args, "")) 95 return NULL; 96 _rv = GetGWorldPixMap(_self->ob_itself); 97 _res = Py_BuildValue("O&", 98 ResObj_New, _rv); 99 return _res; 100} 101 102static PyObject *GWorldObj_as_GrafPtr(GWorldObject *_self, PyObject *_args) 103{ 104 PyObject *_res = NULL; 105 GrafPtr _rv; 106#ifndef as_GrafPtr 107 PyMac_PRECHECK(as_GrafPtr); 108#endif 109 if (!PyArg_ParseTuple(_args, "")) 110 return NULL; 111 _rv = as_GrafPtr(_self->ob_itself); 112 _res = Py_BuildValue("O&", 113 GrafObj_New, _rv); 114 return _res; 115} 116 117static PyMethodDef GWorldObj_methods[] = { 118 {"GetGWorldDevice", (PyCFunction)GWorldObj_GetGWorldDevice, 1, 119 PyDoc_STR("() -> (GDHandle _rv)")}, 120 {"GetGWorldPixMap", (PyCFunction)GWorldObj_GetGWorldPixMap, 1, 121 PyDoc_STR("() -> (PixMapHandle _rv)")}, 122 {"as_GrafPtr", (PyCFunction)GWorldObj_as_GrafPtr, 1, 123 PyDoc_STR("() -> (GrafPtr _rv)")}, 124 {NULL, NULL, 0} 125}; 126 127#define GWorldObj_getsetlist NULL 128 129 130#define GWorldObj_compare NULL 131 132#define GWorldObj_repr NULL 133 134#define GWorldObj_hash NULL 135#define GWorldObj_tp_init 0 136 137#define GWorldObj_tp_alloc PyType_GenericAlloc 138 139static PyObject *GWorldObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) 140{ 141 PyObject *_self; 142 GWorldPtr itself; 143 char *kw[] = {"itself", 0}; 144 145 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, GWorldObj_Convert, &itself)) return NULL; 146 if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; 147 ((GWorldObject *)_self)->ob_itself = itself; 148 return _self; 149} 150 151#define GWorldObj_tp_free PyObject_Del 152 153 154PyTypeObject GWorld_Type = { 155 PyObject_HEAD_INIT(NULL) 156 0, /*ob_size*/ 157 "_Qdoffs.GWorld", /*tp_name*/ 158 sizeof(GWorldObject), /*tp_basicsize*/ 159 0, /*tp_itemsize*/ 160 /* methods */ 161 (destructor) GWorldObj_dealloc, /*tp_dealloc*/ 162 0, /*tp_print*/ 163 (getattrfunc)0, /*tp_getattr*/ 164 (setattrfunc)0, /*tp_setattr*/ 165 (cmpfunc) GWorldObj_compare, /*tp_compare*/ 166 (reprfunc) GWorldObj_repr, /*tp_repr*/ 167 (PyNumberMethods *)0, /* tp_as_number */ 168 (PySequenceMethods *)0, /* tp_as_sequence */ 169 (PyMappingMethods *)0, /* tp_as_mapping */ 170 (hashfunc) GWorldObj_hash, /*tp_hash*/ 171 0, /*tp_call*/ 172 0, /*tp_str*/ 173 PyObject_GenericGetAttr, /*tp_getattro*/ 174 PyObject_GenericSetAttr, /*tp_setattro */ 175 0, /*tp_as_buffer*/ 176 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 177 0, /*tp_doc*/ 178 0, /*tp_traverse*/ 179 0, /*tp_clear*/ 180 0, /*tp_richcompare*/ 181 0, /*tp_weaklistoffset*/ 182 0, /*tp_iter*/ 183 0, /*tp_iternext*/ 184 GWorldObj_methods, /* tp_methods */ 185 0, /*tp_members*/ 186 GWorldObj_getsetlist, /*tp_getset*/ 187 0, /*tp_base*/ 188 0, /*tp_dict*/ 189 0, /*tp_descr_get*/ 190 0, /*tp_descr_set*/ 191 0, /*tp_dictoffset*/ 192 GWorldObj_tp_init, /* tp_init */ 193 GWorldObj_tp_alloc, /* tp_alloc */ 194 GWorldObj_tp_new, /* tp_new */ 195 GWorldObj_tp_free, /* tp_free */ 196}; 197 198/* --------------------- End object type GWorld --------------------- */ 199 200 201static PyObject *Qdoffs_NewGWorld(PyObject *_self, PyObject *_args) 202{ 203 PyObject *_res = NULL; 204 QDErr _err; 205 GWorldPtr offscreenGWorld; 206 short PixelDepth; 207 Rect boundsRect; 208 CTabHandle cTable; 209 GDHandle aGDevice; 210 GWorldFlags flags; 211#ifndef NewGWorld 212 PyMac_PRECHECK(NewGWorld); 213#endif 214 if (!PyArg_ParseTuple(_args, "hO&O&O&l", 215 &PixelDepth, 216 PyMac_GetRect, &boundsRect, 217 OptResObj_Convert, &cTable, 218 OptResObj_Convert, &aGDevice, 219 &flags)) 220 return NULL; 221 _err = NewGWorld(&offscreenGWorld, 222 PixelDepth, 223 &boundsRect, 224 cTable, 225 aGDevice, 226 flags); 227 if (_err != noErr) return PyMac_Error(_err); 228 _res = Py_BuildValue("O&", 229 GWorldObj_New, offscreenGWorld); 230 return _res; 231} 232 233static PyObject *Qdoffs_LockPixels(PyObject *_self, PyObject *_args) 234{ 235 PyObject *_res = NULL; 236 Boolean _rv; 237 PixMapHandle pm; 238#ifndef LockPixels 239 PyMac_PRECHECK(LockPixels); 240#endif 241 if (!PyArg_ParseTuple(_args, "O&", 242 ResObj_Convert, &pm)) 243 return NULL; 244 _rv = LockPixels(pm); 245 _res = Py_BuildValue("b", 246 _rv); 247 return _res; 248} 249 250static PyObject *Qdoffs_UnlockPixels(PyObject *_self, PyObject *_args) 251{ 252 PyObject *_res = NULL; 253 PixMapHandle pm; 254#ifndef UnlockPixels 255 PyMac_PRECHECK(UnlockPixels); 256#endif 257 if (!PyArg_ParseTuple(_args, "O&", 258 ResObj_Convert, &pm)) 259 return NULL; 260 UnlockPixels(pm); 261 Py_INCREF(Py_None); 262 _res = Py_None; 263 return _res; 264} 265 266static PyObject *Qdoffs_UpdateGWorld(PyObject *_self, PyObject *_args) 267{ 268 PyObject *_res = NULL; 269 GWorldFlags _rv; 270 GWorldPtr offscreenGWorld; 271 short pixelDepth; 272 Rect boundsRect; 273 CTabHandle cTable; 274 GDHandle aGDevice; 275 GWorldFlags flags; 276#ifndef UpdateGWorld 277 PyMac_PRECHECK(UpdateGWorld); 278#endif 279 if (!PyArg_ParseTuple(_args, "hO&O&O&l", 280 &pixelDepth, 281 PyMac_GetRect, &boundsRect, 282 OptResObj_Convert, &cTable, 283 OptResObj_Convert, &aGDevice, 284 &flags)) 285 return NULL; 286 _rv = UpdateGWorld(&offscreenGWorld, 287 pixelDepth, 288 &boundsRect, 289 cTable, 290 aGDevice, 291 flags); 292 _res = Py_BuildValue("lO&", 293 _rv, 294 GWorldObj_New, offscreenGWorld); 295 return _res; 296} 297 298static PyObject *Qdoffs_GetGWorld(PyObject *_self, PyObject *_args) 299{ 300 PyObject *_res = NULL; 301 CGrafPtr port; 302 GDHandle gdh; 303#ifndef GetGWorld 304 PyMac_PRECHECK(GetGWorld); 305#endif 306 if (!PyArg_ParseTuple(_args, "")) 307 return NULL; 308 GetGWorld(&port, 309 &gdh); 310 _res = Py_BuildValue("O&O&", 311 GrafObj_New, port, 312 ResObj_New, gdh); 313 return _res; 314} 315 316static PyObject *Qdoffs_SetGWorld(PyObject *_self, PyObject *_args) 317{ 318 PyObject *_res = NULL; 319 CGrafPtr port; 320 GDHandle gdh; 321#ifndef SetGWorld 322 PyMac_PRECHECK(SetGWorld); 323#endif 324 if (!PyArg_ParseTuple(_args, "O&O&", 325 GrafObj_Convert, &port, 326 OptResObj_Convert, &gdh)) 327 return NULL; 328 SetGWorld(port, 329 gdh); 330 Py_INCREF(Py_None); 331 _res = Py_None; 332 return _res; 333} 334 335static PyObject *Qdoffs_CTabChanged(PyObject *_self, PyObject *_args) 336{ 337 PyObject *_res = NULL; 338 CTabHandle ctab; 339#ifndef CTabChanged 340 PyMac_PRECHECK(CTabChanged); 341#endif 342 if (!PyArg_ParseTuple(_args, "O&", 343 OptResObj_Convert, &ctab)) 344 return NULL; 345 CTabChanged(ctab); 346 Py_INCREF(Py_None); 347 _res = Py_None; 348 return _res; 349} 350 351static PyObject *Qdoffs_PixPatChanged(PyObject *_self, PyObject *_args) 352{ 353 PyObject *_res = NULL; 354 PixPatHandle ppat; 355#ifndef PixPatChanged 356 PyMac_PRECHECK(PixPatChanged); 357#endif 358 if (!PyArg_ParseTuple(_args, "O&", 359 ResObj_Convert, &ppat)) 360 return NULL; 361 PixPatChanged(ppat); 362 Py_INCREF(Py_None); 363 _res = Py_None; 364 return _res; 365} 366 367static PyObject *Qdoffs_PortChanged(PyObject *_self, PyObject *_args) 368{ 369 PyObject *_res = NULL; 370 GrafPtr port; 371#ifndef PortChanged 372 PyMac_PRECHECK(PortChanged); 373#endif 374 if (!PyArg_ParseTuple(_args, "O&", 375 GrafObj_Convert, &port)) 376 return NULL; 377 PortChanged(port); 378 Py_INCREF(Py_None); 379 _res = Py_None; 380 return _res; 381} 382 383static PyObject *Qdoffs_GDeviceChanged(PyObject *_self, PyObject *_args) 384{ 385 PyObject *_res = NULL; 386 GDHandle gdh; 387#ifndef GDeviceChanged 388 PyMac_PRECHECK(GDeviceChanged); 389#endif 390 if (!PyArg_ParseTuple(_args, "O&", 391 OptResObj_Convert, &gdh)) 392 return NULL; 393 GDeviceChanged(gdh); 394 Py_INCREF(Py_None); 395 _res = Py_None; 396 return _res; 397} 398 399static PyObject *Qdoffs_AllowPurgePixels(PyObject *_self, PyObject *_args) 400{ 401 PyObject *_res = NULL; 402 PixMapHandle pm; 403#ifndef AllowPurgePixels 404 PyMac_PRECHECK(AllowPurgePixels); 405#endif 406 if (!PyArg_ParseTuple(_args, "O&", 407 ResObj_Convert, &pm)) 408 return NULL; 409 AllowPurgePixels(pm); 410 Py_INCREF(Py_None); 411 _res = Py_None; 412 return _res; 413} 414 415static PyObject *Qdoffs_NoPurgePixels(PyObject *_self, PyObject *_args) 416{ 417 PyObject *_res = NULL; 418 PixMapHandle pm; 419#ifndef NoPurgePixels 420 PyMac_PRECHECK(NoPurgePixels); 421#endif 422 if (!PyArg_ParseTuple(_args, "O&", 423 ResObj_Convert, &pm)) 424 return NULL; 425 NoPurgePixels(pm); 426 Py_INCREF(Py_None); 427 _res = Py_None; 428 return _res; 429} 430 431static PyObject *Qdoffs_GetPixelsState(PyObject *_self, PyObject *_args) 432{ 433 PyObject *_res = NULL; 434 GWorldFlags _rv; 435 PixMapHandle pm; 436#ifndef GetPixelsState 437 PyMac_PRECHECK(GetPixelsState); 438#endif 439 if (!PyArg_ParseTuple(_args, "O&", 440 ResObj_Convert, &pm)) 441 return NULL; 442 _rv = GetPixelsState(pm); 443 _res = Py_BuildValue("l", 444 _rv); 445 return _res; 446} 447 448static PyObject *Qdoffs_SetPixelsState(PyObject *_self, PyObject *_args) 449{ 450 PyObject *_res = NULL; 451 PixMapHandle pm; 452 GWorldFlags state; 453#ifndef SetPixelsState 454 PyMac_PRECHECK(SetPixelsState); 455#endif 456 if (!PyArg_ParseTuple(_args, "O&l", 457 ResObj_Convert, &pm, 458 &state)) 459 return NULL; 460 SetPixelsState(pm, 461 state); 462 Py_INCREF(Py_None); 463 _res = Py_None; 464 return _res; 465} 466 467static PyObject *Qdoffs_GetPixRowBytes(PyObject *_self, PyObject *_args) 468{ 469 PyObject *_res = NULL; 470 long _rv; 471 PixMapHandle pm; 472#ifndef GetPixRowBytes 473 PyMac_PRECHECK(GetPixRowBytes); 474#endif 475 if (!PyArg_ParseTuple(_args, "O&", 476 ResObj_Convert, &pm)) 477 return NULL; 478 _rv = GetPixRowBytes(pm); 479 _res = Py_BuildValue("l", 480 _rv); 481 return _res; 482} 483 484static PyObject *Qdoffs_NewScreenBuffer(PyObject *_self, PyObject *_args) 485{ 486 PyObject *_res = NULL; 487 QDErr _err; 488 Rect globalRect; 489 Boolean purgeable; 490 GDHandle gdh; 491 PixMapHandle offscreenPixMap; 492#ifndef NewScreenBuffer 493 PyMac_PRECHECK(NewScreenBuffer); 494#endif 495 if (!PyArg_ParseTuple(_args, "O&b", 496 PyMac_GetRect, &globalRect, 497 &purgeable)) 498 return NULL; 499 _err = NewScreenBuffer(&globalRect, 500 purgeable, 501 &gdh, 502 &offscreenPixMap); 503 if (_err != noErr) return PyMac_Error(_err); 504 _res = Py_BuildValue("O&O&", 505 ResObj_New, gdh, 506 ResObj_New, offscreenPixMap); 507 return _res; 508} 509 510static PyObject *Qdoffs_DisposeScreenBuffer(PyObject *_self, PyObject *_args) 511{ 512 PyObject *_res = NULL; 513 PixMapHandle offscreenPixMap; 514#ifndef DisposeScreenBuffer 515 PyMac_PRECHECK(DisposeScreenBuffer); 516#endif 517 if (!PyArg_ParseTuple(_args, "O&", 518 ResObj_Convert, &offscreenPixMap)) 519 return NULL; 520 DisposeScreenBuffer(offscreenPixMap); 521 Py_INCREF(Py_None); 522 _res = Py_None; 523 return _res; 524} 525 526static PyObject *Qdoffs_QDDone(PyObject *_self, PyObject *_args) 527{ 528 PyObject *_res = NULL; 529 Boolean _rv; 530 GrafPtr port; 531#ifndef QDDone 532 PyMac_PRECHECK(QDDone); 533#endif 534 if (!PyArg_ParseTuple(_args, "O&", 535 GrafObj_Convert, &port)) 536 return NULL; 537 _rv = QDDone(port); 538 _res = Py_BuildValue("b", 539 _rv); 540 return _res; 541} 542 543static PyObject *Qdoffs_OffscreenVersion(PyObject *_self, PyObject *_args) 544{ 545 PyObject *_res = NULL; 546 long _rv; 547#ifndef OffscreenVersion 548 PyMac_PRECHECK(OffscreenVersion); 549#endif 550 if (!PyArg_ParseTuple(_args, "")) 551 return NULL; 552 _rv = OffscreenVersion(); 553 _res = Py_BuildValue("l", 554 _rv); 555 return _res; 556} 557 558static PyObject *Qdoffs_NewTempScreenBuffer(PyObject *_self, PyObject *_args) 559{ 560 PyObject *_res = NULL; 561 QDErr _err; 562 Rect globalRect; 563 Boolean purgeable; 564 GDHandle gdh; 565 PixMapHandle offscreenPixMap; 566#ifndef NewTempScreenBuffer 567 PyMac_PRECHECK(NewTempScreenBuffer); 568#endif 569 if (!PyArg_ParseTuple(_args, "O&b", 570 PyMac_GetRect, &globalRect, 571 &purgeable)) 572 return NULL; 573 _err = NewTempScreenBuffer(&globalRect, 574 purgeable, 575 &gdh, 576 &offscreenPixMap); 577 if (_err != noErr) return PyMac_Error(_err); 578 _res = Py_BuildValue("O&O&", 579 ResObj_New, gdh, 580 ResObj_New, offscreenPixMap); 581 return _res; 582} 583 584static PyObject *Qdoffs_PixMap32Bit(PyObject *_self, PyObject *_args) 585{ 586 PyObject *_res = NULL; 587 Boolean _rv; 588 PixMapHandle pmHandle; 589#ifndef PixMap32Bit 590 PyMac_PRECHECK(PixMap32Bit); 591#endif 592 if (!PyArg_ParseTuple(_args, "O&", 593 ResObj_Convert, &pmHandle)) 594 return NULL; 595 _rv = PixMap32Bit(pmHandle); 596 _res = Py_BuildValue("b", 597 _rv); 598 return _res; 599} 600 601static PyObject *Qdoffs_GetPixMapBytes(PyObject *_self, PyObject *_args) 602{ 603 PyObject *_res = NULL; 604 605 PixMapHandle pm; 606 int from, length; 607 char *cp; 608 609 if ( !PyArg_ParseTuple(_args, "O&ii", ResObj_Convert, &pm, &from, &length) ) 610 return NULL; 611 cp = GetPixBaseAddr(pm)+from; 612 _res = PyString_FromStringAndSize(cp, length); 613 return _res; 614 615} 616 617static PyObject *Qdoffs_PutPixMapBytes(PyObject *_self, PyObject *_args) 618{ 619 PyObject *_res = NULL; 620 621 PixMapHandle pm; 622 int from, length; 623 char *cp, *icp; 624 625 if ( !PyArg_ParseTuple(_args, "O&is#", ResObj_Convert, &pm, &from, &icp, &length) ) 626 return NULL; 627 cp = GetPixBaseAddr(pm)+from; 628 memcpy(cp, icp, length); 629 Py_INCREF(Py_None); 630 _res = Py_None; 631 return _res; 632 633} 634#endif /* __LP64__ */ 635 636static PyMethodDef Qdoffs_methods[] = { 637#if !defined(__LP64__) && !defined(MAC_OS_X_VERSION_10_7) 638 {"NewGWorld", (PyCFunction)Qdoffs_NewGWorld, 1, 639 PyDoc_STR("(short PixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldPtr offscreenGWorld)")}, 640 {"LockPixels", (PyCFunction)Qdoffs_LockPixels, 1, 641 PyDoc_STR("(PixMapHandle pm) -> (Boolean _rv)")}, 642 {"UnlockPixels", (PyCFunction)Qdoffs_UnlockPixels, 1, 643 PyDoc_STR("(PixMapHandle pm) -> None")}, 644 {"UpdateGWorld", (PyCFunction)Qdoffs_UpdateGWorld, 1, 645 PyDoc_STR("(short pixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldFlags _rv, GWorldPtr offscreenGWorld)")}, 646 {"GetGWorld", (PyCFunction)Qdoffs_GetGWorld, 1, 647 PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")}, 648 {"SetGWorld", (PyCFunction)Qdoffs_SetGWorld, 1, 649 PyDoc_STR("(CGrafPtr port, GDHandle gdh) -> None")}, 650 {"CTabChanged", (PyCFunction)Qdoffs_CTabChanged, 1, 651 PyDoc_STR("(CTabHandle ctab) -> None")}, 652 {"PixPatChanged", (PyCFunction)Qdoffs_PixPatChanged, 1, 653 PyDoc_STR("(PixPatHandle ppat) -> None")}, 654 {"PortChanged", (PyCFunction)Qdoffs_PortChanged, 1, 655 PyDoc_STR("(GrafPtr port) -> None")}, 656 {"GDeviceChanged", (PyCFunction)Qdoffs_GDeviceChanged, 1, 657 PyDoc_STR("(GDHandle gdh) -> None")}, 658 {"AllowPurgePixels", (PyCFunction)Qdoffs_AllowPurgePixels, 1, 659 PyDoc_STR("(PixMapHandle pm) -> None")}, 660 {"NoPurgePixels", (PyCFunction)Qdoffs_NoPurgePixels, 1, 661 PyDoc_STR("(PixMapHandle pm) -> None")}, 662 {"GetPixelsState", (PyCFunction)Qdoffs_GetPixelsState, 1, 663 PyDoc_STR("(PixMapHandle pm) -> (GWorldFlags _rv)")}, 664 {"SetPixelsState", (PyCFunction)Qdoffs_SetPixelsState, 1, 665 PyDoc_STR("(PixMapHandle pm, GWorldFlags state) -> None")}, 666 {"GetPixRowBytes", (PyCFunction)Qdoffs_GetPixRowBytes, 1, 667 PyDoc_STR("(PixMapHandle pm) -> (long _rv)")}, 668 {"NewScreenBuffer", (PyCFunction)Qdoffs_NewScreenBuffer, 1, 669 PyDoc_STR("(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)")}, 670 {"DisposeScreenBuffer", (PyCFunction)Qdoffs_DisposeScreenBuffer, 1, 671 PyDoc_STR("(PixMapHandle offscreenPixMap) -> None")}, 672 {"QDDone", (PyCFunction)Qdoffs_QDDone, 1, 673 PyDoc_STR("(GrafPtr port) -> (Boolean _rv)")}, 674 {"OffscreenVersion", (PyCFunction)Qdoffs_OffscreenVersion, 1, 675 PyDoc_STR("() -> (long _rv)")}, 676 {"NewTempScreenBuffer", (PyCFunction)Qdoffs_NewTempScreenBuffer, 1, 677 PyDoc_STR("(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)")}, 678 {"PixMap32Bit", (PyCFunction)Qdoffs_PixMap32Bit, 1, 679 PyDoc_STR("(PixMapHandle pmHandle) -> (Boolean _rv)")}, 680 {"GetPixMapBytes", (PyCFunction)Qdoffs_GetPixMapBytes, 1, 681 PyDoc_STR("(pixmap, int start, int size) -> string. Return bytes from the pixmap")}, 682 {"PutPixMapBytes", (PyCFunction)Qdoffs_PutPixMapBytes, 1, 683 PyDoc_STR("(pixmap, int start, string data). Store bytes into the pixmap")}, 684#endif /* __LP64__ */ 685 {NULL, NULL, 0} 686}; 687 688 689 690 691void init_Qdoffs(void) 692{ 693 PyObject *m; 694#if !defined(__LP64__) && !defined(MAC_OS_X_VERSION_10_7) 695 PyObject *d; 696 697 698 699 PyMac_INIT_TOOLBOX_OBJECT_NEW(GWorldPtr, GWorldObj_New); 700 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(GWorldPtr, GWorldObj_Convert); 701 702#endif /* __LP64__ */ 703 704 m = Py_InitModule("_Qdoffs", Qdoffs_methods); 705#if !defined(__LP64__) && !defined(MAC_OS_X_VERSION_10_7) 706 d = PyModule_GetDict(m); 707 Qdoffs_Error = PyMac_GetOSErrException(); 708 if (Qdoffs_Error == NULL || 709 PyDict_SetItemString(d, "Error", Qdoffs_Error) != 0) 710 return; 711 GWorld_Type.ob_type = &PyType_Type; 712 if (PyType_Ready(&GWorld_Type) < 0) return; 713 Py_INCREF(&GWorld_Type); 714 PyModule_AddObject(m, "GWorld", (PyObject *)&GWorld_Type); 715 /* Backward-compatible name */ 716 Py_INCREF(&GWorld_Type); 717 PyModule_AddObject(m, "GWorldType", (PyObject *)&GWorld_Type); 718#endif /* __LP64__ */ 719} 720 721/* ======================= End module _Qdoffs ======================= */ 722 723