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