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