Mac/Modules/menu/_Menumodule.c

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