1 2 /* ========================== Module _Menu ========================== */ 3 4 #include "Python.h" 5 6 #ifndef __LP64__ 7 8 9 #include "pymactoolbox.h" 10 11 /* Macro to test whether a weak-loaded CFM function exists */ 12 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ 13 PyErr_SetString(PyExc_NotImplementedError, \ 14 "Not available in this shared library/OS version"); \ 15 return NULL; \ 16 }} while(0) 17 18 19 #include <Carbon/Carbon.h> 20 21 22 #ifdef USE_TOOLBOX_OBJECT_GLUE 23 24 extern PyObject *_MenuObj_New(MenuHandle); 25 extern int _MenuObj_Convert(PyObject *, MenuHandle *); 26 27 #define MenuObj_New _MenuObj_New 28 #define MenuObj_Convert _MenuObj_Convert 29 #endif 30 31 #define as_Menu(h) ((MenuHandle)h) 32 #define as_Resource(h) ((Handle)h) 33 34 35 /* Alternative version of MenuObj_New, which returns None for NULL argument */ 36 PyObject *OptMenuObj_New(MenuRef itself) 37 { 38 if (itself == NULL) { 39 Py_INCREF(Py_None); 40 return Py_None; 41 } 42 return MenuObj_New(itself); 43 } 44 45 /* Alternative version of MenuObj_Convert, which returns NULL for a None argument */ 46 int OptMenuObj_Convert(PyObject *v, MenuRef *p_itself) 47 { 48 if ( v == Py_None ) { 49 *p_itself = NULL; 50 return 1; 51 } 52 return MenuObj_Convert(v, p_itself); 53 } 54 55 static PyObject *Menu_Error; 56 57 /* ------------------------ Object type Menu ------------------------ */ 58 59 PyTypeObject Menu_Type; 60 61 #define MenuObj_Check(x) ((x)->ob_type == &Menu_Type || PyObject_TypeCheck((x), &Menu_Type)) 62 63 typedef struct MenuObject { 64 PyObject_HEAD 65 MenuHandle ob_itself; 66 } MenuObject; 67 68 PyObject *MenuObj_New(MenuHandle itself) 69 { 70 MenuObject *it; 71 it = PyObject_NEW(MenuObject, &Menu_Type); 72 if (it == NULL) return NULL; 73 it->ob_itself = itself; 74 return (PyObject *)it; 75 } 76 77 int MenuObj_Convert(PyObject *v, MenuHandle *p_itself) 78 { 79 if (!MenuObj_Check(v)) 80 { 81 PyErr_SetString(PyExc_TypeError, "Menu required"); 82 return 0; 83 } 84 *p_itself = ((MenuObject *)v)->ob_itself; 85 return 1; 86 } 87 88 static void MenuObj_dealloc(MenuObject *self) 89 { 90 /* Cleanup of self->ob_itself goes here */ 91 self->ob_type->tp_free((PyObject *)self); 92 } 93 94 static PyObject *MenuObj_DisposeMenu(MenuObject *_self, PyObject *_args) 95 { 96 PyObject *_res = NULL; 97 #ifndef DisposeMenu 98 PyMac_PRECHECK(DisposeMenu); 99 #endif 100 if (!PyArg_ParseTuple(_args, "")) 101 return NULL; 102 DisposeMenu(_self->ob_itself); 103 Py_INCREF(Py_None); 104 _res = Py_None; 105 return _res; 106 } 107 108 static PyObject *MenuObj_CalcMenuSize(MenuObject *_self, PyObject *_args) 109 { 110 PyObject *_res = NULL; 111 #ifndef CalcMenuSize 112 PyMac_PRECHECK(CalcMenuSize); 113 #endif 114 if (!PyArg_ParseTuple(_args, "")) 115 return NULL; 116 CalcMenuSize(_self->ob_itself); 117 Py_INCREF(Py_None); 118 _res = Py_None; 119 return _res; 120 } 121 122 static PyObject *MenuObj_CountMenuItems(MenuObject *_self, PyObject *_args) 123 { 124 PyObject *_res = NULL; 125 UInt16 _rv; 126 #ifndef CountMenuItems 127 PyMac_PRECHECK(CountMenuItems); 128 #endif 129 if (!PyArg_ParseTuple(_args, "")) 130 return NULL; 131 _rv = CountMenuItems(_self->ob_itself); 132 _res = Py_BuildValue("H", 133 _rv); 134 return _res; 135 } 136 137 static PyObject *MenuObj_GetMenuFont(MenuObject *_self, PyObject *_args) 138 { 139 PyObject *_res = NULL; 140 OSStatus _err; 141 SInt16 outFontID; 142 UInt16 outFontSize; 143 #ifndef GetMenuFont 144 PyMac_PRECHECK(GetMenuFont); 145 #endif 146 if (!PyArg_ParseTuple(_args, "")) 147 return NULL; 148 _err = GetMenuFont(_self->ob_itself, 149 &outFontID, 150 &outFontSize); 151 if (_err != noErr) return PyMac_Error(_err); 152 _res = Py_BuildValue("hH", 153 outFontID, 154 outFontSize); 155 return _res; 156 } 157 158 static PyObject *MenuObj_SetMenuFont(MenuObject *_self, PyObject *_args) 159 { 160 PyObject *_res = NULL; 161 OSStatus _err; 162 SInt16 inFontID; 163 UInt16 inFontSize; 164 #ifndef SetMenuFont 165 PyMac_PRECHECK(SetMenuFont); 166 #endif 167 if (!PyArg_ParseTuple(_args, "hH", 168 &inFontID, 169 &inFontSize)) 170 return NULL; 171 _err = SetMenuFont(_self->ob_itself, 172 inFontID, 173 inFontSize); 174 if (_err != noErr) return PyMac_Error(_err); 175 Py_INCREF(Py_None); 176 _res = Py_None; 177 return _res; 178 } 179 180 static PyObject *MenuObj_GetMenuExcludesMarkColumn(MenuObject *_self, PyObject *_args) 181 { 182 PyObject *_res = NULL; 183 Boolean _rv; 184 #ifndef GetMenuExcludesMarkColumn 185 PyMac_PRECHECK(GetMenuExcludesMarkColumn); 186 #endif 187 if (!PyArg_ParseTuple(_args, "")) 188 return NULL; 189 _rv = GetMenuExcludesMarkColumn(_self->ob_itself); 190 _res = Py_BuildValue("b", 191 _rv); 192 return _res; 193 } 194 195 static PyObject *MenuObj_SetMenuExcludesMarkColumn(MenuObject *_self, PyObject *_args) 196 { 197 PyObject *_res = NULL; 198 OSStatus _err; 199 Boolean excludesMark; 200 #ifndef SetMenuExcludesMarkColumn 201 PyMac_PRECHECK(SetMenuExcludesMarkColumn); 202 #endif 203 if (!PyArg_ParseTuple(_args, "b", 204 &excludesMark)) 205 return NULL; 206 _err = SetMenuExcludesMarkColumn(_self->ob_itself, 207 excludesMark); 208 if (_err != noErr) return PyMac_Error(_err); 209 Py_INCREF(Py_None); 210 _res = Py_None; 211 return _res; 212 } 213 214 static PyObject *MenuObj_IsValidMenu(MenuObject *_self, PyObject *_args) 215 { 216 PyObject *_res = NULL; 217 Boolean _rv; 218 #ifndef IsValidMenu 219 PyMac_PRECHECK(IsValidMenu); 220 #endif 221 if (!PyArg_ParseTuple(_args, "")) 222 return NULL; 223 _rv = IsValidMenu(_self->ob_itself); 224 _res = Py_BuildValue("b", 225 _rv); 226 return _res; 227 } 228 229 static PyObject *MenuObj_GetMenuRetainCount(MenuObject *_self, PyObject *_args) 230 { 231 PyObject *_res = NULL; 232 ItemCount _rv; 233 #ifndef GetMenuRetainCount 234 PyMac_PRECHECK(GetMenuRetainCount); 235 #endif 236 if (!PyArg_ParseTuple(_args, "")) 237 return NULL; 238 _rv = GetMenuRetainCount(_self->ob_itself); 239 _res = Py_BuildValue("l", 240 _rv); 241 return _res; 242 } 243 244 static PyObject *MenuObj_RetainMenu(MenuObject *_self, PyObject *_args) 245 { 246 PyObject *_res = NULL; 247 OSStatus _err; 248 #ifndef RetainMenu 249 PyMac_PRECHECK(RetainMenu); 250 #endif 251 if (!PyArg_ParseTuple(_args, "")) 252 return NULL; 253 _err = RetainMenu(_self->ob_itself); 254 if (_err != noErr) return PyMac_Error(_err); 255 Py_INCREF(Py_None); 256 _res = Py_None; 257 return _res; 258 } 259 260 static PyObject *MenuObj_ReleaseMenu(MenuObject *_self, PyObject *_args) 261 { 262 PyObject *_res = NULL; 263 OSStatus _err; 264 #ifndef ReleaseMenu 265 PyMac_PRECHECK(ReleaseMenu); 266 #endif 267 if (!PyArg_ParseTuple(_args, "")) 268 return NULL; 269 _err = ReleaseMenu(_self->ob_itself); 270 if (_err != noErr) return PyMac_Error(_err); 271 Py_INCREF(Py_None); 272 _res = Py_None; 273 return _res; 274 } 275 276 static PyObject *MenuObj_DuplicateMenu(MenuObject *_self, PyObject *_args) 277 { 278 PyObject *_res = NULL; 279 OSStatus _err; 280 MenuHandle outMenu; 281 #ifndef DuplicateMenu 282 PyMac_PRECHECK(DuplicateMenu); 283 #endif 284 if (!PyArg_ParseTuple(_args, "")) 285 return NULL; 286 _err = DuplicateMenu(_self->ob_itself, 287 &outMenu); 288 if (_err != noErr) return PyMac_Error(_err); 289 _res = Py_BuildValue("O&", 290 MenuObj_New, outMenu); 291 return _res; 292 } 293 294 static PyObject *MenuObj_CopyMenuTitleAsCFString(MenuObject *_self, PyObject *_args) 295 { 296 PyObject *_res = NULL; 297 OSStatus _err; 298 CFStringRef outString; 299 #ifndef CopyMenuTitleAsCFString 300 PyMac_PRECHECK(CopyMenuTitleAsCFString); 301 #endif 302 if (!PyArg_ParseTuple(_args, "")) 303 return NULL; 304 _err = CopyMenuTitleAsCFString(_self->ob_itself, 305 &outString); 306 if (_err != noErr) return PyMac_Error(_err); 307 _res = Py_BuildValue("O&", 308 CFStringRefObj_New, outString); 309 return _res; 310 } 311 312 static PyObject *MenuObj_SetMenuTitleWithCFString(MenuObject *_self, PyObject *_args) 313 { 314 PyObject *_res = NULL; 315 OSStatus _err; 316 CFStringRef inString; 317 #ifndef SetMenuTitleWithCFString 318 PyMac_PRECHECK(SetMenuTitleWithCFString); 319 #endif 320 if (!PyArg_ParseTuple(_args, "O&", 321 CFStringRefObj_Convert, &inString)) 322 return NULL; 323 _err = SetMenuTitleWithCFString(_self->ob_itself, 324 inString); 325 if (_err != noErr) return PyMac_Error(_err); 326 Py_INCREF(Py_None); 327 _res = Py_None; 328 return _res; 329 } 330 331 static PyObject *MenuObj_InvalidateMenuSize(MenuObject *_self, PyObject *_args) 332 { 333 PyObject *_res = NULL; 334 OSStatus _err; 335 #ifndef InvalidateMenuSize 336 PyMac_PRECHECK(InvalidateMenuSize); 337 #endif 338 if (!PyArg_ParseTuple(_args, "")) 339 return NULL; 340 _err = InvalidateMenuSize(_self->ob_itself); 341 if (_err != noErr) return PyMac_Error(_err); 342 Py_INCREF(Py_None); 343 _res = Py_None; 344 return _res; 345 } 346 347 static PyObject *MenuObj_IsMenuSizeInvalid(MenuObject *_self, PyObject *_args) 348 { 349 PyObject *_res = NULL; 350 Boolean _rv; 351 #ifndef IsMenuSizeInvalid 352 PyMac_PRECHECK(IsMenuSizeInvalid); 353 #endif 354 if (!PyArg_ParseTuple(_args, "")) 355 return NULL; 356 _rv = IsMenuSizeInvalid(_self->ob_itself); 357 _res = Py_BuildValue("b", 358 _rv); 359 return _res; 360 } 361 362 static PyObject *MenuObj_MacAppendMenu(MenuObject *_self, PyObject *_args) 363 { 364 PyObject *_res = NULL; 365 Str255 data; 366 #ifndef MacAppendMenu 367 PyMac_PRECHECK(MacAppendMenu); 368 #endif 369 if (!PyArg_ParseTuple(_args, "O&", 370 PyMac_GetStr255, data)) 371 return NULL; 372 MacAppendMenu(_self->ob_itself, 373 data); 374 Py_INCREF(Py_None); 375 _res = Py_None; 376 return _res; 377 } 378 379 static PyObject *MenuObj_InsertResMenu(MenuObject *_self, PyObject *_args) 380 { 381 PyObject *_res = NULL; 382 ResType theType; 383 short afterItem; 384 #ifndef InsertResMenu 385 PyMac_PRECHECK(InsertResMenu); 386 #endif 387 if (!PyArg_ParseTuple(_args, "O&h", 388 PyMac_GetOSType, &theType, 389 &afterItem)) 390 return NULL; 391 InsertResMenu(_self->ob_itself, 392 theType, 393 afterItem); 394 Py_INCREF(Py_None); 395 _res = Py_None; 396 return _res; 397 } 398 399 static PyObject *MenuObj_AppendResMenu(MenuObject *_self, PyObject *_args) 400 { 401 PyObject *_res = NULL; 402 ResType theType; 403 #ifndef AppendResMenu 404 PyMac_PRECHECK(AppendResMenu); 405 #endif 406 if (!PyArg_ParseTuple(_args, "O&", 407 PyMac_GetOSType, &theType)) 408 return NULL; 409 AppendResMenu(_self->ob_itself, 410 theType); 411 Py_INCREF(Py_None); 412 _res = Py_None; 413 return _res; 414 } 415 416 static PyObject *MenuObj_MacInsertMenuItem(MenuObject *_self, PyObject *_args) 417 { 418 PyObject *_res = NULL; 419 Str255 itemString; 420 short afterItem; 421 #ifndef MacInsertMenuItem 422 PyMac_PRECHECK(MacInsertMenuItem); 423 #endif 424 if (!PyArg_ParseTuple(_args, "O&h", 425 PyMac_GetStr255, itemString, 426 &afterItem)) 427 return NULL; 428 MacInsertMenuItem(_self->ob_itself, 429 itemString, 430 afterItem); 431 Py_INCREF(Py_None); 432 _res = Py_None; 433 return _res; 434 } 435 436 static PyObject *MenuObj_DeleteMenuItem(MenuObject *_self, PyObject *_args) 437 { 438 PyObject *_res = NULL; 439 short item; 440 #ifndef DeleteMenuItem 441 PyMac_PRECHECK(DeleteMenuItem); 442 #endif 443 if (!PyArg_ParseTuple(_args, "h", 444 &item)) 445 return NULL; 446 DeleteMenuItem(_self->ob_itself, 447 item); 448 Py_INCREF(Py_None); 449 _res = Py_None; 450 return _res; 451 } 452 453 static PyObject *MenuObj_InsertFontResMenu(MenuObject *_self, PyObject *_args) 454 { 455 PyObject *_res = NULL; 456 short afterItem; 457 short scriptFilter; 458 #ifndef InsertFontResMenu 459 PyMac_PRECHECK(InsertFontResMenu); 460 #endif 461 if (!PyArg_ParseTuple(_args, "hh", 462 &afterItem, 463 &scriptFilter)) 464 return NULL; 465 InsertFontResMenu(_self->ob_itself, 466 afterItem, 467 scriptFilter); 468 Py_INCREF(Py_None); 469 _res = Py_None; 470 return _res; 471 } 472 473 static PyObject *MenuObj_InsertIntlResMenu(MenuObject *_self, PyObject *_args) 474 { 475 PyObject *_res = NULL; 476 ResType theType; 477 short afterItem; 478 short scriptFilter; 479 #ifndef InsertIntlResMenu 480 PyMac_PRECHECK(InsertIntlResMenu); 481 #endif 482 if (!PyArg_ParseTuple(_args, "O&hh", 483 PyMac_GetOSType, &theType, 484 &afterItem, 485 &scriptFilter)) 486 return NULL; 487 InsertIntlResMenu(_self->ob_itself, 488 theType, 489 afterItem, 490 scriptFilter); 491 Py_INCREF(Py_None); 492 _res = Py_None; 493 return _res; 494 } 495 496 static PyObject *MenuObj_AppendMenuItemText(MenuObject *_self, PyObject *_args) 497 { 498 PyObject *_res = NULL; 499 OSStatus _err; 500 Str255 inString; 501 #ifndef AppendMenuItemText 502 PyMac_PRECHECK(AppendMenuItemText); 503 #endif 504 if (!PyArg_ParseTuple(_args, "O&", 505 PyMac_GetStr255, inString)) 506 return NULL; 507 _err = AppendMenuItemText(_self->ob_itself, 508 inString); 509 if (_err != noErr) return PyMac_Error(_err); 510 Py_INCREF(Py_None); 511 _res = Py_None; 512 return _res; 513 } 514 515 static PyObject *MenuObj_InsertMenuItemText(MenuObject *_self, PyObject *_args) 516 { 517 PyObject *_res = NULL; 518 OSStatus _err; 519 Str255 inString; 520 MenuItemIndex afterItem; 521 #ifndef InsertMenuItemText 522 PyMac_PRECHECK(InsertMenuItemText); 523 #endif 524 if (!PyArg_ParseTuple(_args, "O&h", 525 PyMac_GetStr255, inString, 526 &afterItem)) 527 return NULL; 528 _err = InsertMenuItemText(_self->ob_itself, 529 inString, 530 afterItem); 531 if (_err != noErr) return PyMac_Error(_err); 532 Py_INCREF(Py_None); 533 _res = Py_None; 534 return _res; 535 } 536 537 static PyObject *MenuObj_CopyMenuItems(MenuObject *_self, PyObject *_args) 538 { 539 PyObject *_res = NULL; 540 OSStatus _err; 541 MenuItemIndex inFirstItem; 542 ItemCount inNumItems; 543 MenuHandle inDestMenu; 544 MenuItemIndex inInsertAfter; 545 #ifndef CopyMenuItems 546 PyMac_PRECHECK(CopyMenuItems); 547 #endif 548 if (!PyArg_ParseTuple(_args, "hlO&h", 549 &inFirstItem, 550 &inNumItems, 551 MenuObj_Convert, &inDestMenu, 552 &inInsertAfter)) 553 return NULL; 554 _err = CopyMenuItems(_self->ob_itself, 555 inFirstItem, 556 inNumItems, 557 inDestMenu, 558 inInsertAfter); 559 if (_err != noErr) return PyMac_Error(_err); 560 Py_INCREF(Py_None); 561 _res = Py_None; 562 return _res; 563 } 564 565 static PyObject *MenuObj_DeleteMenuItems(MenuObject *_self, PyObject *_args) 566 { 567 PyObject *_res = NULL; 568 OSStatus _err; 569 MenuItemIndex inFirstItem; 570 ItemCount inNumItems; 571 #ifndef DeleteMenuItems 572 PyMac_PRECHECK(DeleteMenuItems); 573 #endif 574 if (!PyArg_ParseTuple(_args, "hl", 575 &inFirstItem, 576 &inNumItems)) 577 return NULL; 578 _err = DeleteMenuItems(_self->ob_itself, 579 inFirstItem, 580 inNumItems); 581 if (_err != noErr) return PyMac_Error(_err); 582 Py_INCREF(Py_None); 583 _res = Py_None; 584 return _res; 585 } 586 587 static PyObject *MenuObj_AppendMenuItemTextWithCFString(MenuObject *_self, PyObject *_args) 588 { 589 PyObject *_res = NULL; 590 OSStatus _err; 591 CFStringRef inString; 592 MenuItemAttributes inAttributes; 593 MenuCommand inCommandID; 594 MenuItemIndex outNewItem; 595 #ifndef AppendMenuItemTextWithCFString 596 PyMac_PRECHECK(AppendMenuItemTextWithCFString); 597 #endif 598 if (!PyArg_ParseTuple(_args, "O&ll", 599 CFStringRefObj_Convert, &inString, 600 &inAttributes, 601 &inCommandID)) 602 return NULL; 603 _err = AppendMenuItemTextWithCFString(_self->ob_itself, 604 inString, 605 inAttributes, 606 inCommandID, 607 &outNewItem); 608 if (_err != noErr) return PyMac_Error(_err); 609 _res = Py_BuildValue("h", 610 outNewItem); 611 return _res; 612 } 613 614 static PyObject *MenuObj_InsertMenuItemTextWithCFString(MenuObject *_self, PyObject *_args) 615 { 616 PyObject *_res = NULL; 617 OSStatus _err; 618 CFStringRef inString; 619 MenuItemIndex inAfterItem; 620 MenuItemAttributes inAttributes; 621 MenuCommand inCommandID; 622 #ifndef InsertMenuItemTextWithCFString 623 PyMac_PRECHECK(InsertMenuItemTextWithCFString); 624 #endif 625 if (!PyArg_ParseTuple(_args, "O&hll", 626 CFStringRefObj_Convert, &inString, 627 &inAfterItem, 628 &inAttributes, 629 &inCommandID)) 630 return NULL; 631 _err = InsertMenuItemTextWithCFString(_self->ob_itself, 632 inString, 633 inAfterItem, 634 inAttributes, 635 inCommandID); 636 if (_err != noErr) return PyMac_Error(_err); 637 Py_INCREF(Py_None); 638 _res = Py_None; 639 return _res; 640 } 641 642 static PyObject *MenuObj_PopUpMenuSelect(MenuObject *_self, PyObject *_args) 643 { 644 PyObject *_res = NULL; 645 long _rv; 646 short top; 647 short left; 648 short popUpItem; 649 #ifndef PopUpMenuSelect 650 PyMac_PRECHECK(PopUpMenuSelect); 651 #endif 652 if (!PyArg_ParseTuple(_args, "hhh", 653 &top, 654 &left, 655 &popUpItem)) 656 return NULL; 657 _rv = PopUpMenuSelect(_self->ob_itself, 658 top, 659 left, 660 popUpItem); 661 _res = Py_BuildValue("l", 662 _rv); 663 return _res; 664 } 665 666 static PyObject *MenuObj_InvalidateMenuEnabling(MenuObject *_self, PyObject *_args) 667 { 668 PyObject *_res = NULL; 669 OSStatus _err; 670 #ifndef InvalidateMenuEnabling 671 PyMac_PRECHECK(InvalidateMenuEnabling); 672 #endif 673 if (!PyArg_ParseTuple(_args, "")) 674 return NULL; 675 _err = InvalidateMenuEnabling(_self->ob_itself); 676 if (_err != noErr) return PyMac_Error(_err); 677 Py_INCREF(Py_None); 678 _res = Py_None; 679 return _res; 680 } 681 682 static PyObject *MenuObj_IsMenuBarInvalid(MenuObject *_self, PyObject *_args) 683 { 684 PyObject *_res = NULL; 685 Boolean _rv; 686 #ifndef IsMenuBarInvalid 687 PyMac_PRECHECK(IsMenuBarInvalid); 688 #endif 689 if (!PyArg_ParseTuple(_args, "")) 690 return NULL; 691 _rv = IsMenuBarInvalid(_self->ob_itself); 692 _res = Py_BuildValue("b", 693 _rv); 694 return _res; 695 } 696 697 static PyObject *MenuObj_MacInsertMenu(MenuObject *_self, PyObject *_args) 698 { 699 PyObject *_res = NULL; 700 MenuID beforeID; 701 #ifndef MacInsertMenu 702 PyMac_PRECHECK(MacInsertMenu); 703 #endif 704 if (!PyArg_ParseTuple(_args, "h", 705 &beforeID)) 706 return NULL; 707 MacInsertMenu(_self->ob_itself, 708 beforeID); 709 Py_INCREF(Py_None); 710 _res = Py_None; 711 return _res; 712 } 713 714 static PyObject *MenuObj_SetRootMenu(MenuObject *_self, PyObject *_args) 715 { 716 PyObject *_res = NULL; 717 OSStatus _err; 718 #ifndef SetRootMenu 719 PyMac_PRECHECK(SetRootMenu); 720 #endif 721 if (!PyArg_ParseTuple(_args, "")) 722 return NULL; 723 _err = SetRootMenu(_self->ob_itself); 724 if (_err != noErr) return PyMac_Error(_err); 725 Py_INCREF(Py_None); 726 _res = Py_None; 727 return _res; 728 } 729 730 static PyObject *MenuObj_MacCheckMenuItem(MenuObject *_self, PyObject *_args) 731 { 732 PyObject *_res = NULL; 733 short item; 734 Boolean checked; 735 #ifndef MacCheckMenuItem 736 PyMac_PRECHECK(MacCheckMenuItem); 737 #endif 738 if (!PyArg_ParseTuple(_args, "hb", 739 &item, 740 &checked)) 741 return NULL; 742 MacCheckMenuItem(_self->ob_itself, 743 item, 744 checked); 745 Py_INCREF(Py_None); 746 _res = Py_None; 747 return _res; 748 } 749 750 static PyObject *MenuObj_SetMenuItemText(MenuObject *_self, PyObject *_args) 751 { 752 PyObject *_res = NULL; 753 short item; 754 Str255 itemString; 755 #ifndef SetMenuItemText 756 PyMac_PRECHECK(SetMenuItemText); 757 #endif 758 if (!PyArg_ParseTuple(_args, "hO&", 759 &item, 760 PyMac_GetStr255, itemString)) 761 return NULL; 762 SetMenuItemText(_self->ob_itself, 763 item, 764 itemString); 765 Py_INCREF(Py_None); 766 _res = Py_None; 767 return _res; 768 } 769 770 static PyObject *MenuObj_GetMenuItemText(MenuObject *_self, PyObject *_args) 771 { 772 PyObject *_res = NULL; 773 short item; 774 Str255 itemString; 775 #ifndef GetMenuItemText 776 PyMac_PRECHECK(GetMenuItemText); 777 #endif 778 if (!PyArg_ParseTuple(_args, "h", 779 &item)) 780 return NULL; 781 GetMenuItemText(_self->ob_itself, 782 item, 783 itemString); 784 _res = Py_BuildValue("O&", 785 PyMac_BuildStr255, itemString); 786 return _res; 787 } 788 789 static PyObject *MenuObj_SetItemMark(MenuObject *_self, PyObject *_args) 790 { 791 PyObject *_res = NULL; 792 short item; 793 CharParameter markChar; 794 #ifndef SetItemMark 795 PyMac_PRECHECK(SetItemMark); 796 #endif 797 if (!PyArg_ParseTuple(_args, "hh", 798 &item, 799 &markChar)) 800 return NULL; 801 SetItemMark(_self->ob_itself, 802 item, 803 markChar); 804 Py_INCREF(Py_None); 805 _res = Py_None; 806 return _res; 807 } 808 809 static PyObject *MenuObj_GetItemMark(MenuObject *_self, PyObject *_args) 810 { 811 PyObject *_res = NULL; 812 short item; 813 CharParameter markChar; 814 #ifndef GetItemMark 815 PyMac_PRECHECK(GetItemMark); 816 #endif 817 if (!PyArg_ParseTuple(_args, "h", 818 &item)) 819 return NULL; 820 GetItemMark(_self->ob_itself, 821 item, 822 &markChar); 823 _res = Py_BuildValue("h", 824 markChar); 825 return _res; 826 } 827 828 static PyObject *MenuObj_SetItemCmd(MenuObject *_self, PyObject *_args) 829 { 830 PyObject *_res = NULL; 831 short item; 832 CharParameter cmdChar; 833 #ifndef SetItemCmd 834 PyMac_PRECHECK(SetItemCmd); 835 #endif 836 if (!PyArg_ParseTuple(_args, "hh", 837 &item, 838 &cmdChar)) 839 return NULL; 840 SetItemCmd(_self->ob_itself, 841 item, 842 cmdChar); 843 Py_INCREF(Py_None); 844 _res = Py_None; 845 return _res; 846 } 847 848 static PyObject *MenuObj_GetItemCmd(MenuObject *_self, PyObject *_args) 849 { 850 PyObject *_res = NULL; 851 short item; 852 CharParameter cmdChar; 853 #ifndef GetItemCmd 854 PyMac_PRECHECK(GetItemCmd); 855 #endif 856 if (!PyArg_ParseTuple(_args, "h", 857 &item)) 858 return NULL; 859 GetItemCmd(_self->ob_itself, 860 item, 861 &cmdChar); 862 _res = Py_BuildValue("h", 863 cmdChar); 864 return _res; 865 } 866 867 static PyObject *MenuObj_SetItemIcon(MenuObject *_self, PyObject *_args) 868 { 869 PyObject *_res = NULL; 870 short item; 871 short iconIndex; 872 #ifndef SetItemIcon 873 PyMac_PRECHECK(SetItemIcon); 874 #endif 875 if (!PyArg_ParseTuple(_args, "hh", 876 &item, 877 &iconIndex)) 878 return NULL; 879 SetItemIcon(_self->ob_itself, 880 item, 881 iconIndex); 882 Py_INCREF(Py_None); 883 _res = Py_None; 884 return _res; 885 } 886 887 static PyObject *MenuObj_GetItemIcon(MenuObject *_self, PyObject *_args) 888 { 889 PyObject *_res = NULL; 890 short item; 891 short iconIndex; 892 #ifndef GetItemIcon 893 PyMac_PRECHECK(GetItemIcon); 894 #endif 895 if (!PyArg_ParseTuple(_args, "h", 896 &item)) 897 return NULL; 898 GetItemIcon(_self->ob_itself, 899 item, 900 &iconIndex); 901 _res = Py_BuildValue("h", 902 iconIndex); 903 return _res; 904 } 905 906 static PyObject *MenuObj_SetItemStyle(MenuObject *_self, PyObject *_args) 907 { 908 PyObject *_res = NULL; 909 short item; 910 StyleParameter chStyle; 911 #ifndef SetItemStyle 912 PyMac_PRECHECK(SetItemStyle); 913 #endif 914 if (!PyArg_ParseTuple(_args, "hh", 915 &item, 916 &chStyle)) 917 return NULL; 918 SetItemStyle(_self->ob_itself, 919 item, 920 chStyle); 921 Py_INCREF(Py_None); 922 _res = Py_None; 923 return _res; 924 } 925 926 static PyObject *MenuObj_GetItemStyle(MenuObject *_self, PyObject *_args) 927 { 928 PyObject *_res = NULL; 929 short item; 930 Style chStyle; 931 #ifndef GetItemStyle 932 PyMac_PRECHECK(GetItemStyle); 933 #endif 934 if (!PyArg_ParseTuple(_args, "h", 935 &item)) 936 return NULL; 937 GetItemStyle(_self->ob_itself, 938 item, 939 &chStyle); 940 _res = Py_BuildValue("b", 941 chStyle); 942 return _res; 943 } 944 945 static PyObject *MenuObj_SetMenuItemCommandID(MenuObject *_self, PyObject *_args) 946 { 947 PyObject *_res = NULL; 948 OSErr _err; 949 SInt16 inItem; 950 MenuCommand inCommandID; 951 #ifndef SetMenuItemCommandID 952 PyMac_PRECHECK(SetMenuItemCommandID); 953 #endif 954 if (!PyArg_ParseTuple(_args, "hl", 955 &inItem, 956 &inCommandID)) 957 return NULL; 958 _err = SetMenuItemCommandID(_self->ob_itself, 959 inItem, 960 inCommandID); 961 if (_err != noErr) return PyMac_Error(_err); 962 Py_INCREF(Py_None); 963 _res = Py_None; 964 return _res; 965 } 966 967 static PyObject *MenuObj_GetMenuItemCommandID(MenuObject *_self, PyObject *_args) 968 { 969 PyObject *_res = NULL; 970 OSErr _err; 971 SInt16 inItem; 972 MenuCommand outCommandID; 973 #ifndef GetMenuItemCommandID 974 PyMac_PRECHECK(GetMenuItemCommandID); 975 #endif 976 if (!PyArg_ParseTuple(_args, "h", 977 &inItem)) 978 return NULL; 979 _err = GetMenuItemCommandID(_self->ob_itself, 980 inItem, 981 &outCommandID); 982 if (_err != noErr) return PyMac_Error(_err); 983 _res = Py_BuildValue("l", 984 outCommandID); 985 return _res; 986 } 987 988 static PyObject *MenuObj_SetMenuItemModifiers(MenuObject *_self, PyObject *_args) 989 { 990 PyObject *_res = NULL; 991 OSErr _err; 992 SInt16 inItem; 993 UInt8 inModifiers; 994 #ifndef SetMenuItemModifiers 995 PyMac_PRECHECK(SetMenuItemModifiers); 996 #endif 997 if (!PyArg_ParseTuple(_args, "hb", 998 &inItem, 999 &inModifiers)) 1000 return NULL; 1001 _err = SetMenuItemModifiers(_self->ob_itself, 1002 inItem, 1003 inModifiers); 1004 if (_err != noErr) return PyMac_Error(_err); 1005 Py_INCREF(Py_None); 1006 _res = Py_None; 1007 return _res; 1008 } 1009 1010 static PyObject *MenuObj_GetMenuItemModifiers(MenuObject *_self, PyObject *_args) 1011 { 1012 PyObject *_res = NULL; 1013 OSErr _err; 1014 SInt16 inItem; 1015 UInt8 outModifiers; 1016 #ifndef GetMenuItemModifiers 1017 PyMac_PRECHECK(GetMenuItemModifiers); 1018 #endif 1019 if (!PyArg_ParseTuple(_args, "h", 1020 &inItem)) 1021 return NULL; 1022 _err = GetMenuItemModifiers(_self->ob_itself, 1023 inItem, 1024 &outModifiers); 1025 if (_err != noErr) return PyMac_Error(_err); 1026 _res = Py_BuildValue("b", 1027 outModifiers); 1028 return _res; 1029 } 1030 1031 static PyObject *MenuObj_SetMenuItemIconHandle(MenuObject *_self, PyObject *_args) 1032 { 1033 PyObject *_res = NULL; 1034 OSErr _err; 1035 SInt16 inItem; 1036 UInt8 inIconType; 1037 Handle inIconHandle; 1038 #ifndef SetMenuItemIconHandle 1039 PyMac_PRECHECK(SetMenuItemIconHandle); 1040 #endif 1041 if (!PyArg_ParseTuple(_args, "hbO&", 1042 &inItem, 1043 &inIconType, 1044 ResObj_Convert, &inIconHandle)) 1045 return NULL; 1046 _err = SetMenuItemIconHandle(_self->ob_itself, 1047 inItem, 1048 inIconType, 1049 inIconHandle); 1050 if (_err != noErr) return PyMac_Error(_err); 1051 Py_INCREF(Py_None); 1052 _res = Py_None; 1053 return _res; 1054 } 1055 1056 static PyObject *MenuObj_GetMenuItemIconHandle(MenuObject *_self, PyObject *_args) 1057 { 1058 PyObject *_res = NULL; 1059 OSErr _err; 1060 SInt16 inItem; 1061 UInt8 outIconType; 1062 Handle outIconHandle; 1063 #ifndef GetMenuItemIconHandle 1064 PyMac_PRECHECK(GetMenuItemIconHandle); 1065 #endif 1066 if (!PyArg_ParseTuple(_args, "h", 1067 &inItem)) 1068 return NULL; 1069 _err = GetMenuItemIconHandle(_self->ob_itself, 1070 inItem, 1071 &outIconType, 1072 &outIconHandle); 1073 if (_err != noErr) return PyMac_Error(_err); 1074 _res = Py_BuildValue("bO&", 1075 outIconType, 1076 ResObj_New, outIconHandle); 1077 return _res; 1078 } 1079 1080 static PyObject *MenuObj_SetMenuItemTextEncoding(MenuObject *_self, PyObject *_args) 1081 { 1082 PyObject *_res = NULL; 1083 OSErr _err; 1084 SInt16 inItem; 1085 TextEncoding inScriptID; 1086 #ifndef SetMenuItemTextEncoding 1087 PyMac_PRECHECK(SetMenuItemTextEncoding); 1088 #endif 1089 if (!PyArg_ParseTuple(_args, "hl", 1090 &inItem, 1091 &inScriptID)) 1092 return NULL; 1093 _err = SetMenuItemTextEncoding(_self->ob_itself, 1094 inItem, 1095 inScriptID); 1096 if (_err != noErr) return PyMac_Error(_err); 1097 Py_INCREF(Py_None); 1098 _res = Py_None; 1099 return _res; 1100 } 1101 1102 static PyObject *MenuObj_GetMenuItemTextEncoding(MenuObject *_self, PyObject *_args) 1103 { 1104 PyObject *_res = NULL; 1105 OSErr _err; 1106 SInt16 inItem; 1107 TextEncoding outScriptID; 1108 #ifndef GetMenuItemTextEncoding 1109 PyMac_PRECHECK(GetMenuItemTextEncoding); 1110 #endif 1111 if (!PyArg_ParseTuple(_args, "h", 1112 &inItem)) 1113 return NULL; 1114 _err = GetMenuItemTextEncoding(_self->ob_itself, 1115 inItem, 1116 &outScriptID); 1117 if (_err != noErr) return PyMac_Error(_err); 1118 _res = Py_BuildValue("l", 1119 outScriptID); 1120 return _res; 1121 } 1122 1123 static PyObject *MenuObj_SetMenuItemHierarchicalID(MenuObject *_self, PyObject *_args) 1124 { 1125 PyObject *_res = NULL; 1126 OSErr _err; 1127 SInt16 inItem; 1128 MenuID inHierID; 1129 #ifndef SetMenuItemHierarchicalID 1130 PyMac_PRECHECK(SetMenuItemHierarchicalID); 1131 #endif 1132 if (!PyArg_ParseTuple(_args, "hh", 1133 &inItem, 1134 &inHierID)) 1135 return NULL; 1136 _err = SetMenuItemHierarchicalID(_self->ob_itself, 1137 inItem, 1138 inHierID); 1139 if (_err != noErr) return PyMac_Error(_err); 1140 Py_INCREF(Py_None); 1141 _res = Py_None; 1142 return _res; 1143 } 1144 1145 static PyObject *MenuObj_GetMenuItemHierarchicalID(MenuObject *_self, PyObject *_args) 1146 { 1147 PyObject *_res = NULL; 1148 OSErr _err; 1149 SInt16 inItem; 1150 MenuID outHierID; 1151 #ifndef GetMenuItemHierarchicalID 1152 PyMac_PRECHECK(GetMenuItemHierarchicalID); 1153 #endif 1154 if (!PyArg_ParseTuple(_args, "h", 1155 &inItem)) 1156 return NULL; 1157 _err = GetMenuItemHierarchicalID(_self->ob_itself, 1158 inItem, 1159 &outHierID); 1160 if (_err != noErr) return PyMac_Error(_err); 1161 _res = Py_BuildValue("h", 1162 outHierID); 1163 return _res; 1164 } 1165 1166 static PyObject *MenuObj_SetMenuItemFontID(MenuObject *_self, PyObject *_args) 1167 { 1168 PyObject *_res = NULL; 1169 OSErr _err; 1170 SInt16 inItem; 1171 SInt16 inFontID; 1172 #ifndef SetMenuItemFontID 1173 PyMac_PRECHECK(SetMenuItemFontID); 1174 #endif 1175 if (!PyArg_ParseTuple(_args, "hh", 1176 &inItem, 1177 &inFontID)) 1178 return NULL; 1179 _err = SetMenuItemFontID(_self->ob_itself, 1180 inItem, 1181 inFontID); 1182 if (_err != noErr) return PyMac_Error(_err); 1183 Py_INCREF(Py_None); 1184 _res = Py_None; 1185 return _res; 1186 } 1187 1188 static PyObject *MenuObj_GetMenuItemFontID(MenuObject *_self, PyObject *_args) 1189 { 1190 PyObject *_res = NULL; 1191 OSErr _err; 1192 SInt16 inItem; 1193 SInt16 outFontID; 1194 #ifndef GetMenuItemFontID 1195 PyMac_PRECHECK(GetMenuItemFontID); 1196 #endif 1197 if (!PyArg_ParseTuple(_args, "h", 1198 &inItem)) 1199 return NULL; 1200 _err = GetMenuItemFontID(_self->ob_itself, 1201 inItem, 1202 &outFontID); 1203 if (_err != noErr) return PyMac_Error(_err); 1204 _res = Py_BuildValue("h", 1205 outFontID); 1206 return _res; 1207 } 1208 1209 static PyObject *MenuObj_SetMenuItemRefCon(MenuObject *_self, PyObject *_args) 1210 { 1211 PyObject *_res = NULL; 1212 OSErr _err; 1213 SInt16 inItem; 1214 UInt32 inRefCon; 1215 #ifndef SetMenuItemRefCon 1216 PyMac_PRECHECK(SetMenuItemRefCon); 1217 #endif 1218 if (!PyArg_ParseTuple(_args, "hl", 1219 &inItem, 1220 &inRefCon)) 1221 return NULL; 1222 _err = SetMenuItemRefCon(_self->ob_itself, 1223 inItem, 1224 inRefCon); 1225 if (_err != noErr) return PyMac_Error(_err); 1226 Py_INCREF(Py_None); 1227 _res = Py_None; 1228 return _res; 1229 } 1230 1231 static PyObject *MenuObj_GetMenuItemRefCon(MenuObject *_self, PyObject *_args) 1232 { 1233 PyObject *_res = NULL; 1234 OSErr _err; 1235 SInt16 inItem; 1236 UInt32 outRefCon; 1237 #ifndef GetMenuItemRefCon 1238 PyMac_PRECHECK(GetMenuItemRefCon); 1239 #endif 1240 if (!PyArg_ParseTuple(_args, "h", 1241 &inItem)) 1242 return NULL; 1243 _err = GetMenuItemRefCon(_self->ob_itself, 1244 inItem, 1245 &outRefCon); 1246 if (_err != noErr) return PyMac_Error(_err); 1247 _res = Py_BuildValue("l", 1248 outRefCon); 1249 return _res; 1250 } 1251 1252 static PyObject *MenuObj_SetMenuItemKeyGlyph(MenuObject *_self, PyObject *_args) 1253 { 1254 PyObject *_res = NULL; 1255 OSErr _err; 1256 SInt16 inItem; 1257 SInt16 inGlyph; 1258 #ifndef SetMenuItemKeyGlyph 1259 PyMac_PRECHECK(SetMenuItemKeyGlyph); 1260 #endif 1261 if (!PyArg_ParseTuple(_args, "hh", 1262 &inItem, 1263 &inGlyph)) 1264 return NULL; 1265 _err = SetMenuItemKeyGlyph(_self->ob_itself, 1266 inItem, 1267 inGlyph); 1268 if (_err != noErr) return PyMac_Error(_err); 1269 Py_INCREF(Py_None); 1270 _res = Py_None; 1271 return _res; 1272 } 1273 1274 static PyObject *MenuObj_GetMenuItemKeyGlyph(MenuObject *_self, PyObject *_args) 1275 { 1276 PyObject *_res = NULL; 1277 OSErr _err; 1278 SInt16 inItem; 1279 SInt16 outGlyph; 1280 #ifndef GetMenuItemKeyGlyph 1281 PyMac_PRECHECK(GetMenuItemKeyGlyph); 1282 #endif 1283 if (!PyArg_ParseTuple(_args, "h", 1284 &inItem)) 1285 return NULL; 1286 _err = GetMenuItemKeyGlyph(_self->ob_itself, 1287 inItem, 1288 &outGlyph); 1289 if (_err != noErr) return PyMac_Error(_err); 1290 _res = Py_BuildValue("h", 1291 outGlyph); 1292 return _res; 1293 } 1294 1295 static PyObject *MenuObj_MacEnableMenuItem(MenuObject *_self, PyObject *_args) 1296 { 1297 PyObject *_res = NULL; 1298 MenuItemIndex item; 1299 #ifndef MacEnableMenuItem 1300 PyMac_PRECHECK(MacEnableMenuItem); 1301 #endif 1302 if (!PyArg_ParseTuple(_args, "h", 1303 &item)) 1304 return NULL; 1305 MacEnableMenuItem(_self->ob_itself, 1306 item); 1307 Py_INCREF(Py_None); 1308 _res = Py_None; 1309 return _res; 1310 } 1311 1312 static PyObject *MenuObj_DisableMenuItem(MenuObject *_self, PyObject *_args) 1313 { 1314 PyObject *_res = NULL; 1315 MenuItemIndex item; 1316 #ifndef DisableMenuItem 1317 PyMac_PRECHECK(DisableMenuItem); 1318 #endif 1319 if (!PyArg_ParseTuple(_args, "h", 1320 &item)) 1321 return NULL; 1322 DisableMenuItem(_self->ob_itself, 1323 item); 1324 Py_INCREF(Py_None); 1325 _res = Py_None; 1326 return _res; 1327 } 1328 1329 static PyObject *MenuObj_IsMenuItemEnabled(MenuObject *_self, PyObject *_args) 1330 { 1331 PyObject *_res = NULL; 1332 Boolean _rv; 1333 MenuItemIndex item; 1334 #ifndef IsMenuItemEnabled 1335 PyMac_PRECHECK(IsMenuItemEnabled); 1336 #endif 1337 if (!PyArg_ParseTuple(_args, "h", 1338 &item)) 1339 return NULL; 1340 _rv = IsMenuItemEnabled(_self->ob_itself, 1341 item); 1342 _res = Py_BuildValue("b", 1343 _rv); 1344 return _res; 1345 } 1346 1347 static PyObject *MenuObj_EnableMenuItemIcon(MenuObject *_self, PyObject *_args) 1348 { 1349 PyObject *_res = NULL; 1350 MenuItemIndex item; 1351 #ifndef EnableMenuItemIcon 1352 PyMac_PRECHECK(EnableMenuItemIcon); 1353 #endif 1354 if (!PyArg_ParseTuple(_args, "h", 1355 &item)) 1356 return NULL; 1357 EnableMenuItemIcon(_self->ob_itself, 1358 item); 1359 Py_INCREF(Py_None); 1360 _res = Py_None; 1361 return _res; 1362 } 1363 1364 static PyObject *MenuObj_DisableMenuItemIcon(MenuObject *_self, PyObject *_args) 1365 { 1366 PyObject *_res = NULL; 1367 MenuItemIndex item; 1368 #ifndef DisableMenuItemIcon 1369 PyMac_PRECHECK(DisableMenuItemIcon); 1370 #endif 1371 if (!PyArg_ParseTuple(_args, "h", 1372 &item)) 1373 return NULL; 1374 DisableMenuItemIcon(_self->ob_itself, 1375 item); 1376 Py_INCREF(Py_None); 1377 _res = Py_None; 1378 return _res; 1379 } 1380 1381 static PyObject *MenuObj_IsMenuItemIconEnabled(MenuObject *_self, PyObject *_args) 1382 { 1383 PyObject *_res = NULL; 1384 Boolean _rv; 1385 MenuItemIndex item; 1386 #ifndef IsMenuItemIconEnabled 1387 PyMac_PRECHECK(IsMenuItemIconEnabled); 1388 #endif 1389 if (!PyArg_ParseTuple(_args, "h", 1390 &item)) 1391 return NULL; 1392 _rv = IsMenuItemIconEnabled(_self->ob_itself, 1393 item); 1394 _res = Py_BuildValue("b", 1395 _rv); 1396 return _res; 1397 } 1398 1399 static PyObject *MenuObj_SetMenuItemHierarchicalMenu(MenuObject *_self, PyObject *_args) 1400 { 1401 PyObject *_res = NULL; 1402 OSStatus _err; 1403 MenuItemIndex inItem; 1404 MenuHandle inHierMenu; 1405 #ifndef SetMenuItemHierarchicalMenu 1406 PyMac_PRECHECK(SetMenuItemHierarchicalMenu); 1407 #endif 1408 if (!PyArg_ParseTuple(_args, "hO&", 1409 &inItem, 1410 MenuObj_Convert, &inHierMenu)) 1411 return NULL; 1412 _err = SetMenuItemHierarchicalMenu(_self->ob_itself, 1413 inItem, 1414 inHierMenu); 1415 if (_err != noErr) return PyMac_Error(_err); 1416 Py_INCREF(Py_None); 1417 _res = Py_None; 1418 return _res; 1419 } 1420 1421 static PyObject *MenuObj_GetMenuItemHierarchicalMenu(MenuObject *_self, PyObject *_args) 1422 { 1423 PyObject *_res = NULL; 1424 OSStatus _err; 1425 MenuItemIndex inItem; 1426 MenuHandle outHierMenu; 1427 #ifndef GetMenuItemHierarchicalMenu 1428 PyMac_PRECHECK(GetMenuItemHierarchicalMenu); 1429 #endif 1430 if (!PyArg_ParseTuple(_args, "h", 1431 &inItem)) 1432 return NULL; 1433 _err = GetMenuItemHierarchicalMenu(_self->ob_itself, 1434 inItem, 1435 &outHierMenu); 1436 if (_err != noErr) return PyMac_Error(_err); 1437 _res = Py_BuildValue("O&", 1438 OptMenuObj_New, outHierMenu); 1439 return _res; 1440 } 1441 1442 static PyObject *MenuObj_CopyMenuItemTextAsCFString(MenuObject *_self, PyObject *_args) 1443 { 1444 PyObject *_res = NULL; 1445 OSStatus _err; 1446 MenuItemIndex inItem; 1447 CFStringRef outString; 1448 #ifndef CopyMenuItemTextAsCFString 1449 PyMac_PRECHECK(CopyMenuItemTextAsCFString); 1450 #endif 1451 if (!PyArg_ParseTuple(_args, "h", 1452 &inItem)) 1453 return NULL; 1454 _err = CopyMenuItemTextAsCFString(_self->ob_itself, 1455 inItem, 1456 &outString); 1457 if (_err != noErr) return PyMac_Error(_err); 1458 _res = Py_BuildValue("O&", 1459 CFStringRefObj_New, outString); 1460 return _res; 1461 } 1462 1463 static PyObject *MenuObj_SetMenuItemTextWithCFString(MenuObject *_self, PyObject *_args) 1464 { 1465 PyObject *_res = NULL; 1466 OSStatus _err; 1467 MenuItemIndex inItem; 1468 CFStringRef inString; 1469 #ifndef SetMenuItemTextWithCFString 1470 PyMac_PRECHECK(SetMenuItemTextWithCFString); 1471 #endif 1472 if (!PyArg_ParseTuple(_args, "hO&", 1473 &inItem, 1474 CFStringRefObj_Convert, &inString)) 1475 return NULL; 1476 _err = SetMenuItemTextWithCFString(_self->ob_itself, 1477 inItem, 1478 inString); 1479 if (_err != noErr) return PyMac_Error(_err); 1480 Py_INCREF(Py_None); 1481 _res = Py_None; 1482 return _res; 1483 } 1484 1485 static PyObject *MenuObj_GetMenuItemIndent(MenuObject *_self, PyObject *_args) 1486 { 1487 PyObject *_res = NULL; 1488 OSStatus _err; 1489 MenuItemIndex inItem; 1490 UInt32 outIndent; 1491 #ifndef GetMenuItemIndent 1492 PyMac_PRECHECK(GetMenuItemIndent); 1493 #endif 1494 if (!PyArg_ParseTuple(_args, "h", 1495 &inItem)) 1496 return NULL; 1497 _err = GetMenuItemIndent(_self->ob_itself, 1498 inItem, 1499 &outIndent); 1500 if (_err != noErr) return PyMac_Error(_err); 1501 _res = Py_BuildValue("l", 1502 outIndent); 1503 return _res; 1504 } 1505 1506 static PyObject *MenuObj_SetMenuItemIndent(MenuObject *_self, PyObject *_args) 1507 { 1508 PyObject *_res = NULL; 1509 OSStatus _err; 1510 MenuItemIndex inItem; 1511 UInt32 inIndent; 1512 #ifndef SetMenuItemIndent 1513 PyMac_PRECHECK(SetMenuItemIndent); 1514 #endif 1515 if (!PyArg_ParseTuple(_args, "hl", 1516 &inItem, 1517 &inIndent)) 1518 return NULL; 1519 _err = SetMenuItemIndent(_self->ob_itself, 1520 inItem, 1521 inIndent); 1522 if (_err != noErr) return PyMac_Error(_err); 1523 Py_INCREF(Py_None); 1524 _res = Py_None; 1525 return _res; 1526 } 1527 1528 static PyObject *MenuObj_GetMenuItemCommandKey(MenuObject *_self, PyObject *_args) 1529 { 1530 PyObject *_res = NULL; 1531 OSStatus _err; 1532 MenuItemIndex inItem; 1533 Boolean inGetVirtualKey; 1534 UInt16 outKey; 1535 #ifndef GetMenuItemCommandKey 1536 PyMac_PRECHECK(GetMenuItemCommandKey); 1537 #endif 1538 if (!PyArg_ParseTuple(_args, "hb", 1539 &inItem, 1540 &inGetVirtualKey)) 1541 return NULL; 1542 _err = GetMenuItemCommandKey(_self->ob_itself, 1543 inItem, 1544 inGetVirtualKey, 1545 &outKey); 1546 if (_err != noErr) return PyMac_Error(_err); 1547 _res = Py_BuildValue("H", 1548 outKey); 1549 return _res; 1550 } 1551 1552 static PyObject *MenuObj_SetMenuItemCommandKey(MenuObject *_self, PyObject *_args) 1553 { 1554 PyObject *_res = NULL; 1555 OSStatus _err; 1556 MenuItemIndex inItem; 1557 Boolean inSetVirtualKey; 1558 UInt16 inKey; 1559 #ifndef SetMenuItemCommandKey 1560 PyMac_PRECHECK(SetMenuItemCommandKey); 1561 #endif 1562 if (!PyArg_ParseTuple(_args, "hbH", 1563 &inItem, 1564 &inSetVirtualKey, 1565 &inKey)) 1566 return NULL; 1567 _err = SetMenuItemCommandKey(_self->ob_itself, 1568 inItem, 1569 inSetVirtualKey, 1570 inKey); 1571 if (_err != noErr) return PyMac_Error(_err); 1572 Py_INCREF(Py_None); 1573 _res = Py_None; 1574 return _res; 1575 } 1576 1577 static PyObject *MenuObj_GetMenuItemPropertyAttributes(MenuObject *_self, PyObject *_args) 1578 { 1579 PyObject *_res = NULL; 1580 OSStatus _err; 1581 MenuItemIndex item; 1582 OSType propertyCreator; 1583 OSType propertyTag; 1584 UInt32 attributes; 1585 #ifndef GetMenuItemPropertyAttributes 1586 PyMac_PRECHECK(GetMenuItemPropertyAttributes); 1587 #endif 1588 if (!PyArg_ParseTuple(_args, "hO&O&", 1589 &item, 1590 PyMac_GetOSType, &propertyCreator, 1591 PyMac_GetOSType, &propertyTag)) 1592 return NULL; 1593 _err = GetMenuItemPropertyAttributes(_self->ob_itself, 1594 item, 1595 propertyCreator, 1596 propertyTag, 1597 &attributes); 1598 if (_err != noErr) return PyMac_Error(_err); 1599 _res = Py_BuildValue("l", 1600 attributes); 1601 return _res; 1602 } 1603 1604 static PyObject *MenuObj_ChangeMenuItemPropertyAttributes(MenuObject *_self, PyObject *_args) 1605 { 1606 PyObject *_res = NULL; 1607 OSStatus _err; 1608 MenuItemIndex item; 1609 OSType propertyCreator; 1610 OSType propertyTag; 1611 UInt32 attributesToSet; 1612 UInt32 attributesToClear; 1613 #ifndef ChangeMenuItemPropertyAttributes 1614 PyMac_PRECHECK(ChangeMenuItemPropertyAttributes); 1615 #endif 1616 if (!PyArg_ParseTuple(_args, "hO&O&ll", 1617 &item, 1618 PyMac_GetOSType, &propertyCreator, 1619 PyMac_GetOSType, &propertyTag, 1620 &attributesToSet, 1621 &attributesToClear)) 1622 return NULL; 1623 _err = ChangeMenuItemPropertyAttributes(_self->ob_itself, 1624 item, 1625 propertyCreator, 1626 propertyTag, 1627 attributesToSet, 1628 attributesToClear); 1629 if (_err != noErr) return PyMac_Error(_err); 1630 Py_INCREF(Py_None); 1631 _res = Py_None; 1632 return _res; 1633 } 1634 1635 static PyObject *MenuObj_GetMenuAttributes(MenuObject *_self, PyObject *_args) 1636 { 1637 PyObject *_res = NULL; 1638 OSStatus _err; 1639 MenuAttributes outAttributes; 1640 #ifndef GetMenuAttributes 1641 PyMac_PRECHECK(GetMenuAttributes); 1642 #endif 1643 if (!PyArg_ParseTuple(_args, "")) 1644 return NULL; 1645 _err = GetMenuAttributes(_self->ob_itself, 1646 &outAttributes); 1647 if (_err != noErr) return PyMac_Error(_err); 1648 _res = Py_BuildValue("l", 1649 outAttributes); 1650 return _res; 1651 } 1652 1653 static PyObject *MenuObj_ChangeMenuAttributes(MenuObject *_self, PyObject *_args) 1654 { 1655 PyObject *_res = NULL; 1656 OSStatus _err; 1657 MenuAttributes setTheseAttributes; 1658 MenuAttributes clearTheseAttributes; 1659 #ifndef ChangeMenuAttributes 1660 PyMac_PRECHECK(ChangeMenuAttributes); 1661 #endif 1662 if (!PyArg_ParseTuple(_args, "ll", 1663 &setTheseAttributes, 1664 &clearTheseAttributes)) 1665 return NULL; 1666 _err = ChangeMenuAttributes(_self->ob_itself, 1667 setTheseAttributes, 1668 clearTheseAttributes); 1669 if (_err != noErr) return PyMac_Error(_err); 1670 Py_INCREF(Py_None); 1671 _res = Py_None; 1672 return _res; 1673 } 1674 1675 static PyObject *MenuObj_GetMenuItemAttributes(MenuObject *_self, PyObject *_args) 1676 { 1677 PyObject *_res = NULL; 1678 OSStatus _err; 1679 MenuItemIndex item; 1680 MenuItemAttributes outAttributes; 1681 #ifndef GetMenuItemAttributes 1682 PyMac_PRECHECK(GetMenuItemAttributes); 1683 #endif 1684 if (!PyArg_ParseTuple(_args, "h", 1685 &item)) 1686 return NULL; 1687 _err = GetMenuItemAttributes(_self->ob_itself, 1688 item, 1689 &outAttributes); 1690 if (_err != noErr) return PyMac_Error(_err); 1691 _res = Py_BuildValue("l", 1692 outAttributes); 1693 return _res; 1694 } 1695 1696 static PyObject *MenuObj_ChangeMenuItemAttributes(MenuObject *_self, PyObject *_args) 1697 { 1698 PyObject *_res = NULL; 1699 OSStatus _err; 1700 MenuItemIndex item; 1701 MenuItemAttributes setTheseAttributes; 1702 MenuItemAttributes clearTheseAttributes; 1703 #ifndef ChangeMenuItemAttributes 1704 PyMac_PRECHECK(ChangeMenuItemAttributes); 1705 #endif 1706 if (!PyArg_ParseTuple(_args, "hll", 1707 &item, 1708 &setTheseAttributes, 1709 &clearTheseAttributes)) 1710 return NULL; 1711 _err = ChangeMenuItemAttributes(_self->ob_itself, 1712 item, 1713 setTheseAttributes, 1714 clearTheseAttributes); 1715 if (_err != noErr) return PyMac_Error(_err); 1716 Py_INCREF(Py_None); 1717 _res = Py_None; 1718 return _res; 1719 } 1720 1721 static PyObject *MenuObj_DisableAllMenuItems(MenuObject *_self, PyObject *_args) 1722 { 1723 PyObject *_res = NULL; 1724 #ifndef DisableAllMenuItems 1725 PyMac_PRECHECK(DisableAllMenuItems); 1726 #endif 1727 if (!PyArg_ParseTuple(_args, "")) 1728 return NULL; 1729 DisableAllMenuItems(_self->ob_itself); 1730 Py_INCREF(Py_None); 1731 _res = Py_None; 1732 return _res; 1733 } 1734 1735 static PyObject *MenuObj_EnableAllMenuItems(MenuObject *_self, PyObject *_args) 1736 { 1737 PyObject *_res = NULL; 1738 #ifndef EnableAllMenuItems 1739 PyMac_PRECHECK(EnableAllMenuItems); 1740 #endif 1741 if (!PyArg_ParseTuple(_args, "")) 1742 return NULL; 1743 EnableAllMenuItems(_self->ob_itself); 1744 Py_INCREF(Py_None); 1745 _res = Py_None; 1746 return _res; 1747 } 1748 1749 static PyObject *MenuObj_MenuHasEnabledItems(MenuObject *_self, PyObject *_args) 1750 { 1751 PyObject *_res = NULL; 1752 Boolean _rv; 1753 #ifndef MenuHasEnabledItems 1754 PyMac_PRECHECK(MenuHasEnabledItems); 1755 #endif 1756 if (!PyArg_ParseTuple(_args, "")) 1757 return NULL; 1758 _rv = MenuHasEnabledItems(_self->ob_itself); 1759 _res = Py_BuildValue("b", 1760 _rv); 1761 return _res; 1762 } 1763 1764 static PyObject *MenuObj_GetMenuType(MenuObject *_self, PyObject *_args) 1765 { 1766 PyObject *_res = NULL; 1767 OSStatus _err; 1768 UInt16 outType; 1769 #ifndef GetMenuType 1770 PyMac_PRECHECK(GetMenuType); 1771 #endif 1772 if (!PyArg_ParseTuple(_args, "")) 1773 return NULL; 1774 _err = GetMenuType(_self->ob_itself, 1775 &outType); 1776 if (_err != noErr) return PyMac_Error(_err); 1777 _res = Py_BuildValue("H", 1778 outType); 1779 return _res; 1780 } 1781 1782 static PyObject *MenuObj_CountMenuItemsWithCommandID(MenuObject *_self, PyObject *_args) 1783 { 1784 PyObject *_res = NULL; 1785 ItemCount _rv; 1786 MenuCommand inCommandID; 1787 #ifndef CountMenuItemsWithCommandID 1788 PyMac_PRECHECK(CountMenuItemsWithCommandID); 1789 #endif 1790 if (!PyArg_ParseTuple(_args, "l", 1791 &inCommandID)) 1792 return NULL; 1793 _rv = CountMenuItemsWithCommandID(_self->ob_itself, 1794 inCommandID); 1795 _res = Py_BuildValue("l", 1796 _rv); 1797 return _res; 1798 } 1799 1800 static PyObject *MenuObj_GetIndMenuItemWithCommandID(MenuObject *_self, PyObject *_args) 1801 { 1802 PyObject *_res = NULL; 1803 OSStatus _err; 1804 MenuCommand inCommandID; 1805 UInt32 inItemIndex; 1806 MenuHandle outMenu; 1807 MenuItemIndex outIndex; 1808 #ifndef GetIndMenuItemWithCommandID 1809 PyMac_PRECHECK(GetIndMenuItemWithCommandID); 1810 #endif 1811 if (!PyArg_ParseTuple(_args, "ll", 1812 &inCommandID, 1813 &inItemIndex)) 1814 return NULL; 1815 _err = GetIndMenuItemWithCommandID(_self->ob_itself, 1816 inCommandID, 1817 inItemIndex, 1818 &outMenu, 1819 &outIndex); 1820 if (_err != noErr) return PyMac_Error(_err); 1821 _res = Py_BuildValue("O&h", 1822 MenuObj_New, outMenu, 1823 outIndex); 1824 return _res; 1825 } 1826 1827 static PyObject *MenuObj_EnableMenuCommand(MenuObject *_self, PyObject *_args) 1828 { 1829 PyObject *_res = NULL; 1830 MenuCommand inCommandID; 1831 #ifndef EnableMenuCommand 1832 PyMac_PRECHECK(EnableMenuCommand); 1833 #endif 1834 if (!PyArg_ParseTuple(_args, "l", 1835 &inCommandID)) 1836 return NULL; 1837 EnableMenuCommand(_self->ob_itself, 1838 inCommandID); 1839 Py_INCREF(Py_None); 1840 _res = Py_None; 1841 return _res; 1842 } 1843 1844 static PyObject *MenuObj_DisableMenuCommand(MenuObject *_self, PyObject *_args) 1845 { 1846 PyObject *_res = NULL; 1847 MenuCommand inCommandID; 1848 #ifndef DisableMenuCommand 1849 PyMac_PRECHECK(DisableMenuCommand); 1850 #endif 1851 if (!PyArg_ParseTuple(_args, "l", 1852 &inCommandID)) 1853 return NULL; 1854 DisableMenuCommand(_self->ob_itself, 1855 inCommandID); 1856 Py_INCREF(Py_None); 1857 _res = Py_None; 1858 return _res; 1859 } 1860 1861 static PyObject *MenuObj_IsMenuCommandEnabled(MenuObject *_self, PyObject *_args) 1862 { 1863 PyObject *_res = NULL; 1864 Boolean _rv; 1865 MenuCommand inCommandID; 1866 #ifndef IsMenuCommandEnabled 1867 PyMac_PRECHECK(IsMenuCommandEnabled); 1868 #endif 1869 if (!PyArg_ParseTuple(_args, "l", 1870 &inCommandID)) 1871 return NULL; 1872 _rv = IsMenuCommandEnabled(_self->ob_itself, 1873 inCommandID); 1874 _res = Py_BuildValue("b", 1875 _rv); 1876 return _res; 1877 } 1878 1879 static PyObject *MenuObj_SetMenuCommandMark(MenuObject *_self, PyObject *_args) 1880 { 1881 PyObject *_res = NULL; 1882 OSStatus _err; 1883 MenuCommand inCommandID; 1884 UniChar inMark; 1885 #ifndef SetMenuCommandMark 1886 PyMac_PRECHECK(SetMenuCommandMark); 1887 #endif 1888 if (!PyArg_ParseTuple(_args, "lh", 1889 &inCommandID, 1890 &inMark)) 1891 return NULL; 1892 _err = SetMenuCommandMark(_self->ob_itself, 1893 inCommandID, 1894 inMark); 1895 if (_err != noErr) return PyMac_Error(_err); 1896 Py_INCREF(Py_None); 1897 _res = Py_None; 1898 return _res; 1899 } 1900 1901 static PyObject *MenuObj_GetMenuCommandMark(MenuObject *_self, PyObject *_args) 1902 { 1903 PyObject *_res = NULL; 1904 OSStatus _err; 1905 MenuCommand inCommandID; 1906 UniChar outMark; 1907 #ifndef GetMenuCommandMark 1908 PyMac_PRECHECK(GetMenuCommandMark); 1909 #endif 1910 if (!PyArg_ParseTuple(_args, "l", 1911 &inCommandID)) 1912 return NULL; 1913 _err = GetMenuCommandMark(_self->ob_itself, 1914 inCommandID, 1915 &outMark); 1916 if (_err != noErr) return PyMac_Error(_err); 1917 _res = Py_BuildValue("h", 1918 outMark); 1919 return _res; 1920 } 1921 1922 static PyObject *MenuObj_GetMenuCommandPropertySize(MenuObject *_self, PyObject *_args) 1923 { 1924 PyObject *_res = NULL; 1925 OSStatus _err; 1926 MenuCommand inCommandID; 1927 OSType inPropertyCreator; 1928 OSType inPropertyTag; 1929 ByteCount outSize; 1930 #ifndef GetMenuCommandPropertySize 1931 PyMac_PRECHECK(GetMenuCommandPropertySize); 1932 #endif 1933 if (!PyArg_ParseTuple(_args, "lO&O&", 1934 &inCommandID, 1935 PyMac_GetOSType, &inPropertyCreator, 1936 PyMac_GetOSType, &inPropertyTag)) 1937 return NULL; 1938 _err = GetMenuCommandPropertySize(_self->ob_itself, 1939 inCommandID, 1940 inPropertyCreator, 1941 inPropertyTag, 1942 &outSize); 1943 if (_err != noErr) return PyMac_Error(_err); 1944 _res = Py_BuildValue("l", 1945 outSize); 1946 return _res; 1947 } 1948 1949 static PyObject *MenuObj_RemoveMenuCommandProperty(MenuObject *_self, PyObject *_args) 1950 { 1951 PyObject *_res = NULL; 1952 OSStatus _err; 1953 MenuCommand inCommandID; 1954 OSType inPropertyCreator; 1955 OSType inPropertyTag; 1956 #ifndef RemoveMenuCommandProperty 1957 PyMac_PRECHECK(RemoveMenuCommandProperty); 1958 #endif 1959 if (!PyArg_ParseTuple(_args, "lO&O&", 1960 &inCommandID, 1961 PyMac_GetOSType, &inPropertyCreator, 1962 PyMac_GetOSType, &inPropertyTag)) 1963 return NULL; 1964 _err = RemoveMenuCommandProperty(_self->ob_itself, 1965 inCommandID, 1966 inPropertyCreator, 1967 inPropertyTag); 1968 if (_err != noErr) return PyMac_Error(_err); 1969 Py_INCREF(Py_None); 1970 _res = Py_None; 1971 return _res; 1972 } 1973 1974 static PyObject *MenuObj_IsMenuItemInvalid(MenuObject *_self, PyObject *_args) 1975 { 1976 PyObject *_res = NULL; 1977 Boolean _rv; 1978 MenuItemIndex inItem; 1979 #ifndef IsMenuItemInvalid 1980 PyMac_PRECHECK(IsMenuItemInvalid); 1981 #endif 1982 if (!PyArg_ParseTuple(_args, "h", 1983 &inItem)) 1984 return NULL; 1985 _rv = IsMenuItemInvalid(_self->ob_itself, 1986 inItem); 1987 _res = Py_BuildValue("b", 1988 _rv); 1989 return _res; 1990 } 1991 1992 static PyObject *MenuObj_InvalidateMenuItems(MenuObject *_self, PyObject *_args) 1993 { 1994 PyObject *_res = NULL; 1995 OSStatus _err; 1996 MenuItemIndex inFirstItem; 1997 ItemCount inNumItems; 1998 #ifndef InvalidateMenuItems 1999 PyMac_PRECHECK(InvalidateMenuItems); 2000 #endif 2001 if (!PyArg_ParseTuple(_args, "hl", 2002 &inFirstItem, 2003 &inNumItems)) 2004 return NULL; 2005 _err = InvalidateMenuItems(_self->ob_itself, 2006 inFirstItem, 2007 inNumItems); 2008 if (_err != noErr) return PyMac_Error(_err); 2009 Py_INCREF(Py_None); 2010 _res = Py_None; 2011 return _res; 2012 } 2013 2014 static PyObject *MenuObj_UpdateInvalidMenuItems(MenuObject *_self, PyObject *_args) 2015 { 2016 PyObject *_res = NULL; 2017 OSStatus _err; 2018 #ifndef UpdateInvalidMenuItems 2019 PyMac_PRECHECK(UpdateInvalidMenuItems); 2020 #endif 2021 if (!PyArg_ParseTuple(_args, "")) 2022 return NULL; 2023 _err = UpdateInvalidMenuItems(_self->ob_itself); 2024 if (_err != noErr) return PyMac_Error(_err); 2025 Py_INCREF(Py_None); 2026 _res = Py_None; 2027 return _res; 2028 } 2029 2030 static PyObject *MenuObj_CreateStandardFontMenu(MenuObject *_self, PyObject *_args) 2031 { 2032 PyObject *_res = NULL; 2033 OSStatus _err; 2034 MenuItemIndex afterItem; 2035 MenuID firstHierMenuID; 2036 OptionBits options; 2037 ItemCount outHierMenuCount; 2038 #ifndef CreateStandardFontMenu 2039 PyMac_PRECHECK(CreateStandardFontMenu); 2040 #endif 2041 if (!PyArg_ParseTuple(_args, "hhl", 2042 &afterItem, 2043 &firstHierMenuID, 2044 &options)) 2045 return NULL; 2046 _err = CreateStandardFontMenu(_self->ob_itself, 2047 afterItem, 2048 firstHierMenuID, 2049 options, 2050 &outHierMenuCount); 2051 if (_err != noErr) return PyMac_Error(_err); 2052 _res = Py_BuildValue("l", 2053 outHierMenuCount); 2054 return _res; 2055 } 2056 2057 static PyObject *MenuObj_UpdateStandardFontMenu(MenuObject *_self, PyObject *_args) 2058 { 2059 PyObject *_res = NULL; 2060 OSStatus _err; 2061 ItemCount outHierMenuCount; 2062 #ifndef UpdateStandardFontMenu 2063 PyMac_PRECHECK(UpdateStandardFontMenu); 2064 #endif 2065 if (!PyArg_ParseTuple(_args, "")) 2066 return NULL; 2067 _err = UpdateStandardFontMenu(_self->ob_itself, 2068 &outHierMenuCount); 2069 if (_err != noErr) return PyMac_Error(_err); 2070 _res = Py_BuildValue("l", 2071 outHierMenuCount); 2072 return _res; 2073 } 2074 2075 static PyObject *MenuObj_GetFontFamilyFromMenuSelection(MenuObject *_self, PyObject *_args) 2076 { 2077 PyObject *_res = NULL; 2078 OSStatus _err; 2079 MenuItemIndex item; 2080 FMFontFamily outFontFamily; 2081 FMFontStyle outStyle; 2082 #ifndef GetFontFamilyFromMenuSelection 2083 PyMac_PRECHECK(GetFontFamilyFromMenuSelection); 2084 #endif 2085 if (!PyArg_ParseTuple(_args, "h", 2086 &item)) 2087 return NULL; 2088 _err = GetFontFamilyFromMenuSelection(_self->ob_itself, 2089 item, 2090 &outFontFamily, 2091 &outStyle); 2092 if (_err != noErr) return PyMac_Error(_err); 2093 _res = Py_BuildValue("hh", 2094 outFontFamily, 2095 outStyle); 2096 return _res; 2097 } 2098 2099 static PyObject *MenuObj_GetMenuID(MenuObject *_self, PyObject *_args) 2100 { 2101 PyObject *_res = NULL; 2102 MenuID _rv; 2103 #ifndef GetMenuID 2104 PyMac_PRECHECK(GetMenuID); 2105 #endif 2106 if (!PyArg_ParseTuple(_args, "")) 2107 return NULL; 2108 _rv = GetMenuID(_self->ob_itself); 2109 _res = Py_BuildValue("h", 2110 _rv); 2111 return _res; 2112 } 2113 2114 static PyObject *MenuObj_GetMenuWidth(MenuObject *_self, PyObject *_args) 2115 { 2116 PyObject *_res = NULL; 2117 SInt16 _rv; 2118 #ifndef GetMenuWidth 2119 PyMac_PRECHECK(GetMenuWidth); 2120 #endif 2121 if (!PyArg_ParseTuple(_args, "")) 2122 return NULL; 2123 _rv = GetMenuWidth(_self->ob_itself); 2124 _res = Py_BuildValue("h", 2125 _rv); 2126 return _res; 2127 } 2128 2129 static PyObject *MenuObj_GetMenuHeight(MenuObject *_self, PyObject *_args) 2130 { 2131 PyObject *_res = NULL; 2132 SInt16 _rv; 2133 #ifndef GetMenuHeight 2134 PyMac_PRECHECK(GetMenuHeight); 2135 #endif 2136 if (!PyArg_ParseTuple(_args, "")) 2137 return NULL; 2138 _rv = GetMenuHeight(_self->ob_itself); 2139 _res = Py_BuildValue("h", 2140 _rv); 2141 return _res; 2142 } 2143 2144 static PyObject *MenuObj_SetMenuID(MenuObject *_self, PyObject *_args) 2145 { 2146 PyObject *_res = NULL; 2147 MenuID menuID; 2148 #ifndef SetMenuID 2149 PyMac_PRECHECK(SetMenuID); 2150 #endif 2151 if (!PyArg_ParseTuple(_args, "h", 2152 &menuID)) 2153 return NULL; 2154 SetMenuID(_self->ob_itself, 2155 menuID); 2156 Py_INCREF(Py_None); 2157 _res = Py_None; 2158 return _res; 2159 } 2160 2161 static PyObject *MenuObj_SetMenuWidth(MenuObject *_self, PyObject *_args) 2162 { 2163 PyObject *_res = NULL; 2164 SInt16 width; 2165 #ifndef SetMenuWidth 2166 PyMac_PRECHECK(SetMenuWidth); 2167 #endif 2168 if (!PyArg_ParseTuple(_args, "h", 2169 &width)) 2170 return NULL; 2171 SetMenuWidth(_self->ob_itself, 2172 width); 2173 Py_INCREF(Py_None); 2174 _res = Py_None; 2175 return _res; 2176 } 2177 2178 static PyObject *MenuObj_SetMenuHeight(MenuObject *_self, PyObject *_args) 2179 { 2180 PyObject *_res = NULL; 2181 SInt16 height; 2182 #ifndef SetMenuHeight 2183 PyMac_PRECHECK(SetMenuHeight); 2184 #endif 2185 if (!PyArg_ParseTuple(_args, "h", 2186 &height)) 2187 return NULL; 2188 SetMenuHeight(_self->ob_itself, 2189 height); 2190 Py_INCREF(Py_None); 2191 _res = Py_None; 2192 return _res; 2193 } 2194 2195 static PyObject *MenuObj_as_Resource(MenuObject *_self, PyObject *_args) 2196 { 2197 PyObject *_res = NULL; 2198 Handle _rv; 2199 #ifndef as_Resource 2200 PyMac_PRECHECK(as_Resource); 2201 #endif 2202 if (!PyArg_ParseTuple(_args, "")) 2203 return NULL; 2204 _rv = as_Resource(_self->ob_itself); 2205 _res = Py_BuildValue("O&", 2206 ResObj_New, _rv); 2207 return _res; 2208 } 2209 2210 static PyObject *MenuObj_AppendMenu(MenuObject *_self, PyObject *_args) 2211 { 2212 PyObject *_res = NULL; 2213 Str255 data; 2214 #ifndef AppendMenu 2215 PyMac_PRECHECK(AppendMenu); 2216 #endif 2217 if (!PyArg_ParseTuple(_args, "O&", 2218 PyMac_GetStr255, data)) 2219 return NULL; 2220 AppendMenu(_self->ob_itself, 2221 data); 2222 Py_INCREF(Py_None); 2223 _res = Py_None; 2224 return _res; 2225 } 2226 2227 static PyObject *MenuObj_InsertMenu(MenuObject *_self, PyObject *_args) 2228 { 2229 PyObject *_res = NULL; 2230 short beforeID; 2231 #ifndef InsertMenu 2232 PyMac_PRECHECK(InsertMenu); 2233 #endif 2234 if (!PyArg_ParseTuple(_args, "h", 2235 &beforeID)) 2236 return NULL; 2237 InsertMenu(_self->ob_itself, 2238 beforeID); 2239 Py_INCREF(Py_None); 2240 _res = Py_None; 2241 return _res; 2242 } 2243 2244 static PyObject *MenuObj_InsertMenuItem(MenuObject *_self, PyObject *_args) 2245 { 2246 PyObject *_res = NULL; 2247 Str255 itemString; 2248 short afterItem; 2249 #ifndef InsertMenuItem 2250 PyMac_PRECHECK(InsertMenuItem); 2251 #endif 2252 if (!PyArg_ParseTuple(_args, "O&h", 2253 PyMac_GetStr255, itemString, 2254 &afterItem)) 2255 return NULL; 2256 InsertMenuItem(_self->ob_itself, 2257 itemString, 2258 afterItem); 2259 Py_INCREF(Py_None); 2260 _res = Py_None; 2261 return _res; 2262 } 2263 2264 static PyObject *MenuObj_EnableMenuItem(MenuObject *_self, PyObject *_args) 2265 { 2266 PyObject *_res = NULL; 2267 UInt16 item; 2268 #ifndef EnableMenuItem 2269 PyMac_PRECHECK(EnableMenuItem); 2270 #endif 2271 if (!PyArg_ParseTuple(_args, "H", 2272 &item)) 2273 return NULL; 2274 EnableMenuItem(_self->ob_itself, 2275 item); 2276 Py_INCREF(Py_None); 2277 _res = Py_None; 2278 return _res; 2279 } 2280 2281 static PyObject *MenuObj_CheckMenuItem(MenuObject *_self, PyObject *_args) 2282 { 2283 PyObject *_res = NULL; 2284 short item; 2285 Boolean checked; 2286 #ifndef CheckMenuItem 2287 PyMac_PRECHECK(CheckMenuItem); 2288 #endif 2289 if (!PyArg_ParseTuple(_args, "hb", 2290 &item, 2291 &checked)) 2292 return NULL; 2293 CheckMenuItem(_self->ob_itself, 2294 item, 2295 checked); 2296 Py_INCREF(Py_None); 2297 _res = Py_None; 2298 return _res; 2299 } 2300 2301 static PyMethodDef MenuObj_methods[] = { 2302 {"DisposeMenu", (PyCFunction)MenuObj_DisposeMenu, 1, 2303 PyDoc_STR("() -> None")}, 2304 {"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1, 2305 PyDoc_STR("() -> None")}, 2306 {"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1, 2307 PyDoc_STR("() -> (UInt16 _rv)")}, 2308 {"GetMenuFont", (PyCFunction)MenuObj_GetMenuFont, 1, 2309 PyDoc_STR("() -> (SInt16 outFontID, UInt16 outFontSize)")}, 2310 {"SetMenuFont", (PyCFunction)MenuObj_SetMenuFont, 1, 2311 PyDoc_STR("(SInt16 inFontID, UInt16 inFontSize) -> None")}, 2312 {"GetMenuExcludesMarkColumn", (PyCFunction)MenuObj_GetMenuExcludesMarkColumn, 1, 2313 PyDoc_STR("() -> (Boolean _rv)")}, 2314 {"SetMenuExcludesMarkColumn", (PyCFunction)MenuObj_SetMenuExcludesMarkColumn, 1, 2315 PyDoc_STR("(Boolean excludesMark) -> None")}, 2316 {"IsValidMenu", (PyCFunction)MenuObj_IsValidMenu, 1, 2317 PyDoc_STR("() -> (Boolean _rv)")}, 2318 {"GetMenuRetainCount", (PyCFunction)MenuObj_GetMenuRetainCount, 1, 2319 PyDoc_STR("() -> (ItemCount _rv)")}, 2320 {"RetainMenu", (PyCFunction)MenuObj_RetainMenu, 1, 2321 PyDoc_STR("() -> None")}, 2322 {"ReleaseMenu", (PyCFunction)MenuObj_ReleaseMenu, 1, 2323 PyDoc_STR("() -> None")}, 2324 {"DuplicateMenu", (PyCFunction)MenuObj_DuplicateMenu, 1, 2325 PyDoc_STR("() -> (MenuHandle outMenu)")}, 2326 {"CopyMenuTitleAsCFString", (PyCFunction)MenuObj_CopyMenuTitleAsCFString, 1, 2327 PyDoc_STR("() -> (CFStringRef outString)")}, 2328 {"SetMenuTitleWithCFString", (PyCFunction)MenuObj_SetMenuTitleWithCFString, 1, 2329 PyDoc_STR("(CFStringRef inString) -> None")}, 2330 {"InvalidateMenuSize", (PyCFunction)MenuObj_InvalidateMenuSize, 1, 2331 PyDoc_STR("() -> None")}, 2332 {"IsMenuSizeInvalid", (PyCFunction)MenuObj_IsMenuSizeInvalid, 1, 2333 PyDoc_STR("() -> (Boolean _rv)")}, 2334 {"MacAppendMenu", (PyCFunction)MenuObj_MacAppendMenu, 1, 2335 PyDoc_STR("(Str255 data) -> None")}, 2336 {"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1, 2337 PyDoc_STR("(ResType theType, short afterItem) -> None")}, 2338 {"AppendResMenu", (PyCFunction)MenuObj_AppendResMenu, 1, 2339 PyDoc_STR("(ResType theType) -> None")}, 2340 {"MacInsertMenuItem", (PyCFunction)MenuObj_MacInsertMenuItem, 1, 2341 PyDoc_STR("(Str255 itemString, short afterItem) -> None")}, 2342 {"DeleteMenuItem", (PyCFunction)MenuObj_DeleteMenuItem, 1, 2343 PyDoc_STR("(short item) -> None")}, 2344 {"InsertFontResMenu", (PyCFunction)MenuObj_InsertFontResMenu, 1, 2345 PyDoc_STR("(short afterItem, short scriptFilter) -> None")}, 2346 {"InsertIntlResMenu", (PyCFunction)MenuObj_InsertIntlResMenu, 1, 2347 PyDoc_STR("(ResType theType, short afterItem, short scriptFilter) -> None")}, 2348 {"AppendMenuItemText", (PyCFunction)MenuObj_AppendMenuItemText, 1, 2349 PyDoc_STR("(Str255 inString) -> None")}, 2350 {"InsertMenuItemText", (PyCFunction)MenuObj_InsertMenuItemText, 1, 2351 PyDoc_STR("(Str255 inString, MenuItemIndex afterItem) -> None")}, 2352 {"CopyMenuItems", (PyCFunction)MenuObj_CopyMenuItems, 1, 2353 PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems, MenuHandle inDestMenu, MenuItemIndex inInsertAfter) -> None")}, 2354 {"DeleteMenuItems", (PyCFunction)MenuObj_DeleteMenuItems, 1, 2355 PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None")}, 2356 {"AppendMenuItemTextWithCFString", (PyCFunction)MenuObj_AppendMenuItemTextWithCFString, 1, 2357 PyDoc_STR("(CFStringRef inString, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> (MenuItemIndex outNewItem)")}, 2358 {"InsertMenuItemTextWithCFString", (PyCFunction)MenuObj_InsertMenuItemTextWithCFString, 1, 2359 PyDoc_STR("(CFStringRef inString, MenuItemIndex inAfterItem, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> None")}, 2360 {"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1, 2361 PyDoc_STR("(short top, short left, short popUpItem) -> (long _rv)")}, 2362 {"InvalidateMenuEnabling", (PyCFunction)MenuObj_InvalidateMenuEnabling, 1, 2363 PyDoc_STR("() -> None")}, 2364 {"IsMenuBarInvalid", (PyCFunction)MenuObj_IsMenuBarInvalid, 1, 2365 PyDoc_STR("() -> (Boolean _rv)")}, 2366 {"MacInsertMenu", (PyCFunction)MenuObj_MacInsertMenu, 1, 2367 PyDoc_STR("(MenuID beforeID) -> None")}, 2368 {"SetRootMenu", (PyCFunction)MenuObj_SetRootMenu, 1, 2369 PyDoc_STR("() -> None")}, 2370 {"MacCheckMenuItem", (PyCFunction)MenuObj_MacCheckMenuItem, 1, 2371 PyDoc_STR("(short item, Boolean checked) -> None")}, 2372 {"SetMenuItemText", (PyCFunction)MenuObj_SetMenuItemText, 1, 2373 PyDoc_STR("(short item, Str255 itemString) -> None")}, 2374 {"GetMenuItemText", (PyCFunction)MenuObj_GetMenuItemText, 1, 2375 PyDoc_STR("(short item) -> (Str255 itemString)")}, 2376 {"SetItemMark", (PyCFunction)MenuObj_SetItemMark, 1, 2377 PyDoc_STR("(short item, CharParameter markChar) -> None")}, 2378 {"GetItemMark", (PyCFunction)MenuObj_GetItemMark, 1, 2379 PyDoc_STR("(short item) -> (CharParameter markChar)")}, 2380 {"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1, 2381 PyDoc_STR("(short item, CharParameter cmdChar) -> None")}, 2382 {"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1, 2383 PyDoc_STR("(short item) -> (CharParameter cmdChar)")}, 2384 {"SetItemIcon", (PyCFunction)MenuObj_SetItemIcon, 1, 2385 PyDoc_STR("(short item, short iconIndex) -> None")}, 2386 {"GetItemIcon", (PyCFunction)MenuObj_GetItemIcon, 1, 2387 PyDoc_STR("(short item) -> (short iconIndex)")}, 2388 {"SetItemStyle", (PyCFunction)MenuObj_SetItemStyle, 1, 2389 PyDoc_STR("(short item, StyleParameter chStyle) -> None")}, 2390 {"GetItemStyle", (PyCFunction)MenuObj_GetItemStyle, 1, 2391 PyDoc_STR("(short item) -> (Style chStyle)")}, 2392 {"SetMenuItemCommandID", (PyCFunction)MenuObj_SetMenuItemCommandID, 1, 2393 PyDoc_STR("(SInt16 inItem, MenuCommand inCommandID) -> None")}, 2394 {"GetMenuItemCommandID", (PyCFunction)MenuObj_GetMenuItemCommandID, 1, 2395 PyDoc_STR("(SInt16 inItem) -> (MenuCommand outCommandID)")}, 2396 {"SetMenuItemModifiers", (PyCFunction)MenuObj_SetMenuItemModifiers, 1, 2397 PyDoc_STR("(SInt16 inItem, UInt8 inModifiers) -> None")}, 2398 {"GetMenuItemModifiers", (PyCFunction)MenuObj_GetMenuItemModifiers, 1, 2399 PyDoc_STR("(SInt16 inItem) -> (UInt8 outModifiers)")}, 2400 {"SetMenuItemIconHandle", (PyCFunction)MenuObj_SetMenuItemIconHandle, 1, 2401 PyDoc_STR("(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None")}, 2402 {"GetMenuItemIconHandle", (PyCFunction)MenuObj_GetMenuItemIconHandle, 1, 2403 PyDoc_STR("(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)")}, 2404 {"SetMenuItemTextEncoding", (PyCFunction)MenuObj_SetMenuItemTextEncoding, 1, 2405 PyDoc_STR("(SInt16 inItem, TextEncoding inScriptID) -> None")}, 2406 {"GetMenuItemTextEncoding", (PyCFunction)MenuObj_GetMenuItemTextEncoding, 1, 2407 PyDoc_STR("(SInt16 inItem) -> (TextEncoding outScriptID)")}, 2408 {"SetMenuItemHierarchicalID", (PyCFunction)MenuObj_SetMenuItemHierarchicalID, 1, 2409 PyDoc_STR("(SInt16 inItem, MenuID inHierID) -> None")}, 2410 {"GetMenuItemHierarchicalID", (PyCFunction)MenuObj_GetMenuItemHierarchicalID, 1, 2411 PyDoc_STR("(SInt16 inItem) -> (MenuID outHierID)")}, 2412 {"SetMenuItemFontID", (PyCFunction)MenuObj_SetMenuItemFontID, 1, 2413 PyDoc_STR("(SInt16 inItem, SInt16 inFontID) -> None")}, 2414 {"GetMenuItemFontID", (PyCFunction)MenuObj_GetMenuItemFontID, 1, 2415 PyDoc_STR("(SInt16 inItem) -> (SInt16 outFontID)")}, 2416 {"SetMenuItemRefCon", (PyCFunction)MenuObj_SetMenuItemRefCon, 1, 2417 PyDoc_STR("(SInt16 inItem, UInt32 inRefCon) -> None")}, 2418 {"GetMenuItemRefCon", (PyCFunction)MenuObj_GetMenuItemRefCon, 1, 2419 PyDoc_STR("(SInt16 inItem) -> (UInt32 outRefCon)")}, 2420 {"SetMenuItemKeyGlyph", (PyCFunction)MenuObj_SetMenuItemKeyGlyph, 1, 2421 PyDoc_STR("(SInt16 inItem, SInt16 inGlyph) -> None")}, 2422 {"GetMenuItemKeyGlyph", (PyCFunction)MenuObj_GetMenuItemKeyGlyph, 1, 2423 PyDoc_STR("(SInt16 inItem) -> (SInt16 outGlyph)")}, 2424 {"MacEnableMenuItem", (PyCFunction)MenuObj_MacEnableMenuItem, 1, 2425 PyDoc_STR("(MenuItemIndex item) -> None")}, 2426 {"DisableMenuItem", (PyCFunction)MenuObj_DisableMenuItem, 1, 2427 PyDoc_STR("(MenuItemIndex item) -> None")}, 2428 {"IsMenuItemEnabled", (PyCFunction)MenuObj_IsMenuItemEnabled, 1, 2429 PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")}, 2430 {"EnableMenuItemIcon", (PyCFunction)MenuObj_EnableMenuItemIcon, 1, 2431 PyDoc_STR("(MenuItemIndex item) -> None")}, 2432 {"DisableMenuItemIcon", (PyCFunction)MenuObj_DisableMenuItemIcon, 1, 2433 PyDoc_STR("(MenuItemIndex item) -> None")}, 2434 {"IsMenuItemIconEnabled", (PyCFunction)MenuObj_IsMenuItemIconEnabled, 1, 2435 PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")}, 2436 {"SetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_SetMenuItemHierarchicalMenu, 1, 2437 PyDoc_STR("(MenuItemIndex inItem, MenuHandle inHierMenu) -> None")}, 2438 {"GetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_GetMenuItemHierarchicalMenu, 1, 2439 PyDoc_STR("(MenuItemIndex inItem) -> (MenuHandle outHierMenu)")}, 2440 {"CopyMenuItemTextAsCFString", (PyCFunction)MenuObj_CopyMenuItemTextAsCFString, 1, 2441 PyDoc_STR("(MenuItemIndex inItem) -> (CFStringRef outString)")}, 2442 {"SetMenuItemTextWithCFString", (PyCFunction)MenuObj_SetMenuItemTextWithCFString, 1, 2443 PyDoc_STR("(MenuItemIndex inItem, CFStringRef inString) -> None")}, 2444 {"GetMenuItemIndent", (PyCFunction)MenuObj_GetMenuItemIndent, 1, 2445 PyDoc_STR("(MenuItemIndex inItem) -> (UInt32 outIndent)")}, 2446 {"SetMenuItemIndent", (PyCFunction)MenuObj_SetMenuItemIndent, 1, 2447 PyDoc_STR("(MenuItemIndex inItem, UInt32 inIndent) -> None")}, 2448 {"GetMenuItemCommandKey", (PyCFunction)MenuObj_GetMenuItemCommandKey, 1, 2449 PyDoc_STR("(MenuItemIndex inItem, Boolean inGetVirtualKey) -> (UInt16 outKey)")}, 2450 {"SetMenuItemCommandKey", (PyCFunction)MenuObj_SetMenuItemCommandKey, 1, 2451 PyDoc_STR("(MenuItemIndex inItem, Boolean inSetVirtualKey, UInt16 inKey) -> None")}, 2452 {"GetMenuItemPropertyAttributes", (PyCFunction)MenuObj_GetMenuItemPropertyAttributes, 1, 2453 PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")}, 2454 {"ChangeMenuItemPropertyAttributes", (PyCFunction)MenuObj_ChangeMenuItemPropertyAttributes, 1, 2455 PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")}, 2456 {"GetMenuAttributes", (PyCFunction)MenuObj_GetMenuAttributes, 1, 2457 PyDoc_STR("() -> (MenuAttributes outAttributes)")}, 2458 {"ChangeMenuAttributes", (PyCFunction)MenuObj_ChangeMenuAttributes, 1, 2459 PyDoc_STR("(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None")}, 2460 {"GetMenuItemAttributes", (PyCFunction)MenuObj_GetMenuItemAttributes, 1, 2461 PyDoc_STR("(MenuItemIndex item) -> (MenuItemAttributes outAttributes)")}, 2462 {"ChangeMenuItemAttributes", (PyCFunction)MenuObj_ChangeMenuItemAttributes, 1, 2463 PyDoc_STR("(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None")}, 2464 {"DisableAllMenuItems", (PyCFunction)MenuObj_DisableAllMenuItems, 1, 2465 PyDoc_STR("() -> None")}, 2466 {"EnableAllMenuItems", (PyCFunction)MenuObj_EnableAllMenuItems, 1, 2467 PyDoc_STR("() -> None")}, 2468 {"MenuHasEnabledItems", (PyCFunction)MenuObj_MenuHasEnabledItems, 1, 2469 PyDoc_STR("() -> (Boolean _rv)")}, 2470 {"GetMenuType", (PyCFunction)MenuObj_GetMenuType, 1, 2471 PyDoc_STR("() -> (UInt16 outType)")}, 2472 {"CountMenuItemsWithCommandID", (PyCFunction)MenuObj_CountMenuItemsWithCommandID, 1, 2473 PyDoc_STR("(MenuCommand inCommandID) -> (ItemCount _rv)")}, 2474 {"GetIndMenuItemWithCommandID", (PyCFunction)MenuObj_GetIndMenuItemWithCommandID, 1, 2475 PyDoc_STR("(MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")}, 2476 {"EnableMenuCommand", (PyCFunction)MenuObj_EnableMenuCommand, 1, 2477 PyDoc_STR("(MenuCommand inCommandID) -> None")}, 2478 {"DisableMenuCommand", (PyCFunction)MenuObj_DisableMenuCommand, 1, 2479 PyDoc_STR("(MenuCommand inCommandID) -> None")}, 2480 {"IsMenuCommandEnabled", (PyCFunction)MenuObj_IsMenuCommandEnabled, 1, 2481 PyDoc_STR("(MenuCommand inCommandID) -> (Boolean _rv)")}, 2482 {"SetMenuCommandMark", (PyCFunction)MenuObj_SetMenuCommandMark, 1, 2483 PyDoc_STR("(MenuCommand inCommandID, UniChar inMark) -> None")}, 2484 {"GetMenuCommandMark", (PyCFunction)MenuObj_GetMenuCommandMark, 1, 2485 PyDoc_STR("(MenuCommand inCommandID) -> (UniChar outMark)")}, 2486 {"GetMenuCommandPropertySize", (PyCFunction)MenuObj_GetMenuCommandPropertySize, 1, 2487 PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")}, 2488 {"RemoveMenuCommandProperty", (PyCFunction)MenuObj_RemoveMenuCommandProperty, 1, 2489 PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")}, 2490 {"IsMenuItemInvalid", (PyCFunction)MenuObj_IsMenuItemInvalid, 1, 2491 PyDoc_STR("(MenuItemIndex inItem) -> (Boolean _rv)")}, 2492 {"InvalidateMenuItems", (PyCFunction)MenuObj_InvalidateMenuItems, 1, 2493 PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None")}, 2494 {"UpdateInvalidMenuItems", (PyCFunction)MenuObj_UpdateInvalidMenuItems, 1, 2495 PyDoc_STR("() -> None")}, 2496 {"CreateStandardFontMenu", (PyCFunction)MenuObj_CreateStandardFontMenu, 1, 2497 PyDoc_STR("(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)")}, 2498 {"UpdateStandardFontMenu", (PyCFunction)MenuObj_UpdateStandardFontMenu, 1, 2499 PyDoc_STR("() -> (ItemCount outHierMenuCount)")}, 2500 {"GetFontFamilyFromMenuSelection", (PyCFunction)MenuObj_GetFontFamilyFromMenuSelection, 1, 2501 PyDoc_STR("(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)")}, 2502 {"GetMenuID", (PyCFunction)MenuObj_GetMenuID, 1, 2503 PyDoc_STR("() -> (MenuID _rv)")}, 2504 {"GetMenuWidth", (PyCFunction)MenuObj_GetMenuWidth, 1, 2505 PyDoc_STR("() -> (SInt16 _rv)")}, 2506 {"GetMenuHeight", (PyCFunction)MenuObj_GetMenuHeight, 1, 2507 PyDoc_STR("() -> (SInt16 _rv)")}, 2508 {"SetMenuID", (PyCFunction)MenuObj_SetMenuID, 1, 2509 PyDoc_STR("(MenuID menuID) -> None")}, 2510 {"SetMenuWidth", (PyCFunction)MenuObj_SetMenuWidth, 1, 2511 PyDoc_STR("(SInt16 width) -> None")}, 2512 {"SetMenuHeight", (PyCFunction)MenuObj_SetMenuHeight, 1, 2513 PyDoc_STR("(SInt16 height) -> None")}, 2514 {"as_Resource", (PyCFunction)MenuObj_as_Resource, 1, 2515 PyDoc_STR("() -> (Handle _rv)")}, 2516 {"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1, 2517 PyDoc_STR("(Str255 data) -> None")}, 2518 {"InsertMenu", (PyCFunction)MenuObj_InsertMenu, 1, 2519 PyDoc_STR("(short beforeID) -> None")}, 2520 {"InsertMenuItem", (PyCFunction)MenuObj_InsertMenuItem, 1, 2521 PyDoc_STR("(Str255 itemString, short afterItem) -> None")}, 2522 {"EnableMenuItem", (PyCFunction)MenuObj_EnableMenuItem, 1, 2523 PyDoc_STR("(UInt16 item) -> None")}, 2524 {"CheckMenuItem", (PyCFunction)MenuObj_CheckMenuItem, 1, 2525 PyDoc_STR("(short item, Boolean checked) -> None")}, 2526 {NULL, NULL, 0} 2527 }; 2528 2529 #define MenuObj_getsetlist NULL 2530 2531 2532 #define MenuObj_compare NULL 2533 2534 #define MenuObj_repr NULL 2535 2536 #define MenuObj_hash NULL 2537 #define MenuObj_tp_init 0 2538 2539 #define MenuObj_tp_alloc PyType_GenericAlloc 2540 2541 static PyObject *MenuObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) 2542 { 2543 PyObject *_self; 2544 MenuHandle itself; 2545 char *kw[] = {"itself", 0}; 2546 2547 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, MenuObj_Convert, &itself)) return NULL; 2548 if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; 2549 ((MenuObject *)_self)->ob_itself = itself; 2550 return _self; 2551 } 2552 2553 #define MenuObj_tp_free PyObject_Del 2554 2555 2556 PyTypeObject Menu_Type = { 2557 PyObject_HEAD_INIT(NULL) 2558 0, /*ob_size*/ 2559 "_Menu.Menu", /*tp_name*/ 2560 sizeof(MenuObject), /*tp_basicsize*/ 2561 0, /*tp_itemsize*/ 2562 /* methods */ 2563 (destructor) MenuObj_dealloc, /*tp_dealloc*/ 2564 0, /*tp_print*/ 2565 (getattrfunc)0, /*tp_getattr*/ 2566 (setattrfunc)0, /*tp_setattr*/ 2567 (cmpfunc) MenuObj_compare, /*tp_compare*/ 2568 (reprfunc) MenuObj_repr, /*tp_repr*/ 2569 (PyNumberMethods *)0, /* tp_as_number */ 2570 (PySequenceMethods *)0, /* tp_as_sequence */ 2571 (PyMappingMethods *)0, /* tp_as_mapping */ 2572 (hashfunc) MenuObj_hash, /*tp_hash*/ 2573 0, /*tp_call*/ 2574 0, /*tp_str*/ 2575 PyObject_GenericGetAttr, /*tp_getattro*/ 2576 PyObject_GenericSetAttr, /*tp_setattro */ 2577 0, /*tp_as_buffer*/ 2578 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 2579 0, /*tp_doc*/ 2580 0, /*tp_traverse*/ 2581 0, /*tp_clear*/ 2582 0, /*tp_richcompare*/ 2583 0, /*tp_weaklistoffset*/ 2584 0, /*tp_iter*/ 2585 0, /*tp_iternext*/ 2586 MenuObj_methods, /* tp_methods */ 2587 0, /*tp_members*/ 2588 MenuObj_getsetlist, /*tp_getset*/ 2589 0, /*tp_base*/ 2590 0, /*tp_dict*/ 2591 0, /*tp_descr_get*/ 2592 0, /*tp_descr_set*/ 2593 0, /*tp_dictoffset*/ 2594 MenuObj_tp_init, /* tp_init */ 2595 MenuObj_tp_alloc, /* tp_alloc */ 2596 MenuObj_tp_new, /* tp_new */ 2597 MenuObj_tp_free, /* tp_free */ 2598 }; 2599 2600 /* ---------------------- End object type Menu ---------------------- */ 2601 2602 2603 static PyObject *Menu_NewMenu(PyObject *_self, PyObject *_args) 2604 { 2605 PyObject *_res = NULL; 2606 MenuHandle _rv; 2607 MenuID menuID; 2608 Str255 menuTitle; 2609 #ifndef NewMenu 2610 PyMac_PRECHECK(NewMenu); 2611 #endif 2612 if (!PyArg_ParseTuple(_args, "hO&", 2613 &menuID, 2614 PyMac_GetStr255, menuTitle)) 2615 return NULL; 2616 _rv = NewMenu(menuID, 2617 menuTitle); 2618 _res = Py_BuildValue("O&", 2619 MenuObj_New, _rv); 2620 return _res; 2621 } 2622 2623 static PyObject *Menu_MacGetMenu(PyObject *_self, PyObject *_args) 2624 { 2625 PyObject *_res = NULL; 2626 MenuHandle _rv; 2627 short resourceID; 2628 #ifndef MacGetMenu 2629 PyMac_PRECHECK(MacGetMenu); 2630 #endif 2631 if (!PyArg_ParseTuple(_args, "h", 2632 &resourceID)) 2633 return NULL; 2634 _rv = MacGetMenu(resourceID); 2635 _res = Py_BuildValue("O&", 2636 MenuObj_New, _rv); 2637 return _res; 2638 } 2639 2640 static PyObject *Menu_CreateNewMenu(PyObject *_self, PyObject *_args) 2641 { 2642 PyObject *_res = NULL; 2643 OSStatus _err; 2644 MenuID inMenuID; 2645 MenuAttributes inMenuAttributes; 2646 MenuHandle outMenuRef; 2647 #ifndef CreateNewMenu 2648 PyMac_PRECHECK(CreateNewMenu); 2649 #endif 2650 if (!PyArg_ParseTuple(_args, "hl", 2651 &inMenuID, 2652 &inMenuAttributes)) 2653 return NULL; 2654 _err = CreateNewMenu(inMenuID, 2655 inMenuAttributes, 2656 &outMenuRef); 2657 if (_err != noErr) return PyMac_Error(_err); 2658 _res = Py_BuildValue("O&", 2659 MenuObj_New, outMenuRef); 2660 return _res; 2661 } 2662 2663 static PyObject *Menu_MenuKey(PyObject *_self, PyObject *_args) 2664 { 2665 PyObject *_res = NULL; 2666 long _rv; 2667 CharParameter ch; 2668 #ifndef MenuKey 2669 PyMac_PRECHECK(MenuKey); 2670 #endif 2671 if (!PyArg_ParseTuple(_args, "h", 2672 &ch)) 2673 return NULL; 2674 _rv = MenuKey(ch); 2675 _res = Py_BuildValue("l", 2676 _rv); 2677 return _res; 2678 } 2679 2680 static PyObject *Menu_MenuSelect(PyObject *_self, PyObject *_args) 2681 { 2682 PyObject *_res = NULL; 2683 long _rv; 2684 Point startPt; 2685 #ifndef MenuSelect 2686 PyMac_PRECHECK(MenuSelect); 2687 #endif 2688 if (!PyArg_ParseTuple(_args, "O&", 2689 PyMac_GetPoint, &startPt)) 2690 return NULL; 2691 _rv = MenuSelect(startPt); 2692 _res = Py_BuildValue("l", 2693 _rv); 2694 return _res; 2695 } 2696 2697 static PyObject *Menu_MenuChoice(PyObject *_self, PyObject *_args) 2698 { 2699 PyObject *_res = NULL; 2700 long _rv; 2701 #ifndef MenuChoice 2702 PyMac_PRECHECK(MenuChoice); 2703 #endif 2704 if (!PyArg_ParseTuple(_args, "")) 2705 return NULL; 2706 _rv = MenuChoice(); 2707 _res = Py_BuildValue("l", 2708 _rv); 2709 return _res; 2710 } 2711 2712 static PyObject *Menu_MenuEvent(PyObject *_self, PyObject *_args) 2713 { 2714 PyObject *_res = NULL; 2715 UInt32 _rv; 2716 EventRecord inEvent; 2717 #ifndef MenuEvent 2718 PyMac_PRECHECK(MenuEvent); 2719 #endif 2720 if (!PyArg_ParseTuple(_args, "O&", 2721 PyMac_GetEventRecord, &inEvent)) 2722 return NULL; 2723 _rv = MenuEvent(&inEvent); 2724 _res = Py_BuildValue("l", 2725 _rv); 2726 return _res; 2727 } 2728 2729 static PyObject *Menu_GetMBarHeight(PyObject *_self, PyObject *_args) 2730 { 2731 PyObject *_res = NULL; 2732 short _rv; 2733 #ifndef GetMBarHeight 2734 PyMac_PRECHECK(GetMBarHeight); 2735 #endif 2736 if (!PyArg_ParseTuple(_args, "")) 2737 return NULL; 2738 _rv = GetMBarHeight(); 2739 _res = Py_BuildValue("h", 2740 _rv); 2741 return _res; 2742 } 2743 2744 static PyObject *Menu_MacDrawMenuBar(PyObject *_self, PyObject *_args) 2745 { 2746 PyObject *_res = NULL; 2747 #ifndef MacDrawMenuBar 2748 PyMac_PRECHECK(MacDrawMenuBar); 2749 #endif 2750 if (!PyArg_ParseTuple(_args, "")) 2751 return NULL; 2752 MacDrawMenuBar(); 2753 Py_INCREF(Py_None); 2754 _res = Py_None; 2755 return _res; 2756 } 2757 2758 static PyObject *Menu_InvalMenuBar(PyObject *_self, PyObject *_args) 2759 { 2760 PyObject *_res = NULL; 2761 #ifndef InvalMenuBar 2762 PyMac_PRECHECK(InvalMenuBar); 2763 #endif 2764 if (!PyArg_ParseTuple(_args, "")) 2765 return NULL; 2766 InvalMenuBar(); 2767 Py_INCREF(Py_None); 2768 _res = Py_None; 2769 return _res; 2770 } 2771 2772 static PyObject *Menu_HiliteMenu(PyObject *_self, PyObject *_args) 2773 { 2774 PyObject *_res = NULL; 2775 MenuID menuID; 2776 #ifndef HiliteMenu 2777 PyMac_PRECHECK(HiliteMenu); 2778 #endif 2779 if (!PyArg_ParseTuple(_args, "h", 2780 &menuID)) 2781 return NULL; 2782 HiliteMenu(menuID); 2783 Py_INCREF(Py_None); 2784 _res = Py_None; 2785 return _res; 2786 } 2787 2788 static PyObject *Menu_GetNewMBar(PyObject *_self, PyObject *_args) 2789 { 2790 PyObject *_res = NULL; 2791 MenuBarHandle _rv; 2792 short menuBarID; 2793 #ifndef GetNewMBar 2794 PyMac_PRECHECK(GetNewMBar); 2795 #endif 2796 if (!PyArg_ParseTuple(_args, "h", 2797 &menuBarID)) 2798 return NULL; 2799 _rv = GetNewMBar(menuBarID); 2800 _res = Py_BuildValue("O&", 2801 ResObj_New, _rv); 2802 return _res; 2803 } 2804 2805 static PyObject *Menu_GetMenuBar(PyObject *_self, PyObject *_args) 2806 { 2807 PyObject *_res = NULL; 2808 MenuBarHandle _rv; 2809 #ifndef GetMenuBar 2810 PyMac_PRECHECK(GetMenuBar); 2811 #endif 2812 if (!PyArg_ParseTuple(_args, "")) 2813 return NULL; 2814 _rv = GetMenuBar(); 2815 _res = Py_BuildValue("O&", 2816 ResObj_New, _rv); 2817 return _res; 2818 } 2819 2820 static PyObject *Menu_SetMenuBar(PyObject *_self, PyObject *_args) 2821 { 2822 PyObject *_res = NULL; 2823 MenuBarHandle mbar; 2824 #ifndef SetMenuBar 2825 PyMac_PRECHECK(SetMenuBar); 2826 #endif 2827 if (!PyArg_ParseTuple(_args, "O&", 2828 ResObj_Convert, &mbar)) 2829 return NULL; 2830 SetMenuBar(mbar); 2831 Py_INCREF(Py_None); 2832 _res = Py_None; 2833 return _res; 2834 } 2835 2836 static PyObject *Menu_DuplicateMenuBar(PyObject *_self, PyObject *_args) 2837 { 2838 PyObject *_res = NULL; 2839 OSStatus _err; 2840 MenuBarHandle inMbar; 2841 MenuBarHandle outMbar; 2842 #ifndef DuplicateMenuBar 2843 PyMac_PRECHECK(DuplicateMenuBar); 2844 #endif 2845 if (!PyArg_ParseTuple(_args, "O&", 2846 ResObj_Convert, &inMbar)) 2847 return NULL; 2848 _err = DuplicateMenuBar(inMbar, 2849 &outMbar); 2850 if (_err != noErr) return PyMac_Error(_err); 2851 _res = Py_BuildValue("O&", 2852 ResObj_New, outMbar); 2853 return _res; 2854 } 2855 2856 static PyObject *Menu_DisposeMenuBar(PyObject *_self, PyObject *_args) 2857 { 2858 PyObject *_res = NULL; 2859 OSStatus _err; 2860 MenuBarHandle inMbar; 2861 #ifndef DisposeMenuBar 2862 PyMac_PRECHECK(DisposeMenuBar); 2863 #endif 2864 if (!PyArg_ParseTuple(_args, "O&", 2865 ResObj_Convert, &inMbar)) 2866 return NULL; 2867 _err = DisposeMenuBar(inMbar); 2868 if (_err != noErr) return PyMac_Error(_err); 2869 Py_INCREF(Py_None); 2870 _res = Py_None; 2871 return _res; 2872 } 2873 2874 static PyObject *Menu_GetMenuHandle(PyObject *_self, PyObject *_args) 2875 { 2876 PyObject *_res = NULL; 2877 MenuHandle _rv; 2878 MenuID menuID; 2879 #ifndef GetMenuHandle 2880 PyMac_PRECHECK(GetMenuHandle); 2881 #endif 2882 if (!PyArg_ParseTuple(_args, "h", 2883 &menuID)) 2884 return NULL; 2885 _rv = GetMenuHandle(menuID); 2886 _res = Py_BuildValue("O&", 2887 MenuObj_New, _rv); 2888 return _res; 2889 } 2890 2891 static PyObject *Menu_MacDeleteMenu(PyObject *_self, PyObject *_args) 2892 { 2893 PyObject *_res = NULL; 2894 MenuID menuID; 2895 #ifndef MacDeleteMenu 2896 PyMac_PRECHECK(MacDeleteMenu); 2897 #endif 2898 if (!PyArg_ParseTuple(_args, "h", 2899 &menuID)) 2900 return NULL; 2901 MacDeleteMenu(menuID); 2902 Py_INCREF(Py_None); 2903 _res = Py_None; 2904 return _res; 2905 } 2906 2907 static PyObject *Menu_ClearMenuBar(PyObject *_self, PyObject *_args) 2908 { 2909 PyObject *_res = NULL; 2910 #ifndef ClearMenuBar 2911 PyMac_PRECHECK(ClearMenuBar); 2912 #endif 2913 if (!PyArg_ParseTuple(_args, "")) 2914 return NULL; 2915 ClearMenuBar(); 2916 Py_INCREF(Py_None); 2917 _res = Py_None; 2918 return _res; 2919 } 2920 2921 static PyObject *Menu_SetMenuFlashCount(PyObject *_self, PyObject *_args) 2922 { 2923 PyObject *_res = NULL; 2924 short count; 2925 #ifndef SetMenuFlashCount 2926 PyMac_PRECHECK(SetMenuFlashCount); 2927 #endif 2928 if (!PyArg_ParseTuple(_args, "h", 2929 &count)) 2930 return NULL; 2931 SetMenuFlashCount(count); 2932 Py_INCREF(Py_None); 2933 _res = Py_None; 2934 return _res; 2935 } 2936 2937 static PyObject *Menu_FlashMenuBar(PyObject *_self, PyObject *_args) 2938 { 2939 PyObject *_res = NULL; 2940 MenuID menuID; 2941 #ifndef FlashMenuBar 2942 PyMac_PRECHECK(FlashMenuBar); 2943 #endif 2944 if (!PyArg_ParseTuple(_args, "h", 2945 &menuID)) 2946 return NULL; 2947 FlashMenuBar(menuID); 2948 Py_INCREF(Py_None); 2949 _res = Py_None; 2950 return _res; 2951 } 2952 2953 static PyObject *Menu_IsMenuBarVisible(PyObject *_self, PyObject *_args) 2954 { 2955 PyObject *_res = NULL; 2956 Boolean _rv; 2957 #ifndef IsMenuBarVisible 2958 PyMac_PRECHECK(IsMenuBarVisible); 2959 #endif 2960 if (!PyArg_ParseTuple(_args, "")) 2961 return NULL; 2962 _rv = IsMenuBarVisible(); 2963 _res = Py_BuildValue("b", 2964 _rv); 2965 return _res; 2966 } 2967 2968 static PyObject *Menu_ShowMenuBar(PyObject *_self, PyObject *_args) 2969 { 2970 PyObject *_res = NULL; 2971 #ifndef ShowMenuBar 2972 PyMac_PRECHECK(ShowMenuBar); 2973 #endif 2974 if (!PyArg_ParseTuple(_args, "")) 2975 return NULL; 2976 ShowMenuBar(); 2977 Py_INCREF(Py_None); 2978 _res = Py_None; 2979 return _res; 2980 } 2981 2982 static PyObject *Menu_HideMenuBar(PyObject *_self, PyObject *_args) 2983 { 2984 PyObject *_res = NULL; 2985 #ifndef HideMenuBar 2986 PyMac_PRECHECK(HideMenuBar); 2987 #endif 2988 if (!PyArg_ParseTuple(_args, "")) 2989 return NULL; 2990 HideMenuBar(); 2991 Py_INCREF(Py_None); 2992 _res = Py_None; 2993 return _res; 2994 } 2995 2996 static PyObject *Menu_AcquireRootMenu(PyObject *_self, PyObject *_args) 2997 { 2998 PyObject *_res = NULL; 2999 MenuHandle _rv; 3000 #ifndef AcquireRootMenu 3001 PyMac_PRECHECK(AcquireRootMenu); 3002 #endif 3003 if (!PyArg_ParseTuple(_args, "")) 3004 return NULL; 3005 _rv = AcquireRootMenu(); 3006 _res = Py_BuildValue("O&", 3007 MenuObj_New, _rv); 3008 return _res; 3009 } 3010 3011 static PyObject *Menu_DeleteMCEntries(PyObject *_self, PyObject *_args) 3012 { 3013 PyObject *_res = NULL; 3014 MenuID menuID; 3015 short menuItem; 3016 #ifndef DeleteMCEntries 3017 PyMac_PRECHECK(DeleteMCEntries); 3018 #endif 3019 if (!PyArg_ParseTuple(_args, "hh", 3020 &menuID, 3021 &menuItem)) 3022 return NULL; 3023 DeleteMCEntries(menuID, 3024 menuItem); 3025 Py_INCREF(Py_None); 3026 _res = Py_None; 3027 return _res; 3028 } 3029 3030 static PyObject *Menu_InitContextualMenus(PyObject *_self, PyObject *_args) 3031 { 3032 PyObject *_res = NULL; 3033 OSStatus _err; 3034 #ifndef InitContextualMenus 3035 PyMac_PRECHECK(InitContextualMenus); 3036 #endif 3037 if (!PyArg_ParseTuple(_args, "")) 3038 return NULL; 3039 _err = InitContextualMenus(); 3040 if (_err != noErr) return PyMac_Error(_err); 3041 Py_INCREF(Py_None); 3042 _res = Py_None; 3043 return _res; 3044 } 3045 3046 static PyObject *Menu_IsShowContextualMenuClick(PyObject *_self, PyObject *_args) 3047 { 3048 PyObject *_res = NULL; 3049 Boolean _rv; 3050 EventRecord inEvent; 3051 #ifndef IsShowContextualMenuClick 3052 PyMac_PRECHECK(IsShowContextualMenuClick); 3053 #endif 3054 if (!PyArg_ParseTuple(_args, "O&", 3055 PyMac_GetEventRecord, &inEvent)) 3056 return NULL; 3057 _rv = IsShowContextualMenuClick(&inEvent); 3058 _res = Py_BuildValue("b", 3059 _rv); 3060 return _res; 3061 } 3062 3063 static PyObject *Menu_LMGetTheMenu(PyObject *_self, PyObject *_args) 3064 { 3065 PyObject *_res = NULL; 3066 SInt16 _rv; 3067 #ifndef LMGetTheMenu 3068 PyMac_PRECHECK(LMGetTheMenu); 3069 #endif 3070 if (!PyArg_ParseTuple(_args, "")) 3071 return NULL; 3072 _rv = LMGetTheMenu(); 3073 _res = Py_BuildValue("h", 3074 _rv); 3075 return _res; 3076 } 3077 3078 static PyObject *Menu_as_Menu(PyObject *_self, PyObject *_args) 3079 { 3080 PyObject *_res = NULL; 3081 MenuHandle _rv; 3082 Handle h; 3083 #ifndef as_Menu 3084 PyMac_PRECHECK(as_Menu); 3085 #endif 3086 if (!PyArg_ParseTuple(_args, "O&", 3087 ResObj_Convert, &h)) 3088 return NULL; 3089 _rv = as_Menu(h); 3090 _res = Py_BuildValue("O&", 3091 MenuObj_New, _rv); 3092 return _res; 3093 } 3094 3095 static PyObject *Menu_GetMenu(PyObject *_self, PyObject *_args) 3096 { 3097 PyObject *_res = NULL; 3098 MenuHandle _rv; 3099 short resourceID; 3100 #ifndef GetMenu 3101 PyMac_PRECHECK(GetMenu); 3102 #endif 3103 if (!PyArg_ParseTuple(_args, "h", 3104 &resourceID)) 3105 return NULL; 3106 _rv = GetMenu(resourceID); 3107 _res = Py_BuildValue("O&", 3108 MenuObj_New, _rv); 3109 return _res; 3110 } 3111 3112 static PyObject *Menu_DeleteMenu(PyObject *_self, PyObject *_args) 3113 { 3114 PyObject *_res = NULL; 3115 short menuID; 3116 #ifndef DeleteMenu 3117 PyMac_PRECHECK(DeleteMenu); 3118 #endif 3119 if (!PyArg_ParseTuple(_args, "h", 3120 &menuID)) 3121 return NULL; 3122 DeleteMenu(menuID); 3123 Py_INCREF(Py_None); 3124 _res = Py_None; 3125 return _res; 3126 } 3127 3128 static PyObject *Menu_DrawMenuBar(PyObject *_self, PyObject *_args) 3129 { 3130 PyObject *_res = NULL; 3131 #ifndef DrawMenuBar 3132 PyMac_PRECHECK(DrawMenuBar); 3133 #endif 3134 if (!PyArg_ParseTuple(_args, "")) 3135 return NULL; 3136 DrawMenuBar(); 3137 Py_INCREF(Py_None); 3138 _res = Py_None; 3139 return _res; 3140 } 3141 3142 static PyObject *Menu_CountMenuItemsWithCommandID(PyObject *_self, PyObject *_args) 3143 { 3144 PyObject *_res = NULL; 3145 ItemCount _rv; 3146 MenuHandle inMenu; 3147 MenuCommand inCommandID; 3148 #ifndef CountMenuItemsWithCommandID 3149 PyMac_PRECHECK(CountMenuItemsWithCommandID); 3150 #endif 3151 if (!PyArg_ParseTuple(_args, "O&l", 3152 OptMenuObj_Convert, &inMenu, 3153 &inCommandID)) 3154 return NULL; 3155 _rv = CountMenuItemsWithCommandID(inMenu, 3156 inCommandID); 3157 _res = Py_BuildValue("l", 3158 _rv); 3159 return _res; 3160 } 3161 3162 static PyObject *Menu_GetIndMenuItemWithCommandID(PyObject *_self, PyObject *_args) 3163 { 3164 PyObject *_res = NULL; 3165 OSStatus _err; 3166 MenuHandle inMenu; 3167 MenuCommand inCommandID; 3168 UInt32 inItemIndex; 3169 MenuHandle outMenu; 3170 MenuItemIndex outIndex; 3171 #ifndef GetIndMenuItemWithCommandID 3172 PyMac_PRECHECK(GetIndMenuItemWithCommandID); 3173 #endif 3174 if (!PyArg_ParseTuple(_args, "O&ll", 3175 OptMenuObj_Convert, &inMenu, 3176 &inCommandID, 3177 &inItemIndex)) 3178 return NULL; 3179 _err = GetIndMenuItemWithCommandID(inMenu, 3180 inCommandID, 3181 inItemIndex, 3182 &outMenu, 3183 &outIndex); 3184 if (_err != noErr) return PyMac_Error(_err); 3185 _res = Py_BuildValue("O&h", 3186 MenuObj_New, outMenu, 3187 outIndex); 3188 return _res; 3189 } 3190 3191 static PyObject *Menu_EnableMenuCommand(PyObject *_self, PyObject *_args) 3192 { 3193 PyObject *_res = NULL; 3194 MenuHandle inMenu; 3195 MenuCommand inCommandID; 3196 #ifndef EnableMenuCommand 3197 PyMac_PRECHECK(EnableMenuCommand); 3198 #endif 3199 if (!PyArg_ParseTuple(_args, "O&l", 3200 OptMenuObj_Convert, &inMenu, 3201 &inCommandID)) 3202 return NULL; 3203 EnableMenuCommand(inMenu, 3204 inCommandID); 3205 Py_INCREF(Py_None); 3206 _res = Py_None; 3207 return _res; 3208 } 3209 3210 static PyObject *Menu_DisableMenuCommand(PyObject *_self, PyObject *_args) 3211 { 3212 PyObject *_res = NULL; 3213 MenuHandle inMenu; 3214 MenuCommand inCommandID; 3215 #ifndef DisableMenuCommand 3216 PyMac_PRECHECK(DisableMenuCommand); 3217 #endif 3218 if (!PyArg_ParseTuple(_args, "O&l", 3219 OptMenuObj_Convert, &inMenu, 3220 &inCommandID)) 3221 return NULL; 3222 DisableMenuCommand(inMenu, 3223 inCommandID); 3224 Py_INCREF(Py_None); 3225 _res = Py_None; 3226 return _res; 3227 } 3228 3229 static PyObject *Menu_IsMenuCommandEnabled(PyObject *_self, PyObject *_args) 3230 { 3231 PyObject *_res = NULL; 3232 Boolean _rv; 3233 MenuHandle inMenu; 3234 MenuCommand inCommandID; 3235 #ifndef IsMenuCommandEnabled 3236 PyMac_PRECHECK(IsMenuCommandEnabled); 3237 #endif 3238 if (!PyArg_ParseTuple(_args, "O&l", 3239 OptMenuObj_Convert, &inMenu, 3240 &inCommandID)) 3241 return NULL; 3242 _rv = IsMenuCommandEnabled(inMenu, 3243 inCommandID); 3244 _res = Py_BuildValue("b", 3245 _rv); 3246 return _res; 3247 } 3248 3249 static PyObject *Menu_SetMenuCommandMark(PyObject *_self, PyObject *_args) 3250 { 3251 PyObject *_res = NULL; 3252 OSStatus _err; 3253 MenuHandle inMenu; 3254 MenuCommand inCommandID; 3255 UniChar inMark; 3256 #ifndef SetMenuCommandMark 3257 PyMac_PRECHECK(SetMenuCommandMark); 3258 #endif 3259 if (!PyArg_ParseTuple(_args, "O&lh", 3260 OptMenuObj_Convert, &inMenu, 3261 &inCommandID, 3262 &inMark)) 3263 return NULL; 3264 _err = SetMenuCommandMark(inMenu, 3265 inCommandID, 3266 inMark); 3267 if (_err != noErr) return PyMac_Error(_err); 3268 Py_INCREF(Py_None); 3269 _res = Py_None; 3270 return _res; 3271 } 3272 3273 static PyObject *Menu_GetMenuCommandMark(PyObject *_self, PyObject *_args) 3274 { 3275 PyObject *_res = NULL; 3276 OSStatus _err; 3277 MenuHandle inMenu; 3278 MenuCommand inCommandID; 3279 UniChar outMark; 3280 #ifndef GetMenuCommandMark 3281 PyMac_PRECHECK(GetMenuCommandMark); 3282 #endif 3283 if (!PyArg_ParseTuple(_args, "O&l", 3284 OptMenuObj_Convert, &inMenu, 3285 &inCommandID)) 3286 return NULL; 3287 _err = GetMenuCommandMark(inMenu, 3288 inCommandID, 3289 &outMark); 3290 if (_err != noErr) return PyMac_Error(_err); 3291 _res = Py_BuildValue("h", 3292 outMark); 3293 return _res; 3294 } 3295 3296 static PyObject *Menu_GetMenuCommandPropertySize(PyObject *_self, PyObject *_args) 3297 { 3298 PyObject *_res = NULL; 3299 OSStatus _err; 3300 MenuHandle inMenu; 3301 MenuCommand inCommandID; 3302 OSType inPropertyCreator; 3303 OSType inPropertyTag; 3304 ByteCount outSize; 3305 #ifndef GetMenuCommandPropertySize 3306 PyMac_PRECHECK(GetMenuCommandPropertySize); 3307 #endif 3308 if (!PyArg_ParseTuple(_args, "O&lO&O&", 3309 OptMenuObj_Convert, &inMenu, 3310 &inCommandID, 3311 PyMac_GetOSType, &inPropertyCreator, 3312 PyMac_GetOSType, &inPropertyTag)) 3313 return NULL; 3314 _err = GetMenuCommandPropertySize(inMenu, 3315 inCommandID, 3316 inPropertyCreator, 3317 inPropertyTag, 3318 &outSize); 3319 if (_err != noErr) return PyMac_Error(_err); 3320 _res = Py_BuildValue("l", 3321 outSize); 3322 return _res; 3323 } 3324 3325 static PyObject *Menu_RemoveMenuCommandProperty(PyObject *_self, PyObject *_args) 3326 { 3327 PyObject *_res = NULL; 3328 OSStatus _err; 3329 MenuHandle inMenu; 3330 MenuCommand inCommandID; 3331 OSType inPropertyCreator; 3332 OSType inPropertyTag; 3333 #ifndef RemoveMenuCommandProperty 3334 PyMac_PRECHECK(RemoveMenuCommandProperty); 3335 #endif 3336 if (!PyArg_ParseTuple(_args, "O&lO&O&", 3337 OptMenuObj_Convert, &inMenu, 3338 &inCommandID, 3339 PyMac_GetOSType, &inPropertyCreator, 3340 PyMac_GetOSType, &inPropertyTag)) 3341 return NULL; 3342 _err = RemoveMenuCommandProperty(inMenu, 3343 inCommandID, 3344 inPropertyCreator, 3345 inPropertyTag); 3346 if (_err != noErr) return PyMac_Error(_err); 3347 Py_INCREF(Py_None); 3348 _res = Py_None; 3349 return _res; 3350 } 3351 #endif /* __LP64__ */ 3352 3353 static PyMethodDef Menu_methods[] = { 3354 #ifndef __LP64__ 3355 {"NewMenu", (PyCFunction)Menu_NewMenu, 1, 3356 PyDoc_STR("(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)")}, 3357 {"MacGetMenu", (PyCFunction)Menu_MacGetMenu, 1, 3358 PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")}, 3359 {"CreateNewMenu", (PyCFunction)Menu_CreateNewMenu, 1, 3360 PyDoc_STR("(MenuID inMenuID, MenuAttributes inMenuAttributes) -> (MenuHandle outMenuRef)")}, 3361 {"MenuKey", (PyCFunction)Menu_MenuKey, 1, 3362 PyDoc_STR("(CharParameter ch) -> (long _rv)")}, 3363 {"MenuSelect", (PyCFunction)Menu_MenuSelect, 1, 3364 PyDoc_STR("(Point startPt) -> (long _rv)")}, 3365 {"MenuChoice", (PyCFunction)Menu_MenuChoice, 1, 3366 PyDoc_STR("() -> (long _rv)")}, 3367 {"MenuEvent", (PyCFunction)Menu_MenuEvent, 1, 3368 PyDoc_STR("(EventRecord inEvent) -> (UInt32 _rv)")}, 3369 {"GetMBarHeight", (PyCFunction)Menu_GetMBarHeight, 1, 3370 PyDoc_STR("() -> (short _rv)")}, 3371 {"MacDrawMenuBar", (PyCFunction)Menu_MacDrawMenuBar, 1, 3372 PyDoc_STR("() -> None")}, 3373 {"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1, 3374 PyDoc_STR("() -> None")}, 3375 {"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1, 3376 PyDoc_STR("(MenuID menuID) -> None")}, 3377 {"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1, 3378 PyDoc_STR("(short menuBarID) -> (MenuBarHandle _rv)")}, 3379 {"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1, 3380 PyDoc_STR("() -> (MenuBarHandle _rv)")}, 3381 {"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1, 3382 PyDoc_STR("(MenuBarHandle mbar) -> None")}, 3383 {"DuplicateMenuBar", (PyCFunction)Menu_DuplicateMenuBar, 1, 3384 PyDoc_STR("(MenuBarHandle inMbar) -> (MenuBarHandle outMbar)")}, 3385 {"DisposeMenuBar", (PyCFunction)Menu_DisposeMenuBar, 1, 3386 PyDoc_STR("(MenuBarHandle inMbar) -> None")}, 3387 {"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1, 3388 PyDoc_STR("(MenuID menuID) -> (MenuHandle _rv)")}, 3389 {"MacDeleteMenu", (PyCFunction)Menu_MacDeleteMenu, 1, 3390 PyDoc_STR("(MenuID menuID) -> None")}, 3391 {"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1, 3392 PyDoc_STR("() -> None")}, 3393 {"SetMenuFlashCount", (PyCFunction)Menu_SetMenuFlashCount, 1, 3394 PyDoc_STR("(short count) -> None")}, 3395 {"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1, 3396 PyDoc_STR("(MenuID menuID) -> None")}, 3397 {"IsMenuBarVisible", (PyCFunction)Menu_IsMenuBarVisible, 1, 3398 PyDoc_STR("() -> (Boolean _rv)")}, 3399 {"ShowMenuBar", (PyCFunction)Menu_ShowMenuBar, 1, 3400 PyDoc_STR("() -> None")}, 3401 {"HideMenuBar", (PyCFunction)Menu_HideMenuBar, 1, 3402 PyDoc_STR("() -> None")}, 3403 {"AcquireRootMenu", (PyCFunction)Menu_AcquireRootMenu, 1, 3404 PyDoc_STR("() -> (MenuHandle _rv)")}, 3405 {"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1, 3406 PyDoc_STR("(MenuID menuID, short menuItem) -> None")}, 3407 {"InitContextualMenus", (PyCFunction)Menu_InitContextualMenus, 1, 3408 PyDoc_STR("() -> None")}, 3409 {"IsShowContextualMenuClick", (PyCFunction)Menu_IsShowContextualMenuClick, 1, 3410 PyDoc_STR("(EventRecord inEvent) -> (Boolean _rv)")}, 3411 {"LMGetTheMenu", (PyCFunction)Menu_LMGetTheMenu, 1, 3412 PyDoc_STR("() -> (SInt16 _rv)")}, 3413 {"as_Menu", (PyCFunction)Menu_as_Menu, 1, 3414 PyDoc_STR("(Handle h) -> (MenuHandle _rv)")}, 3415 {"GetMenu", (PyCFunction)Menu_GetMenu, 1, 3416 PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")}, 3417 {"DeleteMenu", (PyCFunction)Menu_DeleteMenu, 1, 3418 PyDoc_STR("(short menuID) -> None")}, 3419 {"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1, 3420 PyDoc_STR("() -> None")}, 3421 {"CountMenuItemsWithCommandID", (PyCFunction)Menu_CountMenuItemsWithCommandID, 1, 3422 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (ItemCount _rv)")}, 3423 {"GetIndMenuItemWithCommandID", (PyCFunction)Menu_GetIndMenuItemWithCommandID, 1, 3424 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")}, 3425 {"EnableMenuCommand", (PyCFunction)Menu_EnableMenuCommand, 1, 3426 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")}, 3427 {"DisableMenuCommand", (PyCFunction)Menu_DisableMenuCommand, 1, 3428 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")}, 3429 {"IsMenuCommandEnabled", (PyCFunction)Menu_IsMenuCommandEnabled, 1, 3430 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (Boolean _rv)")}, 3431 {"SetMenuCommandMark", (PyCFunction)Menu_SetMenuCommandMark, 1, 3432 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UniChar inMark) -> None")}, 3433 {"GetMenuCommandMark", (PyCFunction)Menu_GetMenuCommandMark, 1, 3434 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (UniChar outMark)")}, 3435 {"GetMenuCommandPropertySize", (PyCFunction)Menu_GetMenuCommandPropertySize, 1, 3436 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")}, 3437 {"RemoveMenuCommandProperty", (PyCFunction)Menu_RemoveMenuCommandProperty, 1, 3438 PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")}, 3439 #endif /* __LP64__ */ 3440 {NULL, NULL, 0} 3441 }; 3442 3443 3444 3445 3446 void init_Menu(void) 3447 { 3448 PyObject *m; 3449 #ifndef __LP64__ 3450 PyObject *d; 3451 3452 3453 3454 PyMac_INIT_TOOLBOX_OBJECT_NEW(MenuHandle, MenuObj_New); 3455 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(MenuHandle, MenuObj_Convert); 3456 #endif /* __LP64__ */ 3457 3458 3459 m = Py_InitModule("_Menu", Menu_methods); 3460 #ifndef __LP64__ 3461 d = PyModule_GetDict(m); 3462 Menu_Error = PyMac_GetOSErrException(); 3463 if (Menu_Error == NULL || 3464 PyDict_SetItemString(d, "Error", Menu_Error) != 0) 3465 return; 3466 Menu_Type.ob_type = &PyType_Type; 3467 if (PyType_Ready(&Menu_Type) < 0) return; 3468 Py_INCREF(&Menu_Type); 3469 PyModule_AddObject(m, "Menu", (PyObject *)&Menu_Type); 3470 /* Backward-compatible name */ 3471 Py_INCREF(&Menu_Type); 3472 PyModule_AddObject(m, "MenuType", (PyObject *)&Menu_Type); 3473 #endif /* __LP64__ */ 3474 } 3475 3476 /* ======================== End module _Menu ======================== */ 3477 3478
