source: python/trunk/Mac/Modules/qd/_Qdmodule.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 192.2 KB
Line 
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
22extern PyObject *_GrafObj_New(GrafPtr);
23extern int _GrafObj_Convert(PyObject *, GrafPtr *);
24extern PyObject *_BMObj_New(BitMapPtr);
25extern int _BMObj_Convert(PyObject *, BitMapPtr *);
26extern PyObject *_QdRGB_New(RGBColorPtr);
27extern 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
37static PyObject *BMObj_NewCopied(BitMapPtr);
38
39/*
40** Parse/generate RGB records
41*/
42PyObject *QdRGB_New(RGBColorPtr itself)
43{
44
45 return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue);
46}
47
48int 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*/
63static
64PyObject *QdFI_New(FontInfo *itself)
65{
66
67 return Py_BuildValue("hhhh", itself->ascent, itself->descent,
68 itself->widMax, itself->leading);
69}
70
71static PyObject *Qd_Error;
72
73/* ---------------------- Object type GrafPort ---------------------- */
74
75PyTypeObject GrafPort_Type;
76
77#define GrafObj_Check(x) ((x)->ob_type == &GrafPort_Type || PyObject_TypeCheck((x), &GrafPort_Type))
78
79typedef struct GrafPortObject {
80 PyObject_HEAD
81 GrafPtr ob_itself;
82} GrafPortObject;
83
84PyObject *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
94int 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
126static void GrafObj_dealloc(GrafPortObject *self)
127{
128 /* Cleanup of self->ob_itself goes here */
129 self->ob_type->tp_free((PyObject *)self);
130}
131
132static 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
146static 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
164static 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
179static 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
194static 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
209static 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
225static 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
241static 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
257static 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
273static 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
289static 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
304static 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
319static 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
334static 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
349static 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
364static 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
379static 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
394static 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
409static 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
427static 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
445static 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
463static 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
481static 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
499static 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
516static 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
531static 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
548static 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
563static 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
578static 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
593static 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
608static 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
623static 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
638static 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
653static 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
670static 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
687static 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
705static 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
723static 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
741static 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
758static 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
775static 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
792static 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
809static 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
826static 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
843static 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
860static 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
877static 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
894static 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
911static 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
928static 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
945static 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
962static 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
979static 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
993static 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
1010static 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
1027static 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
1043static 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
1059static 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, &region))
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
1077static 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, &region))
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
1095static 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
1110static 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
1125static 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, &region))
1134 return NULL;
1135 QDFlushPortBuffer(_self->ob_itself,
1136 region);
1137 Py_INCREF(Py_None);
1138 _res = Py_None;
1139 return _res;
1140}
1141
1142static 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
1161static 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
1180static 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
1312static 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
1321static 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
1330static 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
1346static 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
1361PyTypeObject 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
1410PyTypeObject BitMap_Type;
1411
1412#define BMObj_Check(x) ((x)->ob_type == &BitMap_Type || PyObject_TypeCheck((x), &BitMap_Type))
1413
1414typedef struct BitMapObject {
1415 PyObject_HEAD
1416 BitMapPtr ob_itself;
1417 PyObject *referred_object;
1418 BitMap *referred_bitmap;
1419} BitMapObject;
1420
1421PyObject *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
1433int 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
1444static 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
1451static 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
1466static 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
1483static 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
1491static 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
1498static 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
1505static 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
1512static 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
1519static 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
1526static 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
1545static 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
1560PyTypeObject 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
1607static 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
1622static 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
1638static 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
1654static 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
1673static 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
1692static 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
1711static 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
1727static 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
1743static 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
1759static 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
1782static 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
1796static 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
1819static 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
1833static 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
1847static 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
1861static 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
1875static 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
1889static 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
1904static 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
1919static 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
1942static 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
1961static 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
1977static 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
2000static 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
2014static 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
2033static 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
2052static 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
2071static 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
2090static 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
2106static 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
2122static 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
2138static 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
2165static 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
2187static 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
2209static 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
2232static 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
2253static 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
2273static 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
2290static 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
2306static 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
2322static 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
2338static 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
2354static 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
2380static 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
2396static 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
2412static 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
2428static 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
2444static 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
2470static 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
2492static 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
2514static 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
2536static 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
2558static 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
2590static 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
2612static 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
2634static 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
2656static 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
2678static 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
2710static 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
2725static 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
2739static 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
2755static 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, &region,
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
2776static 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, &region,
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
2795static 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
2811static 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
2830static 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
2846static 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
2874static 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
2893static 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
2915static 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
2937static 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
2959static 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
2981static 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
3003static 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
3025static 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
3045static 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
3065static 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
3082static 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
3098static 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
3114static 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
3130static 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
3146static 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
3172static 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
3197static 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
3228static 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
3259static 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
3276static 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
3298static 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
3312static 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
3331static 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
3347static 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
3362static 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
3376static 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
3392static 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
3414static 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
3430static 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
3446static 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
3462static 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
3478static 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
3504static 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
3525static 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
3541static 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
3557static 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
3572static 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
3592static 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
3614static 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
3636static 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
3658static 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
3680static 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
3702static 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
3730static 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
3749static 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
3769static 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
3789static 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
3810static 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
3831static 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
3850static 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
3870static 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
3885static 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
3901static 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
3920static 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
3935static 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
3951static 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
3970static 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
3986static 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
4002static 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
4019static 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
4038static 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
4057static 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
4076static 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
4101static 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
4126static 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
4145static 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
4164static 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
4180static 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
4196static 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
4218static 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
4234static 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
4255static 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
4270static 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
4285static 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
4301static 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
4317static 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
4333static 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
4350static 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
4367static 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
4383static 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
4397static 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
4413static 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
4430static 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
4445static 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
4460static 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
4475static 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
4492static 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
4512static 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
4534static 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
4556static 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
4576static 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
4592static 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
4608static 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
4623static 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
4640static 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
4658static 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
4673static 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
4690static 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
4712static 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
4734static 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
4750static 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
4769static 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
4788static 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
4803static 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
4840static 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
4857static 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
4874static 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
4891static 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
4911static 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
4930static 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
4948static 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
4969static 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
4986static 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
5003static 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
5021static 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
5038static 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
5053static 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
5068static 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
5083static 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
5098static 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(&ltGray__out__);
5108 _res = Py_BuildValue("s#",
5109 (char *)&ltGray__out__, (int)sizeof(Pattern));
5110 return _res;
5111}
5112
5113static 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
5128static 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
5143static 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
5158static 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
5173static 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
5189static 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
5212static 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, &region))
5222 return NULL;
5223 GetRegionBounds(region,
5224 &bounds);
5225 _res = Py_BuildValue("O&",
5226 PyMac_BuildRect, &bounds);
5227 return _res;
5228}
5229
5230static 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, &region))
5240 return NULL;
5241 _rv = IsRegionRectangular(region);
5242 _res = Py_BuildValue("b",
5243 _rv);
5244 return _res;
5245}
5246
5247static 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
5262static 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
5278static 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
5293static 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
5309static 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
5324static 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
5340static 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
5355static 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
5371static 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
5386static 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
5402static 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
5417static 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
5433static 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
5448static 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
5464static 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
5479static 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
5495static 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
5510static 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
5526static 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
5541static 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
5557static 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
5572static 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
5588static 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
5603static 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
5619static 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
5634static 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
5650static 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
5665static 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
5681static 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
5696static 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
5712static 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
5728static 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
5744static 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
5760static 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
5776static 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
5792static 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
5808static 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
5824static 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
5849static 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
5866static 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
5883static 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
5909static 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
5924static 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
5940static 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
5963static 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
5979static 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
5996static 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
6019static 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
6033static 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
6052static 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
6079static 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
6101static 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
6123static 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
6144static 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
6164static 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
6180static 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
6196static 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
6222static 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
6241static 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
6269static 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
6291static 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
6313static 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
6335static 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
6355static 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
6371static 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
6387static 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
6403static 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
6429static 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
6449static 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
6469static 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
6494static 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
6524static 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
6550static 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*/
7096PyObject *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
7112void 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
Note: See TracBrowser for help on using the repository browser.