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