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