_Qdmodule.c revision c83ea137d7e717f764e2f31fc2544f522de7d857
1 2/* =========================== Module _Qd =========================== */ 3 4#include "Python.h" 5 6 7#ifndef __LP64__ 8 9#include "pymactoolbox.h" 10 11/* Macro to test whether a weak-loaded CFM function exists */ 12#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ 13 PyErr_SetString(PyExc_NotImplementedError, \ 14 "Not available in this shared library/OS version"); \ 15 return NULL; \ 16 }} while(0) 17 18 19#include <Carbon/Carbon.h> 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, ®ion)) 1069 return NULL; 1070 _rv = QDLocalToGlobalRegion(_self->ob_itself, 1071 region); 1072 _res = Py_BuildValue("O&", 1073 ResObj_New, _rv); 1074 return _res; 1075} 1076 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, ®ion)) 1087 return NULL; 1088 _rv = QDGlobalToLocalRegion(_self->ob_itself, 1089 region); 1090 _res = Py_BuildValue("O&", 1091 ResObj_New, _rv); 1092 return _res; 1093} 1094 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, ®ion)) 1134 return NULL; 1135 QDFlushPortBuffer(_self->ob_itself, 1136 region); 1137 Py_INCREF(Py_None); 1138 _res = Py_None; 1139 return _res; 1140} 1141 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, ®ion, 2766 BMObj_Convert, &bMap)) 2767 return NULL; 2768 _err = BitMapToRegion(region, 2769 bMap); 2770 if (_err != noErr) return PyMac_Error(_err); 2771 Py_INCREF(Py_None); 2772 _res = Py_None; 2773 return _res; 2774} 2775 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, ®ion, 2786 ResObj_Convert, &flattenedRgnDataHdl)) 2787 return NULL; 2788 RgnToHandle(region, 2789 flattenedRgnDataHdl); 2790 Py_INCREF(Py_None); 2791 _res = Py_None; 2792 return _res; 2793} 2794 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(<Gray__out__); 5108 _res = Py_BuildValue("s#", 5109 (char *)<Gray__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, ®ion)) 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, ®ion)) 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#ifndef __LP64__ 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#ifndef __LP64__ 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#ifndef __LP64__ 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#ifndef __LP64__ 7131 d = PyModule_GetDict(m); 7132 Qd_Error = PyMac_GetOSErrException(); 7133 if (Qd_Error == NULL || 7134 PyDict_SetItemString(d, "Error", Qd_Error) != 0) 7135 return; 7136 GrafPort_Type.ob_type = &PyType_Type; 7137 if (PyType_Ready(&GrafPort_Type) < 0) return; 7138 Py_INCREF(&GrafPort_Type); 7139 PyModule_AddObject(m, "GrafPort", (PyObject *)&GrafPort_Type); 7140 /* Backward-compatible name */ 7141 Py_INCREF(&GrafPort_Type); 7142 PyModule_AddObject(m, "GrafPortType", (PyObject *)&GrafPort_Type); 7143 BitMap_Type.ob_type = &PyType_Type; 7144 if (PyType_Ready(&BitMap_Type) < 0) return; 7145 Py_INCREF(&BitMap_Type); 7146 PyModule_AddObject(m, "BitMap", (PyObject *)&BitMap_Type); 7147 /* Backward-compatible name */ 7148 Py_INCREF(&BitMap_Type); 7149 PyModule_AddObject(m, "BitMapType", (PyObject *)&BitMap_Type); 7150#endif /* __LP64__ */ 7151} 7152 7153/* ========================= End module _Qd ========================= */ 7154 7155