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