Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython3 / bd58edaa011680e26fccd3b88619b9596b16a2d7 / . / Mac / Modules / qd / Qdmodule.c
blob: b85e4163a8ab3cee7d3da97eaeac616e9d289579 [file] [log] [blame]
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]1
2/* =========================== Module Qd ============================ */
3
4#include "Python.h"
5
6
7
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]8#include "macglue.h"
Jack Jansen9d8b96c2000-07-14 22:16:45 +0000[diff] [blame]9#include "pymactoolbox.h"
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]10
11#include <QuickDraw.h>
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]12
Jack Jansenbd58eda2001-01-24 14:05:11 +0000[diff] [blame^]13#if !ACCESSOR_CALLS_ARE_FUNCTIONS
14#define GetPortBitMapForCopyBits(port) (((GrafPort)(port))->portBits)
15#define GetPortPixMap(port) (((CGrafPtr)(port))->portPixMap)
16#define GetPortBounds(port, bounds) (*(bounds) = (port)->portRect, (bounds))
17#define GetPortForeColor(port, color) (*(color) = (port)->rgbFgColor, (color))
18#define GetPortBackColor(port, color) (*(color) = (port)->rgbBkColor, (color))
19#define GetPortOpColor(port, color) (*(color) = (*(GVarHandle)((port)->grafVars))->rgbOpColor, (color))
20#define GetPortHiliteColor(port, color) (*(color) = (*(GVarHandle)((port)->grafVars))->rgbHiliteColor, (color))
21#define GetPortTextFont(port) ((port)->txFont)
22#define GetPortTextFace(port) ((port)->txFace)
23#define GetPortTextMode(port) ((port)->txMode)
24#define GetPortTextSize(port) ((port)->txSize)
25#define GetPortChExtra(port) ((port)->chExtra)
26#define GetPortFracHPenLocation(port) ((port)->pnLocHFrac)
27#define GetPortSpExtra(port) ((port)->spExtra)
28#define GetPortPenVisibility(port) ((port)->pnVis)
29#define GetPortVisibleRegion(port, rgn) ((rgn) = (port)->visRgn, (rgn))
30#define GetPortClipRegion(port, rgn) ((rgn) = (port)->clipRgn, (rgn))
31#define GetPortBackPixPat(port, pat) ((pat) = (port)->bkPixPat, (pat))
32#define GetPortPenPixPat(port, pat) ((pat) = (port)->pnPixPat, (pat))
33#define GetPortFillPixPat(port, pat) ((pat) = (port)->fillPixPat, (pat))
34#define GetPortPenSize(port, pensize) (*(pensize) = (port)->pnSize, (pensize))
35#define GetPortPenMode(port) ((port)->pnMode)
36#define GetPortPenLocation(port, location) ((*location) = (port)->pnLoc, (location))
37#define IsPortRegionBeingDefined(port) (!!((port)->rgnSave))
38#define IsPortPictureBeingDefined(port) (!!((port)->picSave))
39/* #define IsPortOffscreen(port) */
40/* #define IsPortColor(port) */
41
42#define SetPortBounds(port, bounds) ((port)->portRect = *(bounds))
43#define SetPortOpColor(port, color) ((*(GVarHandle)((port)->grafVars))->rgbOpColor = *(color))
44#define SetPortVisibleRegion(port, rgn) ((port)->visRgn = (rgn))
45#define SetPortClipRegion(port, rgn) ((port)->clipRgn = (rgn))
46#define SetPortBackPixPat(port, pat) ((port)->bkPixPat = (pat))
47#define SetPortPenPixPat(port, pat) ((port)->pnPixPat = (pat))
48#define SetPortFillPixPat(port, pat) ((port)->fillPixPat = (pat))
49#define SetPortPenSize(port, pensize) ((port)->pnSize = (pensize))
50#define SetPortPenMode(port, mode) ((port)->pnMode = (mode))
51#define SetPortFracHPenLocation(port, frac) ((port)->pnLocHFrac = (frac))
52
53/* On pixmaps */
54#define GetPixBounds(pixmap, rect) (*(rect) = (*(pixmap))->bounds, (rect))
55#define GetPixDepth(pixmap) ((*(pixmap))->pixelSize)
56
57/* On regions */
58#define GetRegionBounds(rgn, rect) (*(rect) = (*(rgn))->rgnBBox, (rect))
59
60/* On QD Globals */
61#define GetQDGlobalsRandomSeed() (qd.randSeed)
62#define GetQDGlobalsScreenBits(bits) (*(bits) = qd.screenBits, (bits))
63#define GetQDGlobalsArrow(crsr) (*(crsr) = qd.arrow, (crsr))
64#define GetQDGlobalsDarkGray(pat) (*(pat) = qd.dkGray, (pat))
65#define GetQDGlobalsLightGray(pat) (*(pat) = qd.ltGray, (pat))
66#define GetQDGlobalsGray(pat) (*(pat) = qd.gray, (pat))
67#define GetQDGlobalsBlack(pat) (*(pat) = qd.black, (pat))
68#define GetQDGlobalsWhite(pat) (*(pat) = qd.white, (pat))
69#define GetQDGlobalsThePort() ((CGrafPtr)qd.thePort)
70
71#define SetQDGlobalsRandomSeed(seed) (qd.randSeed = (seed))
72#define SetQDGlobalsArrow(crsr) (qd.arrow = *(crsr))
73
74#endif /* ACCESSOR_CALLS_ARE_FUNCTIONS */
75
76#if !TARGET_API_MAC_CARBON
77#define QDFlushPortBuffer(port, rgn) /* pass */
78#define QDIsPortBufferDirty(port) 0
79#define QDIsPortBuffered(port) 0
80#endif /* !TARGET_API_MAC_CARBON */
81
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]82/*
83** Parse/generate RGB records
84*/
85PyObject *QdRGB_New(itself)
86 RGBColorPtr itself;
87{
88
89 return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue);
90}
91
92QdRGB_Convert(v, p_itself)
93 PyObject *v;
94 RGBColorPtr p_itself;
95{
96 long red, green, blue;
97
98 if( !PyArg_ParseTuple(v, "lll", &red, &green, &blue) )
99 return 0;
100 p_itself->red = (unsigned short)red;
101 p_itself->green = (unsigned short)green;
102 p_itself->blue = (unsigned short)blue;
103 return 1;
104}
105
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]106/*
107** Generate FontInfo records
108*/
109static
110PyObject *QdFI_New(itself)
111 FontInfo *itself;
112{
113
114 return Py_BuildValue("hhhh", itself->ascent, itself->descent,
115 itself->widMax, itself->leading);
116}
117
118
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]119
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]120static PyObject *Qd_Error;
121
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]122/* ---------------------- Object type GrafPort ---------------------- */
123
124PyTypeObject GrafPort_Type;
125
126#define GrafObj_Check(x) ((x)->ob_type == &GrafPort_Type)
127
128typedef struct GrafPortObject {
129 PyObject_HEAD
130 GrafPtr ob_itself;
131} GrafPortObject;
132
133PyObject *GrafObj_New(itself)
134 GrafPtr itself;
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]135{
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]136 GrafPortObject *it;
137 if (itself == NULL) return PyMac_Error(resNotFound);
138 it = PyObject_NEW(GrafPortObject, &GrafPort_Type);
139 if (it == NULL) return NULL;
140 it->ob_itself = itself;
141 return (PyObject *)it;
142}
143GrafObj_Convert(v, p_itself)
144 PyObject *v;
145 GrafPtr *p_itself;
146{
147 if (DlgObj_Check(v) || WinObj_Check(v)) {
148 *p_itself = ((GrafPortObject *)v)->ob_itself;
149 return 1;
150 }
151 if (!GrafObj_Check(v))
152 {
153 PyErr_SetString(PyExc_TypeError, "GrafPort required");
154 return 0;
155 }
156 *p_itself = ((GrafPortObject *)v)->ob_itself;
157 return 1;
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]158}
159
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]160static void GrafObj_dealloc(self)
161 GrafPortObject *self;
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]162{
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]163 /* Cleanup of self->ob_itself goes here */
164 PyMem_DEL(self);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]165}
166
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]167static PyMethodDef GrafObj_methods[] = {
168 {NULL, NULL, 0}
169};
170
171PyMethodChain GrafObj_chain = { GrafObj_methods, NULL };
172
173static PyObject *GrafObj_getattr(self, name)
174 GrafPortObject *self;
175 char *name;
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]176{
Jack Jansenbd58eda2001-01-24 14:05:11 +0000[diff] [blame^]177#if !ACCESSOR_CALLS_ARE_FUNCTIONS
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]178
179 { CGrafPtr itself_color = (CGrafPtr)self->ob_itself;
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]180
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]181 if ( strcmp(name, "data") == 0 )
182 return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(GrafPort));
183
184 if ( (itself_color->portVersion&0xc000) == 0xc000 ) {
185 /* Color-only attributes */
186
187 if ( strcmp(name, "portBits") == 0 )
188 /* XXXX Do we need HLock() stuff here?? */
189 return BMObj_New((BitMapPtr)*itself_color->portPixMap);
190 if ( strcmp(name, "grafVars") == 0 )
191 return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->visRgn);
192 if ( strcmp(name, "chExtra") == 0 )
193 return Py_BuildValue("h", itself_color->chExtra);
194 if ( strcmp(name, "pnLocHFrac") == 0 )
195 return Py_BuildValue("h", itself_color->pnLocHFrac);
Jack Jansen61f3df41996-01-15 14:39:56 +0000[diff] [blame]196 if ( strcmp(name, "bkPixPat") == 0 )
197 return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->bkPixPat);
198 if ( strcmp(name, "rgbFgColor") == 0 )
199 return Py_BuildValue("O&", QdRGB_New, &itself_color->rgbFgColor);
200 if ( strcmp(name, "rgbBkColor") == 0 )
201 return Py_BuildValue("O&", QdRGB_New, &itself_color->rgbBkColor);
202 if ( strcmp(name, "pnPixPat") == 0 )
203 return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->pnPixPat);
204 if ( strcmp(name, "fillPixPat") == 0 )
205 return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->fillPixPat);
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]206 } else {
207 /* Mono-only attributes */
208 if ( strcmp(name, "portBits") == 0 )
209 return BMObj_New(&self->ob_itself->portBits);
Jack Jansen61f3df41996-01-15 14:39:56 +0000[diff] [blame]210 if ( strcmp(name, "bkPat") == 0 )
211 return Py_BuildValue("s#", (char *)&self->ob_itself->bkPat, sizeof(Pattern));
212 if ( strcmp(name, "fillPat") == 0 )
213 return Py_BuildValue("s#", (char *)&self->ob_itself->fillPat, sizeof(Pattern));
214 if ( strcmp(name, "pnPat") == 0 )
215 return Py_BuildValue("s#", (char *)&self->ob_itself->pnPat, sizeof(Pattern));
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]216 }
217 /*
218 ** Accessible for both color/mono windows.
219 ** portVersion is really color-only, but we put it here
220 ** for convenience
221 */
222 if ( strcmp(name, "portVersion") == 0 )
223 return Py_BuildValue("h", itself_color->portVersion);
224 if ( strcmp(name, "device") == 0 )
225 return PyInt_FromLong((long)self->ob_itself->device);
226 if ( strcmp(name, "portRect") == 0 )
227 return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->portRect);
228 if ( strcmp(name, "visRgn") == 0 )
229 return Py_BuildValue("O&", ResObj_New, (Handle)self->ob_itself->visRgn);
230 if ( strcmp(name, "clipRgn") == 0 )
231 return Py_BuildValue("O&", ResObj_New, (Handle)self->ob_itself->clipRgn);
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]232 if ( strcmp(name, "pnLoc") == 0 )
233 return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself->pnLoc);
234 if ( strcmp(name, "pnSize") == 0 )
235 return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself->pnSize);
236 if ( strcmp(name, "pnMode") == 0 )
237 return Py_BuildValue("h", self->ob_itself->pnMode);
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]238 if ( strcmp(name, "pnVis") == 0 )
239 return Py_BuildValue("h", self->ob_itself->pnVis);
240 if ( strcmp(name, "txFont") == 0 )
241 return Py_BuildValue("h", self->ob_itself->txFont);
242 if ( strcmp(name, "txFace") == 0 )
243 return Py_BuildValue("h", (short)self->ob_itself->txFace);
244 if ( strcmp(name, "txMode") == 0 )
245 return Py_BuildValue("h", self->ob_itself->txMode);
246 if ( strcmp(name, "txSize") == 0 )
247 return Py_BuildValue("h", self->ob_itself->txSize);
248 if ( strcmp(name, "spExtra") == 0 )
249 return Py_BuildValue("O&", PyMac_BuildFixed, self->ob_itself->spExtra);
250 /* XXXX Add more, as needed */
Jack Jansen3355be31996-05-08 15:33:20 +0000[diff] [blame]251 /* This one is so we can compare grafports: */
252 if ( strcmp(name, "_id") == 0 )
253 return Py_BuildValue("l", (long)self->ob_itself);
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]254 }
Jack Jansenbd58eda2001-01-24 14:05:11 +0000[diff] [blame^]255#else
256
257 { CGrafPtr itself_color = (CGrafPtr)self->ob_itself;
258 /*
259 if ( strcmp(name, "portBits") == 0 )
260 return BMObj_New((BitMapPtr)GetPortPixMap(itself_color));
261 */
262 if ( strcmp(name, "chExtra") == 0 )
263 return Py_BuildValue("h", GetPortChExtra(itself_color));
264 if ( strcmp(name, "pnLocHFrac") == 0 )
265 return Py_BuildValue("h", GetPortFracHPenLocation(itself_color));
266 if ( strcmp(name, "bkPixPat") == 0 ) {
267 PixPatHandle h=0;
268 return Py_BuildValue("O&", ResObj_New, (Handle)GetPortBackPixPat(itself_color, h));
269 }
270 if ( strcmp(name, "rgbFgColor") == 0 ) {
271 RGBColor c;
272 return Py_BuildValue("O&", QdRGB_New, GetPortForeColor(itself_color, &c));
273 }
274 if ( strcmp(name, "rgbBkColor") == 0 ) {
275 RGBColor c;
276 return Py_BuildValue("O&", QdRGB_New, GetPortBackColor(itself_color, &c));
277 }
278 if ( strcmp(name, "pnPixPat") == 0 ) {
279 PixPatHandle h=0;
280
281 return Py_BuildValue("O&", ResObj_New, (Handle)GetPortPenPixPat(itself_color, h));
282 }
283 if ( strcmp(name, "fillPixPat") == 0 ) {
284 PixPatHandle h=0;
285 return Py_BuildValue("O&", ResObj_New, (Handle)GetPortFillPixPat(itself_color, h));
286 }
287 if ( strcmp(name, "portRect") == 0 ) {
288 Rect r;
289 return Py_BuildValue("O&", PyMac_BuildRect, GetPortBounds(itself_color, &r));
290 }
291 if ( strcmp(name, "visRgn") == 0 ) {
292 RgnHandle h=0;
293 return Py_BuildValue("O&", ResObj_New, (Handle)GetPortVisibleRegion(itself_color, h));
294 }
295 if ( strcmp(name, "clipRgn") == 0 ) {
296 RgnHandle h=0;
297 return Py_BuildValue("O&", ResObj_New, (Handle)GetPortClipRegion(itself_color, h));
298 }
299 if ( strcmp(name, "pnLoc") == 0 ) {
300 Point p;
301 return Py_BuildValue("O&", PyMac_BuildPoint, *GetPortPenLocation(itself_color, &p));
302 }
303 if ( strcmp(name, "pnSize") == 0 ) {
304 Point p;
305 return Py_BuildValue("O&", PyMac_BuildPoint, *GetPortPenSize(itself_color, &p));
306 }
307 if ( strcmp(name, "pnMode") == 0 )
308 return Py_BuildValue("h", GetPortPenMode(itself_color));
309 if ( strcmp(name, "pnVis") == 0 )
310 return Py_BuildValue("h", GetPortPenVisibility(itself_color));
311 if ( strcmp(name, "txFont") == 0 )
312 return Py_BuildValue("h", GetPortTextFont(itself_color));
313 if ( strcmp(name, "txFace") == 0 )
314 return Py_BuildValue("h", (short)GetPortTextFace(itself_color));
315 if ( strcmp(name, "txMode") == 0 )
316 return Py_BuildValue("h", GetPortTextMode(itself_color));
317 if ( strcmp(name, "txSize") == 0 )
318 return Py_BuildValue("h", GetPortTextSize(itself_color));
319 if ( strcmp(name, "spExtra") == 0 )
320 return Py_BuildValue("O&", PyMac_BuildFixed, GetPortSpExtra(itself_color));
321 /* XXXX Add more, as needed */
322 /* This one is so we can compare grafports: */
323 if ( strcmp(name, "_id") == 0 )
324 return Py_BuildValue("l", (long)self->ob_itself);
325 }
Jack Jansene79dc762000-06-02 21:35:07 +0000[diff] [blame]326#endif
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]327 return Py_FindMethodInChain(&GrafObj_chain, (PyObject *)self, name);
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]328}
329
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]330#define GrafObj_setattr NULL
331
Jack Jansena05ac601999-12-12 21:41:51 +0000[diff] [blame]332#define GrafObj_compare NULL
333
334#define GrafObj_repr NULL
335
336#define GrafObj_hash NULL
337
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]338PyTypeObject GrafPort_Type = {
339 PyObject_HEAD_INIT(&PyType_Type)
340 0, /*ob_size*/
341 "GrafPort", /*tp_name*/
342 sizeof(GrafPortObject), /*tp_basicsize*/
343 0, /*tp_itemsize*/
344 /* methods */
345 (destructor) GrafObj_dealloc, /*tp_dealloc*/
346 0, /*tp_print*/
347 (getattrfunc) GrafObj_getattr, /*tp_getattr*/
348 (setattrfunc) GrafObj_setattr, /*tp_setattr*/
Jack Jansena05ac601999-12-12 21:41:51 +0000[diff] [blame]349 (cmpfunc) GrafObj_compare, /*tp_compare*/
350 (reprfunc) GrafObj_repr, /*tp_repr*/
351 (PyNumberMethods *)0, /* tp_as_number */
352 (PySequenceMethods *)0, /* tp_as_sequence */
353 (PyMappingMethods *)0, /* tp_as_mapping */
354 (hashfunc) GrafObj_hash, /*tp_hash*/
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]355};
356
357/* -------------------- End object type GrafPort -------------------- */
358
359
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]360/* ----------------------- Object type BitMap ----------------------- */
361
362PyTypeObject BitMap_Type;
363
364#define BMObj_Check(x) ((x)->ob_type == &BitMap_Type)
365
366typedef struct BitMapObject {
367 PyObject_HEAD
368 BitMapPtr ob_itself;
369 PyObject *referred_object;
370 BitMap *referred_bitmap;
371} BitMapObject;
372
373PyObject *BMObj_New(itself)
374 BitMapPtr itself;
375{
376 BitMapObject *it;
377 if (itself == NULL) return PyMac_Error(resNotFound);
378 it = PyObject_NEW(BitMapObject, &BitMap_Type);
379 if (it == NULL) return NULL;
380 it->ob_itself = itself;
381 it->referred_object = NULL;
382 it->referred_bitmap = NULL;
383 return (PyObject *)it;
384}
385BMObj_Convert(v, p_itself)
386 PyObject *v;
387 BitMapPtr *p_itself;
388{
389 if (!BMObj_Check(v))
390 {
391 PyErr_SetString(PyExc_TypeError, "BitMap required");
392 return 0;
393 }
394 *p_itself = ((BitMapObject *)v)->ob_itself;
395 return 1;
396}
397
398static void BMObj_dealloc(self)
399 BitMapObject *self;
400{
401 Py_XDECREF(self->referred_object);
402 if (self->referred_bitmap) free(self->referred_bitmap);
403 PyMem_DEL(self);
404}
405
Jack Jansen484be612000-03-03 16:01:11 +0000[diff] [blame]406static PyObject *BMObj_getdata(_self, _args)
407 BitMapObject *_self;
408 PyObject *_args;
409{
410 PyObject *_res = NULL;
411
412 int from, length;
413 char *cp;
414
415 if ( !PyArg_ParseTuple(_args, "ii", &from, &length) )
416 return NULL;
417 cp = _self->ob_itself->baseAddr+from;
418 return PyString_FromStringAndSize(cp, length);
419
420}
421
422static PyObject *BMObj_putdata(_self, _args)
423 BitMapObject *_self;
424 PyObject *_args;
425{
426 PyObject *_res = NULL;
427
428 int from, length;
429 char *cp, *icp;
430
431 if ( !PyArg_ParseTuple(_args, "is#", &from, &icp, &length) )
432 return NULL;
433 cp = _self->ob_itself->baseAddr+from;
434 memcpy(cp, icp, length);
435 Py_INCREF(Py_None);
436 return Py_None;
437
438}
439
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]440static PyMethodDef BMObj_methods[] = {
Jack Jansen484be612000-03-03 16:01:11 +0000[diff] [blame]441 {"getdata", (PyCFunction)BMObj_getdata, 1,
442 "(int start, int size) -> string. Return bytes from the bitmap"},
443 {"putdata", (PyCFunction)BMObj_putdata, 1,
444 "(int start, string data). Store bytes into the bitmap"},
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]445 {NULL, NULL, 0}
446};
447
448PyMethodChain BMObj_chain = { BMObj_methods, NULL };
449
450static PyObject *BMObj_getattr(self, name)
451 BitMapObject *self;
452 char *name;
453{
454 if ( strcmp(name, "baseAddr") == 0 )
455 return PyInt_FromLong((long)self->ob_itself->baseAddr);
456 if ( strcmp(name, "rowBytes") == 0 )
457 return PyInt_FromLong((long)self->ob_itself->rowBytes);
458 if ( strcmp(name, "bounds") == 0 )
459 return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->bounds);
460 /* XXXX Add more, as needed */
Jack Jansen425e9eb1995-12-12 15:02:03 +0000[diff] [blame]461 if ( strcmp(name, "bitmap_data") == 0 )
462 return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));
463 if ( strcmp(name, "pixmap_data") == 0 )
464 return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]465
466 return Py_FindMethodInChain(&BMObj_chain, (PyObject *)self, name);
467}
468
469#define BMObj_setattr NULL
470
Jack Jansena05ac601999-12-12 21:41:51 +0000[diff] [blame]471#define BMObj_compare NULL
472
473#define BMObj_repr NULL
474
475#define BMObj_hash NULL
476
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]477PyTypeObject BitMap_Type = {
478 PyObject_HEAD_INIT(&PyType_Type)
479 0, /*ob_size*/
480 "BitMap", /*tp_name*/
481 sizeof(BitMapObject), /*tp_basicsize*/
482 0, /*tp_itemsize*/
483 /* methods */
484 (destructor) BMObj_dealloc, /*tp_dealloc*/
485 0, /*tp_print*/
486 (getattrfunc) BMObj_getattr, /*tp_getattr*/
487 (setattrfunc) BMObj_setattr, /*tp_setattr*/
Jack Jansena05ac601999-12-12 21:41:51 +0000[diff] [blame]488 (cmpfunc) BMObj_compare, /*tp_compare*/
489 (reprfunc) BMObj_repr, /*tp_repr*/
490 (PyNumberMethods *)0, /* tp_as_number */
491 (PySequenceMethods *)0, /* tp_as_sequence */
492 (PyMappingMethods *)0, /* tp_as_mapping */
493 (hashfunc) BMObj_hash, /*tp_hash*/
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]494};
495
496/* --------------------- End object type BitMap --------------------- */
497
498
Jack Jansenbdd07471996-01-29 15:44:03 +0000[diff] [blame]499/* ------------------ Object type QDGlobalsAccess ------------------- */
500
501staticforward PyTypeObject QDGlobalsAccess_Type;
502
503#define QDGA_Check(x) ((x)->ob_type == &QDGlobalsAccess_Type)
504
505typedef struct QDGlobalsAccessObject {
506 PyObject_HEAD
507} QDGlobalsAccessObject;
508
509static PyObject *QDGA_New()
510{
511 QDGlobalsAccessObject *it;
512 it = PyObject_NEW(QDGlobalsAccessObject, &QDGlobalsAccess_Type);
513 if (it == NULL) return NULL;
514 return (PyObject *)it;
515}
516
517static void QDGA_dealloc(self)
518 QDGlobalsAccessObject *self;
519{
520 PyMem_DEL(self);
521}
522
523static PyMethodDef QDGA_methods[] = {
524 {NULL, NULL, 0}
525};
526
527static PyMethodChain QDGA_chain = { QDGA_methods, NULL };
528
529static PyObject *QDGA_getattr(self, name)
530 QDGlobalsAccessObject *self;
531 char *name;
532{
Jack Jansenbd58eda2001-01-24 14:05:11 +0000[diff] [blame^]533#if !ACCESSOR_CALLS_ARE_FUNCTIONS
Jack Jansenbdd07471996-01-29 15:44:03 +0000[diff] [blame]534
535 if ( strcmp(name, "arrow") == 0 )
536 return PyString_FromStringAndSize((char *)&qd.arrow, sizeof(qd.arrow));
537 if ( strcmp(name, "black") == 0 )
538 return PyString_FromStringAndSize((char *)&qd.black, sizeof(qd.black));
539 if ( strcmp(name, "white") == 0 )
540 return PyString_FromStringAndSize((char *)&qd.white, sizeof(qd.white));
541 if ( strcmp(name, "gray") == 0 )
542 return PyString_FromStringAndSize((char *)&qd.gray, sizeof(qd.gray));
543 if ( strcmp(name, "ltGray") == 0 )
544 return PyString_FromStringAndSize((char *)&qd.ltGray, sizeof(qd.ltGray));
545 if ( strcmp(name, "dkGray") == 0 )
546 return PyString_FromStringAndSize((char *)&qd.dkGray, sizeof(qd.dkGray));
547 if ( strcmp(name, "screenBits") == 0 )
548 return BMObj_New(&qd.screenBits);
549 if ( strcmp(name, "thePort") == 0 )
550 return GrafObj_New(qd.thePort);
551 if ( strcmp(name, "randSeed") == 0 )
552 return Py_BuildValue("l", &qd.randSeed);
553
Jack Jansenfd78de32000-06-20 07:42:00 +0000[diff] [blame]554#else
555
556 if ( strcmp(name, "arrow") == 0 ) {
557 Cursor rv;
558 GetQDGlobalsArrow(&rv);
559 return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
560 }
561 if ( strcmp(name, "black") == 0 ) {
562 Pattern rv;
563 GetQDGlobalsBlack(&rv);
564 return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
565 }
566 if ( strcmp(name, "white") == 0 ) {
567 Pattern rv;
568 GetQDGlobalsWhite(&rv);
569 return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
570 }
571 if ( strcmp(name, "gray") == 0 ) {
572 Pattern rv;
573 GetQDGlobalsGray(&rv);
574 return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
575 }
576 if ( strcmp(name, "ltGray") == 0 ) {
577 Pattern rv;
578 GetQDGlobalsLightGray(&rv);
579 return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
580 }
581 if ( strcmp(name, "dkGray") == 0 ) {
582 Pattern rv;
583 GetQDGlobalsDarkGray(&rv);
584 return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
585 }
586 if ( strcmp(name, "screenBits") == 0 ) {
587 BitMap rv;
588 GetQDGlobalsScreenBits(&rv);
589 return BMObj_New(&rv);
590 }
591 if ( strcmp(name, "thePort") == 0 )
592 return GrafObj_New(GetQDGlobalsThePort());
593 if ( strcmp(name, "randSeed") == 0 )
594 return Py_BuildValue("l", GetQDGlobalsRandomSeed());
595
Jack Jansene79dc762000-06-02 21:35:07 +0000[diff] [blame]596#endif
Jack Jansenbdd07471996-01-29 15:44:03 +0000[diff] [blame]597 return Py_FindMethodInChain(&QDGA_chain, (PyObject *)self, name);
598}
599
600#define QDGA_setattr NULL
601
Jack Jansena05ac601999-12-12 21:41:51 +0000[diff] [blame]602#define QDGA_compare NULL
603
604#define QDGA_repr NULL
605
606#define QDGA_hash NULL
607
Jack Jansenbdd07471996-01-29 15:44:03 +0000[diff] [blame]608staticforward PyTypeObject QDGlobalsAccess_Type = {
609 PyObject_HEAD_INIT(&PyType_Type)
610 0, /*ob_size*/
611 "QDGlobalsAccess", /*tp_name*/
612 sizeof(QDGlobalsAccessObject), /*tp_basicsize*/
613 0, /*tp_itemsize*/
614 /* methods */
615 (destructor) QDGA_dealloc, /*tp_dealloc*/
616 0, /*tp_print*/
617 (getattrfunc) QDGA_getattr, /*tp_getattr*/
618 (setattrfunc) QDGA_setattr, /*tp_setattr*/
Jack Jansena05ac601999-12-12 21:41:51 +0000[diff] [blame]619 (cmpfunc) QDGA_compare, /*tp_compare*/
620 (reprfunc) QDGA_repr, /*tp_repr*/
621 (PyNumberMethods *)0, /* tp_as_number */
622 (PySequenceMethods *)0, /* tp_as_sequence */
623 (PyMappingMethods *)0, /* tp_as_mapping */
624 (hashfunc) QDGA_hash, /*tp_hash*/
Jack Jansenbdd07471996-01-29 15:44:03 +0000[diff] [blame]625};
626
627/* ---------------- End object type QDGlobalsAccess ----------------- */
628
629
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]630static PyObject *Qd_MacSetPort(_self, _args)
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]631 PyObject *_self;
632 PyObject *_args;
633{
634 PyObject *_res = NULL;
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]635 GrafPtr port;
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]636 if (!PyArg_ParseTuple(_args, "O&",
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]637 GrafObj_Convert, &port))
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]638 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]639 MacSetPort(port);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]640 Py_INCREF(Py_None);
641 _res = Py_None;
642 return _res;
643}
644
645static PyObject *Qd_GetPort(_self, _args)
646 PyObject *_self;
647 PyObject *_args;
648{
649 PyObject *_res = NULL;
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]650 GrafPtr port;
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]651 if (!PyArg_ParseTuple(_args, ""))
652 return NULL;
653 GetPort(&port);
654 _res = Py_BuildValue("O&",
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]655 GrafObj_New, port);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]656 return _res;
657}
658
659static PyObject *Qd_GrafDevice(_self, _args)
660 PyObject *_self;
661 PyObject *_args;
662{
663 PyObject *_res = NULL;
664 short device;
665 if (!PyArg_ParseTuple(_args, "h",
666 &device))
667 return NULL;
668 GrafDevice(device);
669 Py_INCREF(Py_None);
670 _res = Py_None;
671 return _res;
672}
673
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]674static PyObject *Qd_SetPortBits(_self, _args)
675 PyObject *_self;
676 PyObject *_args;
677{
678 PyObject *_res = NULL;
679 BitMapPtr bm;
680 if (!PyArg_ParseTuple(_args, "O&",
681 BMObj_Convert, &bm))
682 return NULL;
683 SetPortBits(bm);
684 Py_INCREF(Py_None);
685 _res = Py_None;
686 return _res;
687}
688
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]689static PyObject *Qd_PortSize(_self, _args)
690 PyObject *_self;
691 PyObject *_args;
692{
693 PyObject *_res = NULL;
694 short width;
695 short height;
696 if (!PyArg_ParseTuple(_args, "hh",
697 &width,
698 &height))
699 return NULL;
700 PortSize(width,
701 height);
702 Py_INCREF(Py_None);
703 _res = Py_None;
704 return _res;
705}
706
707static PyObject *Qd_MovePortTo(_self, _args)
708 PyObject *_self;
709 PyObject *_args;
710{
711 PyObject *_res = NULL;
712 short leftGlobal;
713 short topGlobal;
714 if (!PyArg_ParseTuple(_args, "hh",
715 &leftGlobal,
716 &topGlobal))
717 return NULL;
718 MovePortTo(leftGlobal,
719 topGlobal);
720 Py_INCREF(Py_None);
721 _res = Py_None;
722 return _res;
723}
724
725static PyObject *Qd_SetOrigin(_self, _args)
726 PyObject *_self;
727 PyObject *_args;
728{
729 PyObject *_res = NULL;
730 short h;
731 short v;
732 if (!PyArg_ParseTuple(_args, "hh",
733 &h,
734 &v))
735 return NULL;
736 SetOrigin(h,
737 v);
738 Py_INCREF(Py_None);
739 _res = Py_None;
740 return _res;
741}
742
743static PyObject *Qd_SetClip(_self, _args)
744 PyObject *_self;
745 PyObject *_args;
746{
747 PyObject *_res = NULL;
748 RgnHandle rgn;
749 if (!PyArg_ParseTuple(_args, "O&",
750 ResObj_Convert, &rgn))
751 return NULL;
752 SetClip(rgn);
753 Py_INCREF(Py_None);
754 _res = Py_None;
755 return _res;
756}
757
758static PyObject *Qd_GetClip(_self, _args)
759 PyObject *_self;
760 PyObject *_args;
761{
762 PyObject *_res = NULL;
763 RgnHandle rgn;
764 if (!PyArg_ParseTuple(_args, "O&",
765 ResObj_Convert, &rgn))
766 return NULL;
767 GetClip(rgn);
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]768 Py_INCREF(Py_None);
769 _res = Py_None;
770 return _res;
771}
772
773static PyObject *Qd_ClipRect(_self, _args)
774 PyObject *_self;
775 PyObject *_args;
776{
777 PyObject *_res = NULL;
778 Rect r;
779 if (!PyArg_ParseTuple(_args, "O&",
780 PyMac_GetRect, &r))
781 return NULL;
782 ClipRect(&r);
783 Py_INCREF(Py_None);
784 _res = Py_None;
785 return _res;
786}
787
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]788static PyObject *Qd_BackPat(_self, _args)
789 PyObject *_self;
790 PyObject *_args;
791{
792 PyObject *_res = NULL;
793 Pattern *pat__in__;
794 int pat__in_len__;
795 if (!PyArg_ParseTuple(_args, "s#",
796 (char **)&pat__in__, &pat__in_len__))
797 return NULL;
798 if (pat__in_len__ != sizeof(Pattern))
799 {
800 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
801 goto pat__error__;
802 }
803 BackPat(pat__in__);
804 Py_INCREF(Py_None);
805 _res = Py_None;
806 pat__error__: ;
807 return _res;
808}
809
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]810static PyObject *Qd_InitCursor(_self, _args)
811 PyObject *_self;
812 PyObject *_args;
813{
814 PyObject *_res = NULL;
815 if (!PyArg_ParseTuple(_args, ""))
816 return NULL;
817 InitCursor();
818 Py_INCREF(Py_None);
819 _res = Py_None;
820 return _res;
821}
822
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]823static PyObject *Qd_MacSetCursor(_self, _args)
Jack Jansenb5394061996-01-05 18:06:41 +0000[diff] [blame]824 PyObject *_self;
825 PyObject *_args;
826{
827 PyObject *_res = NULL;
828 Cursor *crsr__in__;
829 int crsr__in_len__;
830 if (!PyArg_ParseTuple(_args, "s#",
831 (char **)&crsr__in__, &crsr__in_len__))
832 return NULL;
833 if (crsr__in_len__ != sizeof(Cursor))
834 {
835 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Cursor)");
836 goto crsr__error__;
837 }
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]838 MacSetCursor(crsr__in__);
Jack Jansenb5394061996-01-05 18:06:41 +0000[diff] [blame]839 Py_INCREF(Py_None);
840 _res = Py_None;
841 crsr__error__: ;
842 return _res;
843}
844
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]845static PyObject *Qd_HideCursor(_self, _args)
846 PyObject *_self;
847 PyObject *_args;
848{
849 PyObject *_res = NULL;
850 if (!PyArg_ParseTuple(_args, ""))
851 return NULL;
852 HideCursor();
853 Py_INCREF(Py_None);
854 _res = Py_None;
855 return _res;
856}
857
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]858static PyObject *Qd_MacShowCursor(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]859 PyObject *_self;
860 PyObject *_args;
861{
862 PyObject *_res = NULL;
863 if (!PyArg_ParseTuple(_args, ""))
864 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]865 MacShowCursor();
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]866 Py_INCREF(Py_None);
867 _res = Py_None;
868 return _res;
869}
870
871static PyObject *Qd_ObscureCursor(_self, _args)
872 PyObject *_self;
873 PyObject *_args;
874{
875 PyObject *_res = NULL;
876 if (!PyArg_ParseTuple(_args, ""))
877 return NULL;
878 ObscureCursor();
879 Py_INCREF(Py_None);
880 _res = Py_None;
881 return _res;
882}
883
884static PyObject *Qd_HidePen(_self, _args)
885 PyObject *_self;
886 PyObject *_args;
887{
888 PyObject *_res = NULL;
889 if (!PyArg_ParseTuple(_args, ""))
890 return NULL;
891 HidePen();
892 Py_INCREF(Py_None);
893 _res = Py_None;
894 return _res;
895}
896
897static PyObject *Qd_ShowPen(_self, _args)
898 PyObject *_self;
899 PyObject *_args;
900{
901 PyObject *_res = NULL;
902 if (!PyArg_ParseTuple(_args, ""))
903 return NULL;
904 ShowPen();
905 Py_INCREF(Py_None);
906 _res = Py_None;
907 return _res;
908}
909
910static PyObject *Qd_GetPen(_self, _args)
911 PyObject *_self;
912 PyObject *_args;
913{
914 PyObject *_res = NULL;
915 Point pt;
Jack Jansen1d8ede71996-01-08 23:47:31 +0000[diff] [blame]916 if (!PyArg_ParseTuple(_args, ""))
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]917 return NULL;
918 GetPen(&pt);
919 _res = Py_BuildValue("O&",
920 PyMac_BuildPoint, pt);
921 return _res;
922}
923
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]924static PyObject *Qd_GetPenState(_self, _args)
925 PyObject *_self;
926 PyObject *_args;
927{
928 PyObject *_res = NULL;
929 PenState pnState__out__;
930 if (!PyArg_ParseTuple(_args, ""))
931 return NULL;
932 GetPenState(&pnState__out__);
933 _res = Py_BuildValue("s#",
934 (char *)&pnState__out__, (int)sizeof(PenState));
935 pnState__error__: ;
936 return _res;
937}
938
939static PyObject *Qd_SetPenState(_self, _args)
940 PyObject *_self;
941 PyObject *_args;
942{
943 PyObject *_res = NULL;
944 PenState *pnState__in__;
945 int pnState__in_len__;
946 if (!PyArg_ParseTuple(_args, "s#",
947 (char **)&pnState__in__, &pnState__in_len__))
948 return NULL;
949 if (pnState__in_len__ != sizeof(PenState))
950 {
951 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(PenState)");
952 goto pnState__error__;
953 }
954 SetPenState(pnState__in__);
955 Py_INCREF(Py_None);
956 _res = Py_None;
957 pnState__error__: ;
958 return _res;
959}
960
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]961static PyObject *Qd_PenSize(_self, _args)
962 PyObject *_self;
963 PyObject *_args;
964{
965 PyObject *_res = NULL;
966 short width;
967 short height;
968 if (!PyArg_ParseTuple(_args, "hh",
969 &width,
970 &height))
971 return NULL;
972 PenSize(width,
973 height);
974 Py_INCREF(Py_None);
975 _res = Py_None;
976 return _res;
977}
978
979static PyObject *Qd_PenMode(_self, _args)
980 PyObject *_self;
981 PyObject *_args;
982{
983 PyObject *_res = NULL;
984 short mode;
985 if (!PyArg_ParseTuple(_args, "h",
986 &mode))
987 return NULL;
988 PenMode(mode);
989 Py_INCREF(Py_None);
990 _res = Py_None;
991 return _res;
992}
993
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]994static PyObject *Qd_PenPat(_self, _args)
995 PyObject *_self;
996 PyObject *_args;
997{
998 PyObject *_res = NULL;
999 Pattern *pat__in__;
1000 int pat__in_len__;
1001 if (!PyArg_ParseTuple(_args, "s#",
1002 (char **)&pat__in__, &pat__in_len__))
1003 return NULL;
1004 if (pat__in_len__ != sizeof(Pattern))
1005 {
1006 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
1007 goto pat__error__;
1008 }
1009 PenPat(pat__in__);
1010 Py_INCREF(Py_None);
1011 _res = Py_None;
1012 pat__error__: ;
1013 return _res;
1014}
1015
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1016static PyObject *Qd_PenNormal(_self, _args)
1017 PyObject *_self;
1018 PyObject *_args;
1019{
1020 PyObject *_res = NULL;
1021 if (!PyArg_ParseTuple(_args, ""))
1022 return NULL;
1023 PenNormal();
1024 Py_INCREF(Py_None);
1025 _res = Py_None;
1026 return _res;
1027}
1028
1029static PyObject *Qd_MoveTo(_self, _args)
1030 PyObject *_self;
1031 PyObject *_args;
1032{
1033 PyObject *_res = NULL;
1034 short h;
1035 short v;
1036 if (!PyArg_ParseTuple(_args, "hh",
1037 &h,
1038 &v))
1039 return NULL;
1040 MoveTo(h,
1041 v);
1042 Py_INCREF(Py_None);
1043 _res = Py_None;
1044 return _res;
1045}
1046
1047static PyObject *Qd_Move(_self, _args)
1048 PyObject *_self;
1049 PyObject *_args;
1050{
1051 PyObject *_res = NULL;
1052 short dh;
1053 short dv;
1054 if (!PyArg_ParseTuple(_args, "hh",
1055 &dh,
1056 &dv))
1057 return NULL;
1058 Move(dh,
1059 dv);
1060 Py_INCREF(Py_None);
1061 _res = Py_None;
1062 return _res;
1063}
1064
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1065static PyObject *Qd_MacLineTo(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1066 PyObject *_self;
1067 PyObject *_args;
1068{
1069 PyObject *_res = NULL;
1070 short h;
1071 short v;
1072 if (!PyArg_ParseTuple(_args, "hh",
1073 &h,
1074 &v))
1075 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1076 MacLineTo(h,
1077 v);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1078 Py_INCREF(Py_None);
1079 _res = Py_None;
1080 return _res;
1081}
1082
1083static PyObject *Qd_Line(_self, _args)
1084 PyObject *_self;
1085 PyObject *_args;
1086{
1087 PyObject *_res = NULL;
1088 short dh;
1089 short dv;
1090 if (!PyArg_ParseTuple(_args, "hh",
1091 &dh,
1092 &dv))
1093 return NULL;
1094 Line(dh,
1095 dv);
1096 Py_INCREF(Py_None);
1097 _res = Py_None;
1098 return _res;
1099}
1100
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1101static PyObject *Qd_ForeColor(_self, _args)
1102 PyObject *_self;
1103 PyObject *_args;
1104{
1105 PyObject *_res = NULL;
1106 long color;
1107 if (!PyArg_ParseTuple(_args, "l",
1108 &color))
1109 return NULL;
1110 ForeColor(color);
1111 Py_INCREF(Py_None);
1112 _res = Py_None;
1113 return _res;
1114}
1115
1116static PyObject *Qd_BackColor(_self, _args)
1117 PyObject *_self;
1118 PyObject *_args;
1119{
1120 PyObject *_res = NULL;
1121 long color;
1122 if (!PyArg_ParseTuple(_args, "l",
1123 &color))
1124 return NULL;
1125 BackColor(color);
1126 Py_INCREF(Py_None);
1127 _res = Py_None;
1128 return _res;
1129}
1130
1131static PyObject *Qd_ColorBit(_self, _args)
1132 PyObject *_self;
1133 PyObject *_args;
1134{
1135 PyObject *_res = NULL;
1136 short whichBit;
1137 if (!PyArg_ParseTuple(_args, "h",
1138 &whichBit))
1139 return NULL;
1140 ColorBit(whichBit);
1141 Py_INCREF(Py_None);
1142 _res = Py_None;
1143 return _res;
1144}
1145
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1146static PyObject *Qd_MacSetRect(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1147 PyObject *_self;
1148 PyObject *_args;
1149{
1150 PyObject *_res = NULL;
1151 Rect r;
1152 short left;
1153 short top;
1154 short right;
1155 short bottom;
1156 if (!PyArg_ParseTuple(_args, "hhhh",
1157 &left,
1158 &top,
1159 &right,
1160 &bottom))
1161 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1162 MacSetRect(&r,
1163 left,
1164 top,
1165 right,
1166 bottom);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1167 _res = Py_BuildValue("O&",
1168 PyMac_BuildRect, &r);
1169 return _res;
1170}
1171
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1172static PyObject *Qd_MacOffsetRect(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1173 PyObject *_self;
1174 PyObject *_args;
1175{
1176 PyObject *_res = NULL;
1177 Rect r;
1178 short dh;
1179 short dv;
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]1180 if (!PyArg_ParseTuple(_args, "O&hh",
1181 PyMac_GetRect, &r,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1182 &dh,
1183 &dv))
1184 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1185 MacOffsetRect(&r,
1186 dh,
1187 dv);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1188 _res = Py_BuildValue("O&",
1189 PyMac_BuildRect, &r);
1190 return _res;
1191}
1192
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1193static PyObject *Qd_MacInsetRect(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1194 PyObject *_self;
1195 PyObject *_args;
1196{
1197 PyObject *_res = NULL;
1198 Rect r;
1199 short dh;
1200 short dv;
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]1201 if (!PyArg_ParseTuple(_args, "O&hh",
1202 PyMac_GetRect, &r,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1203 &dh,
1204 &dv))
1205 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1206 MacInsetRect(&r,
1207 dh,
1208 dv);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1209 _res = Py_BuildValue("O&",
1210 PyMac_BuildRect, &r);
1211 return _res;
1212}
1213
1214static PyObject *Qd_SectRect(_self, _args)
1215 PyObject *_self;
1216 PyObject *_args;
1217{
1218 PyObject *_res = NULL;
1219 Boolean _rv;
1220 Rect src1;
1221 Rect src2;
1222 Rect dstRect;
1223 if (!PyArg_ParseTuple(_args, "O&O&",
1224 PyMac_GetRect, &src1,
1225 PyMac_GetRect, &src2))
1226 return NULL;
1227 _rv = SectRect(&src1,
1228 &src2,
1229 &dstRect);
1230 _res = Py_BuildValue("bO&",
1231 _rv,
1232 PyMac_BuildRect, &dstRect);
1233 return _res;
1234}
1235
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1236static PyObject *Qd_MacUnionRect(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1237 PyObject *_self;
1238 PyObject *_args;
1239{
1240 PyObject *_res = NULL;
1241 Rect src1;
1242 Rect src2;
1243 Rect dstRect;
1244 if (!PyArg_ParseTuple(_args, "O&O&",
1245 PyMac_GetRect, &src1,
1246 PyMac_GetRect, &src2))
1247 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1248 MacUnionRect(&src1,
1249 &src2,
1250 &dstRect);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1251 _res = Py_BuildValue("O&",
1252 PyMac_BuildRect, &dstRect);
1253 return _res;
1254}
1255
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1256static PyObject *Qd_MacEqualRect(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1257 PyObject *_self;
1258 PyObject *_args;
1259{
1260 PyObject *_res = NULL;
1261 Boolean _rv;
1262 Rect rect1;
1263 Rect rect2;
1264 if (!PyArg_ParseTuple(_args, "O&O&",
1265 PyMac_GetRect, &rect1,
1266 PyMac_GetRect, &rect2))
1267 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1268 _rv = MacEqualRect(&rect1,
1269 &rect2);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1270 _res = Py_BuildValue("b",
1271 _rv);
1272 return _res;
1273}
1274
1275static PyObject *Qd_EmptyRect(_self, _args)
1276 PyObject *_self;
1277 PyObject *_args;
1278{
1279 PyObject *_res = NULL;
1280 Boolean _rv;
1281 Rect r;
1282 if (!PyArg_ParseTuple(_args, "O&",
1283 PyMac_GetRect, &r))
1284 return NULL;
1285 _rv = EmptyRect(&r);
1286 _res = Py_BuildValue("b",
1287 _rv);
1288 return _res;
1289}
1290
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1291static PyObject *Qd_MacFrameRect(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1292 PyObject *_self;
1293 PyObject *_args;
1294{
1295 PyObject *_res = NULL;
1296 Rect r;
1297 if (!PyArg_ParseTuple(_args, "O&",
1298 PyMac_GetRect, &r))
1299 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1300 MacFrameRect(&r);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1301 Py_INCREF(Py_None);
1302 _res = Py_None;
1303 return _res;
1304}
1305
1306static PyObject *Qd_PaintRect(_self, _args)
1307 PyObject *_self;
1308 PyObject *_args;
1309{
1310 PyObject *_res = NULL;
1311 Rect r;
1312 if (!PyArg_ParseTuple(_args, "O&",
1313 PyMac_GetRect, &r))
1314 return NULL;
1315 PaintRect(&r);
1316 Py_INCREF(Py_None);
1317 _res = Py_None;
1318 return _res;
1319}
1320
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]1321static PyObject *Qd_EraseRect(_self, _args)
1322 PyObject *_self;
1323 PyObject *_args;
1324{
1325 PyObject *_res = NULL;
1326 Rect r;
1327 if (!PyArg_ParseTuple(_args, "O&",
1328 PyMac_GetRect, &r))
1329 return NULL;
1330 EraseRect(&r);
1331 Py_INCREF(Py_None);
1332 _res = Py_None;
1333 return _res;
1334}
1335
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1336static PyObject *Qd_MacInvertRect(_self, _args)
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]1337 PyObject *_self;
1338 PyObject *_args;
1339{
1340 PyObject *_res = NULL;
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1341 Rect r;
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]1342 if (!PyArg_ParseTuple(_args, "O&",
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1343 PyMac_GetRect, &r))
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]1344 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1345 MacInvertRect(&r);
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]1346 Py_INCREF(Py_None);
1347 _res = Py_None;
1348 return _res;
1349}
1350
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1351static PyObject *Qd_MacFillRect(_self, _args)
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]1352 PyObject *_self;
1353 PyObject *_args;
1354{
1355 PyObject *_res = NULL;
1356 Rect r;
1357 Pattern *pat__in__;
1358 int pat__in_len__;
1359 if (!PyArg_ParseTuple(_args, "O&s#",
1360 PyMac_GetRect, &r,
1361 (char **)&pat__in__, &pat__in_len__))
1362 return NULL;
1363 if (pat__in_len__ != sizeof(Pattern))
1364 {
1365 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
1366 goto pat__error__;
1367 }
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1368 MacFillRect(&r,
1369 pat__in__);
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]1370 Py_INCREF(Py_None);
1371 _res = Py_None;
1372 pat__error__: ;
1373 return _res;
1374}
1375
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1376static PyObject *Qd_FrameOval(_self, _args)
1377 PyObject *_self;
1378 PyObject *_args;
1379{
1380 PyObject *_res = NULL;
1381 Rect r;
1382 if (!PyArg_ParseTuple(_args, "O&",
1383 PyMac_GetRect, &r))
1384 return NULL;
1385 FrameOval(&r);
1386 Py_INCREF(Py_None);
1387 _res = Py_None;
1388 return _res;
1389}
1390
1391static PyObject *Qd_PaintOval(_self, _args)
1392 PyObject *_self;
1393 PyObject *_args;
1394{
1395 PyObject *_res = NULL;
1396 Rect r;
1397 if (!PyArg_ParseTuple(_args, "O&",
1398 PyMac_GetRect, &r))
1399 return NULL;
1400 PaintOval(&r);
1401 Py_INCREF(Py_None);
1402 _res = Py_None;
1403 return _res;
1404}
1405
1406static PyObject *Qd_EraseOval(_self, _args)
1407 PyObject *_self;
1408 PyObject *_args;
1409{
1410 PyObject *_res = NULL;
1411 Rect r;
1412 if (!PyArg_ParseTuple(_args, "O&",
1413 PyMac_GetRect, &r))
1414 return NULL;
1415 EraseOval(&r);
1416 Py_INCREF(Py_None);
1417 _res = Py_None;
1418 return _res;
1419}
1420
1421static PyObject *Qd_InvertOval(_self, _args)
1422 PyObject *_self;
1423 PyObject *_args;
1424{
1425 PyObject *_res = NULL;
1426 Rect r;
1427 if (!PyArg_ParseTuple(_args, "O&",
1428 PyMac_GetRect, &r))
1429 return NULL;
1430 InvertOval(&r);
1431 Py_INCREF(Py_None);
1432 _res = Py_None;
1433 return _res;
1434}
1435
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]1436static PyObject *Qd_FillOval(_self, _args)
1437 PyObject *_self;
1438 PyObject *_args;
1439{
1440 PyObject *_res = NULL;
1441 Rect r;
1442 Pattern *pat__in__;
1443 int pat__in_len__;
1444 if (!PyArg_ParseTuple(_args, "O&s#",
1445 PyMac_GetRect, &r,
1446 (char **)&pat__in__, &pat__in_len__))
1447 return NULL;
1448 if (pat__in_len__ != sizeof(Pattern))
1449 {
1450 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
1451 goto pat__error__;
1452 }
1453 FillOval(&r,
1454 pat__in__);
1455 Py_INCREF(Py_None);
1456 _res = Py_None;
1457 pat__error__: ;
1458 return _res;
1459}
1460
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1461static PyObject *Qd_FrameRoundRect(_self, _args)
1462 PyObject *_self;
1463 PyObject *_args;
1464{
1465 PyObject *_res = NULL;
1466 Rect r;
1467 short ovalWidth;
1468 short ovalHeight;
1469 if (!PyArg_ParseTuple(_args, "O&hh",
1470 PyMac_GetRect, &r,
1471 &ovalWidth,
1472 &ovalHeight))
1473 return NULL;
1474 FrameRoundRect(&r,
1475 ovalWidth,
1476 ovalHeight);
1477 Py_INCREF(Py_None);
1478 _res = Py_None;
1479 return _res;
1480}
1481
1482static PyObject *Qd_PaintRoundRect(_self, _args)
1483 PyObject *_self;
1484 PyObject *_args;
1485{
1486 PyObject *_res = NULL;
1487 Rect r;
1488 short ovalWidth;
1489 short ovalHeight;
1490 if (!PyArg_ParseTuple(_args, "O&hh",
1491 PyMac_GetRect, &r,
1492 &ovalWidth,
1493 &ovalHeight))
1494 return NULL;
1495 PaintRoundRect(&r,
1496 ovalWidth,
1497 ovalHeight);
1498 Py_INCREF(Py_None);
1499 _res = Py_None;
1500 return _res;
1501}
1502
1503static PyObject *Qd_EraseRoundRect(_self, _args)
1504 PyObject *_self;
1505 PyObject *_args;
1506{
1507 PyObject *_res = NULL;
1508 Rect r;
1509 short ovalWidth;
1510 short ovalHeight;
1511 if (!PyArg_ParseTuple(_args, "O&hh",
1512 PyMac_GetRect, &r,
1513 &ovalWidth,
1514 &ovalHeight))
1515 return NULL;
1516 EraseRoundRect(&r,
1517 ovalWidth,
1518 ovalHeight);
1519 Py_INCREF(Py_None);
1520 _res = Py_None;
1521 return _res;
1522}
1523
1524static PyObject *Qd_InvertRoundRect(_self, _args)
1525 PyObject *_self;
1526 PyObject *_args;
1527{
1528 PyObject *_res = NULL;
1529 Rect r;
1530 short ovalWidth;
1531 short ovalHeight;
1532 if (!PyArg_ParseTuple(_args, "O&hh",
1533 PyMac_GetRect, &r,
1534 &ovalWidth,
1535 &ovalHeight))
1536 return NULL;
1537 InvertRoundRect(&r,
1538 ovalWidth,
1539 ovalHeight);
1540 Py_INCREF(Py_None);
1541 _res = Py_None;
1542 return _res;
1543}
1544
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]1545static PyObject *Qd_FillRoundRect(_self, _args)
1546 PyObject *_self;
1547 PyObject *_args;
1548{
1549 PyObject *_res = NULL;
1550 Rect r;
1551 short ovalWidth;
1552 short ovalHeight;
1553 Pattern *pat__in__;
1554 int pat__in_len__;
1555 if (!PyArg_ParseTuple(_args, "O&hhs#",
1556 PyMac_GetRect, &r,
1557 &ovalWidth,
1558 &ovalHeight,
1559 (char **)&pat__in__, &pat__in_len__))
1560 return NULL;
1561 if (pat__in_len__ != sizeof(Pattern))
1562 {
1563 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
1564 goto pat__error__;
1565 }
1566 FillRoundRect(&r,
1567 ovalWidth,
1568 ovalHeight,
1569 pat__in__);
1570 Py_INCREF(Py_None);
1571 _res = Py_None;
1572 pat__error__: ;
1573 return _res;
1574}
1575
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1576static PyObject *Qd_FrameArc(_self, _args)
1577 PyObject *_self;
1578 PyObject *_args;
1579{
1580 PyObject *_res = NULL;
1581 Rect r;
1582 short startAngle;
1583 short arcAngle;
1584 if (!PyArg_ParseTuple(_args, "O&hh",
1585 PyMac_GetRect, &r,
1586 &startAngle,
1587 &arcAngle))
1588 return NULL;
1589 FrameArc(&r,
1590 startAngle,
1591 arcAngle);
1592 Py_INCREF(Py_None);
1593 _res = Py_None;
1594 return _res;
1595}
1596
1597static PyObject *Qd_PaintArc(_self, _args)
1598 PyObject *_self;
1599 PyObject *_args;
1600{
1601 PyObject *_res = NULL;
1602 Rect r;
1603 short startAngle;
1604 short arcAngle;
1605 if (!PyArg_ParseTuple(_args, "O&hh",
1606 PyMac_GetRect, &r,
1607 &startAngle,
1608 &arcAngle))
1609 return NULL;
1610 PaintArc(&r,
1611 startAngle,
1612 arcAngle);
1613 Py_INCREF(Py_None);
1614 _res = Py_None;
1615 return _res;
1616}
1617
1618static PyObject *Qd_EraseArc(_self, _args)
1619 PyObject *_self;
1620 PyObject *_args;
1621{
1622 PyObject *_res = NULL;
1623 Rect r;
1624 short startAngle;
1625 short arcAngle;
1626 if (!PyArg_ParseTuple(_args, "O&hh",
1627 PyMac_GetRect, &r,
1628 &startAngle,
1629 &arcAngle))
1630 return NULL;
1631 EraseArc(&r,
1632 startAngle,
1633 arcAngle);
1634 Py_INCREF(Py_None);
1635 _res = Py_None;
1636 return _res;
1637}
1638
1639static PyObject *Qd_InvertArc(_self, _args)
1640 PyObject *_self;
1641 PyObject *_args;
1642{
1643 PyObject *_res = NULL;
1644 Rect r;
1645 short startAngle;
1646 short arcAngle;
1647 if (!PyArg_ParseTuple(_args, "O&hh",
1648 PyMac_GetRect, &r,
1649 &startAngle,
1650 &arcAngle))
1651 return NULL;
1652 InvertArc(&r,
1653 startAngle,
1654 arcAngle);
1655 Py_INCREF(Py_None);
1656 _res = Py_None;
1657 return _res;
1658}
1659
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]1660static PyObject *Qd_FillArc(_self, _args)
1661 PyObject *_self;
1662 PyObject *_args;
1663{
1664 PyObject *_res = NULL;
1665 Rect r;
1666 short startAngle;
1667 short arcAngle;
1668 Pattern *pat__in__;
1669 int pat__in_len__;
1670 if (!PyArg_ParseTuple(_args, "O&hhs#",
1671 PyMac_GetRect, &r,
1672 &startAngle,
1673 &arcAngle,
1674 (char **)&pat__in__, &pat__in_len__))
1675 return NULL;
1676 if (pat__in_len__ != sizeof(Pattern))
1677 {
1678 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
1679 goto pat__error__;
1680 }
1681 FillArc(&r,
1682 startAngle,
1683 arcAngle,
1684 pat__in__);
1685 Py_INCREF(Py_None);
1686 _res = Py_None;
1687 pat__error__: ;
1688 return _res;
1689}
1690
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1691static PyObject *Qd_NewRgn(_self, _args)
1692 PyObject *_self;
1693 PyObject *_args;
1694{
1695 PyObject *_res = NULL;
1696 RgnHandle _rv;
1697 if (!PyArg_ParseTuple(_args, ""))
1698 return NULL;
1699 _rv = NewRgn();
1700 _res = Py_BuildValue("O&",
1701 ResObj_New, _rv);
1702 return _res;
1703}
1704
1705static PyObject *Qd_OpenRgn(_self, _args)
1706 PyObject *_self;
1707 PyObject *_args;
1708{
1709 PyObject *_res = NULL;
1710 if (!PyArg_ParseTuple(_args, ""))
1711 return NULL;
1712 OpenRgn();
1713 Py_INCREF(Py_None);
1714 _res = Py_None;
1715 return _res;
1716}
1717
1718static PyObject *Qd_CloseRgn(_self, _args)
1719 PyObject *_self;
1720 PyObject *_args;
1721{
1722 PyObject *_res = NULL;
1723 RgnHandle dstRgn;
1724 if (!PyArg_ParseTuple(_args, "O&",
1725 ResObj_Convert, &dstRgn))
1726 return NULL;
1727 CloseRgn(dstRgn);
1728 Py_INCREF(Py_None);
1729 _res = Py_None;
1730 return _res;
1731}
1732
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]1733static PyObject *Qd_BitMapToRegion(_self, _args)
1734 PyObject *_self;
1735 PyObject *_args;
1736{
1737 PyObject *_res = NULL;
1738 OSErr _err;
1739 RgnHandle region;
1740 BitMapPtr bMap;
1741 if (!PyArg_ParseTuple(_args, "O&O&",
1742 ResObj_Convert, &region,
1743 BMObj_Convert, &bMap))
1744 return NULL;
1745 _err = BitMapToRegion(region,
1746 bMap);
1747 if (_err != noErr) return PyMac_Error(_err);
1748 Py_INCREF(Py_None);
1749 _res = Py_None;
1750 return _res;
1751}
1752
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1753static PyObject *Qd_DisposeRgn(_self, _args)
1754 PyObject *_self;
1755 PyObject *_args;
1756{
1757 PyObject *_res = NULL;
1758 RgnHandle rgn;
1759 if (!PyArg_ParseTuple(_args, "O&",
1760 ResObj_Convert, &rgn))
1761 return NULL;
1762 DisposeRgn(rgn);
1763 Py_INCREF(Py_None);
1764 _res = Py_None;
1765 return _res;
1766}
1767
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1768static PyObject *Qd_MacCopyRgn(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1769 PyObject *_self;
1770 PyObject *_args;
1771{
1772 PyObject *_res = NULL;
1773 RgnHandle srcRgn;
1774 RgnHandle dstRgn;
1775 if (!PyArg_ParseTuple(_args, "O&O&",
1776 ResObj_Convert, &srcRgn,
1777 ResObj_Convert, &dstRgn))
1778 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1779 MacCopyRgn(srcRgn,
1780 dstRgn);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1781 Py_INCREF(Py_None);
1782 _res = Py_None;
1783 return _res;
1784}
1785
1786static PyObject *Qd_SetEmptyRgn(_self, _args)
1787 PyObject *_self;
1788 PyObject *_args;
1789{
1790 PyObject *_res = NULL;
1791 RgnHandle rgn;
1792 if (!PyArg_ParseTuple(_args, "O&",
1793 ResObj_Convert, &rgn))
1794 return NULL;
1795 SetEmptyRgn(rgn);
1796 Py_INCREF(Py_None);
1797 _res = Py_None;
1798 return _res;
1799}
1800
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1801static PyObject *Qd_MacSetRectRgn(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1802 PyObject *_self;
1803 PyObject *_args;
1804{
1805 PyObject *_res = NULL;
1806 RgnHandle rgn;
1807 short left;
1808 short top;
1809 short right;
1810 short bottom;
1811 if (!PyArg_ParseTuple(_args, "O&hhhh",
1812 ResObj_Convert, &rgn,
1813 &left,
1814 &top,
1815 &right,
1816 &bottom))
1817 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1818 MacSetRectRgn(rgn,
1819 left,
1820 top,
1821 right,
1822 bottom);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1823 Py_INCREF(Py_None);
1824 _res = Py_None;
1825 return _res;
1826}
1827
1828static PyObject *Qd_RectRgn(_self, _args)
1829 PyObject *_self;
1830 PyObject *_args;
1831{
1832 PyObject *_res = NULL;
1833 RgnHandle rgn;
1834 Rect r;
1835 if (!PyArg_ParseTuple(_args, "O&O&",
1836 ResObj_Convert, &rgn,
1837 PyMac_GetRect, &r))
1838 return NULL;
1839 RectRgn(rgn,
1840 &r);
1841 Py_INCREF(Py_None);
1842 _res = Py_None;
1843 return _res;
1844}
1845
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1846static PyObject *Qd_MacOffsetRgn(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1847 PyObject *_self;
1848 PyObject *_args;
1849{
1850 PyObject *_res = NULL;
1851 RgnHandle rgn;
1852 short dh;
1853 short dv;
1854 if (!PyArg_ParseTuple(_args, "O&hh",
1855 ResObj_Convert, &rgn,
1856 &dh,
1857 &dv))
1858 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1859 MacOffsetRgn(rgn,
1860 dh,
1861 dv);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1862 Py_INCREF(Py_None);
1863 _res = Py_None;
1864 return _res;
1865}
1866
1867static PyObject *Qd_InsetRgn(_self, _args)
1868 PyObject *_self;
1869 PyObject *_args;
1870{
1871 PyObject *_res = NULL;
1872 RgnHandle rgn;
1873 short dh;
1874 short dv;
1875 if (!PyArg_ParseTuple(_args, "O&hh",
1876 ResObj_Convert, &rgn,
1877 &dh,
1878 &dv))
1879 return NULL;
1880 InsetRgn(rgn,
1881 dh,
1882 dv);
1883 Py_INCREF(Py_None);
1884 _res = Py_None;
1885 return _res;
1886}
1887
1888static PyObject *Qd_SectRgn(_self, _args)
1889 PyObject *_self;
1890 PyObject *_args;
1891{
1892 PyObject *_res = NULL;
1893 RgnHandle srcRgnA;
1894 RgnHandle srcRgnB;
1895 RgnHandle dstRgn;
1896 if (!PyArg_ParseTuple(_args, "O&O&O&",
1897 ResObj_Convert, &srcRgnA,
1898 ResObj_Convert, &srcRgnB,
1899 ResObj_Convert, &dstRgn))
1900 return NULL;
1901 SectRgn(srcRgnA,
1902 srcRgnB,
1903 dstRgn);
1904 Py_INCREF(Py_None);
1905 _res = Py_None;
1906 return _res;
1907}
1908
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1909static PyObject *Qd_MacUnionRgn(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1910 PyObject *_self;
1911 PyObject *_args;
1912{
1913 PyObject *_res = NULL;
1914 RgnHandle srcRgnA;
1915 RgnHandle srcRgnB;
1916 RgnHandle dstRgn;
1917 if (!PyArg_ParseTuple(_args, "O&O&O&",
1918 ResObj_Convert, &srcRgnA,
1919 ResObj_Convert, &srcRgnB,
1920 ResObj_Convert, &dstRgn))
1921 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1922 MacUnionRgn(srcRgnA,
1923 srcRgnB,
1924 dstRgn);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1925 Py_INCREF(Py_None);
1926 _res = Py_None;
1927 return _res;
1928}
1929
1930static PyObject *Qd_DiffRgn(_self, _args)
1931 PyObject *_self;
1932 PyObject *_args;
1933{
1934 PyObject *_res = NULL;
1935 RgnHandle srcRgnA;
1936 RgnHandle srcRgnB;
1937 RgnHandle dstRgn;
1938 if (!PyArg_ParseTuple(_args, "O&O&O&",
1939 ResObj_Convert, &srcRgnA,
1940 ResObj_Convert, &srcRgnB,
1941 ResObj_Convert, &dstRgn))
1942 return NULL;
1943 DiffRgn(srcRgnA,
1944 srcRgnB,
1945 dstRgn);
1946 Py_INCREF(Py_None);
1947 _res = Py_None;
1948 return _res;
1949}
1950
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1951static PyObject *Qd_MacXorRgn(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1952 PyObject *_self;
1953 PyObject *_args;
1954{
1955 PyObject *_res = NULL;
1956 RgnHandle srcRgnA;
1957 RgnHandle srcRgnB;
1958 RgnHandle dstRgn;
1959 if (!PyArg_ParseTuple(_args, "O&O&O&",
1960 ResObj_Convert, &srcRgnA,
1961 ResObj_Convert, &srcRgnB,
1962 ResObj_Convert, &dstRgn))
1963 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1964 MacXorRgn(srcRgnA,
1965 srcRgnB,
1966 dstRgn);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1967 Py_INCREF(Py_None);
1968 _res = Py_None;
1969 return _res;
1970}
1971
1972static PyObject *Qd_RectInRgn(_self, _args)
1973 PyObject *_self;
1974 PyObject *_args;
1975{
1976 PyObject *_res = NULL;
1977 Boolean _rv;
1978 Rect r;
1979 RgnHandle rgn;
1980 if (!PyArg_ParseTuple(_args, "O&O&",
1981 PyMac_GetRect, &r,
1982 ResObj_Convert, &rgn))
1983 return NULL;
1984 _rv = RectInRgn(&r,
1985 rgn);
1986 _res = Py_BuildValue("b",
1987 _rv);
1988 return _res;
1989}
1990
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]1991static PyObject *Qd_MacEqualRgn(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]1992 PyObject *_self;
1993 PyObject *_args;
1994{
1995 PyObject *_res = NULL;
1996 Boolean _rv;
1997 RgnHandle rgnA;
1998 RgnHandle rgnB;
1999 if (!PyArg_ParseTuple(_args, "O&O&",
2000 ResObj_Convert, &rgnA,
2001 ResObj_Convert, &rgnB))
2002 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2003 _rv = MacEqualRgn(rgnA,
2004 rgnB);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2005 _res = Py_BuildValue("b",
2006 _rv);
2007 return _res;
2008}
2009
2010static PyObject *Qd_EmptyRgn(_self, _args)
2011 PyObject *_self;
2012 PyObject *_args;
2013{
2014 PyObject *_res = NULL;
2015 Boolean _rv;
2016 RgnHandle rgn;
2017 if (!PyArg_ParseTuple(_args, "O&",
2018 ResObj_Convert, &rgn))
2019 return NULL;
2020 _rv = EmptyRgn(rgn);
2021 _res = Py_BuildValue("b",
2022 _rv);
2023 return _res;
2024}
2025
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2026static PyObject *Qd_MacFrameRgn(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2027 PyObject *_self;
2028 PyObject *_args;
2029{
2030 PyObject *_res = NULL;
2031 RgnHandle rgn;
2032 if (!PyArg_ParseTuple(_args, "O&",
2033 ResObj_Convert, &rgn))
2034 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2035 MacFrameRgn(rgn);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2036 Py_INCREF(Py_None);
2037 _res = Py_None;
2038 return _res;
2039}
2040
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2041static PyObject *Qd_MacPaintRgn(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2042 PyObject *_self;
2043 PyObject *_args;
2044{
2045 PyObject *_res = NULL;
2046 RgnHandle rgn;
2047 if (!PyArg_ParseTuple(_args, "O&",
2048 ResObj_Convert, &rgn))
2049 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2050 MacPaintRgn(rgn);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2051 Py_INCREF(Py_None);
2052 _res = Py_None;
2053 return _res;
2054}
2055
2056static PyObject *Qd_EraseRgn(_self, _args)
2057 PyObject *_self;
2058 PyObject *_args;
2059{
2060 PyObject *_res = NULL;
2061 RgnHandle rgn;
2062 if (!PyArg_ParseTuple(_args, "O&",
2063 ResObj_Convert, &rgn))
2064 return NULL;
2065 EraseRgn(rgn);
2066 Py_INCREF(Py_None);
2067 _res = Py_None;
2068 return _res;
2069}
2070
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2071static PyObject *Qd_MacInvertRgn(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2072 PyObject *_self;
2073 PyObject *_args;
2074{
2075 PyObject *_res = NULL;
2076 RgnHandle rgn;
2077 if (!PyArg_ParseTuple(_args, "O&",
2078 ResObj_Convert, &rgn))
2079 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2080 MacInvertRgn(rgn);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2081 Py_INCREF(Py_None);
2082 _res = Py_None;
2083 return _res;
2084}
2085
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2086static PyObject *Qd_MacFillRgn(_self, _args)
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]2087 PyObject *_self;
2088 PyObject *_args;
2089{
2090 PyObject *_res = NULL;
2091 RgnHandle rgn;
2092 Pattern *pat__in__;
2093 int pat__in_len__;
2094 if (!PyArg_ParseTuple(_args, "O&s#",
2095 ResObj_Convert, &rgn,
2096 (char **)&pat__in__, &pat__in_len__))
2097 return NULL;
2098 if (pat__in_len__ != sizeof(Pattern))
2099 {
2100 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
2101 goto pat__error__;
2102 }
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2103 MacFillRgn(rgn,
2104 pat__in__);
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]2105 Py_INCREF(Py_None);
2106 _res = Py_None;
2107 pat__error__: ;
2108 return _res;
2109}
2110
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2111static PyObject *Qd_ScrollRect(_self, _args)
2112 PyObject *_self;
2113 PyObject *_args;
2114{
2115 PyObject *_res = NULL;
2116 Rect r;
2117 short dh;
2118 short dv;
2119 RgnHandle updateRgn;
2120 if (!PyArg_ParseTuple(_args, "O&hhO&",
2121 PyMac_GetRect, &r,
2122 &dh,
2123 &dv,
2124 ResObj_Convert, &updateRgn))
2125 return NULL;
2126 ScrollRect(&r,
2127 dh,
2128 dv,
2129 updateRgn);
2130 Py_INCREF(Py_None);
2131 _res = Py_None;
2132 return _res;
2133}
2134
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]2135static PyObject *Qd_CopyBits(_self, _args)
2136 PyObject *_self;
2137 PyObject *_args;
2138{
2139 PyObject *_res = NULL;
2140 BitMapPtr srcBits;
2141 BitMapPtr dstBits;
2142 Rect srcRect;
2143 Rect dstRect;
2144 short mode;
2145 RgnHandle maskRgn;
2146 if (!PyArg_ParseTuple(_args, "O&O&O&O&hO&",
2147 BMObj_Convert, &srcBits,
2148 BMObj_Convert, &dstBits,
2149 PyMac_GetRect, &srcRect,
2150 PyMac_GetRect, &dstRect,
2151 &mode,
Jack Jansen425e9eb1995-12-12 15:02:03 +0000[diff] [blame]2152 OptResObj_Convert, &maskRgn))
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]2153 return NULL;
2154 CopyBits(srcBits,
2155 dstBits,
2156 &srcRect,
2157 &dstRect,
2158 mode,
2159 maskRgn);
2160 Py_INCREF(Py_None);
2161 _res = Py_None;
2162 return _res;
2163}
2164
2165static PyObject *Qd_CopyMask(_self, _args)
2166 PyObject *_self;
2167 PyObject *_args;
2168{
2169 PyObject *_res = NULL;
2170 BitMapPtr srcBits;
2171 BitMapPtr maskBits;
2172 BitMapPtr dstBits;
2173 Rect srcRect;
2174 Rect maskRect;
2175 Rect dstRect;
2176 if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&",
2177 BMObj_Convert, &srcBits,
2178 BMObj_Convert, &maskBits,
2179 BMObj_Convert, &dstBits,
2180 PyMac_GetRect, &srcRect,
2181 PyMac_GetRect, &maskRect,
2182 PyMac_GetRect, &dstRect))
2183 return NULL;
2184 CopyMask(srcBits,
2185 maskBits,
2186 dstBits,
2187 &srcRect,
2188 &maskRect,
2189 &dstRect);
2190 Py_INCREF(Py_None);
2191 _res = Py_None;
2192 return _res;
2193}
2194
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2195static PyObject *Qd_OpenPicture(_self, _args)
2196 PyObject *_self;
2197 PyObject *_args;
2198{
2199 PyObject *_res = NULL;
2200 PicHandle _rv;
2201 Rect picFrame;
2202 if (!PyArg_ParseTuple(_args, "O&",
2203 PyMac_GetRect, &picFrame))
2204 return NULL;
2205 _rv = OpenPicture(&picFrame);
2206 _res = Py_BuildValue("O&",
2207 ResObj_New, _rv);
2208 return _res;
2209}
2210
2211static PyObject *Qd_PicComment(_self, _args)
2212 PyObject *_self;
2213 PyObject *_args;
2214{
2215 PyObject *_res = NULL;
2216 short kind;
2217 short dataSize;
2218 Handle dataHandle;
2219 if (!PyArg_ParseTuple(_args, "hhO&",
2220 &kind,
2221 &dataSize,
2222 ResObj_Convert, &dataHandle))
2223 return NULL;
2224 PicComment(kind,
2225 dataSize,
2226 dataHandle);
2227 Py_INCREF(Py_None);
2228 _res = Py_None;
2229 return _res;
2230}
2231
2232static PyObject *Qd_ClosePicture(_self, _args)
2233 PyObject *_self;
2234 PyObject *_args;
2235{
2236 PyObject *_res = NULL;
2237 if (!PyArg_ParseTuple(_args, ""))
2238 return NULL;
2239 ClosePicture();
2240 Py_INCREF(Py_None);
2241 _res = Py_None;
2242 return _res;
2243}
2244
2245static PyObject *Qd_DrawPicture(_self, _args)
2246 PyObject *_self;
2247 PyObject *_args;
2248{
2249 PyObject *_res = NULL;
2250 PicHandle myPicture;
2251 Rect dstRect;
2252 if (!PyArg_ParseTuple(_args, "O&O&",
2253 ResObj_Convert, &myPicture,
2254 PyMac_GetRect, &dstRect))
2255 return NULL;
2256 DrawPicture(myPicture,
2257 &dstRect);
2258 Py_INCREF(Py_None);
2259 _res = Py_None;
2260 return _res;
2261}
2262
2263static PyObject *Qd_KillPicture(_self, _args)
2264 PyObject *_self;
2265 PyObject *_args;
2266{
2267 PyObject *_res = NULL;
2268 PicHandle myPicture;
2269 if (!PyArg_ParseTuple(_args, "O&",
2270 ResObj_Convert, &myPicture))
2271 return NULL;
2272 KillPicture(myPicture);
2273 Py_INCREF(Py_None);
2274 _res = Py_None;
2275 return _res;
2276}
2277
2278static PyObject *Qd_OpenPoly(_self, _args)
2279 PyObject *_self;
2280 PyObject *_args;
2281{
2282 PyObject *_res = NULL;
2283 PolyHandle _rv;
2284 if (!PyArg_ParseTuple(_args, ""))
2285 return NULL;
2286 _rv = OpenPoly();
2287 _res = Py_BuildValue("O&",
2288 ResObj_New, _rv);
2289 return _res;
2290}
2291
2292static PyObject *Qd_ClosePoly(_self, _args)
2293 PyObject *_self;
2294 PyObject *_args;
2295{
2296 PyObject *_res = NULL;
2297 if (!PyArg_ParseTuple(_args, ""))
2298 return NULL;
2299 ClosePoly();
2300 Py_INCREF(Py_None);
2301 _res = Py_None;
2302 return _res;
2303}
2304
2305static PyObject *Qd_KillPoly(_self, _args)
2306 PyObject *_self;
2307 PyObject *_args;
2308{
2309 PyObject *_res = NULL;
2310 PolyHandle poly;
2311 if (!PyArg_ParseTuple(_args, "O&",
2312 ResObj_Convert, &poly))
2313 return NULL;
2314 KillPoly(poly);
2315 Py_INCREF(Py_None);
2316 _res = Py_None;
2317 return _res;
2318}
2319
2320static PyObject *Qd_OffsetPoly(_self, _args)
2321 PyObject *_self;
2322 PyObject *_args;
2323{
2324 PyObject *_res = NULL;
2325 PolyHandle poly;
2326 short dh;
2327 short dv;
2328 if (!PyArg_ParseTuple(_args, "O&hh",
2329 ResObj_Convert, &poly,
2330 &dh,
2331 &dv))
2332 return NULL;
2333 OffsetPoly(poly,
2334 dh,
2335 dv);
2336 Py_INCREF(Py_None);
2337 _res = Py_None;
2338 return _res;
2339}
2340
2341static PyObject *Qd_FramePoly(_self, _args)
2342 PyObject *_self;
2343 PyObject *_args;
2344{
2345 PyObject *_res = NULL;
2346 PolyHandle poly;
2347 if (!PyArg_ParseTuple(_args, "O&",
2348 ResObj_Convert, &poly))
2349 return NULL;
2350 FramePoly(poly);
2351 Py_INCREF(Py_None);
2352 _res = Py_None;
2353 return _res;
2354}
2355
2356static PyObject *Qd_PaintPoly(_self, _args)
2357 PyObject *_self;
2358 PyObject *_args;
2359{
2360 PyObject *_res = NULL;
2361 PolyHandle poly;
2362 if (!PyArg_ParseTuple(_args, "O&",
2363 ResObj_Convert, &poly))
2364 return NULL;
2365 PaintPoly(poly);
2366 Py_INCREF(Py_None);
2367 _res = Py_None;
2368 return _res;
2369}
2370
2371static PyObject *Qd_ErasePoly(_self, _args)
2372 PyObject *_self;
2373 PyObject *_args;
2374{
2375 PyObject *_res = NULL;
2376 PolyHandle poly;
2377 if (!PyArg_ParseTuple(_args, "O&",
2378 ResObj_Convert, &poly))
2379 return NULL;
2380 ErasePoly(poly);
2381 Py_INCREF(Py_None);
2382 _res = Py_None;
2383 return _res;
2384}
2385
2386static PyObject *Qd_InvertPoly(_self, _args)
2387 PyObject *_self;
2388 PyObject *_args;
2389{
2390 PyObject *_res = NULL;
2391 PolyHandle poly;
2392 if (!PyArg_ParseTuple(_args, "O&",
2393 ResObj_Convert, &poly))
2394 return NULL;
2395 InvertPoly(poly);
2396 Py_INCREF(Py_None);
2397 _res = Py_None;
2398 return _res;
2399}
2400
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]2401static PyObject *Qd_FillPoly(_self, _args)
2402 PyObject *_self;
2403 PyObject *_args;
2404{
2405 PyObject *_res = NULL;
2406 PolyHandle poly;
2407 Pattern *pat__in__;
2408 int pat__in_len__;
2409 if (!PyArg_ParseTuple(_args, "O&s#",
2410 ResObj_Convert, &poly,
2411 (char **)&pat__in__, &pat__in_len__))
2412 return NULL;
2413 if (pat__in_len__ != sizeof(Pattern))
2414 {
2415 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
2416 goto pat__error__;
2417 }
2418 FillPoly(poly,
2419 pat__in__);
2420 Py_INCREF(Py_None);
2421 _res = Py_None;
2422 pat__error__: ;
2423 return _res;
2424}
2425
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2426static PyObject *Qd_SetPt(_self, _args)
2427 PyObject *_self;
2428 PyObject *_args;
2429{
2430 PyObject *_res = NULL;
2431 Point pt;
2432 short h;
2433 short v;
Jack Jansen1d8ede71996-01-08 23:47:31 +0000[diff] [blame]2434 if (!PyArg_ParseTuple(_args, "hh",
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2435 &h,
2436 &v))
2437 return NULL;
2438 SetPt(&pt,
2439 h,
2440 v);
2441 _res = Py_BuildValue("O&",
2442 PyMac_BuildPoint, pt);
2443 return _res;
2444}
2445
2446static PyObject *Qd_LocalToGlobal(_self, _args)
2447 PyObject *_self;
2448 PyObject *_args;
2449{
2450 PyObject *_res = NULL;
2451 Point pt;
2452 if (!PyArg_ParseTuple(_args, "O&",
2453 PyMac_GetPoint, &pt))
2454 return NULL;
2455 LocalToGlobal(&pt);
2456 _res = Py_BuildValue("O&",
2457 PyMac_BuildPoint, pt);
2458 return _res;
2459}
2460
2461static PyObject *Qd_GlobalToLocal(_self, _args)
2462 PyObject *_self;
2463 PyObject *_args;
2464{
2465 PyObject *_res = NULL;
2466 Point pt;
2467 if (!PyArg_ParseTuple(_args, "O&",
2468 PyMac_GetPoint, &pt))
2469 return NULL;
2470 GlobalToLocal(&pt);
2471 _res = Py_BuildValue("O&",
2472 PyMac_BuildPoint, pt);
2473 return _res;
2474}
2475
2476static PyObject *Qd_Random(_self, _args)
2477 PyObject *_self;
2478 PyObject *_args;
2479{
2480 PyObject *_res = NULL;
2481 short _rv;
2482 if (!PyArg_ParseTuple(_args, ""))
2483 return NULL;
2484 _rv = Random();
2485 _res = Py_BuildValue("h",
2486 _rv);
2487 return _res;
2488}
2489
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2490static PyObject *Qd_MacGetPixel(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2491 PyObject *_self;
2492 PyObject *_args;
2493{
2494 PyObject *_res = NULL;
2495 Boolean _rv;
2496 short h;
2497 short v;
2498 if (!PyArg_ParseTuple(_args, "hh",
2499 &h,
2500 &v))
2501 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2502 _rv = MacGetPixel(h,
2503 v);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2504 _res = Py_BuildValue("b",
2505 _rv);
2506 return _res;
2507}
2508
2509static PyObject *Qd_ScalePt(_self, _args)
2510 PyObject *_self;
2511 PyObject *_args;
2512{
2513 PyObject *_res = NULL;
2514 Point pt;
2515 Rect srcRect;
2516 Rect dstRect;
2517 if (!PyArg_ParseTuple(_args, "O&O&O&",
2518 PyMac_GetPoint, &pt,
2519 PyMac_GetRect, &srcRect,
2520 PyMac_GetRect, &dstRect))
2521 return NULL;
2522 ScalePt(&pt,
2523 &srcRect,
2524 &dstRect);
2525 _res = Py_BuildValue("O&",
2526 PyMac_BuildPoint, pt);
2527 return _res;
2528}
2529
2530static PyObject *Qd_MapPt(_self, _args)
2531 PyObject *_self;
2532 PyObject *_args;
2533{
2534 PyObject *_res = NULL;
2535 Point pt;
2536 Rect srcRect;
2537 Rect dstRect;
2538 if (!PyArg_ParseTuple(_args, "O&O&O&",
2539 PyMac_GetPoint, &pt,
2540 PyMac_GetRect, &srcRect,
2541 PyMac_GetRect, &dstRect))
2542 return NULL;
2543 MapPt(&pt,
2544 &srcRect,
2545 &dstRect);
2546 _res = Py_BuildValue("O&",
2547 PyMac_BuildPoint, pt);
2548 return _res;
2549}
2550
2551static PyObject *Qd_MapRect(_self, _args)
2552 PyObject *_self;
2553 PyObject *_args;
2554{
2555 PyObject *_res = NULL;
2556 Rect r;
2557 Rect srcRect;
2558 Rect dstRect;
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]2559 if (!PyArg_ParseTuple(_args, "O&O&O&",
2560 PyMac_GetRect, &r,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2561 PyMac_GetRect, &srcRect,
2562 PyMac_GetRect, &dstRect))
2563 return NULL;
2564 MapRect(&r,
2565 &srcRect,
2566 &dstRect);
2567 _res = Py_BuildValue("O&",
2568 PyMac_BuildRect, &r);
2569 return _res;
2570}
2571
2572static PyObject *Qd_MapRgn(_self, _args)
2573 PyObject *_self;
2574 PyObject *_args;
2575{
2576 PyObject *_res = NULL;
2577 RgnHandle rgn;
2578 Rect srcRect;
2579 Rect dstRect;
2580 if (!PyArg_ParseTuple(_args, "O&O&O&",
2581 ResObj_Convert, &rgn,
2582 PyMac_GetRect, &srcRect,
2583 PyMac_GetRect, &dstRect))
2584 return NULL;
2585 MapRgn(rgn,
2586 &srcRect,
2587 &dstRect);
2588 Py_INCREF(Py_None);
2589 _res = Py_None;
2590 return _res;
2591}
2592
2593static PyObject *Qd_MapPoly(_self, _args)
2594 PyObject *_self;
2595 PyObject *_args;
2596{
2597 PyObject *_res = NULL;
2598 PolyHandle poly;
2599 Rect srcRect;
2600 Rect dstRect;
2601 if (!PyArg_ParseTuple(_args, "O&O&O&",
2602 ResObj_Convert, &poly,
2603 PyMac_GetRect, &srcRect,
2604 PyMac_GetRect, &dstRect))
2605 return NULL;
2606 MapPoly(poly,
2607 &srcRect,
2608 &dstRect);
2609 Py_INCREF(Py_None);
2610 _res = Py_None;
2611 return _res;
2612}
2613
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]2614static PyObject *Qd_StdBits(_self, _args)
2615 PyObject *_self;
2616 PyObject *_args;
2617{
2618 PyObject *_res = NULL;
2619 BitMapPtr srcBits;
2620 Rect srcRect;
2621 Rect dstRect;
2622 short mode;
2623 RgnHandle maskRgn;
2624 if (!PyArg_ParseTuple(_args, "O&O&O&hO&",
2625 BMObj_Convert, &srcBits,
2626 PyMac_GetRect, &srcRect,
2627 PyMac_GetRect, &dstRect,
2628 &mode,
Jack Jansen425e9eb1995-12-12 15:02:03 +0000[diff] [blame]2629 OptResObj_Convert, &maskRgn))
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]2630 return NULL;
2631 StdBits(srcBits,
2632 &srcRect,
2633 &dstRect,
2634 mode,
2635 maskRgn);
2636 Py_INCREF(Py_None);
2637 _res = Py_None;
2638 return _res;
2639}
2640
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2641static PyObject *Qd_AddPt(_self, _args)
2642 PyObject *_self;
2643 PyObject *_args;
2644{
2645 PyObject *_res = NULL;
2646 Point src;
2647 Point dst;
2648 if (!PyArg_ParseTuple(_args, "O&O&",
2649 PyMac_GetPoint, &src,
2650 PyMac_GetPoint, &dst))
2651 return NULL;
2652 AddPt(src,
2653 &dst);
2654 _res = Py_BuildValue("O&",
2655 PyMac_BuildPoint, dst);
2656 return _res;
2657}
2658
2659static PyObject *Qd_EqualPt(_self, _args)
2660 PyObject *_self;
2661 PyObject *_args;
2662{
2663 PyObject *_res = NULL;
2664 Boolean _rv;
2665 Point pt1;
2666 Point pt2;
2667 if (!PyArg_ParseTuple(_args, "O&O&",
2668 PyMac_GetPoint, &pt1,
2669 PyMac_GetPoint, &pt2))
2670 return NULL;
2671 _rv = EqualPt(pt1,
2672 pt2);
2673 _res = Py_BuildValue("b",
2674 _rv);
2675 return _res;
2676}
2677
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2678static PyObject *Qd_MacPtInRect(_self, _args)
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2679 PyObject *_self;
2680 PyObject *_args;
2681{
2682 PyObject *_res = NULL;
2683 Boolean _rv;
2684 Point pt;
2685 Rect r;
2686 if (!PyArg_ParseTuple(_args, "O&O&",
2687 PyMac_GetPoint, &pt,
2688 PyMac_GetRect, &r))
2689 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]2690 _rv = MacPtInRect(pt,
2691 &r);
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2692 _res = Py_BuildValue("b",
2693 _rv);
2694 return _res;
2695}
2696
2697static PyObject *Qd_Pt2Rect(_self, _args)
2698 PyObject *_self;
2699 PyObject *_args;
2700{
2701 PyObject *_res = NULL;
2702 Point pt1;
2703 Point pt2;
2704 Rect dstRect;
2705 if (!PyArg_ParseTuple(_args, "O&O&",
2706 PyMac_GetPoint, &pt1,
2707 PyMac_GetPoint, &pt2))
2708 return NULL;
2709 Pt2Rect(pt1,
2710 pt2,
2711 &dstRect);
2712 _res = Py_BuildValue("O&",
2713 PyMac_BuildRect, &dstRect);
2714 return _res;
2715}
2716
2717static PyObject *Qd_PtToAngle(_self, _args)
2718 PyObject *_self;
2719 PyObject *_args;
2720{
2721 PyObject *_res = NULL;
2722 Rect r;
2723 Point pt;
2724 short angle;
2725 if (!PyArg_ParseTuple(_args, "O&O&",
2726 PyMac_GetRect, &r,
2727 PyMac_GetPoint, &pt))
2728 return NULL;
2729 PtToAngle(&r,
2730 pt,
2731 &angle);
2732 _res = Py_BuildValue("h",
2733 angle);
2734 return _res;
2735}
2736
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]2737static PyObject *Qd_SubPt(_self, _args)
2738 PyObject *_self;
2739 PyObject *_args;
2740{
2741 PyObject *_res = NULL;
2742 Point src;
2743 Point dst;
2744 if (!PyArg_ParseTuple(_args, "O&O&",
2745 PyMac_GetPoint, &src,
2746 PyMac_GetPoint, &dst))
2747 return NULL;
2748 SubPt(src,
2749 &dst);
2750 _res = Py_BuildValue("O&",
2751 PyMac_BuildPoint, dst);
2752 return _res;
2753}
2754
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2755static PyObject *Qd_PtInRgn(_self, _args)
2756 PyObject *_self;
2757 PyObject *_args;
2758{
2759 PyObject *_res = NULL;
2760 Boolean _rv;
2761 Point pt;
2762 RgnHandle rgn;
2763 if (!PyArg_ParseTuple(_args, "O&O&",
2764 PyMac_GetPoint, &pt,
2765 ResObj_Convert, &rgn))
2766 return NULL;
2767 _rv = PtInRgn(pt,
2768 rgn);
2769 _res = Py_BuildValue("b",
2770 _rv);
2771 return _res;
2772}
2773
2774static PyObject *Qd_NewPixMap(_self, _args)
2775 PyObject *_self;
2776 PyObject *_args;
2777{
2778 PyObject *_res = NULL;
2779 PixMapHandle _rv;
2780 if (!PyArg_ParseTuple(_args, ""))
2781 return NULL;
2782 _rv = NewPixMap();
2783 _res = Py_BuildValue("O&",
2784 ResObj_New, _rv);
2785 return _res;
2786}
2787
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2788static PyObject *Qd_DisposePixMap(_self, _args)
2789 PyObject *_self;
2790 PyObject *_args;
2791{
2792 PyObject *_res = NULL;
2793 PixMapHandle pm;
2794 if (!PyArg_ParseTuple(_args, "O&",
2795 ResObj_Convert, &pm))
2796 return NULL;
2797 DisposePixMap(pm);
2798 Py_INCREF(Py_None);
2799 _res = Py_None;
2800 return _res;
2801}
2802
2803static PyObject *Qd_CopyPixMap(_self, _args)
2804 PyObject *_self;
2805 PyObject *_args;
2806{
2807 PyObject *_res = NULL;
2808 PixMapHandle srcPM;
2809 PixMapHandle dstPM;
2810 if (!PyArg_ParseTuple(_args, "O&O&",
2811 ResObj_Convert, &srcPM,
2812 ResObj_Convert, &dstPM))
2813 return NULL;
2814 CopyPixMap(srcPM,
2815 dstPM);
2816 Py_INCREF(Py_None);
2817 _res = Py_None;
2818 return _res;
2819}
2820
2821static PyObject *Qd_NewPixPat(_self, _args)
2822 PyObject *_self;
2823 PyObject *_args;
2824{
2825 PyObject *_res = NULL;
2826 PixPatHandle _rv;
2827 if (!PyArg_ParseTuple(_args, ""))
2828 return NULL;
2829 _rv = NewPixPat();
2830 _res = Py_BuildValue("O&",
2831 ResObj_New, _rv);
2832 return _res;
2833}
2834
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2835static PyObject *Qd_DisposePixPat(_self, _args)
2836 PyObject *_self;
2837 PyObject *_args;
2838{
2839 PyObject *_res = NULL;
2840 PixPatHandle pp;
2841 if (!PyArg_ParseTuple(_args, "O&",
2842 ResObj_Convert, &pp))
2843 return NULL;
2844 DisposePixPat(pp);
2845 Py_INCREF(Py_None);
2846 _res = Py_None;
2847 return _res;
2848}
2849
2850static PyObject *Qd_CopyPixPat(_self, _args)
2851 PyObject *_self;
2852 PyObject *_args;
2853{
2854 PyObject *_res = NULL;
2855 PixPatHandle srcPP;
2856 PixPatHandle dstPP;
2857 if (!PyArg_ParseTuple(_args, "O&O&",
2858 ResObj_Convert, &srcPP,
2859 ResObj_Convert, &dstPP))
2860 return NULL;
2861 CopyPixPat(srcPP,
2862 dstPP);
2863 Py_INCREF(Py_None);
2864 _res = Py_None;
2865 return _res;
2866}
2867
2868static PyObject *Qd_PenPixPat(_self, _args)
2869 PyObject *_self;
2870 PyObject *_args;
2871{
2872 PyObject *_res = NULL;
2873 PixPatHandle pp;
2874 if (!PyArg_ParseTuple(_args, "O&",
2875 ResObj_Convert, &pp))
2876 return NULL;
2877 PenPixPat(pp);
2878 Py_INCREF(Py_None);
2879 _res = Py_None;
2880 return _res;
2881}
2882
2883static PyObject *Qd_BackPixPat(_self, _args)
2884 PyObject *_self;
2885 PyObject *_args;
2886{
2887 PyObject *_res = NULL;
2888 PixPatHandle pp;
2889 if (!PyArg_ParseTuple(_args, "O&",
2890 ResObj_Convert, &pp))
2891 return NULL;
2892 BackPixPat(pp);
2893 Py_INCREF(Py_None);
2894 _res = Py_None;
2895 return _res;
2896}
2897
2898static PyObject *Qd_GetPixPat(_self, _args)
2899 PyObject *_self;
2900 PyObject *_args;
2901{
2902 PyObject *_res = NULL;
2903 PixPatHandle _rv;
2904 short patID;
2905 if (!PyArg_ParseTuple(_args, "h",
2906 &patID))
2907 return NULL;
2908 _rv = GetPixPat(patID);
2909 _res = Py_BuildValue("O&",
2910 ResObj_New, _rv);
2911 return _res;
2912}
2913
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]2914static PyObject *Qd_MakeRGBPat(_self, _args)
2915 PyObject *_self;
2916 PyObject *_args;
2917{
2918 PyObject *_res = NULL;
2919 PixPatHandle pp;
2920 RGBColor myColor;
2921 if (!PyArg_ParseTuple(_args, "O&O&",
2922 ResObj_Convert, &pp,
2923 QdRGB_Convert, &myColor))
2924 return NULL;
2925 MakeRGBPat(pp,
2926 &myColor);
2927 Py_INCREF(Py_None);
2928 _res = Py_None;
2929 return _res;
2930}
2931
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]2932static PyObject *Qd_FillCRect(_self, _args)
2933 PyObject *_self;
2934 PyObject *_args;
2935{
2936 PyObject *_res = NULL;
2937 Rect r;
2938 PixPatHandle pp;
2939 if (!PyArg_ParseTuple(_args, "O&O&",
2940 PyMac_GetRect, &r,
2941 ResObj_Convert, &pp))
2942 return NULL;
2943 FillCRect(&r,
2944 pp);
2945 Py_INCREF(Py_None);
2946 _res = Py_None;
2947 return _res;
2948}
2949
2950static PyObject *Qd_FillCOval(_self, _args)
2951 PyObject *_self;
2952 PyObject *_args;
2953{
2954 PyObject *_res = NULL;
2955 Rect r;
2956 PixPatHandle pp;
2957 if (!PyArg_ParseTuple(_args, "O&O&",
2958 PyMac_GetRect, &r,
2959 ResObj_Convert, &pp))
2960 return NULL;
2961 FillCOval(&r,
2962 pp);
2963 Py_INCREF(Py_None);
2964 _res = Py_None;
2965 return _res;
2966}
2967
2968static PyObject *Qd_FillCRoundRect(_self, _args)
2969 PyObject *_self;
2970 PyObject *_args;
2971{
2972 PyObject *_res = NULL;
2973 Rect r;
2974 short ovalWidth;
2975 short ovalHeight;
2976 PixPatHandle pp;
2977 if (!PyArg_ParseTuple(_args, "O&hhO&",
2978 PyMac_GetRect, &r,
2979 &ovalWidth,
2980 &ovalHeight,
2981 ResObj_Convert, &pp))
2982 return NULL;
2983 FillCRoundRect(&r,
2984 ovalWidth,
2985 ovalHeight,
2986 pp);
2987 Py_INCREF(Py_None);
2988 _res = Py_None;
2989 return _res;
2990}
2991
2992static PyObject *Qd_FillCArc(_self, _args)
2993 PyObject *_self;
2994 PyObject *_args;
2995{
2996 PyObject *_res = NULL;
2997 Rect r;
2998 short startAngle;
2999 short arcAngle;
3000 PixPatHandle pp;
3001 if (!PyArg_ParseTuple(_args, "O&hhO&",
3002 PyMac_GetRect, &r,
3003 &startAngle,
3004 &arcAngle,
3005 ResObj_Convert, &pp))
3006 return NULL;
3007 FillCArc(&r,
3008 startAngle,
3009 arcAngle,
3010 pp);
3011 Py_INCREF(Py_None);
3012 _res = Py_None;
3013 return _res;
3014}
3015
3016static PyObject *Qd_FillCRgn(_self, _args)
3017 PyObject *_self;
3018 PyObject *_args;
3019{
3020 PyObject *_res = NULL;
3021 RgnHandle rgn;
3022 PixPatHandle pp;
3023 if (!PyArg_ParseTuple(_args, "O&O&",
3024 ResObj_Convert, &rgn,
3025 ResObj_Convert, &pp))
3026 return NULL;
3027 FillCRgn(rgn,
3028 pp);
3029 Py_INCREF(Py_None);
3030 _res = Py_None;
3031 return _res;
3032}
3033
3034static PyObject *Qd_FillCPoly(_self, _args)
3035 PyObject *_self;
3036 PyObject *_args;
3037{
3038 PyObject *_res = NULL;
3039 PolyHandle poly;
3040 PixPatHandle pp;
3041 if (!PyArg_ParseTuple(_args, "O&O&",
3042 ResObj_Convert, &poly,
3043 ResObj_Convert, &pp))
3044 return NULL;
3045 FillCPoly(poly,
3046 pp);
3047 Py_INCREF(Py_None);
3048 _res = Py_None;
3049 return _res;
3050}
3051
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]3052static PyObject *Qd_RGBForeColor(_self, _args)
3053 PyObject *_self;
3054 PyObject *_args;
3055{
3056 PyObject *_res = NULL;
3057 RGBColor color;
3058 if (!PyArg_ParseTuple(_args, "O&",
3059 QdRGB_Convert, &color))
3060 return NULL;
3061 RGBForeColor(&color);
3062 Py_INCREF(Py_None);
3063 _res = Py_None;
3064 return _res;
3065}
3066
3067static PyObject *Qd_RGBBackColor(_self, _args)
3068 PyObject *_self;
3069 PyObject *_args;
3070{
3071 PyObject *_res = NULL;
3072 RGBColor color;
3073 if (!PyArg_ParseTuple(_args, "O&",
3074 QdRGB_Convert, &color))
3075 return NULL;
3076 RGBBackColor(&color);
3077 Py_INCREF(Py_None);
3078 _res = Py_None;
3079 return _res;
3080}
3081
3082static PyObject *Qd_SetCPixel(_self, _args)
3083 PyObject *_self;
3084 PyObject *_args;
3085{
3086 PyObject *_res = NULL;
3087 short h;
3088 short v;
3089 RGBColor cPix;
3090 if (!PyArg_ParseTuple(_args, "hhO&",
3091 &h,
3092 &v,
3093 QdRGB_Convert, &cPix))
3094 return NULL;
3095 SetCPixel(h,
3096 v,
3097 &cPix);
3098 Py_INCREF(Py_None);
3099 _res = Py_None;
3100 return _res;
3101}
3102
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]3103static PyObject *Qd_SetPortPix(_self, _args)
3104 PyObject *_self;
3105 PyObject *_args;
3106{
3107 PyObject *_res = NULL;
3108 PixMapHandle pm;
3109 if (!PyArg_ParseTuple(_args, "O&",
3110 ResObj_Convert, &pm))
3111 return NULL;
3112 SetPortPix(pm);
3113 Py_INCREF(Py_None);
3114 _res = Py_None;
3115 return _res;
3116}
3117
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]3118static PyObject *Qd_GetCPixel(_self, _args)
3119 PyObject *_self;
3120 PyObject *_args;
3121{
3122 PyObject *_res = NULL;
3123 short h;
3124 short v;
3125 RGBColor cPix;
3126 if (!PyArg_ParseTuple(_args, "hh",
3127 &h,
3128 &v))
3129 return NULL;
3130 GetCPixel(h,
3131 v,
3132 &cPix);
3133 _res = Py_BuildValue("O&",
3134 QdRGB_New, &cPix);
3135 return _res;
3136}
3137
3138static PyObject *Qd_GetForeColor(_self, _args)
3139 PyObject *_self;
3140 PyObject *_args;
3141{
3142 PyObject *_res = NULL;
3143 RGBColor color;
3144 if (!PyArg_ParseTuple(_args, ""))
3145 return NULL;
3146 GetForeColor(&color);
3147 _res = Py_BuildValue("O&",
3148 QdRGB_New, &color);
3149 return _res;
3150}
3151
3152static PyObject *Qd_GetBackColor(_self, _args)
3153 PyObject *_self;
3154 PyObject *_args;
3155{
3156 PyObject *_res = NULL;
3157 RGBColor color;
3158 if (!PyArg_ParseTuple(_args, ""))
3159 return NULL;
3160 GetBackColor(&color);
3161 _res = Py_BuildValue("O&",
3162 QdRGB_New, &color);
3163 return _res;
3164}
3165
3166static PyObject *Qd_OpColor(_self, _args)
3167 PyObject *_self;
3168 PyObject *_args;
3169{
3170 PyObject *_res = NULL;
3171 RGBColor color;
3172 if (!PyArg_ParseTuple(_args, "O&",
3173 QdRGB_Convert, &color))
3174 return NULL;
3175 OpColor(&color);
3176 Py_INCREF(Py_None);
3177 _res = Py_None;
3178 return _res;
3179}
3180
3181static PyObject *Qd_HiliteColor(_self, _args)
3182 PyObject *_self;
3183 PyObject *_args;
3184{
3185 PyObject *_res = NULL;
3186 RGBColor color;
3187 if (!PyArg_ParseTuple(_args, "O&",
3188 QdRGB_Convert, &color))
3189 return NULL;
3190 HiliteColor(&color);
3191 Py_INCREF(Py_None);
3192 _res = Py_None;
3193 return _res;
3194}
3195
Jack Jansen69b43ed1997-08-15 14:35:54 +0000[diff] [blame]3196static PyObject *Qd_DisposeCTable(_self, _args)
3197 PyObject *_self;
3198 PyObject *_args;
3199{
3200 PyObject *_res = NULL;
3201 CTabHandle cTable;
3202 if (!PyArg_ParseTuple(_args, "O&",
3203 ResObj_Convert, &cTable))
3204 return NULL;
3205 DisposeCTable(cTable);
3206 Py_INCREF(Py_None);
3207 _res = Py_None;
3208 return _res;
3209}
3210
3211static PyObject *Qd_GetCTable(_self, _args)
3212 PyObject *_self;
3213 PyObject *_args;
3214{
3215 PyObject *_res = NULL;
3216 CTabHandle _rv;
3217 short ctID;
3218 if (!PyArg_ParseTuple(_args, "h",
3219 &ctID))
3220 return NULL;
3221 _rv = GetCTable(ctID);
3222 _res = Py_BuildValue("O&",
3223 ResObj_New, _rv);
3224 return _res;
3225}
3226
3227static PyObject *Qd_GetCCursor(_self, _args)
3228 PyObject *_self;
3229 PyObject *_args;
3230{
3231 PyObject *_res = NULL;
3232 CCrsrHandle _rv;
3233 short crsrID;
3234 if (!PyArg_ParseTuple(_args, "h",
3235 &crsrID))
3236 return NULL;
3237 _rv = GetCCursor(crsrID);
3238 _res = Py_BuildValue("O&",
3239 ResObj_New, _rv);
3240 return _res;
3241}
3242
3243static PyObject *Qd_SetCCursor(_self, _args)
3244 PyObject *_self;
3245 PyObject *_args;
3246{
3247 PyObject *_res = NULL;
3248 CCrsrHandle cCrsr;
3249 if (!PyArg_ParseTuple(_args, "O&",
3250 ResObj_Convert, &cCrsr))
3251 return NULL;
3252 SetCCursor(cCrsr);
3253 Py_INCREF(Py_None);
3254 _res = Py_None;
3255 return _res;
3256}
3257
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]3258static PyObject *Qd_AllocCursor(_self, _args)
3259 PyObject *_self;
3260 PyObject *_args;
3261{
3262 PyObject *_res = NULL;
3263 if (!PyArg_ParseTuple(_args, ""))
3264 return NULL;
3265 AllocCursor();
3266 Py_INCREF(Py_None);
3267 _res = Py_None;
3268 return _res;
3269}
3270
Jack Jansen69b43ed1997-08-15 14:35:54 +0000[diff] [blame]3271static PyObject *Qd_DisposeCCursor(_self, _args)
3272 PyObject *_self;
3273 PyObject *_args;
3274{
3275 PyObject *_res = NULL;
3276 CCrsrHandle cCrsr;
3277 if (!PyArg_ParseTuple(_args, "O&",
3278 ResObj_Convert, &cCrsr))
3279 return NULL;
3280 DisposeCCursor(cCrsr);
3281 Py_INCREF(Py_None);
3282 _res = Py_None;
3283 return _res;
3284}
3285
3286static PyObject *Qd_GetMaxDevice(_self, _args)
3287 PyObject *_self;
3288 PyObject *_args;
3289{
3290 PyObject *_res = NULL;
3291 GDHandle _rv;
3292 Rect globalRect;
3293 if (!PyArg_ParseTuple(_args, "O&",
3294 PyMac_GetRect, &globalRect))
3295 return NULL;
3296 _rv = GetMaxDevice(&globalRect);
3297 _res = Py_BuildValue("O&",
3298 ResObj_New, _rv);
3299 return _res;
3300}
3301
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]3302static PyObject *Qd_GetCTSeed(_self, _args)
3303 PyObject *_self;
3304 PyObject *_args;
3305{
3306 PyObject *_res = NULL;
3307 long _rv;
3308 if (!PyArg_ParseTuple(_args, ""))
3309 return NULL;
3310 _rv = GetCTSeed();
3311 _res = Py_BuildValue("l",
3312 _rv);
3313 return _res;
3314}
3315
Jack Jansen69b43ed1997-08-15 14:35:54 +0000[diff] [blame]3316static PyObject *Qd_GetDeviceList(_self, _args)
3317 PyObject *_self;
3318 PyObject *_args;
3319{
3320 PyObject *_res = NULL;
3321 GDHandle _rv;
3322 if (!PyArg_ParseTuple(_args, ""))
3323 return NULL;
3324 _rv = GetDeviceList();
3325 _res = Py_BuildValue("O&",
3326 ResObj_New, _rv);
3327 return _res;
3328}
3329
3330static PyObject *Qd_GetMainDevice(_self, _args)
3331 PyObject *_self;
3332 PyObject *_args;
3333{
3334 PyObject *_res = NULL;
3335 GDHandle _rv;
3336 if (!PyArg_ParseTuple(_args, ""))
3337 return NULL;
3338 _rv = GetMainDevice();
3339 _res = Py_BuildValue("O&",
3340 ResObj_New, _rv);
3341 return _res;
3342}
3343
3344static PyObject *Qd_GetNextDevice(_self, _args)
3345 PyObject *_self;
3346 PyObject *_args;
3347{
3348 PyObject *_res = NULL;
3349 GDHandle _rv;
3350 GDHandle curDevice;
3351 if (!PyArg_ParseTuple(_args, "O&",
3352 ResObj_Convert, &curDevice))
3353 return NULL;
3354 _rv = GetNextDevice(curDevice);
3355 _res = Py_BuildValue("O&",
3356 ResObj_New, _rv);
3357 return _res;
3358}
3359
3360static PyObject *Qd_TestDeviceAttribute(_self, _args)
3361 PyObject *_self;
3362 PyObject *_args;
3363{
3364 PyObject *_res = NULL;
3365 Boolean _rv;
3366 GDHandle gdh;
3367 short attribute;
3368 if (!PyArg_ParseTuple(_args, "O&h",
3369 ResObj_Convert, &gdh,
3370 &attribute))
3371 return NULL;
3372 _rv = TestDeviceAttribute(gdh,
3373 attribute);
3374 _res = Py_BuildValue("b",
3375 _rv);
3376 return _res;
3377}
3378
3379static PyObject *Qd_SetDeviceAttribute(_self, _args)
3380 PyObject *_self;
3381 PyObject *_args;
3382{
3383 PyObject *_res = NULL;
3384 GDHandle gdh;
3385 short attribute;
3386 Boolean value;
3387 if (!PyArg_ParseTuple(_args, "O&hb",
3388 ResObj_Convert, &gdh,
3389 &attribute,
3390 &value))
3391 return NULL;
3392 SetDeviceAttribute(gdh,
3393 attribute,
3394 value);
3395 Py_INCREF(Py_None);
3396 _res = Py_None;
3397 return _res;
3398}
3399
3400static PyObject *Qd_InitGDevice(_self, _args)
3401 PyObject *_self;
3402 PyObject *_args;
3403{
3404 PyObject *_res = NULL;
3405 short qdRefNum;
3406 long mode;
3407 GDHandle gdh;
3408 if (!PyArg_ParseTuple(_args, "hlO&",
3409 &qdRefNum,
3410 &mode,
3411 ResObj_Convert, &gdh))
3412 return NULL;
3413 InitGDevice(qdRefNum,
3414 mode,
3415 gdh);
3416 Py_INCREF(Py_None);
3417 _res = Py_None;
3418 return _res;
3419}
3420
3421static PyObject *Qd_NewGDevice(_self, _args)
3422 PyObject *_self;
3423 PyObject *_args;
3424{
3425 PyObject *_res = NULL;
3426 GDHandle _rv;
3427 short refNum;
3428 long mode;
3429 if (!PyArg_ParseTuple(_args, "hl",
3430 &refNum,
3431 &mode))
3432 return NULL;
3433 _rv = NewGDevice(refNum,
3434 mode);
3435 _res = Py_BuildValue("O&",
3436 ResObj_New, _rv);
3437 return _res;
3438}
3439
3440static PyObject *Qd_DisposeGDevice(_self, _args)
3441 PyObject *_self;
3442 PyObject *_args;
3443{
3444 PyObject *_res = NULL;
3445 GDHandle gdh;
3446 if (!PyArg_ParseTuple(_args, "O&",
3447 ResObj_Convert, &gdh))
3448 return NULL;
3449 DisposeGDevice(gdh);
3450 Py_INCREF(Py_None);
3451 _res = Py_None;
3452 return _res;
3453}
3454
3455static PyObject *Qd_SetGDevice(_self, _args)
3456 PyObject *_self;
3457 PyObject *_args;
3458{
3459 PyObject *_res = NULL;
3460 GDHandle gd;
3461 if (!PyArg_ParseTuple(_args, "O&",
3462 ResObj_Convert, &gd))
3463 return NULL;
3464 SetGDevice(gd);
3465 Py_INCREF(Py_None);
3466 _res = Py_None;
3467 return _res;
3468}
3469
3470static PyObject *Qd_GetGDevice(_self, _args)
3471 PyObject *_self;
3472 PyObject *_args;
3473{
3474 PyObject *_res = NULL;
3475 GDHandle _rv;
3476 if (!PyArg_ParseTuple(_args, ""))
3477 return NULL;
3478 _rv = GetGDevice();
3479 _res = Py_BuildValue("O&",
3480 ResObj_New, _rv);
3481 return _res;
3482}
3483
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]3484static PyObject *Qd_Color2Index(_self, _args)
3485 PyObject *_self;
3486 PyObject *_args;
3487{
3488 PyObject *_res = NULL;
3489 long _rv;
3490 RGBColor myColor;
3491 if (!PyArg_ParseTuple(_args, "O&",
3492 QdRGB_Convert, &myColor))
3493 return NULL;
3494 _rv = Color2Index(&myColor);
3495 _res = Py_BuildValue("l",
3496 _rv);
3497 return _res;
3498}
3499
3500static PyObject *Qd_Index2Color(_self, _args)
3501 PyObject *_self;
3502 PyObject *_args;
3503{
3504 PyObject *_res = NULL;
3505 long index;
3506 RGBColor aColor;
3507 if (!PyArg_ParseTuple(_args, "l",
3508 &index))
3509 return NULL;
3510 Index2Color(index,
3511 &aColor);
3512 _res = Py_BuildValue("O&",
3513 QdRGB_New, &aColor);
3514 return _res;
3515}
3516
3517static PyObject *Qd_InvertColor(_self, _args)
3518 PyObject *_self;
3519 PyObject *_args;
3520{
3521 PyObject *_res = NULL;
3522 RGBColor myColor;
3523 if (!PyArg_ParseTuple(_args, ""))
3524 return NULL;
3525 InvertColor(&myColor);
3526 _res = Py_BuildValue("O&",
3527 QdRGB_New, &myColor);
3528 return _res;
3529}
3530
3531static PyObject *Qd_RealColor(_self, _args)
3532 PyObject *_self;
3533 PyObject *_args;
3534{
3535 PyObject *_res = NULL;
3536 Boolean _rv;
3537 RGBColor color;
3538 if (!PyArg_ParseTuple(_args, "O&",
3539 QdRGB_Convert, &color))
3540 return NULL;
3541 _rv = RealColor(&color);
3542 _res = Py_BuildValue("b",
3543 _rv);
3544 return _res;
3545}
3546
Jack Jansen69b43ed1997-08-15 14:35:54 +0000[diff] [blame]3547static PyObject *Qd_GetSubTable(_self, _args)
3548 PyObject *_self;
3549 PyObject *_args;
3550{
3551 PyObject *_res = NULL;
3552 CTabHandle myColors;
3553 short iTabRes;
3554 CTabHandle targetTbl;
3555 if (!PyArg_ParseTuple(_args, "O&hO&",
3556 ResObj_Convert, &myColors,
3557 &iTabRes,
3558 ResObj_Convert, &targetTbl))
3559 return NULL;
3560 GetSubTable(myColors,
3561 iTabRes,
3562 targetTbl);
3563 Py_INCREF(Py_None);
3564 _res = Py_None;
3565 return _res;
3566}
3567
3568static PyObject *Qd_MakeITable(_self, _args)
3569 PyObject *_self;
3570 PyObject *_args;
3571{
3572 PyObject *_res = NULL;
3573 CTabHandle cTabH;
3574 ITabHandle iTabH;
3575 short res;
3576 if (!PyArg_ParseTuple(_args, "O&O&h",
3577 ResObj_Convert, &cTabH,
3578 ResObj_Convert, &iTabH,
3579 &res))
3580 return NULL;
3581 MakeITable(cTabH,
3582 iTabH,
3583 res);
3584 Py_INCREF(Py_None);
3585 _res = Py_None;
3586 return _res;
3587}
3588
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]3589static PyObject *Qd_SetClientID(_self, _args)
3590 PyObject *_self;
3591 PyObject *_args;
3592{
3593 PyObject *_res = NULL;
3594 short id;
3595 if (!PyArg_ParseTuple(_args, "h",
3596 &id))
3597 return NULL;
3598 SetClientID(id);
3599 Py_INCREF(Py_None);
3600 _res = Py_None;
3601 return _res;
3602}
3603
3604static PyObject *Qd_ProtectEntry(_self, _args)
3605 PyObject *_self;
3606 PyObject *_args;
3607{
3608 PyObject *_res = NULL;
3609 short index;
3610 Boolean protect;
3611 if (!PyArg_ParseTuple(_args, "hb",
3612 &index,
3613 &protect))
3614 return NULL;
3615 ProtectEntry(index,
3616 protect);
3617 Py_INCREF(Py_None);
3618 _res = Py_None;
3619 return _res;
3620}
3621
3622static PyObject *Qd_ReserveEntry(_self, _args)
3623 PyObject *_self;
3624 PyObject *_args;
3625{
3626 PyObject *_res = NULL;
3627 short index;
3628 Boolean reserve;
3629 if (!PyArg_ParseTuple(_args, "hb",
3630 &index,
3631 &reserve))
3632 return NULL;
3633 ReserveEntry(index,
3634 reserve);
3635 Py_INCREF(Py_None);
3636 _res = Py_None;
3637 return _res;
3638}
3639
3640static PyObject *Qd_QDError(_self, _args)
3641 PyObject *_self;
3642 PyObject *_args;
3643{
3644 PyObject *_res = NULL;
3645 short _rv;
3646 if (!PyArg_ParseTuple(_args, ""))
3647 return NULL;
3648 _rv = QDError();
3649 _res = Py_BuildValue("h",
3650 _rv);
3651 return _res;
3652}
3653
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]3654static PyObject *Qd_CopyDeepMask(_self, _args)
3655 PyObject *_self;
3656 PyObject *_args;
3657{
3658 PyObject *_res = NULL;
3659 BitMapPtr srcBits;
3660 BitMapPtr maskBits;
3661 BitMapPtr dstBits;
3662 Rect srcRect;
3663 Rect maskRect;
3664 Rect dstRect;
3665 short mode;
3666 RgnHandle maskRgn;
3667 if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&hO&",
3668 BMObj_Convert, &srcBits,
3669 BMObj_Convert, &maskBits,
3670 BMObj_Convert, &dstBits,
3671 PyMac_GetRect, &srcRect,
3672 PyMac_GetRect, &maskRect,
3673 PyMac_GetRect, &dstRect,
3674 &mode,
Jack Jansen425e9eb1995-12-12 15:02:03 +0000[diff] [blame]3675 OptResObj_Convert, &maskRgn))
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]3676 return NULL;
3677 CopyDeepMask(srcBits,
3678 maskBits,
3679 dstBits,
3680 &srcRect,
3681 &maskRect,
3682 &dstRect,
3683 mode,
3684 maskRgn);
3685 Py_INCREF(Py_None);
3686 _res = Py_None;
3687 return _res;
3688}
3689
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]3690static PyObject *Qd_GetPattern(_self, _args)
3691 PyObject *_self;
3692 PyObject *_args;
3693{
3694 PyObject *_res = NULL;
3695 PatHandle _rv;
3696 short patternID;
3697 if (!PyArg_ParseTuple(_args, "h",
3698 &patternID))
3699 return NULL;
3700 _rv = GetPattern(patternID);
3701 _res = Py_BuildValue("O&",
3702 ResObj_New, _rv);
3703 return _res;
3704}
3705
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]3706static PyObject *Qd_MacGetCursor(_self, _args)
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]3707 PyObject *_self;
3708 PyObject *_args;
3709{
3710 PyObject *_res = NULL;
3711 CursHandle _rv;
3712 short cursorID;
3713 if (!PyArg_ParseTuple(_args, "h",
3714 &cursorID))
3715 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]3716 _rv = MacGetCursor(cursorID);
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]3717 _res = Py_BuildValue("O&",
3718 ResObj_New, _rv);
3719 return _res;
3720}
3721
3722static PyObject *Qd_GetPicture(_self, _args)
3723 PyObject *_self;
3724 PyObject *_args;
3725{
3726 PyObject *_res = NULL;
3727 PicHandle _rv;
3728 short pictureID;
3729 if (!PyArg_ParseTuple(_args, "h",
3730 &pictureID))
3731 return NULL;
3732 _rv = GetPicture(pictureID);
3733 _res = Py_BuildValue("O&",
3734 ResObj_New, _rv);
3735 return _res;
3736}
3737
3738static PyObject *Qd_DeltaPoint(_self, _args)
3739 PyObject *_self;
3740 PyObject *_args;
3741{
3742 PyObject *_res = NULL;
3743 long _rv;
3744 Point ptA;
3745 Point ptB;
3746 if (!PyArg_ParseTuple(_args, "O&O&",
3747 PyMac_GetPoint, &ptA,
3748 PyMac_GetPoint, &ptB))
3749 return NULL;
3750 _rv = DeltaPoint(ptA,
3751 ptB);
3752 _res = Py_BuildValue("l",
3753 _rv);
3754 return _res;
3755}
3756
3757static PyObject *Qd_ShieldCursor(_self, _args)
3758 PyObject *_self;
3759 PyObject *_args;
3760{
3761 PyObject *_res = NULL;
3762 Rect shieldRect;
3763 Point offsetPt;
3764 if (!PyArg_ParseTuple(_args, "O&O&",
3765 PyMac_GetRect, &shieldRect,
3766 PyMac_GetPoint, &offsetPt))
3767 return NULL;
3768 ShieldCursor(&shieldRect,
3769 offsetPt);
3770 Py_INCREF(Py_None);
3771 _res = Py_None;
3772 return _res;
3773}
3774
3775static PyObject *Qd_ScreenRes(_self, _args)
3776 PyObject *_self;
3777 PyObject *_args;
3778{
3779 PyObject *_res = NULL;
3780 short scrnHRes;
3781 short scrnVRes;
3782 if (!PyArg_ParseTuple(_args, ""))
3783 return NULL;
3784 ScreenRes(&scrnHRes,
3785 &scrnVRes);
3786 _res = Py_BuildValue("hh",
3787 scrnHRes,
3788 scrnVRes);
3789 return _res;
3790}
3791
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]3792static PyObject *Qd_GetIndPattern(_self, _args)
3793 PyObject *_self;
3794 PyObject *_args;
3795{
3796 PyObject *_res = NULL;
3797 Pattern thePat__out__;
3798 short patternListID;
3799 short index;
3800 if (!PyArg_ParseTuple(_args, "hh",
3801 &patternListID,
3802 &index))
3803 return NULL;
3804 GetIndPattern(&thePat__out__,
3805 patternListID,
3806 index);
3807 _res = Py_BuildValue("s#",
3808 (char *)&thePat__out__, (int)sizeof(Pattern));
3809 thePat__error__: ;
3810 return _res;
3811}
3812
Jack Jansen21f96871998-02-20 16:02:09 +0000[diff] [blame]3813static PyObject *Qd_SlopeFromAngle(_self, _args)
3814 PyObject *_self;
3815 PyObject *_args;
3816{
3817 PyObject *_res = NULL;
3818 Fixed _rv;
3819 short angle;
3820 if (!PyArg_ParseTuple(_args, "h",
3821 &angle))
3822 return NULL;
3823 _rv = SlopeFromAngle(angle);
3824 _res = Py_BuildValue("O&",
3825 PyMac_BuildFixed, _rv);
3826 return _res;
3827}
3828
3829static PyObject *Qd_AngleFromSlope(_self, _args)
3830 PyObject *_self;
3831 PyObject *_args;
3832{
3833 PyObject *_res = NULL;
3834 short _rv;
3835 Fixed slope;
3836 if (!PyArg_ParseTuple(_args, "O&",
3837 PyMac_GetFixed, &slope))
3838 return NULL;
3839 _rv = AngleFromSlope(slope);
3840 _res = Py_BuildValue("h",
3841 _rv);
3842 return _res;
3843}
3844
Jack Jansenbd58eda2001-01-24 14:05:11 +0000[diff] [blame^]3845static PyObject *Qd_OpenCursorComponent(_self, _args)
3846 PyObject *_self;
3847 PyObject *_args;
3848{
3849 PyObject *_res = NULL;
3850 OSErr _err;
3851 Component c;
3852 ComponentInstance ci;
3853 if (!PyArg_ParseTuple(_args, "O&",
3854 CmpObj_Convert, &c))
3855 return NULL;
3856 _err = OpenCursorComponent(c,
3857 &ci);
3858 if (_err != noErr) return PyMac_Error(_err);
3859 _res = Py_BuildValue("O&",
3860 CmpInstObj_New, ci);
3861 return _res;
3862}
3863
3864static PyObject *Qd_CloseCursorComponent(_self, _args)
3865 PyObject *_self;
3866 PyObject *_args;
3867{
3868 PyObject *_res = NULL;
3869 OSErr _err;
3870 ComponentInstance ci;
3871 if (!PyArg_ParseTuple(_args, "O&",
3872 CmpInstObj_Convert, &ci))
3873 return NULL;
3874 _err = CloseCursorComponent(ci);
3875 if (_err != noErr) return PyMac_Error(_err);
3876 Py_INCREF(Py_None);
3877 _res = Py_None;
3878 return _res;
3879}
3880
3881static PyObject *Qd_SetCursorComponent(_self, _args)
3882 PyObject *_self;
3883 PyObject *_args;
3884{
3885 PyObject *_res = NULL;
3886 OSErr _err;
3887 ComponentInstance ci;
3888 if (!PyArg_ParseTuple(_args, "O&",
3889 CmpInstObj_Convert, &ci))
3890 return NULL;
3891 _err = SetCursorComponent(ci);
3892 if (_err != noErr) return PyMac_Error(_err);
3893 Py_INCREF(Py_None);
3894 _res = Py_None;
3895 return _res;
3896}
3897
3898static PyObject *Qd_CursorComponentChanged(_self, _args)
3899 PyObject *_self;
3900 PyObject *_args;
3901{
3902 PyObject *_res = NULL;
3903 OSErr _err;
3904 ComponentInstance ci;
3905 if (!PyArg_ParseTuple(_args, "O&",
3906 CmpInstObj_Convert, &ci))
3907 return NULL;
3908 _err = CursorComponentChanged(ci);
3909 if (_err != noErr) return PyMac_Error(_err);
3910 Py_INCREF(Py_None);
3911 _res = Py_None;
3912 return _res;
3913}
3914
3915static PyObject *Qd_CursorComponentSetData(_self, _args)
3916 PyObject *_self;
3917 PyObject *_args;
3918{
3919 PyObject *_res = NULL;
3920 OSErr _err;
3921 ComponentInstance ci;
3922 long data;
3923 if (!PyArg_ParseTuple(_args, "O&l",
3924 CmpInstObj_Convert, &ci,
3925 &data))
3926 return NULL;
3927 _err = CursorComponentSetData(ci,
3928 data);
3929 if (_err != noErr) return PyMac_Error(_err);
3930 Py_INCREF(Py_None);
3931 _res = Py_None;
3932 return _res;
3933}
3934
3935static PyObject *Qd_GetPortPixMap(_self, _args)
3936 PyObject *_self;
3937 PyObject *_args;
3938{
3939 PyObject *_res = NULL;
3940 PixMapHandle _rv;
3941 CGrafPtr port;
3942 if (!PyArg_ParseTuple(_args, "O&",
3943 GrafObj_Convert, &port))
3944 return NULL;
3945 _rv = GetPortPixMap(port);
3946 _res = Py_BuildValue("O&",
3947 ResObj_New, _rv);
3948 return _res;
3949}
3950
3951static PyObject *Qd_GetPortBounds(_self, _args)
3952 PyObject *_self;
3953 PyObject *_args;
3954{
3955 PyObject *_res = NULL;
3956 CGrafPtr port;
3957 Rect rect;
3958 if (!PyArg_ParseTuple(_args, "O&",
3959 GrafObj_Convert, &port))
3960 return NULL;
3961 GetPortBounds(port,
3962 &rect);
3963 _res = Py_BuildValue("O&",
3964 PyMac_BuildRect, &rect);
3965 return _res;
3966}
3967
3968static PyObject *Qd_GetPortForeColor(_self, _args)
3969 PyObject *_self;
3970 PyObject *_args;
3971{
3972 PyObject *_res = NULL;
3973 CGrafPtr port;
3974 RGBColor foreColor;
3975 if (!PyArg_ParseTuple(_args, "O&",
3976 GrafObj_Convert, &port))
3977 return NULL;
3978 GetPortForeColor(port,
3979 &foreColor);
3980 _res = Py_BuildValue("O&",
3981 QdRGB_New, &foreColor);
3982 return _res;
3983}
3984
3985static PyObject *Qd_GetPortBackColor(_self, _args)
3986 PyObject *_self;
3987 PyObject *_args;
3988{
3989 PyObject *_res = NULL;
3990 CGrafPtr port;
3991 RGBColor backColor;
3992 if (!PyArg_ParseTuple(_args, "O&",
3993 GrafObj_Convert, &port))
3994 return NULL;
3995 GetPortBackColor(port,
3996 &backColor);
3997 _res = Py_BuildValue("O&",
3998 QdRGB_New, &backColor);
3999 return _res;
4000}
4001
4002static PyObject *Qd_GetPortOpColor(_self, _args)
4003 PyObject *_self;
4004 PyObject *_args;
4005{
4006 PyObject *_res = NULL;
4007 CGrafPtr port;
4008 RGBColor opColor;
4009 if (!PyArg_ParseTuple(_args, "O&",
4010 GrafObj_Convert, &port))
4011 return NULL;
4012 GetPortOpColor(port,
4013 &opColor);
4014 _res = Py_BuildValue("O&",
4015 QdRGB_New, &opColor);
4016 return _res;
4017}
4018
4019static PyObject *Qd_GetPortHiliteColor(_self, _args)
4020 PyObject *_self;
4021 PyObject *_args;
4022{
4023 PyObject *_res = NULL;
4024 CGrafPtr port;
4025 RGBColor hiliteColor;
4026 if (!PyArg_ParseTuple(_args, "O&",
4027 GrafObj_Convert, &port))
4028 return NULL;
4029 GetPortHiliteColor(port,
4030 &hiliteColor);
4031 _res = Py_BuildValue("O&",
4032 QdRGB_New, &hiliteColor);
4033 return _res;
4034}
4035
4036static PyObject *Qd_GetPortTextFont(_self, _args)
4037 PyObject *_self;
4038 PyObject *_args;
4039{
4040 PyObject *_res = NULL;
4041 short _rv;
4042 CGrafPtr port;
4043 if (!PyArg_ParseTuple(_args, "O&",
4044 GrafObj_Convert, &port))
4045 return NULL;
4046 _rv = GetPortTextFont(port);
4047 _res = Py_BuildValue("h",
4048 _rv);
4049 return _res;
4050}
4051
4052static PyObject *Qd_GetPortTextFace(_self, _args)
4053 PyObject *_self;
4054 PyObject *_args;
4055{
4056 PyObject *_res = NULL;
4057 Style _rv;
4058 CGrafPtr port;
4059 if (!PyArg_ParseTuple(_args, "O&",
4060 GrafObj_Convert, &port))
4061 return NULL;
4062 _rv = GetPortTextFace(port);
4063 _res = Py_BuildValue("b",
4064 _rv);
4065 return _res;
4066}
4067
4068static PyObject *Qd_GetPortTextMode(_self, _args)
4069 PyObject *_self;
4070 PyObject *_args;
4071{
4072 PyObject *_res = NULL;
4073 short _rv;
4074 CGrafPtr port;
4075 if (!PyArg_ParseTuple(_args, "O&",
4076 GrafObj_Convert, &port))
4077 return NULL;
4078 _rv = GetPortTextMode(port);
4079 _res = Py_BuildValue("h",
4080 _rv);
4081 return _res;
4082}
4083
4084static PyObject *Qd_GetPortTextSize(_self, _args)
4085 PyObject *_self;
4086 PyObject *_args;
4087{
4088 PyObject *_res = NULL;
4089 short _rv;
4090 CGrafPtr port;
4091 if (!PyArg_ParseTuple(_args, "O&",
4092 GrafObj_Convert, &port))
4093 return NULL;
4094 _rv = GetPortTextSize(port);
4095 _res = Py_BuildValue("h",
4096 _rv);
4097 return _res;
4098}
4099
4100static PyObject *Qd_GetPortChExtra(_self, _args)
4101 PyObject *_self;
4102 PyObject *_args;
4103{
4104 PyObject *_res = NULL;
4105 short _rv;
4106 CGrafPtr port;
4107 if (!PyArg_ParseTuple(_args, "O&",
4108 GrafObj_Convert, &port))
4109 return NULL;
4110 _rv = GetPortChExtra(port);
4111 _res = Py_BuildValue("h",
4112 _rv);
4113 return _res;
4114}
4115
4116static PyObject *Qd_GetPortFracHPenLocation(_self, _args)
4117 PyObject *_self;
4118 PyObject *_args;
4119{
4120 PyObject *_res = NULL;
4121 short _rv;
4122 CGrafPtr port;
4123 if (!PyArg_ParseTuple(_args, "O&",
4124 GrafObj_Convert, &port))
4125 return NULL;
4126 _rv = GetPortFracHPenLocation(port);
4127 _res = Py_BuildValue("h",
4128 _rv);
4129 return _res;
4130}
4131
4132static PyObject *Qd_GetPortSpExtra(_self, _args)
4133 PyObject *_self;
4134 PyObject *_args;
4135{
4136 PyObject *_res = NULL;
4137 Fixed _rv;
4138 CGrafPtr port;
4139 if (!PyArg_ParseTuple(_args, "O&",
4140 GrafObj_Convert, &port))
4141 return NULL;
4142 _rv = GetPortSpExtra(port);
4143 _res = Py_BuildValue("O&",
4144 PyMac_BuildFixed, _rv);
4145 return _res;
4146}
4147
4148static PyObject *Qd_GetPortPenVisibility(_self, _args)
4149 PyObject *_self;
4150 PyObject *_args;
4151{
4152 PyObject *_res = NULL;
4153 short _rv;
4154 CGrafPtr port;
4155 if (!PyArg_ParseTuple(_args, "O&",
4156 GrafObj_Convert, &port))
4157 return NULL;
4158 _rv = GetPortPenVisibility(port);
4159 _res = Py_BuildValue("h",
4160 _rv);
4161 return _res;
4162}
4163
4164static PyObject *Qd_GetPortVisibleRegion(_self, _args)
4165 PyObject *_self;
4166 PyObject *_args;
4167{
4168 PyObject *_res = NULL;
4169 RgnHandle _rv;
4170 CGrafPtr port;
4171 RgnHandle visRgn;
4172 if (!PyArg_ParseTuple(_args, "O&O&",
4173 GrafObj_Convert, &port,
4174 ResObj_Convert, &visRgn))
4175 return NULL;
4176 _rv = GetPortVisibleRegion(port,
4177 visRgn);
4178 _res = Py_BuildValue("O&",
4179 ResObj_New, _rv);
4180 return _res;
4181}
4182
4183static PyObject *Qd_GetPortClipRegion(_self, _args)
4184 PyObject *_self;
4185 PyObject *_args;
4186{
4187 PyObject *_res = NULL;
4188 RgnHandle _rv;
4189 CGrafPtr port;
4190 RgnHandle clipRgn;
4191 if (!PyArg_ParseTuple(_args, "O&O&",
4192 GrafObj_Convert, &port,
4193 ResObj_Convert, &clipRgn))
4194 return NULL;
4195 _rv = GetPortClipRegion(port,
4196 clipRgn);
4197 _res = Py_BuildValue("O&",
4198 ResObj_New, _rv);
4199 return _res;
4200}
4201
4202static PyObject *Qd_GetPortBackPixPat(_self, _args)
4203 PyObject *_self;
4204 PyObject *_args;
4205{
4206 PyObject *_res = NULL;
4207 PixPatHandle _rv;
4208 CGrafPtr port;
4209 PixPatHandle backPattern;
4210 if (!PyArg_ParseTuple(_args, "O&O&",
4211 GrafObj_Convert, &port,
4212 ResObj_Convert, &backPattern))
4213 return NULL;
4214 _rv = GetPortBackPixPat(port,
4215 backPattern);
4216 _res = Py_BuildValue("O&",
4217 ResObj_New, _rv);
4218 return _res;
4219}
4220
4221static PyObject *Qd_GetPortPenPixPat(_self, _args)
4222 PyObject *_self;
4223 PyObject *_args;
4224{
4225 PyObject *_res = NULL;
4226 PixPatHandle _rv;
4227 CGrafPtr port;
4228 PixPatHandle penPattern;
4229 if (!PyArg_ParseTuple(_args, "O&O&",
4230 GrafObj_Convert, &port,
4231 ResObj_Convert, &penPattern))
4232 return NULL;
4233 _rv = GetPortPenPixPat(port,
4234 penPattern);
4235 _res = Py_BuildValue("O&",
4236 ResObj_New, _rv);
4237 return _res;
4238}
4239
4240static PyObject *Qd_GetPortFillPixPat(_self, _args)
4241 PyObject *_self;
4242 PyObject *_args;
4243{
4244 PyObject *_res = NULL;
4245 PixPatHandle _rv;
4246 CGrafPtr port;
4247 PixPatHandle fillPattern;
4248 if (!PyArg_ParseTuple(_args, "O&O&",
4249 GrafObj_Convert, &port,
4250 ResObj_Convert, &fillPattern))
4251 return NULL;
4252 _rv = GetPortFillPixPat(port,
4253 fillPattern);
4254 _res = Py_BuildValue("O&",
4255 ResObj_New, _rv);
4256 return _res;
4257}
4258
4259static PyObject *Qd_GetPortPenSize(_self, _args)
4260 PyObject *_self;
4261 PyObject *_args;
4262{
4263 PyObject *_res = NULL;
4264 CGrafPtr port;
4265 Point penSize;
4266 if (!PyArg_ParseTuple(_args, "O&O&",
4267 GrafObj_Convert, &port,
4268 PyMac_GetPoint, &penSize))
4269 return NULL;
4270 GetPortPenSize(port,
4271 &penSize);
4272 _res = Py_BuildValue("O&",
4273 PyMac_BuildPoint, penSize);
4274 return _res;
4275}
4276
4277static PyObject *Qd_GetPortPenMode(_self, _args)
4278 PyObject *_self;
4279 PyObject *_args;
4280{
4281 PyObject *_res = NULL;
4282 SInt32 _rv;
4283 CGrafPtr port;
4284 if (!PyArg_ParseTuple(_args, "O&",
4285 GrafObj_Convert, &port))
4286 return NULL;
4287 _rv = GetPortPenMode(port);
4288 _res = Py_BuildValue("l",
4289 _rv);
4290 return _res;
4291}
4292
4293static PyObject *Qd_GetPortPenLocation(_self, _args)
4294 PyObject *_self;
4295 PyObject *_args;
4296{
4297 PyObject *_res = NULL;
4298 CGrafPtr port;
4299 Point penLocation;
4300 if (!PyArg_ParseTuple(_args, "O&O&",
4301 GrafObj_Convert, &port,
4302 PyMac_GetPoint, &penLocation))
4303 return NULL;
4304 GetPortPenLocation(port,
4305 &penLocation);
4306 _res = Py_BuildValue("O&",
4307 PyMac_BuildPoint, penLocation);
4308 return _res;
4309}
4310
4311static PyObject *Qd_IsPortRegionBeingDefined(_self, _args)
4312 PyObject *_self;
4313 PyObject *_args;
4314{
4315 PyObject *_res = NULL;
4316 Boolean _rv;
4317 CGrafPtr port;
4318 if (!PyArg_ParseTuple(_args, "O&",
4319 GrafObj_Convert, &port))
4320 return NULL;
4321 _rv = IsPortRegionBeingDefined(port);
4322 _res = Py_BuildValue("b",
4323 _rv);
4324 return _res;
4325}
4326
4327static PyObject *Qd_IsPortPictureBeingDefined(_self, _args)
4328 PyObject *_self;
4329 PyObject *_args;
4330{
4331 PyObject *_res = NULL;
4332 Boolean _rv;
4333 CGrafPtr port;
4334 if (!PyArg_ParseTuple(_args, "O&",
4335 GrafObj_Convert, &port))
4336 return NULL;
4337 _rv = IsPortPictureBeingDefined(port);
4338 _res = Py_BuildValue("b",
4339 _rv);
4340 return _res;
4341}
4342
4343#if TARGET_API_MAC_CARBON
4344
4345static PyObject *Qd_IsPortOffscreen(_self, _args)
4346 PyObject *_self;
4347 PyObject *_args;
4348{
4349 PyObject *_res = NULL;
4350 Boolean _rv;
4351 CGrafPtr port;
4352 if (!PyArg_ParseTuple(_args, "O&",
4353 GrafObj_Convert, &port))
4354 return NULL;
4355 _rv = IsPortOffscreen(port);
4356 _res = Py_BuildValue("b",
4357 _rv);
4358 return _res;
4359}
4360#endif
4361
4362#if TARGET_API_MAC_CARBON
4363
4364static PyObject *Qd_IsPortColor(_self, _args)
4365 PyObject *_self;
4366 PyObject *_args;
4367{
4368 PyObject *_res = NULL;
4369 Boolean _rv;
4370 CGrafPtr port;
4371 if (!PyArg_ParseTuple(_args, "O&",
4372 GrafObj_Convert, &port))
4373 return NULL;
4374 _rv = IsPortColor(port);
4375 _res = Py_BuildValue("b",
4376 _rv);
4377 return _res;
4378}
4379#endif
4380
4381static PyObject *Qd_SetPortBounds(_self, _args)
4382 PyObject *_self;
4383 PyObject *_args;
4384{
4385 PyObject *_res = NULL;
4386 CGrafPtr port;
4387 Rect rect;
4388 if (!PyArg_ParseTuple(_args, "O&O&",
4389 GrafObj_Convert, &port,
4390 PyMac_GetRect, &rect))
4391 return NULL;
4392 SetPortBounds(port,
4393 &rect);
4394 Py_INCREF(Py_None);
4395 _res = Py_None;
4396 return _res;
4397}
4398
4399static PyObject *Qd_SetPortOpColor(_self, _args)
4400 PyObject *_self;
4401 PyObject *_args;
4402{
4403 PyObject *_res = NULL;
4404 CGrafPtr port;
4405 RGBColor opColor;
4406 if (!PyArg_ParseTuple(_args, "O&O&",
4407 GrafObj_Convert, &port,
4408 QdRGB_Convert, &opColor))
4409 return NULL;
4410 SetPortOpColor(port,
4411 &opColor);
4412 Py_INCREF(Py_None);
4413 _res = Py_None;
4414 return _res;
4415}
4416
4417static PyObject *Qd_SetPortVisibleRegion(_self, _args)
4418 PyObject *_self;
4419 PyObject *_args;
4420{
4421 PyObject *_res = NULL;
4422 CGrafPtr port;
4423 RgnHandle visRgn;
4424 if (!PyArg_ParseTuple(_args, "O&O&",
4425 GrafObj_Convert, &port,
4426 ResObj_Convert, &visRgn))
4427 return NULL;
4428 SetPortVisibleRegion(port,
4429 visRgn);
4430 Py_INCREF(Py_None);
4431 _res = Py_None;
4432 return _res;
4433}
4434
4435static PyObject *Qd_SetPortClipRegion(_self, _args)
4436 PyObject *_self;
4437 PyObject *_args;
4438{
4439 PyObject *_res = NULL;
4440 CGrafPtr port;
4441 RgnHandle clipRgn;
4442 if (!PyArg_ParseTuple(_args, "O&O&",
4443 GrafObj_Convert, &port,
4444 ResObj_Convert, &clipRgn))
4445 return NULL;
4446 SetPortClipRegion(port,
4447 clipRgn);
4448 Py_INCREF(Py_None);
4449 _res = Py_None;
4450 return _res;
4451}
4452
4453static PyObject *Qd_SetPortPenPixPat(_self, _args)
4454 PyObject *_self;
4455 PyObject *_args;
4456{
4457 PyObject *_res = NULL;
4458 CGrafPtr port;
4459 PixPatHandle penPattern;
4460 if (!PyArg_ParseTuple(_args, "O&O&",
4461 GrafObj_Convert, &port,
4462 ResObj_Convert, &penPattern))
4463 return NULL;
4464 SetPortPenPixPat(port,
4465 penPattern);
4466 Py_INCREF(Py_None);
4467 _res = Py_None;
4468 return _res;
4469}
4470
4471static PyObject *Qd_SetPortBackPixPat(_self, _args)
4472 PyObject *_self;
4473 PyObject *_args;
4474{
4475 PyObject *_res = NULL;
4476 CGrafPtr port;
4477 PixPatHandle backPattern;
4478 if (!PyArg_ParseTuple(_args, "O&O&",
4479 GrafObj_Convert, &port,
4480 ResObj_Convert, &backPattern))
4481 return NULL;
4482 SetPortBackPixPat(port,
4483 backPattern);
4484 Py_INCREF(Py_None);
4485 _res = Py_None;
4486 return _res;
4487}
4488
4489static PyObject *Qd_SetPortPenSize(_self, _args)
4490 PyObject *_self;
4491 PyObject *_args;
4492{
4493 PyObject *_res = NULL;
4494 CGrafPtr port;
4495 Point penSize;
4496 if (!PyArg_ParseTuple(_args, "O&O&",
4497 GrafObj_Convert, &port,
4498 PyMac_GetPoint, &penSize))
4499 return NULL;
4500 SetPortPenSize(port,
4501 penSize);
4502 Py_INCREF(Py_None);
4503 _res = Py_None;
4504 return _res;
4505}
4506
4507static PyObject *Qd_SetPortPenMode(_self, _args)
4508 PyObject *_self;
4509 PyObject *_args;
4510{
4511 PyObject *_res = NULL;
4512 CGrafPtr port;
4513 SInt32 penMode;
4514 if (!PyArg_ParseTuple(_args, "O&l",
4515 GrafObj_Convert, &port,
4516 &penMode))
4517 return NULL;
4518 SetPortPenMode(port,
4519 penMode);
4520 Py_INCREF(Py_None);
4521 _res = Py_None;
4522 return _res;
4523}
4524
4525static PyObject *Qd_SetPortFracHPenLocation(_self, _args)
4526 PyObject *_self;
4527 PyObject *_args;
4528{
4529 PyObject *_res = NULL;
4530 CGrafPtr port;
4531 short pnLocHFrac;
4532 if (!PyArg_ParseTuple(_args, "O&h",
4533 GrafObj_Convert, &port,
4534 &pnLocHFrac))
4535 return NULL;
4536 SetPortFracHPenLocation(port,
4537 pnLocHFrac);
4538 Py_INCREF(Py_None);
4539 _res = Py_None;
4540 return _res;
4541}
4542
4543static PyObject *Qd_GetPixBounds(_self, _args)
4544 PyObject *_self;
4545 PyObject *_args;
4546{
4547 PyObject *_res = NULL;
4548 PixMapHandle pixMap;
4549 Rect bounds;
4550 if (!PyArg_ParseTuple(_args, "O&",
4551 ResObj_Convert, &pixMap))
4552 return NULL;
4553 GetPixBounds(pixMap,
4554 &bounds);
4555 _res = Py_BuildValue("O&",
4556 PyMac_BuildRect, &bounds);
4557 return _res;
4558}
4559
4560static PyObject *Qd_GetPixDepth(_self, _args)
4561 PyObject *_self;
4562 PyObject *_args;
4563{
4564 PyObject *_res = NULL;
4565 short _rv;
4566 PixMapHandle pixMap;
4567 if (!PyArg_ParseTuple(_args, "O&",
4568 ResObj_Convert, &pixMap))
4569 return NULL;
4570 _rv = GetPixDepth(pixMap);
4571 _res = Py_BuildValue("h",
4572 _rv);
4573 return _res;
4574}
4575
4576static PyObject *Qd_GetQDGlobalsRandomSeed(_self, _args)
4577 PyObject *_self;
4578 PyObject *_args;
4579{
4580 PyObject *_res = NULL;
4581 long _rv;
4582 if (!PyArg_ParseTuple(_args, ""))
4583 return NULL;
4584 _rv = GetQDGlobalsRandomSeed();
4585 _res = Py_BuildValue("l",
4586 _rv);
4587 return _res;
4588}
4589
4590static PyObject *Qd_GetQDGlobalsScreenBits(_self, _args)
4591 PyObject *_self;
4592 PyObject *_args;
4593{
4594 PyObject *_res = NULL;
4595 BitMap screenBits;
4596 if (!PyArg_ParseTuple(_args, ""))
4597 return NULL;
4598 GetQDGlobalsScreenBits(&screenBits);
4599 _res = Py_BuildValue("O&",
4600 BMObj_New, &screenBits);
4601 return _res;
4602}
4603
4604static PyObject *Qd_GetQDGlobalsArrow(_self, _args)
4605 PyObject *_self;
4606 PyObject *_args;
4607{
4608 PyObject *_res = NULL;
4609 Cursor arrow__out__;
4610 if (!PyArg_ParseTuple(_args, ""))
4611 return NULL;
4612 GetQDGlobalsArrow(&arrow__out__);
4613 _res = Py_BuildValue("s#",
4614 (char *)&arrow__out__, (int)sizeof(Cursor));
4615 arrow__error__: ;
4616 return _res;
4617}
4618
4619static PyObject *Qd_GetQDGlobalsDarkGray(_self, _args)
4620 PyObject *_self;
4621 PyObject *_args;
4622{
4623 PyObject *_res = NULL;
4624 Pattern dkGray__out__;
4625 if (!PyArg_ParseTuple(_args, ""))
4626 return NULL;
4627 GetQDGlobalsDarkGray(&dkGray__out__);
4628 _res = Py_BuildValue("s#",
4629 (char *)&dkGray__out__, (int)sizeof(Pattern));
4630 dkGray__error__: ;
4631 return _res;
4632}
4633
4634static PyObject *Qd_GetQDGlobalsLightGray(_self, _args)
4635 PyObject *_self;
4636 PyObject *_args;
4637{
4638 PyObject *_res = NULL;
4639 Pattern ltGray__out__;
4640 if (!PyArg_ParseTuple(_args, ""))
4641 return NULL;
4642 GetQDGlobalsLightGray(&ltGray__out__);
4643 _res = Py_BuildValue("s#",
4644 (char *)&ltGray__out__, (int)sizeof(Pattern));
4645 ltGray__error__: ;
4646 return _res;
4647}
4648
4649static PyObject *Qd_GetQDGlobalsGray(_self, _args)
4650 PyObject *_self;
4651 PyObject *_args;
4652{
4653 PyObject *_res = NULL;
4654 Pattern gray__out__;
4655 if (!PyArg_ParseTuple(_args, ""))
4656 return NULL;
4657 GetQDGlobalsGray(&gray__out__);
4658 _res = Py_BuildValue("s#",
4659 (char *)&gray__out__, (int)sizeof(Pattern));
4660 gray__error__: ;
4661 return _res;
4662}
4663
4664static PyObject *Qd_GetQDGlobalsBlack(_self, _args)
4665 PyObject *_self;
4666 PyObject *_args;
4667{
4668 PyObject *_res = NULL;
4669 Pattern black__out__;
4670 if (!PyArg_ParseTuple(_args, ""))
4671 return NULL;
4672 GetQDGlobalsBlack(&black__out__);
4673 _res = Py_BuildValue("s#",
4674 (char *)&black__out__, (int)sizeof(Pattern));
4675 black__error__: ;
4676 return _res;
4677}
4678
4679static PyObject *Qd_GetQDGlobalsWhite(_self, _args)
4680 PyObject *_self;
4681 PyObject *_args;
4682{
4683 PyObject *_res = NULL;
4684 Pattern white__out__;
4685 if (!PyArg_ParseTuple(_args, ""))
4686 return NULL;
4687 GetQDGlobalsWhite(&white__out__);
4688 _res = Py_BuildValue("s#",
4689 (char *)&white__out__, (int)sizeof(Pattern));
4690 white__error__: ;
4691 return _res;
4692}
4693
4694static PyObject *Qd_GetQDGlobalsThePort(_self, _args)
4695 PyObject *_self;
4696 PyObject *_args;
4697{
4698 PyObject *_res = NULL;
4699 CGrafPtr _rv;
4700 if (!PyArg_ParseTuple(_args, ""))
4701 return NULL;
4702 _rv = GetQDGlobalsThePort();
4703 _res = Py_BuildValue("O&",
4704 GrafObj_New, _rv);
4705 return _res;
4706}
4707
4708static PyObject *Qd_SetQDGlobalsRandomSeed(_self, _args)
4709 PyObject *_self;
4710 PyObject *_args;
4711{
4712 PyObject *_res = NULL;
4713 long randomSeed;
4714 if (!PyArg_ParseTuple(_args, "l",
4715 &randomSeed))
4716 return NULL;
4717 SetQDGlobalsRandomSeed(randomSeed);
4718 Py_INCREF(Py_None);
4719 _res = Py_None;
4720 return _res;
4721}
4722
4723static PyObject *Qd_SetQDGlobalsArrow(_self, _args)
4724 PyObject *_self;
4725 PyObject *_args;
4726{
4727 PyObject *_res = NULL;
4728 Cursor *arrow__in__;
4729 int arrow__in_len__;
4730 if (!PyArg_ParseTuple(_args, "s#",
4731 (char **)&arrow__in__, &arrow__in_len__))
4732 return NULL;
4733 if (arrow__in_len__ != sizeof(Cursor))
4734 {
4735 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Cursor)");
4736 goto arrow__error__;
4737 }
4738 SetQDGlobalsArrow(arrow__in__);
4739 Py_INCREF(Py_None);
4740 _res = Py_None;
4741 arrow__error__: ;
4742 return _res;
4743}
4744
4745static PyObject *Qd_GetRegionBounds(_self, _args)
4746 PyObject *_self;
4747 PyObject *_args;
4748{
4749 PyObject *_res = NULL;
4750 RgnHandle region;
4751 Rect bounds;
4752 if (!PyArg_ParseTuple(_args, "O&",
4753 ResObj_Convert, &region))
4754 return NULL;
4755 GetRegionBounds(region,
4756 &bounds);
4757 _res = Py_BuildValue("O&",
4758 PyMac_BuildRect, &bounds);
4759 return _res;
4760}
4761
4762#if TARGET_API_MAC_CARBON
4763
4764static PyObject *Qd_IsRegionRectangular(_self, _args)
4765 PyObject *_self;
4766 PyObject *_args;
4767{
4768 PyObject *_res = NULL;
4769 Boolean _rv;
4770 RgnHandle region;
4771 if (!PyArg_ParseTuple(_args, "O&",
4772 ResObj_Convert, &region))
4773 return NULL;
4774 _rv = IsRegionRectangular(region);
4775 _res = Py_BuildValue("b",
4776 _rv);
4777 return _res;
4778}
4779#endif
4780
4781#if TARGET_API_MAC_CARBON
4782
4783static PyObject *Qd_CreateNewPort(_self, _args)
4784 PyObject *_self;
4785 PyObject *_args;
4786{
4787 PyObject *_res = NULL;
4788 CGrafPtr _rv;
4789 if (!PyArg_ParseTuple(_args, ""))
4790 return NULL;
4791 _rv = CreateNewPort();
4792 _res = Py_BuildValue("O&",
4793 GrafObj_New, _rv);
4794 return _res;
4795}
4796#endif
4797
4798#if TARGET_API_MAC_CARBON
4799
4800static PyObject *Qd_DisposePort(_self, _args)
4801 PyObject *_self;
4802 PyObject *_args;
4803{
4804 PyObject *_res = NULL;
4805 CGrafPtr port;
4806 if (!PyArg_ParseTuple(_args, "O&",
4807 GrafObj_Convert, &port))
4808 return NULL;
4809 DisposePort(port);
4810 Py_INCREF(Py_None);
4811 _res = Py_None;
4812 return _res;
4813}
4814#endif
4815
4816#if TARGET_API_MAC_CARBON
4817
4818static PyObject *Qd_SetQDError(_self, _args)
4819 PyObject *_self;
4820 PyObject *_args;
4821{
4822 PyObject *_res = NULL;
4823 OSErr err;
4824 if (!PyArg_ParseTuple(_args, "h",
4825 &err))
4826 return NULL;
4827 SetQDError(err);
4828 Py_INCREF(Py_None);
4829 _res = Py_None;
4830 return _res;
4831}
4832#endif
4833
4834static PyObject *Qd_QDIsPortBuffered(_self, _args)
4835 PyObject *_self;
4836 PyObject *_args;
4837{
4838 PyObject *_res = NULL;
4839 Boolean _rv;
4840 CGrafPtr port;
4841 if (!PyArg_ParseTuple(_args, "O&",
4842 GrafObj_Convert, &port))
4843 return NULL;
4844 _rv = QDIsPortBuffered(port);
4845 _res = Py_BuildValue("b",
4846 _rv);
4847 return _res;
4848}
4849
4850static PyObject *Qd_QDIsPortBufferDirty(_self, _args)
4851 PyObject *_self;
4852 PyObject *_args;
4853{
4854 PyObject *_res = NULL;
4855 Boolean _rv;
4856 CGrafPtr port;
4857 if (!PyArg_ParseTuple(_args, "O&",
4858 GrafObj_Convert, &port))
4859 return NULL;
4860 _rv = QDIsPortBufferDirty(port);
4861 _res = Py_BuildValue("b",
4862 _rv);
4863 return _res;
4864}
4865
4866static PyObject *Qd_QDFlushPortBuffer(_self, _args)
4867 PyObject *_self;
4868 PyObject *_args;
4869{
4870 PyObject *_res = NULL;
4871 CGrafPtr port;
4872 RgnHandle region;
4873 if (!PyArg_ParseTuple(_args, "O&O&",
4874 GrafObj_Convert, &port,
4875 ResObj_Convert, &region))
4876 return NULL;
4877 QDFlushPortBuffer(port,
4878 region);
4879 Py_INCREF(Py_None);
4880 _res = Py_None;
4881 return _res;
4882}
4883
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]4884static PyObject *Qd_TextFont(_self, _args)
4885 PyObject *_self;
4886 PyObject *_args;
4887{
4888 PyObject *_res = NULL;
4889 short font;
4890 if (!PyArg_ParseTuple(_args, "h",
4891 &font))
4892 return NULL;
4893 TextFont(font);
4894 Py_INCREF(Py_None);
4895 _res = Py_None;
4896 return _res;
4897}
4898
4899static PyObject *Qd_TextFace(_self, _args)
4900 PyObject *_self;
4901 PyObject *_args;
4902{
4903 PyObject *_res = NULL;
Jack Jansene742a821998-02-25 15:46:50 +0000[diff] [blame]4904 StyleParameter face;
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]4905 if (!PyArg_ParseTuple(_args, "h",
4906 &face))
4907 return NULL;
4908 TextFace(face);
4909 Py_INCREF(Py_None);
4910 _res = Py_None;
4911 return _res;
4912}
4913
4914static PyObject *Qd_TextMode(_self, _args)
4915 PyObject *_self;
4916 PyObject *_args;
4917{
4918 PyObject *_res = NULL;
4919 short mode;
4920 if (!PyArg_ParseTuple(_args, "h",
4921 &mode))
4922 return NULL;
4923 TextMode(mode);
4924 Py_INCREF(Py_None);
4925 _res = Py_None;
4926 return _res;
4927}
4928
4929static PyObject *Qd_TextSize(_self, _args)
4930 PyObject *_self;
4931 PyObject *_args;
4932{
4933 PyObject *_res = NULL;
4934 short size;
4935 if (!PyArg_ParseTuple(_args, "h",
4936 &size))
4937 return NULL;
4938 TextSize(size);
4939 Py_INCREF(Py_None);
4940 _res = Py_None;
4941 return _res;
4942}
4943
4944static PyObject *Qd_SpaceExtra(_self, _args)
4945 PyObject *_self;
4946 PyObject *_args;
4947{
4948 PyObject *_res = NULL;
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]4949 Fixed extra;
4950 if (!PyArg_ParseTuple(_args, "O&",
4951 PyMac_GetFixed, &extra))
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]4952 return NULL;
4953 SpaceExtra(extra);
4954 Py_INCREF(Py_None);
4955 _res = Py_None;
4956 return _res;
4957}
4958
4959static PyObject *Qd_DrawChar(_self, _args)
4960 PyObject *_self;
4961 PyObject *_args;
4962{
4963 PyObject *_res = NULL;
Jack Jansen21f96871998-02-20 16:02:09 +0000[diff] [blame]4964 CharParameter ch;
Jack Jansene742a821998-02-25 15:46:50 +0000[diff] [blame]4965 if (!PyArg_ParseTuple(_args, "h",
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]4966 &ch))
4967 return NULL;
4968 DrawChar(ch);
4969 Py_INCREF(Py_None);
4970 _res = Py_None;
4971 return _res;
4972}
4973
4974static PyObject *Qd_DrawString(_self, _args)
4975 PyObject *_self;
4976 PyObject *_args;
4977{
4978 PyObject *_res = NULL;
4979 Str255 s;
4980 if (!PyArg_ParseTuple(_args, "O&",
4981 PyMac_GetStr255, s))
4982 return NULL;
4983 DrawString(s);
4984 Py_INCREF(Py_None);
4985 _res = Py_None;
4986 return _res;
4987}
4988
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]4989static PyObject *Qd_MacDrawText(_self, _args)
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]4990 PyObject *_self;
4991 PyObject *_args;
4992{
4993 PyObject *_res = NULL;
4994 char *textBuf__in__;
4995 int textBuf__len__;
4996 int textBuf__in_len__;
4997 short firstByte;
4998 short byteCount;
4999 if (!PyArg_ParseTuple(_args, "s#hh",
5000 &textBuf__in__, &textBuf__in_len__,
5001 &firstByte,
5002 &byteCount))
5003 return NULL;
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5004 MacDrawText(textBuf__in__,
5005 firstByte,
5006 byteCount);
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]5007 Py_INCREF(Py_None);
5008 _res = Py_None;
5009 textBuf__error__: ;
5010 return _res;
5011}
5012
5013static PyObject *Qd_CharWidth(_self, _args)
5014 PyObject *_self;
5015 PyObject *_args;
5016{
5017 PyObject *_res = NULL;
5018 short _rv;
Jack Jansen21f96871998-02-20 16:02:09 +0000[diff] [blame]5019 CharParameter ch;
Jack Jansene742a821998-02-25 15:46:50 +0000[diff] [blame]5020 if (!PyArg_ParseTuple(_args, "h",
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]5021 &ch))
5022 return NULL;
5023 _rv = CharWidth(ch);
5024 _res = Py_BuildValue("h",
5025 _rv);
5026 return _res;
5027}
5028
5029static PyObject *Qd_StringWidth(_self, _args)
5030 PyObject *_self;
5031 PyObject *_args;
5032{
5033 PyObject *_res = NULL;
5034 short _rv;
5035 Str255 s;
5036 if (!PyArg_ParseTuple(_args, "O&",
5037 PyMac_GetStr255, s))
5038 return NULL;
5039 _rv = StringWidth(s);
5040 _res = Py_BuildValue("h",
5041 _rv);
5042 return _res;
5043}
5044
5045static PyObject *Qd_TextWidth(_self, _args)
5046 PyObject *_self;
5047 PyObject *_args;
5048{
5049 PyObject *_res = NULL;
5050 short _rv;
5051 char *textBuf__in__;
5052 int textBuf__len__;
5053 int textBuf__in_len__;
5054 short firstByte;
5055 short byteCount;
5056 if (!PyArg_ParseTuple(_args, "s#hh",
5057 &textBuf__in__, &textBuf__in_len__,
5058 &firstByte,
5059 &byteCount))
5060 return NULL;
5061 _rv = TextWidth(textBuf__in__,
5062 firstByte,
5063 byteCount);
5064 _res = Py_BuildValue("h",
5065 _rv);
5066 textBuf__error__: ;
5067 return _res;
5068}
5069
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]5070static PyObject *Qd_GetFontInfo(_self, _args)
5071 PyObject *_self;
5072 PyObject *_args;
5073{
5074 PyObject *_res = NULL;
5075 FontInfo info;
5076 if (!PyArg_ParseTuple(_args, ""))
5077 return NULL;
5078 GetFontInfo(&info);
5079 _res = Py_BuildValue("O&",
5080 QdFI_New, &info);
5081 return _res;
5082}
5083
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]5084static PyObject *Qd_CharExtra(_self, _args)
5085 PyObject *_self;
5086 PyObject *_args;
5087{
5088 PyObject *_res = NULL;
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]5089 Fixed extra;
5090 if (!PyArg_ParseTuple(_args, "O&",
5091 PyMac_GetFixed, &extra))
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]5092 return NULL;
5093 CharExtra(extra);
5094 Py_INCREF(Py_None);
5095 _res = Py_None;
5096 return _res;
5097}
5098
Jack Jansen7f725e41998-04-23 13:21:09 +0000[diff] [blame]5099static PyObject *Qd_SetPort(_self, _args)
5100 PyObject *_self;
5101 PyObject *_args;
5102{
5103 PyObject *_res = NULL;
Jack Jansen29bfea91998-04-27 15:09:36 +0000[diff] [blame]5104 GrafPtr thePort;
Jack Jansen7f725e41998-04-23 13:21:09 +0000[diff] [blame]5105 if (!PyArg_ParseTuple(_args, "O&",
Jack Jansen29bfea91998-04-27 15:09:36 +0000[diff] [blame]5106 GrafObj_Convert, &thePort))
Jack Jansen7f725e41998-04-23 13:21:09 +0000[diff] [blame]5107 return NULL;
5108 SetPort(thePort);
5109 Py_INCREF(Py_None);
5110 _res = Py_None;
5111 return _res;
5112}
5113
Jack Jansene180d991998-04-24 10:28:20 +0000[diff] [blame]5114static PyObject *Qd_GetCursor(_self, _args)
Jack Jansen7f725e41998-04-23 13:21:09 +0000[diff] [blame]5115 PyObject *_self;
5116 PyObject *_args;
5117{
5118 PyObject *_res = NULL;
Jack Jansene180d991998-04-24 10:28:20 +0000[diff] [blame]5119 CursHandle _rv;
5120 short cursorID;
5121 if (!PyArg_ParseTuple(_args, "h",
5122 &cursorID))
Jack Jansen7f725e41998-04-23 13:21:09 +0000[diff] [blame]5123 return NULL;
Jack Jansene180d991998-04-24 10:28:20 +0000[diff] [blame]5124 _rv = GetCursor(cursorID);
5125 _res = Py_BuildValue("O&",
5126 ResObj_New, _rv);
5127 return _res;
5128}
5129
5130static PyObject *Qd_SetCursor(_self, _args)
5131 PyObject *_self;
5132 PyObject *_args;
5133{
5134 PyObject *_res = NULL;
5135 Cursor *crsr__in__;
5136 int crsr__in_len__;
5137 if (!PyArg_ParseTuple(_args, "s#",
5138 (char **)&crsr__in__, &crsr__in_len__))
5139 return NULL;
5140 if (crsr__in_len__ != sizeof(Cursor))
5141 {
5142 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Cursor)");
5143 goto crsr__error__;
5144 }
5145 SetCursor(crsr__in__);
Jack Jansen7f725e41998-04-23 13:21:09 +0000[diff] [blame]5146 Py_INCREF(Py_None);
5147 _res = Py_None;
Jack Jansene180d991998-04-24 10:28:20 +0000[diff] [blame]5148 crsr__error__: ;
5149 return _res;
5150}
5151
5152static PyObject *Qd_ShowCursor(_self, _args)
5153 PyObject *_self;
5154 PyObject *_args;
5155{
5156 PyObject *_res = NULL;
5157 if (!PyArg_ParseTuple(_args, ""))
5158 return NULL;
5159 ShowCursor();
5160 Py_INCREF(Py_None);
5161 _res = Py_None;
5162 return _res;
5163}
5164
5165static PyObject *Qd_LineTo(_self, _args)
5166 PyObject *_self;
5167 PyObject *_args;
5168{
5169 PyObject *_res = NULL;
5170 short h;
5171 short v;
5172 if (!PyArg_ParseTuple(_args, "hh",
5173 &h,
5174 &v))
5175 return NULL;
5176 LineTo(h,
5177 v);
5178 Py_INCREF(Py_None);
5179 _res = Py_None;
5180 return _res;
5181}
5182
5183static PyObject *Qd_SetRect(_self, _args)
5184 PyObject *_self;
5185 PyObject *_args;
5186{
5187 PyObject *_res = NULL;
5188 Rect r;
5189 short left;
5190 short top;
5191 short right;
5192 short bottom;
5193 if (!PyArg_ParseTuple(_args, "hhhh",
5194 &left,
5195 &top,
5196 &right,
5197 &bottom))
5198 return NULL;
5199 SetRect(&r,
5200 left,
5201 top,
5202 right,
5203 bottom);
5204 _res = Py_BuildValue("O&",
5205 PyMac_BuildRect, &r);
5206 return _res;
5207}
5208
5209static PyObject *Qd_OffsetRect(_self, _args)
5210 PyObject *_self;
5211 PyObject *_args;
5212{
5213 PyObject *_res = NULL;
5214 Rect r;
5215 short dh;
5216 short dv;
5217 if (!PyArg_ParseTuple(_args, "O&hh",
5218 PyMac_GetRect, &r,
5219 &dh,
5220 &dv))
5221 return NULL;
5222 OffsetRect(&r,
5223 dh,
5224 dv);
5225 _res = Py_BuildValue("O&",
5226 PyMac_BuildRect, &r);
5227 return _res;
5228}
5229
5230static PyObject *Qd_InsetRect(_self, _args)
5231 PyObject *_self;
5232 PyObject *_args;
5233{
5234 PyObject *_res = NULL;
5235 Rect r;
5236 short dh;
5237 short dv;
5238 if (!PyArg_ParseTuple(_args, "O&hh",
5239 PyMac_GetRect, &r,
5240 &dh,
5241 &dv))
5242 return NULL;
5243 InsetRect(&r,
5244 dh,
5245 dv);
5246 _res = Py_BuildValue("O&",
5247 PyMac_BuildRect, &r);
5248 return _res;
5249}
5250
5251static PyObject *Qd_UnionRect(_self, _args)
5252 PyObject *_self;
5253 PyObject *_args;
5254{
5255 PyObject *_res = NULL;
5256 Rect src1;
5257 Rect src2;
5258 Rect dstRect;
5259 if (!PyArg_ParseTuple(_args, "O&O&",
5260 PyMac_GetRect, &src1,
5261 PyMac_GetRect, &src2))
5262 return NULL;
5263 UnionRect(&src1,
5264 &src2,
5265 &dstRect);
5266 _res = Py_BuildValue("O&",
5267 PyMac_BuildRect, &dstRect);
5268 return _res;
5269}
5270
5271static PyObject *Qd_EqualRect(_self, _args)
5272 PyObject *_self;
5273 PyObject *_args;
5274{
5275 PyObject *_res = NULL;
5276 Boolean _rv;
5277 Rect rect1;
5278 Rect rect2;
5279 if (!PyArg_ParseTuple(_args, "O&O&",
5280 PyMac_GetRect, &rect1,
5281 PyMac_GetRect, &rect2))
5282 return NULL;
5283 _rv = EqualRect(&rect1,
5284 &rect2);
5285 _res = Py_BuildValue("b",
5286 _rv);
5287 return _res;
5288}
5289
5290static PyObject *Qd_FrameRect(_self, _args)
5291 PyObject *_self;
5292 PyObject *_args;
5293{
5294 PyObject *_res = NULL;
5295 Rect r;
5296 if (!PyArg_ParseTuple(_args, "O&",
5297 PyMac_GetRect, &r))
5298 return NULL;
5299 FrameRect(&r);
5300 Py_INCREF(Py_None);
5301 _res = Py_None;
5302 return _res;
5303}
5304
5305static PyObject *Qd_InvertRect(_self, _args)
5306 PyObject *_self;
5307 PyObject *_args;
5308{
5309 PyObject *_res = NULL;
5310 Rect r;
5311 if (!PyArg_ParseTuple(_args, "O&",
5312 PyMac_GetRect, &r))
5313 return NULL;
5314 InvertRect(&r);
5315 Py_INCREF(Py_None);
5316 _res = Py_None;
5317 return _res;
5318}
5319
5320static PyObject *Qd_FillRect(_self, _args)
5321 PyObject *_self;
5322 PyObject *_args;
5323{
5324 PyObject *_res = NULL;
5325 Rect r;
5326 Pattern *pat__in__;
5327 int pat__in_len__;
5328 if (!PyArg_ParseTuple(_args, "O&s#",
5329 PyMac_GetRect, &r,
5330 (char **)&pat__in__, &pat__in_len__))
5331 return NULL;
5332 if (pat__in_len__ != sizeof(Pattern))
5333 {
5334 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
5335 goto pat__error__;
5336 }
5337 FillRect(&r,
5338 pat__in__);
5339 Py_INCREF(Py_None);
5340 _res = Py_None;
5341 pat__error__: ;
5342 return _res;
5343}
5344
5345static PyObject *Qd_CopyRgn(_self, _args)
5346 PyObject *_self;
5347 PyObject *_args;
5348{
5349 PyObject *_res = NULL;
5350 RgnHandle srcRgn;
5351 RgnHandle dstRgn;
5352 if (!PyArg_ParseTuple(_args, "O&O&",
5353 ResObj_Convert, &srcRgn,
5354 ResObj_Convert, &dstRgn))
5355 return NULL;
5356 CopyRgn(srcRgn,
5357 dstRgn);
5358 Py_INCREF(Py_None);
5359 _res = Py_None;
5360 return _res;
5361}
5362
5363static PyObject *Qd_SetRectRgn(_self, _args)
5364 PyObject *_self;
5365 PyObject *_args;
5366{
5367 PyObject *_res = NULL;
5368 RgnHandle rgn;
5369 short left;
5370 short top;
5371 short right;
5372 short bottom;
5373 if (!PyArg_ParseTuple(_args, "O&hhhh",
5374 ResObj_Convert, &rgn,
5375 &left,
5376 &top,
5377 &right,
5378 &bottom))
5379 return NULL;
5380 SetRectRgn(rgn,
5381 left,
5382 top,
5383 right,
5384 bottom);
5385 Py_INCREF(Py_None);
5386 _res = Py_None;
5387 return _res;
5388}
5389
5390static PyObject *Qd_OffsetRgn(_self, _args)
5391 PyObject *_self;
5392 PyObject *_args;
5393{
5394 PyObject *_res = NULL;
5395 RgnHandle rgn;
5396 short dh;
5397 short dv;
5398 if (!PyArg_ParseTuple(_args, "O&hh",
5399 ResObj_Convert, &rgn,
5400 &dh,
5401 &dv))
5402 return NULL;
5403 OffsetRgn(rgn,
5404 dh,
5405 dv);
5406 Py_INCREF(Py_None);
5407 _res = Py_None;
5408 return _res;
5409}
5410
5411static PyObject *Qd_UnionRgn(_self, _args)
5412 PyObject *_self;
5413 PyObject *_args;
5414{
5415 PyObject *_res = NULL;
5416 RgnHandle srcRgnA;
5417 RgnHandle srcRgnB;
5418 RgnHandle dstRgn;
5419 if (!PyArg_ParseTuple(_args, "O&O&O&",
5420 ResObj_Convert, &srcRgnA,
5421 ResObj_Convert, &srcRgnB,
5422 ResObj_Convert, &dstRgn))
5423 return NULL;
5424 UnionRgn(srcRgnA,
5425 srcRgnB,
5426 dstRgn);
5427 Py_INCREF(Py_None);
5428 _res = Py_None;
5429 return _res;
5430}
5431
5432static PyObject *Qd_XorRgn(_self, _args)
5433 PyObject *_self;
5434 PyObject *_args;
5435{
5436 PyObject *_res = NULL;
5437 RgnHandle srcRgnA;
5438 RgnHandle srcRgnB;
5439 RgnHandle dstRgn;
5440 if (!PyArg_ParseTuple(_args, "O&O&O&",
5441 ResObj_Convert, &srcRgnA,
5442 ResObj_Convert, &srcRgnB,
5443 ResObj_Convert, &dstRgn))
5444 return NULL;
5445 XorRgn(srcRgnA,
5446 srcRgnB,
5447 dstRgn);
5448 Py_INCREF(Py_None);
5449 _res = Py_None;
5450 return _res;
5451}
5452
5453static PyObject *Qd_EqualRgn(_self, _args)
5454 PyObject *_self;
5455 PyObject *_args;
5456{
5457 PyObject *_res = NULL;
5458 Boolean _rv;
5459 RgnHandle rgnA;
5460 RgnHandle rgnB;
5461 if (!PyArg_ParseTuple(_args, "O&O&",
5462 ResObj_Convert, &rgnA,
5463 ResObj_Convert, &rgnB))
5464 return NULL;
5465 _rv = EqualRgn(rgnA,
5466 rgnB);
5467 _res = Py_BuildValue("b",
5468 _rv);
5469 return _res;
5470}
5471
5472static PyObject *Qd_FrameRgn(_self, _args)
5473 PyObject *_self;
5474 PyObject *_args;
5475{
5476 PyObject *_res = NULL;
5477 RgnHandle rgn;
5478 if (!PyArg_ParseTuple(_args, "O&",
5479 ResObj_Convert, &rgn))
5480 return NULL;
5481 FrameRgn(rgn);
5482 Py_INCREF(Py_None);
5483 _res = Py_None;
5484 return _res;
5485}
5486
5487static PyObject *Qd_PaintRgn(_self, _args)
5488 PyObject *_self;
5489 PyObject *_args;
5490{
5491 PyObject *_res = NULL;
5492 RgnHandle rgn;
5493 if (!PyArg_ParseTuple(_args, "O&",
5494 ResObj_Convert, &rgn))
5495 return NULL;
5496 PaintRgn(rgn);
5497 Py_INCREF(Py_None);
5498 _res = Py_None;
5499 return _res;
5500}
5501
5502static PyObject *Qd_InvertRgn(_self, _args)
5503 PyObject *_self;
5504 PyObject *_args;
5505{
5506 PyObject *_res = NULL;
5507 RgnHandle rgn;
5508 if (!PyArg_ParseTuple(_args, "O&",
5509 ResObj_Convert, &rgn))
5510 return NULL;
5511 InvertRgn(rgn);
5512 Py_INCREF(Py_None);
5513 _res = Py_None;
5514 return _res;
5515}
5516
5517static PyObject *Qd_FillRgn(_self, _args)
5518 PyObject *_self;
5519 PyObject *_args;
5520{
5521 PyObject *_res = NULL;
5522 RgnHandle rgn;
5523 Pattern *pat__in__;
5524 int pat__in_len__;
5525 if (!PyArg_ParseTuple(_args, "O&s#",
5526 ResObj_Convert, &rgn,
5527 (char **)&pat__in__, &pat__in_len__))
5528 return NULL;
5529 if (pat__in_len__ != sizeof(Pattern))
5530 {
5531 PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)");
5532 goto pat__error__;
5533 }
5534 FillRgn(rgn,
5535 pat__in__);
5536 Py_INCREF(Py_None);
5537 _res = Py_None;
5538 pat__error__: ;
5539 return _res;
5540}
5541
5542static PyObject *Qd_GetPixel(_self, _args)
5543 PyObject *_self;
5544 PyObject *_args;
5545{
5546 PyObject *_res = NULL;
5547 Boolean _rv;
5548 short h;
5549 short v;
5550 if (!PyArg_ParseTuple(_args, "hh",
5551 &h,
5552 &v))
5553 return NULL;
5554 _rv = GetPixel(h,
5555 v);
5556 _res = Py_BuildValue("b",
5557 _rv);
5558 return _res;
5559}
5560
5561static PyObject *Qd_PtInRect(_self, _args)
5562 PyObject *_self;
5563 PyObject *_args;
5564{
5565 PyObject *_res = NULL;
5566 Boolean _rv;
5567 Point pt;
5568 Rect r;
5569 if (!PyArg_ParseTuple(_args, "O&O&",
5570 PyMac_GetPoint, &pt,
5571 PyMac_GetRect, &r))
5572 return NULL;
5573 _rv = PtInRect(pt,
5574 &r);
5575 _res = Py_BuildValue("b",
5576 _rv);
5577 return _res;
5578}
5579
5580static PyObject *Qd_DrawText(_self, _args)
5581 PyObject *_self;
5582 PyObject *_args;
5583{
5584 PyObject *_res = NULL;
5585 char *textBuf__in__;
5586 int textBuf__len__;
5587 int textBuf__in_len__;
5588 short firstByte;
5589 short byteCount;
5590 if (!PyArg_ParseTuple(_args, "s#hh",
5591 &textBuf__in__, &textBuf__in_len__,
5592 &firstByte,
5593 &byteCount))
5594 return NULL;
5595 DrawText(textBuf__in__,
5596 firstByte,
5597 byteCount);
5598 Py_INCREF(Py_None);
5599 _res = Py_None;
5600 textBuf__error__: ;
Jack Jansen7f725e41998-04-23 13:21:09 +0000[diff] [blame]5601 return _res;
5602}
5603
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]5604static PyObject *Qd_BitMap(_self, _args)
5605 PyObject *_self;
5606 PyObject *_args;
5607{
5608 PyObject *_res = NULL;
5609
5610 BitMap *ptr;
5611 PyObject *source;
5612 Rect bounds;
5613 int rowbytes;
5614 char *data;
5615
5616 if ( !PyArg_ParseTuple(_args, "O!iO&", &PyString_Type, &source, &rowbytes, PyMac_GetRect,
5617 &bounds) )
5618 return NULL;
5619 data = PyString_AsString(source);
5620 if ((ptr=(BitMap *)malloc(sizeof(BitMap))) == NULL )
5621 return PyErr_NoMemory();
5622 ptr->baseAddr = (Ptr)data;
5623 ptr->rowBytes = rowbytes;
5624 ptr->bounds = bounds;
5625 if ( (_res = BMObj_New(ptr)) == NULL ) {
5626 free(ptr);
5627 return NULL;
5628 }
5629 ((BitMapObject *)_res)->referred_object = source;
5630 Py_INCREF(source);
5631 ((BitMapObject *)_res)->referred_bitmap = ptr;
5632 return _res;
5633
5634}
5635
Jack Jansen425e9eb1995-12-12 15:02:03 +0000[diff] [blame]5636static PyObject *Qd_RawBitMap(_self, _args)
5637 PyObject *_self;
5638 PyObject *_args;
5639{
5640 PyObject *_res = NULL;
5641
5642 BitMap *ptr;
5643 PyObject *source;
5644
5645 if ( !PyArg_ParseTuple(_args, "O!", &PyString_Type, &source) )
5646 return NULL;
5647 if ( PyString_Size(source) != sizeof(BitMap) && PyString_Size(source) != sizeof(PixMap) ) {
5648 PyErr_BadArgument();
5649 return NULL;
5650 }
5651 ptr = (BitMapPtr)PyString_AsString(source);
5652 if ( (_res = BMObj_New(ptr)) == NULL ) {
5653 return NULL;
5654 }
5655 ((BitMapObject *)_res)->referred_object = source;
5656 Py_INCREF(source);
5657 return _res;
5658
5659}
5660
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]5661static PyMethodDef Qd_methods[] = {
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5662 {"MacSetPort", (PyCFunction)Qd_MacSetPort, 1,
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]5663 "(GrafPtr port) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5664 {"GetPort", (PyCFunction)Qd_GetPort, 1,
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]5665 "() -> (GrafPtr port)"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5666 {"GrafDevice", (PyCFunction)Qd_GrafDevice, 1,
5667 "(short device) -> None"},
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]5668 {"SetPortBits", (PyCFunction)Qd_SetPortBits, 1,
5669 "(BitMapPtr bm) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5670 {"PortSize", (PyCFunction)Qd_PortSize, 1,
5671 "(short width, short height) -> None"},
5672 {"MovePortTo", (PyCFunction)Qd_MovePortTo, 1,
5673 "(short leftGlobal, short topGlobal) -> None"},
5674 {"SetOrigin", (PyCFunction)Qd_SetOrigin, 1,
5675 "(short h, short v) -> None"},
5676 {"SetClip", (PyCFunction)Qd_SetClip, 1,
5677 "(RgnHandle rgn) -> None"},
5678 {"GetClip", (PyCFunction)Qd_GetClip, 1,
5679 "(RgnHandle rgn) -> None"},
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]5680 {"ClipRect", (PyCFunction)Qd_ClipRect, 1,
5681 "(Rect r) -> None"},
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]5682 {"BackPat", (PyCFunction)Qd_BackPat, 1,
5683 "(Pattern pat) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5684 {"InitCursor", (PyCFunction)Qd_InitCursor, 1,
5685 "() -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5686 {"MacSetCursor", (PyCFunction)Qd_MacSetCursor, 1,
Jack Jansenb5394061996-01-05 18:06:41 +0000[diff] [blame]5687 "(Cursor crsr) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5688 {"HideCursor", (PyCFunction)Qd_HideCursor, 1,
5689 "() -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5690 {"MacShowCursor", (PyCFunction)Qd_MacShowCursor, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5691 "() -> None"},
5692 {"ObscureCursor", (PyCFunction)Qd_ObscureCursor, 1,
5693 "() -> None"},
5694 {"HidePen", (PyCFunction)Qd_HidePen, 1,
5695 "() -> None"},
5696 {"ShowPen", (PyCFunction)Qd_ShowPen, 1,
5697 "() -> None"},
5698 {"GetPen", (PyCFunction)Qd_GetPen, 1,
Jack Jansen1d8ede71996-01-08 23:47:31 +0000[diff] [blame]5699 "() -> (Point pt)"},
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]5700 {"GetPenState", (PyCFunction)Qd_GetPenState, 1,
5701 "() -> (PenState pnState)"},
5702 {"SetPenState", (PyCFunction)Qd_SetPenState, 1,
5703 "(PenState pnState) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5704 {"PenSize", (PyCFunction)Qd_PenSize, 1,
5705 "(short width, short height) -> None"},
5706 {"PenMode", (PyCFunction)Qd_PenMode, 1,
5707 "(short mode) -> None"},
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]5708 {"PenPat", (PyCFunction)Qd_PenPat, 1,
5709 "(Pattern pat) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5710 {"PenNormal", (PyCFunction)Qd_PenNormal, 1,
5711 "() -> None"},
5712 {"MoveTo", (PyCFunction)Qd_MoveTo, 1,
5713 "(short h, short v) -> None"},
5714 {"Move", (PyCFunction)Qd_Move, 1,
5715 "(short dh, short dv) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5716 {"MacLineTo", (PyCFunction)Qd_MacLineTo, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5717 "(short h, short v) -> None"},
5718 {"Line", (PyCFunction)Qd_Line, 1,
5719 "(short dh, short dv) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5720 {"ForeColor", (PyCFunction)Qd_ForeColor, 1,
5721 "(long color) -> None"},
5722 {"BackColor", (PyCFunction)Qd_BackColor, 1,
5723 "(long color) -> None"},
5724 {"ColorBit", (PyCFunction)Qd_ColorBit, 1,
5725 "(short whichBit) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5726 {"MacSetRect", (PyCFunction)Qd_MacSetRect, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5727 "(short left, short top, short right, short bottom) -> (Rect r)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5728 {"MacOffsetRect", (PyCFunction)Qd_MacOffsetRect, 1,
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]5729 "(Rect r, short dh, short dv) -> (Rect r)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5730 {"MacInsetRect", (PyCFunction)Qd_MacInsetRect, 1,
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]5731 "(Rect r, short dh, short dv) -> (Rect r)"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5732 {"SectRect", (PyCFunction)Qd_SectRect, 1,
5733 "(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5734 {"MacUnionRect", (PyCFunction)Qd_MacUnionRect, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5735 "(Rect src1, Rect src2) -> (Rect dstRect)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5736 {"MacEqualRect", (PyCFunction)Qd_MacEqualRect, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5737 "(Rect rect1, Rect rect2) -> (Boolean _rv)"},
5738 {"EmptyRect", (PyCFunction)Qd_EmptyRect, 1,
5739 "(Rect r) -> (Boolean _rv)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5740 {"MacFrameRect", (PyCFunction)Qd_MacFrameRect, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5741 "(Rect r) -> None"},
5742 {"PaintRect", (PyCFunction)Qd_PaintRect, 1,
5743 "(Rect r) -> None"},
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]5744 {"EraseRect", (PyCFunction)Qd_EraseRect, 1,
5745 "(Rect r) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5746 {"MacInvertRect", (PyCFunction)Qd_MacInvertRect, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5747 "(Rect r) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5748 {"MacFillRect", (PyCFunction)Qd_MacFillRect, 1,
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]5749 "(Rect r, Pattern pat) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5750 {"FrameOval", (PyCFunction)Qd_FrameOval, 1,
5751 "(Rect r) -> None"},
5752 {"PaintOval", (PyCFunction)Qd_PaintOval, 1,
5753 "(Rect r) -> None"},
5754 {"EraseOval", (PyCFunction)Qd_EraseOval, 1,
5755 "(Rect r) -> None"},
5756 {"InvertOval", (PyCFunction)Qd_InvertOval, 1,
5757 "(Rect r) -> None"},
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]5758 {"FillOval", (PyCFunction)Qd_FillOval, 1,
5759 "(Rect r, Pattern pat) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5760 {"FrameRoundRect", (PyCFunction)Qd_FrameRoundRect, 1,
5761 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
5762 {"PaintRoundRect", (PyCFunction)Qd_PaintRoundRect, 1,
5763 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
5764 {"EraseRoundRect", (PyCFunction)Qd_EraseRoundRect, 1,
5765 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
5766 {"InvertRoundRect", (PyCFunction)Qd_InvertRoundRect, 1,
5767 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]5768 {"FillRoundRect", (PyCFunction)Qd_FillRoundRect, 1,
5769 "(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5770 {"FrameArc", (PyCFunction)Qd_FrameArc, 1,
5771 "(Rect r, short startAngle, short arcAngle) -> None"},
5772 {"PaintArc", (PyCFunction)Qd_PaintArc, 1,
5773 "(Rect r, short startAngle, short arcAngle) -> None"},
5774 {"EraseArc", (PyCFunction)Qd_EraseArc, 1,
5775 "(Rect r, short startAngle, short arcAngle) -> None"},
5776 {"InvertArc", (PyCFunction)Qd_InvertArc, 1,
5777 "(Rect r, short startAngle, short arcAngle) -> None"},
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]5778 {"FillArc", (PyCFunction)Qd_FillArc, 1,
5779 "(Rect r, short startAngle, short arcAngle, Pattern pat) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5780 {"NewRgn", (PyCFunction)Qd_NewRgn, 1,
5781 "() -> (RgnHandle _rv)"},
5782 {"OpenRgn", (PyCFunction)Qd_OpenRgn, 1,
5783 "() -> None"},
5784 {"CloseRgn", (PyCFunction)Qd_CloseRgn, 1,
5785 "(RgnHandle dstRgn) -> None"},
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]5786 {"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1,
5787 "(RgnHandle region, BitMapPtr bMap) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5788 {"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1,
5789 "(RgnHandle rgn) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5790 {"MacCopyRgn", (PyCFunction)Qd_MacCopyRgn, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5791 "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
5792 {"SetEmptyRgn", (PyCFunction)Qd_SetEmptyRgn, 1,
5793 "(RgnHandle rgn) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5794 {"MacSetRectRgn", (PyCFunction)Qd_MacSetRectRgn, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5795 "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
5796 {"RectRgn", (PyCFunction)Qd_RectRgn, 1,
5797 "(RgnHandle rgn, Rect r) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5798 {"MacOffsetRgn", (PyCFunction)Qd_MacOffsetRgn, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5799 "(RgnHandle rgn, short dh, short dv) -> None"},
5800 {"InsetRgn", (PyCFunction)Qd_InsetRgn, 1,
5801 "(RgnHandle rgn, short dh, short dv) -> None"},
5802 {"SectRgn", (PyCFunction)Qd_SectRgn, 1,
5803 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5804 {"MacUnionRgn", (PyCFunction)Qd_MacUnionRgn, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5805 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
5806 {"DiffRgn", (PyCFunction)Qd_DiffRgn, 1,
5807 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5808 {"MacXorRgn", (PyCFunction)Qd_MacXorRgn, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5809 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
5810 {"RectInRgn", (PyCFunction)Qd_RectInRgn, 1,
5811 "(Rect r, RgnHandle rgn) -> (Boolean _rv)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5812 {"MacEqualRgn", (PyCFunction)Qd_MacEqualRgn, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5813 "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
5814 {"EmptyRgn", (PyCFunction)Qd_EmptyRgn, 1,
5815 "(RgnHandle rgn) -> (Boolean _rv)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5816 {"MacFrameRgn", (PyCFunction)Qd_MacFrameRgn, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5817 "(RgnHandle rgn) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5818 {"MacPaintRgn", (PyCFunction)Qd_MacPaintRgn, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5819 "(RgnHandle rgn) -> None"},
5820 {"EraseRgn", (PyCFunction)Qd_EraseRgn, 1,
5821 "(RgnHandle rgn) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5822 {"MacInvertRgn", (PyCFunction)Qd_MacInvertRgn, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5823 "(RgnHandle rgn) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5824 {"MacFillRgn", (PyCFunction)Qd_MacFillRgn, 1,
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]5825 "(RgnHandle rgn, Pattern pat) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5826 {"ScrollRect", (PyCFunction)Qd_ScrollRect, 1,
5827 "(Rect r, short dh, short dv, RgnHandle updateRgn) -> None"},
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]5828 {"CopyBits", (PyCFunction)Qd_CopyBits, 1,
5829 "(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
5830 {"CopyMask", (PyCFunction)Qd_CopyMask, 1,
5831 "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5832 {"OpenPicture", (PyCFunction)Qd_OpenPicture, 1,
5833 "(Rect picFrame) -> (PicHandle _rv)"},
5834 {"PicComment", (PyCFunction)Qd_PicComment, 1,
5835 "(short kind, short dataSize, Handle dataHandle) -> None"},
5836 {"ClosePicture", (PyCFunction)Qd_ClosePicture, 1,
5837 "() -> None"},
5838 {"DrawPicture", (PyCFunction)Qd_DrawPicture, 1,
5839 "(PicHandle myPicture, Rect dstRect) -> None"},
5840 {"KillPicture", (PyCFunction)Qd_KillPicture, 1,
5841 "(PicHandle myPicture) -> None"},
5842 {"OpenPoly", (PyCFunction)Qd_OpenPoly, 1,
5843 "() -> (PolyHandle _rv)"},
5844 {"ClosePoly", (PyCFunction)Qd_ClosePoly, 1,
5845 "() -> None"},
5846 {"KillPoly", (PyCFunction)Qd_KillPoly, 1,
5847 "(PolyHandle poly) -> None"},
5848 {"OffsetPoly", (PyCFunction)Qd_OffsetPoly, 1,
5849 "(PolyHandle poly, short dh, short dv) -> None"},
5850 {"FramePoly", (PyCFunction)Qd_FramePoly, 1,
5851 "(PolyHandle poly) -> None"},
5852 {"PaintPoly", (PyCFunction)Qd_PaintPoly, 1,
5853 "(PolyHandle poly) -> None"},
5854 {"ErasePoly", (PyCFunction)Qd_ErasePoly, 1,
5855 "(PolyHandle poly) -> None"},
5856 {"InvertPoly", (PyCFunction)Qd_InvertPoly, 1,
5857 "(PolyHandle poly) -> None"},
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]5858 {"FillPoly", (PyCFunction)Qd_FillPoly, 1,
5859 "(PolyHandle poly, Pattern pat) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5860 {"SetPt", (PyCFunction)Qd_SetPt, 1,
Jack Jansen1d8ede71996-01-08 23:47:31 +0000[diff] [blame]5861 "(short h, short v) -> (Point pt)"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5862 {"LocalToGlobal", (PyCFunction)Qd_LocalToGlobal, 1,
5863 "(Point pt) -> (Point pt)"},
5864 {"GlobalToLocal", (PyCFunction)Qd_GlobalToLocal, 1,
5865 "(Point pt) -> (Point pt)"},
5866 {"Random", (PyCFunction)Qd_Random, 1,
5867 "() -> (short _rv)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5868 {"MacGetPixel", (PyCFunction)Qd_MacGetPixel, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5869 "(short h, short v) -> (Boolean _rv)"},
5870 {"ScalePt", (PyCFunction)Qd_ScalePt, 1,
5871 "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
5872 {"MapPt", (PyCFunction)Qd_MapPt, 1,
5873 "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
5874 {"MapRect", (PyCFunction)Qd_MapRect, 1,
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]5875 "(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5876 {"MapRgn", (PyCFunction)Qd_MapRgn, 1,
5877 "(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None"},
5878 {"MapPoly", (PyCFunction)Qd_MapPoly, 1,
5879 "(PolyHandle poly, Rect srcRect, Rect dstRect) -> None"},
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]5880 {"StdBits", (PyCFunction)Qd_StdBits, 1,
5881 "(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5882 {"AddPt", (PyCFunction)Qd_AddPt, 1,
5883 "(Point src, Point dst) -> (Point dst)"},
5884 {"EqualPt", (PyCFunction)Qd_EqualPt, 1,
5885 "(Point pt1, Point pt2) -> (Boolean _rv)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]5886 {"MacPtInRect", (PyCFunction)Qd_MacPtInRect, 1,
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5887 "(Point pt, Rect r) -> (Boolean _rv)"},
5888 {"Pt2Rect", (PyCFunction)Qd_Pt2Rect, 1,
5889 "(Point pt1, Point pt2) -> (Rect dstRect)"},
5890 {"PtToAngle", (PyCFunction)Qd_PtToAngle, 1,
5891 "(Rect r, Point pt) -> (short angle)"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]5892 {"SubPt", (PyCFunction)Qd_SubPt, 1,
5893 "(Point src, Point dst) -> (Point dst)"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5894 {"PtInRgn", (PyCFunction)Qd_PtInRgn, 1,
5895 "(Point pt, RgnHandle rgn) -> (Boolean _rv)"},
5896 {"NewPixMap", (PyCFunction)Qd_NewPixMap, 1,
5897 "() -> (PixMapHandle _rv)"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5898 {"DisposePixMap", (PyCFunction)Qd_DisposePixMap, 1,
5899 "(PixMapHandle pm) -> None"},
5900 {"CopyPixMap", (PyCFunction)Qd_CopyPixMap, 1,
5901 "(PixMapHandle srcPM, PixMapHandle dstPM) -> None"},
5902 {"NewPixPat", (PyCFunction)Qd_NewPixPat, 1,
5903 "() -> (PixPatHandle _rv)"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5904 {"DisposePixPat", (PyCFunction)Qd_DisposePixPat, 1,
5905 "(PixPatHandle pp) -> None"},
5906 {"CopyPixPat", (PyCFunction)Qd_CopyPixPat, 1,
5907 "(PixPatHandle srcPP, PixPatHandle dstPP) -> None"},
5908 {"PenPixPat", (PyCFunction)Qd_PenPixPat, 1,
5909 "(PixPatHandle pp) -> None"},
5910 {"BackPixPat", (PyCFunction)Qd_BackPixPat, 1,
5911 "(PixPatHandle pp) -> None"},
5912 {"GetPixPat", (PyCFunction)Qd_GetPixPat, 1,
5913 "(short patID) -> (PixPatHandle _rv)"},
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]5914 {"MakeRGBPat", (PyCFunction)Qd_MakeRGBPat, 1,
5915 "(PixPatHandle pp, RGBColor myColor) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5916 {"FillCRect", (PyCFunction)Qd_FillCRect, 1,
5917 "(Rect r, PixPatHandle pp) -> None"},
5918 {"FillCOval", (PyCFunction)Qd_FillCOval, 1,
5919 "(Rect r, PixPatHandle pp) -> None"},
5920 {"FillCRoundRect", (PyCFunction)Qd_FillCRoundRect, 1,
5921 "(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None"},
5922 {"FillCArc", (PyCFunction)Qd_FillCArc, 1,
5923 "(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None"},
5924 {"FillCRgn", (PyCFunction)Qd_FillCRgn, 1,
5925 "(RgnHandle rgn, PixPatHandle pp) -> None"},
5926 {"FillCPoly", (PyCFunction)Qd_FillCPoly, 1,
5927 "(PolyHandle poly, PixPatHandle pp) -> None"},
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]5928 {"RGBForeColor", (PyCFunction)Qd_RGBForeColor, 1,
5929 "(RGBColor color) -> None"},
5930 {"RGBBackColor", (PyCFunction)Qd_RGBBackColor, 1,
5931 "(RGBColor color) -> None"},
5932 {"SetCPixel", (PyCFunction)Qd_SetCPixel, 1,
5933 "(short h, short v, RGBColor cPix) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5934 {"SetPortPix", (PyCFunction)Qd_SetPortPix, 1,
5935 "(PixMapHandle pm) -> None"},
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]5936 {"GetCPixel", (PyCFunction)Qd_GetCPixel, 1,
5937 "(short h, short v) -> (RGBColor cPix)"},
5938 {"GetForeColor", (PyCFunction)Qd_GetForeColor, 1,
5939 "() -> (RGBColor color)"},
5940 {"GetBackColor", (PyCFunction)Qd_GetBackColor, 1,
5941 "() -> (RGBColor color)"},
5942 {"OpColor", (PyCFunction)Qd_OpColor, 1,
5943 "(RGBColor color) -> None"},
5944 {"HiliteColor", (PyCFunction)Qd_HiliteColor, 1,
5945 "(RGBColor color) -> None"},
Jack Jansen69b43ed1997-08-15 14:35:54 +0000[diff] [blame]5946 {"DisposeCTable", (PyCFunction)Qd_DisposeCTable, 1,
5947 "(CTabHandle cTable) -> None"},
5948 {"GetCTable", (PyCFunction)Qd_GetCTable, 1,
5949 "(short ctID) -> (CTabHandle _rv)"},
5950 {"GetCCursor", (PyCFunction)Qd_GetCCursor, 1,
5951 "(short crsrID) -> (CCrsrHandle _rv)"},
5952 {"SetCCursor", (PyCFunction)Qd_SetCCursor, 1,
5953 "(CCrsrHandle cCrsr) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5954 {"AllocCursor", (PyCFunction)Qd_AllocCursor, 1,
5955 "() -> None"},
Jack Jansen69b43ed1997-08-15 14:35:54 +0000[diff] [blame]5956 {"DisposeCCursor", (PyCFunction)Qd_DisposeCCursor, 1,
5957 "(CCrsrHandle cCrsr) -> None"},
5958 {"GetMaxDevice", (PyCFunction)Qd_GetMaxDevice, 1,
5959 "(Rect globalRect) -> (GDHandle _rv)"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5960 {"GetCTSeed", (PyCFunction)Qd_GetCTSeed, 1,
5961 "() -> (long _rv)"},
Jack Jansen69b43ed1997-08-15 14:35:54 +0000[diff] [blame]5962 {"GetDeviceList", (PyCFunction)Qd_GetDeviceList, 1,
5963 "() -> (GDHandle _rv)"},
5964 {"GetMainDevice", (PyCFunction)Qd_GetMainDevice, 1,
5965 "() -> (GDHandle _rv)"},
5966 {"GetNextDevice", (PyCFunction)Qd_GetNextDevice, 1,
5967 "(GDHandle curDevice) -> (GDHandle _rv)"},
5968 {"TestDeviceAttribute", (PyCFunction)Qd_TestDeviceAttribute, 1,
5969 "(GDHandle gdh, short attribute) -> (Boolean _rv)"},
5970 {"SetDeviceAttribute", (PyCFunction)Qd_SetDeviceAttribute, 1,
5971 "(GDHandle gdh, short attribute, Boolean value) -> None"},
5972 {"InitGDevice", (PyCFunction)Qd_InitGDevice, 1,
5973 "(short qdRefNum, long mode, GDHandle gdh) -> None"},
5974 {"NewGDevice", (PyCFunction)Qd_NewGDevice, 1,
5975 "(short refNum, long mode) -> (GDHandle _rv)"},
5976 {"DisposeGDevice", (PyCFunction)Qd_DisposeGDevice, 1,
5977 "(GDHandle gdh) -> None"},
5978 {"SetGDevice", (PyCFunction)Qd_SetGDevice, 1,
5979 "(GDHandle gd) -> None"},
5980 {"GetGDevice", (PyCFunction)Qd_GetGDevice, 1,
5981 "() -> (GDHandle _rv)"},
Jack Jansen232f3cd1995-12-09 14:04:31 +0000[diff] [blame]5982 {"Color2Index", (PyCFunction)Qd_Color2Index, 1,
5983 "(RGBColor myColor) -> (long _rv)"},
5984 {"Index2Color", (PyCFunction)Qd_Index2Color, 1,
5985 "(long index) -> (RGBColor aColor)"},
5986 {"InvertColor", (PyCFunction)Qd_InvertColor, 1,
5987 "() -> (RGBColor myColor)"},
5988 {"RealColor", (PyCFunction)Qd_RealColor, 1,
5989 "(RGBColor color) -> (Boolean _rv)"},
Jack Jansen69b43ed1997-08-15 14:35:54 +0000[diff] [blame]5990 {"GetSubTable", (PyCFunction)Qd_GetSubTable, 1,
5991 "(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None"},
5992 {"MakeITable", (PyCFunction)Qd_MakeITable, 1,
5993 "(CTabHandle cTabH, ITabHandle iTabH, short res) -> None"},
Guido van Rossume56db431995-03-19 22:49:50 +0000[diff] [blame]5994 {"SetClientID", (PyCFunction)Qd_SetClientID, 1,
5995 "(short id) -> None"},
5996 {"ProtectEntry", (PyCFunction)Qd_ProtectEntry, 1,
5997 "(short index, Boolean protect) -> None"},
5998 {"ReserveEntry", (PyCFunction)Qd_ReserveEntry, 1,
5999 "(short index, Boolean reserve) -> None"},
6000 {"QDError", (PyCFunction)Qd_QDError, 1,
6001 "() -> (short _rv)"},
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]6002 {"CopyDeepMask", (PyCFunction)Qd_CopyDeepMask, 1,
6003 "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]6004 {"GetPattern", (PyCFunction)Qd_GetPattern, 1,
6005 "(short patternID) -> (PatHandle _rv)"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]6006 {"MacGetCursor", (PyCFunction)Qd_MacGetCursor, 1,
Jack Jansen54c8f7e1995-11-14 10:46:01 +0000[diff] [blame]6007 "(short cursorID) -> (CursHandle _rv)"},
6008 {"GetPicture", (PyCFunction)Qd_GetPicture, 1,
6009 "(short pictureID) -> (PicHandle _rv)"},
6010 {"DeltaPoint", (PyCFunction)Qd_DeltaPoint, 1,
6011 "(Point ptA, Point ptB) -> (long _rv)"},
6012 {"ShieldCursor", (PyCFunction)Qd_ShieldCursor, 1,
6013 "(Rect shieldRect, Point offsetPt) -> None"},
6014 {"ScreenRes", (PyCFunction)Qd_ScreenRes, 1,
6015 "() -> (short scrnHRes, short scrnVRes)"},
Jack Jansen04a02e71996-01-06 17:12:58 +0000[diff] [blame]6016 {"GetIndPattern", (PyCFunction)Qd_GetIndPattern, 1,
6017 "(short patternListID, short index) -> (Pattern thePat)"},
Jack Jansen21f96871998-02-20 16:02:09 +0000[diff] [blame]6018 {"SlopeFromAngle", (PyCFunction)Qd_SlopeFromAngle, 1,
6019 "(short angle) -> (Fixed _rv)"},
6020 {"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1,
6021 "(Fixed slope) -> (short _rv)"},
Jack Jansenbd58eda2001-01-24 14:05:11 +0000[diff] [blame^]6022 {"OpenCursorComponent", (PyCFunction)Qd_OpenCursorComponent, 1,
6023 "(Component c) -> (ComponentInstance ci)"},
6024 {"CloseCursorComponent", (PyCFunction)Qd_CloseCursorComponent, 1,
6025 "(ComponentInstance ci) -> None"},
6026 {"SetCursorComponent", (PyCFunction)Qd_SetCursorComponent, 1,
6027 "(ComponentInstance ci) -> None"},
6028 {"CursorComponentChanged", (PyCFunction)Qd_CursorComponentChanged, 1,
6029 "(ComponentInstance ci) -> None"},
6030 {"CursorComponentSetData", (PyCFunction)Qd_CursorComponentSetData, 1,
6031 "(ComponentInstance ci, long data) -> None"},
6032 {"GetPortPixMap", (PyCFunction)Qd_GetPortPixMap, 1,
6033 "(CGrafPtr port) -> (PixMapHandle _rv)"},
6034 {"GetPortBounds", (PyCFunction)Qd_GetPortBounds, 1,
6035 "(CGrafPtr port) -> (Rect rect)"},
6036 {"GetPortForeColor", (PyCFunction)Qd_GetPortForeColor, 1,
6037 "(CGrafPtr port) -> (RGBColor foreColor)"},
6038 {"GetPortBackColor", (PyCFunction)Qd_GetPortBackColor, 1,
6039 "(CGrafPtr port) -> (RGBColor backColor)"},
6040 {"GetPortOpColor", (PyCFunction)Qd_GetPortOpColor, 1,
6041 "(CGrafPtr port) -> (RGBColor opColor)"},
6042 {"GetPortHiliteColor", (PyCFunction)Qd_GetPortHiliteColor, 1,
6043 "(CGrafPtr port) -> (RGBColor hiliteColor)"},
6044 {"GetPortTextFont", (PyCFunction)Qd_GetPortTextFont, 1,
6045 "(CGrafPtr port) -> (short _rv)"},
6046 {"GetPortTextFace", (PyCFunction)Qd_GetPortTextFace, 1,
6047 "(CGrafPtr port) -> (Style _rv)"},
6048 {"GetPortTextMode", (PyCFunction)Qd_GetPortTextMode, 1,
6049 "(CGrafPtr port) -> (short _rv)"},
6050 {"GetPortTextSize", (PyCFunction)Qd_GetPortTextSize, 1,
6051 "(CGrafPtr port) -> (short _rv)"},
6052 {"GetPortChExtra", (PyCFunction)Qd_GetPortChExtra, 1,
6053 "(CGrafPtr port) -> (short _rv)"},
6054 {"GetPortFracHPenLocation", (PyCFunction)Qd_GetPortFracHPenLocation, 1,
6055 "(CGrafPtr port) -> (short _rv)"},
6056 {"GetPortSpExtra", (PyCFunction)Qd_GetPortSpExtra, 1,
6057 "(CGrafPtr port) -> (Fixed _rv)"},
6058 {"GetPortPenVisibility", (PyCFunction)Qd_GetPortPenVisibility, 1,
6059 "(CGrafPtr port) -> (short _rv)"},
6060 {"GetPortVisibleRegion", (PyCFunction)Qd_GetPortVisibleRegion, 1,
6061 "(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)"},
6062 {"GetPortClipRegion", (PyCFunction)Qd_GetPortClipRegion, 1,
6063 "(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)"},
6064 {"GetPortBackPixPat", (PyCFunction)Qd_GetPortBackPixPat, 1,
6065 "(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)"},
6066 {"GetPortPenPixPat", (PyCFunction)Qd_GetPortPenPixPat, 1,
6067 "(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)"},
6068 {"GetPortFillPixPat", (PyCFunction)Qd_GetPortFillPixPat, 1,
6069 "(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)"},
6070 {"GetPortPenSize", (PyCFunction)Qd_GetPortPenSize, 1,
6071 "(CGrafPtr port, Point penSize) -> (Point penSize)"},
6072 {"GetPortPenMode", (PyCFunction)Qd_GetPortPenMode, 1,
6073 "(CGrafPtr port) -> (SInt32 _rv)"},
6074 {"GetPortPenLocation", (PyCFunction)Qd_GetPortPenLocation, 1,
6075 "(CGrafPtr port, Point penLocation) -> (Point penLocation)"},
6076 {"IsPortRegionBeingDefined", (PyCFunction)Qd_IsPortRegionBeingDefined, 1,
6077 "(CGrafPtr port) -> (Boolean _rv)"},
6078 {"IsPortPictureBeingDefined", (PyCFunction)Qd_IsPortPictureBeingDefined, 1,
6079 "(CGrafPtr port) -> (Boolean _rv)"},
6080
6081#if TARGET_API_MAC_CARBON
6082 {"IsPortOffscreen", (PyCFunction)Qd_IsPortOffscreen, 1,
6083 "(CGrafPtr port) -> (Boolean _rv)"},
6084#endif
6085
6086#if TARGET_API_MAC_CARBON
6087 {"IsPortColor", (PyCFunction)Qd_IsPortColor, 1,
6088 "(CGrafPtr port) -> (Boolean _rv)"},
6089#endif
6090 {"SetPortBounds", (PyCFunction)Qd_SetPortBounds, 1,
6091 "(CGrafPtr port, Rect rect) -> None"},
6092 {"SetPortOpColor", (PyCFunction)Qd_SetPortOpColor, 1,
6093 "(CGrafPtr port, RGBColor opColor) -> None"},
6094 {"SetPortVisibleRegion", (PyCFunction)Qd_SetPortVisibleRegion, 1,
6095 "(CGrafPtr port, RgnHandle visRgn) -> None"},
6096 {"SetPortClipRegion", (PyCFunction)Qd_SetPortClipRegion, 1,
6097 "(CGrafPtr port, RgnHandle clipRgn) -> None"},
6098 {"SetPortPenPixPat", (PyCFunction)Qd_SetPortPenPixPat, 1,
6099 "(CGrafPtr port, PixPatHandle penPattern) -> None"},
6100 {"SetPortBackPixPat", (PyCFunction)Qd_SetPortBackPixPat, 1,
6101 "(CGrafPtr port, PixPatHandle backPattern) -> None"},
6102 {"SetPortPenSize", (PyCFunction)Qd_SetPortPenSize, 1,
6103 "(CGrafPtr port, Point penSize) -> None"},
6104 {"SetPortPenMode", (PyCFunction)Qd_SetPortPenMode, 1,
6105 "(CGrafPtr port, SInt32 penMode) -> None"},
6106 {"SetPortFracHPenLocation", (PyCFunction)Qd_SetPortFracHPenLocation, 1,
6107 "(CGrafPtr port, short pnLocHFrac) -> None"},
6108 {"GetPixBounds", (PyCFunction)Qd_GetPixBounds, 1,
6109 "(PixMapHandle pixMap) -> (Rect bounds)"},
6110 {"GetPixDepth", (PyCFunction)Qd_GetPixDepth, 1,
6111 "(PixMapHandle pixMap) -> (short _rv)"},
6112 {"GetQDGlobalsRandomSeed", (PyCFunction)Qd_GetQDGlobalsRandomSeed, 1,
6113 "() -> (long _rv)"},
6114 {"GetQDGlobalsScreenBits", (PyCFunction)Qd_GetQDGlobalsScreenBits, 1,
6115 "() -> (BitMap screenBits)"},
6116 {"GetQDGlobalsArrow", (PyCFunction)Qd_GetQDGlobalsArrow, 1,
6117 "() -> (Cursor arrow)"},
6118 {"GetQDGlobalsDarkGray", (PyCFunction)Qd_GetQDGlobalsDarkGray, 1,
6119 "() -> (Pattern dkGray)"},
6120 {"GetQDGlobalsLightGray", (PyCFunction)Qd_GetQDGlobalsLightGray, 1,
6121 "() -> (Pattern ltGray)"},
6122 {"GetQDGlobalsGray", (PyCFunction)Qd_GetQDGlobalsGray, 1,
6123 "() -> (Pattern gray)"},
6124 {"GetQDGlobalsBlack", (PyCFunction)Qd_GetQDGlobalsBlack, 1,
6125 "() -> (Pattern black)"},
6126 {"GetQDGlobalsWhite", (PyCFunction)Qd_GetQDGlobalsWhite, 1,
6127 "() -> (Pattern white)"},
6128 {"GetQDGlobalsThePort", (PyCFunction)Qd_GetQDGlobalsThePort, 1,
6129 "() -> (CGrafPtr _rv)"},
6130 {"SetQDGlobalsRandomSeed", (PyCFunction)Qd_SetQDGlobalsRandomSeed, 1,
6131 "(long randomSeed) -> None"},
6132 {"SetQDGlobalsArrow", (PyCFunction)Qd_SetQDGlobalsArrow, 1,
6133 "(Cursor arrow) -> None"},
6134 {"GetRegionBounds", (PyCFunction)Qd_GetRegionBounds, 1,
6135 "(RgnHandle region) -> (Rect bounds)"},
6136
6137#if TARGET_API_MAC_CARBON
6138 {"IsRegionRectangular", (PyCFunction)Qd_IsRegionRectangular, 1,
6139 "(RgnHandle region) -> (Boolean _rv)"},
6140#endif
6141
6142#if TARGET_API_MAC_CARBON
6143 {"CreateNewPort", (PyCFunction)Qd_CreateNewPort, 1,
6144 "() -> (CGrafPtr _rv)"},
6145#endif
6146
6147#if TARGET_API_MAC_CARBON
6148 {"DisposePort", (PyCFunction)Qd_DisposePort, 1,
6149 "(CGrafPtr port) -> None"},
6150#endif
6151
6152#if TARGET_API_MAC_CARBON
6153 {"SetQDError", (PyCFunction)Qd_SetQDError, 1,
6154 "(OSErr err) -> None"},
6155#endif
6156 {"QDIsPortBuffered", (PyCFunction)Qd_QDIsPortBuffered, 1,
6157 "(CGrafPtr port) -> (Boolean _rv)"},
6158 {"QDIsPortBufferDirty", (PyCFunction)Qd_QDIsPortBufferDirty, 1,
6159 "(CGrafPtr port) -> (Boolean _rv)"},
6160 {"QDFlushPortBuffer", (PyCFunction)Qd_QDFlushPortBuffer, 1,
6161 "(CGrafPtr port, RgnHandle region) -> None"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]6162 {"TextFont", (PyCFunction)Qd_TextFont, 1,
6163 "(short font) -> None"},
6164 {"TextFace", (PyCFunction)Qd_TextFace, 1,
Jack Jansene742a821998-02-25 15:46:50 +0000[diff] [blame]6165 "(StyleParameter face) -> None"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]6166 {"TextMode", (PyCFunction)Qd_TextMode, 1,
6167 "(short mode) -> None"},
6168 {"TextSize", (PyCFunction)Qd_TextSize, 1,
6169 "(short size) -> None"},
6170 {"SpaceExtra", (PyCFunction)Qd_SpaceExtra, 1,
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]6171 "(Fixed extra) -> None"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]6172 {"DrawChar", (PyCFunction)Qd_DrawChar, 1,
Jack Jansen21f96871998-02-20 16:02:09 +0000[diff] [blame]6173 "(CharParameter ch) -> None"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]6174 {"DrawString", (PyCFunction)Qd_DrawString, 1,
6175 "(Str255 s) -> None"},
Jack Jansen1c4e6141998-04-21 15:23:55 +0000[diff] [blame]6176 {"MacDrawText", (PyCFunction)Qd_MacDrawText, 1,
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]6177 "(Buffer textBuf, short firstByte, short byteCount) -> None"},
6178 {"CharWidth", (PyCFunction)Qd_CharWidth, 1,
Jack Jansen21f96871998-02-20 16:02:09 +0000[diff] [blame]6179 "(CharParameter ch) -> (short _rv)"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]6180 {"StringWidth", (PyCFunction)Qd_StringWidth, 1,
6181 "(Str255 s) -> (short _rv)"},
6182 {"TextWidth", (PyCFunction)Qd_TextWidth, 1,
6183 "(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)"},
Jack Jansen3a50f8a1996-01-11 16:17:14 +0000[diff] [blame]6184 {"GetFontInfo", (PyCFunction)Qd_GetFontInfo, 1,
6185 "() -> (FontInfo info)"},
Jack Jansenb81cf9d1995-06-06 13:08:40 +0000[diff] [blame]6186 {"CharExtra", (PyCFunction)Qd_CharExtra, 1,
Jack Jansen330381c1995-11-15 15:18:01 +0000[diff] [blame]6187 "(Fixed extra) -> None"},
Jack Jansen7f725e41998-04-23 13:21:09 +0000[diff] [blame]6188 {"SetPort", (PyCFunction)Qd_SetPort, 1,
Jack Jansen29bfea91998-04-27 15:09:36 +0000[diff] [blame]6189 "(GrafPtr thePort) -> None"},
Jack Jansene180d991998-04-24 10:28:20 +0000[diff] [blame]6190 {"GetCursor", (PyCFunction)Qd_GetCursor, 1,
6191 "(short cursorID) -> (CursHandle _rv)"},
6192 {"SetCursor", (PyCFunction)Qd_SetCursor, 1,
6193 "(Cursor crsr) -> None"},
6194 {"ShowCursor", (PyCFunction)Qd_ShowCursor, 1,
6195 "() -> None"},
6196 {"LineTo", (PyCFunction)Qd_LineTo, 1,
6197 "(short h, short v) -> None"},
6198 {"SetRect", (PyCFunction)Qd_SetRect, 1,
6199 "(short left, short top, short right, short bottom) -> (Rect r)"},
6200 {"OffsetRect", (PyCFunction)Qd_OffsetRect, 1,
6201 "(Rect r, short dh, short dv) -> (Rect r)"},
6202 {"InsetRect", (PyCFunction)Qd_InsetRect, 1,
6203 "(Rect r, short dh, short dv) -> (Rect r)"},
6204 {"UnionRect", (PyCFunction)Qd_UnionRect, 1,
6205 "(Rect src1, Rect src2) -> (Rect dstRect)"},
6206 {"EqualRect", (PyCFunction)Qd_EqualRect, 1,
6207 "(Rect rect1, Rect rect2) -> (Boolean _rv)"},
6208 {"FrameRect", (PyCFunction)Qd_FrameRect, 1,
6209 "(Rect r) -> None"},
6210 {"InvertRect", (PyCFunction)Qd_InvertRect, 1,
6211 "(Rect r) -> None"},
6212 {"FillRect", (PyCFunction)Qd_FillRect, 1,
6213 "(Rect r, Pattern pat) -> None"},
6214 {"CopyRgn", (PyCFunction)Qd_CopyRgn, 1,
6215 "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
6216 {"SetRectRgn", (PyCFunction)Qd_SetRectRgn, 1,
6217 "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
6218 {"OffsetRgn", (PyCFunction)Qd_OffsetRgn, 1,
6219 "(RgnHandle rgn, short dh, short dv) -> None"},
6220 {"UnionRgn", (PyCFunction)Qd_UnionRgn, 1,
6221 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
6222 {"XorRgn", (PyCFunction)Qd_XorRgn, 1,
6223 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
6224 {"EqualRgn", (PyCFunction)Qd_EqualRgn, 1,
6225 "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
6226 {"FrameRgn", (PyCFunction)Qd_FrameRgn, 1,
6227 "(RgnHandle rgn) -> None"},
6228 {"PaintRgn", (PyCFunction)Qd_PaintRgn, 1,
6229 "(RgnHandle rgn) -> None"},
6230 {"InvertRgn", (PyCFunction)Qd_InvertRgn, 1,
6231 "(RgnHandle rgn) -> None"},
6232 {"FillRgn", (PyCFunction)Qd_FillRgn, 1,
6233 "(RgnHandle rgn, Pattern pat) -> None"},
6234 {"GetPixel", (PyCFunction)Qd_GetPixel, 1,
6235 "(short h, short v) -> (Boolean _rv)"},
6236 {"PtInRect", (PyCFunction)Qd_PtInRect, 1,
6237 "(Point pt, Rect r) -> (Boolean _rv)"},
6238 {"DrawText", (PyCFunction)Qd_DrawText, 1,
6239 "(Buffer textBuf, short firstByte, short byteCount) -> None"},
Jack Jansen41058c01995-11-16 22:48:29 +0000[diff] [blame]6240 {"BitMap", (PyCFunction)Qd_BitMap, 1,
6241 "Take (string, int, Rect) argument and create BitMap"},
Jack Jansen425e9eb1995-12-12 15:02:03 +0000[diff] [blame]6242 {"RawBitMap", (PyCFunction)Qd_RawBitMap, 1,
6243 "Take string BitMap and turn into BitMap object"},
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]6244 {NULL, NULL, 0}
6245};
6246
6247
6248
6249
6250void initQd()
6251{
6252 PyObject *m;
6253 PyObject *d;
6254
6255
6256
6257
6258 m = Py_InitModule("Qd", Qd_methods);
6259 d = PyModule_GetDict(m);
6260 Qd_Error = PyMac_GetOSErrException();
6261 if (Qd_Error == NULL ||
6262 PyDict_SetItemString(d, "Error", Qd_Error) != 0)
Jack Jansenbd58eda2001-01-24 14:05:11 +0000[diff] [blame^]6263 return;
Jack Jansena755e681997-09-20 17:40:22 +0000[diff] [blame]6264 GrafPort_Type.ob_type = &PyType_Type;
6265 Py_INCREF(&GrafPort_Type);
6266 if (PyDict_SetItemString(d, "GrafPortType", (PyObject *)&GrafPort_Type) != 0)
6267 Py_FatalError("can't initialize GrafPortType");
6268 BitMap_Type.ob_type = &PyType_Type;
6269 Py_INCREF(&BitMap_Type);
6270 if (PyDict_SetItemString(d, "BitMapType", (PyObject *)&BitMap_Type) != 0)
6271 Py_FatalError("can't initialize BitMapType");
6272 QDGlobalsAccess_Type.ob_type = &PyType_Type;
6273 Py_INCREF(&QDGlobalsAccess_Type);
6274 if (PyDict_SetItemString(d, "QDGlobalsAccessType", (PyObject *)&QDGlobalsAccess_Type) != 0)
6275 Py_FatalError("can't initialize QDGlobalsAccessType");
Jack Jansenb5394061996-01-05 18:06:41 +0000[diff] [blame]6276
6277 {
6278 PyObject *o;
Jack Jansenbdd07471996-01-29 15:44:03 +0000[diff] [blame]6279
6280 o = QDGA_New();
6281 if (o == NULL || PyDict_SetItemString(d, "qd", o) != 0)
Jack Jansenbd58eda2001-01-24 14:05:11 +0000[diff] [blame^]6282 return;
Jack Jansenb5394061996-01-05 18:06:41 +0000[diff] [blame]6283 }
6284
6285
Guido van Rossum17448e21995-01-30 11:53:55 +0000[diff] [blame]6286}
6287
6288/* ========================= End module Qd ========================== */
6289