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