
/* ========================== Module _Menu ========================== */

#include "Python.h"

#ifndef __LP64__


#include "pymactoolbox.h"

/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
        PyErr_SetString(PyExc_NotImplementedError, \
            "Not available in this shared library/OS version"); \
        return NULL; \
    }} while(0)


#include <Carbon/Carbon.h>


#ifdef USE_TOOLBOX_OBJECT_GLUE

extern PyObject *_MenuObj_New(MenuHandle);
extern int _MenuObj_Convert(PyObject *, MenuHandle *);

#define MenuObj_New _MenuObj_New
#define MenuObj_Convert _MenuObj_Convert
#endif

#define as_Menu(h) ((MenuHandle)h)
#define as_Resource(h) ((Handle)h)


/* Alternative version of MenuObj_New, which returns None for NULL argument */
PyObject *OptMenuObj_New(MenuRef itself)
{
    if (itself == NULL) {
        Py_INCREF(Py_None);
        return Py_None;
    }
    return MenuObj_New(itself);
}

/* Alternative version of MenuObj_Convert, which returns NULL for a None argument */
int OptMenuObj_Convert(PyObject *v, MenuRef *p_itself)
{
    if ( v == Py_None ) {
        *p_itself = NULL;
        return 1;
    }
    return MenuObj_Convert(v, p_itself);
}

static PyObject *Menu_Error;

/* ------------------------ Object type Menu ------------------------ */

PyTypeObject Menu_Type;

#define MenuObj_Check(x) ((x)->ob_type == &Menu_Type || PyObject_TypeCheck((x), &Menu_Type))

typedef struct MenuObject {
    PyObject_HEAD
    MenuHandle ob_itself;
} MenuObject;

PyObject *MenuObj_New(MenuHandle itself)
{
    MenuObject *it;
    it = PyObject_NEW(MenuObject, &Menu_Type);
    if (it == NULL) return NULL;
    it->ob_itself = itself;
    return (PyObject *)it;
}

int MenuObj_Convert(PyObject *v, MenuHandle *p_itself)
{
    if (!MenuObj_Check(v))
    {
        PyErr_SetString(PyExc_TypeError, "Menu required");
        return 0;
    }
    *p_itself = ((MenuObject *)v)->ob_itself;
    return 1;
}

static void MenuObj_dealloc(MenuObject *self)
{
    /* Cleanup of self->ob_itself goes here */
    self->ob_type->tp_free((PyObject *)self);
}

static PyObject *MenuObj_DisposeMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef DisposeMenu
    PyMac_PRECHECK(DisposeMenu);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    DisposeMenu(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_CalcMenuSize(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef CalcMenuSize
    PyMac_PRECHECK(CalcMenuSize);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    CalcMenuSize(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_CountMenuItems(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    UInt16 _rv;
#ifndef CountMenuItems
    PyMac_PRECHECK(CountMenuItems);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = CountMenuItems(_self->ob_itself);
    _res = Py_BuildValue("H",
                         _rv);
    return _res;
}

static PyObject *MenuObj_GetMenuFont(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    SInt16 outFontID;
    UInt16 outFontSize;
#ifndef GetMenuFont
    PyMac_PRECHECK(GetMenuFont);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMenuFont(_self->ob_itself,
                       &outFontID,
                       &outFontSize);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("hH",
                         outFontID,
                         outFontSize);
    return _res;
}

static PyObject *MenuObj_SetMenuFont(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    SInt16 inFontID;
    UInt16 inFontSize;
#ifndef SetMenuFont
    PyMac_PRECHECK(SetMenuFont);
#endif
    if (!PyArg_ParseTuple(_args, "hH",
                          &inFontID,
                          &inFontSize))
        return NULL;
    _err = SetMenuFont(_self->ob_itself,
                       inFontID,
                       inFontSize);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuExcludesMarkColumn(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
#ifndef GetMenuExcludesMarkColumn
    PyMac_PRECHECK(GetMenuExcludesMarkColumn);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMenuExcludesMarkColumn(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MenuObj_SetMenuExcludesMarkColumn(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    Boolean excludesMark;
#ifndef SetMenuExcludesMarkColumn
    PyMac_PRECHECK(SetMenuExcludesMarkColumn);
#endif
    if (!PyArg_ParseTuple(_args, "b",
                          &excludesMark))
        return NULL;
    _err = SetMenuExcludesMarkColumn(_self->ob_itself,
                                     excludesMark);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_IsValidMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
#ifndef IsValidMenu
    PyMac_PRECHECK(IsValidMenu);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = IsValidMenu(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MenuObj_GetMenuRetainCount(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ItemCount _rv;
#ifndef GetMenuRetainCount
    PyMac_PRECHECK(GetMenuRetainCount);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMenuRetainCount(_self->ob_itself);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MenuObj_RetainMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
#ifndef RetainMenu
    PyMac_PRECHECK(RetainMenu);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = RetainMenu(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_ReleaseMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
#ifndef ReleaseMenu
    PyMac_PRECHECK(ReleaseMenu);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = ReleaseMenu(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_DuplicateMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuHandle outMenu;
#ifndef DuplicateMenu
    PyMac_PRECHECK(DuplicateMenu);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = DuplicateMenu(_self->ob_itself,
                         &outMenu);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         MenuObj_New, outMenu);
    return _res;
}

static PyObject *MenuObj_CopyMenuTitleAsCFString(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    CFStringRef outString;
#ifndef CopyMenuTitleAsCFString
    PyMac_PRECHECK(CopyMenuTitleAsCFString);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = CopyMenuTitleAsCFString(_self->ob_itself,
                                   &outString);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         CFStringRefObj_New, outString);
    return _res;
}

static PyObject *MenuObj_SetMenuTitleWithCFString(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    CFStringRef inString;
#ifndef SetMenuTitleWithCFString
    PyMac_PRECHECK(SetMenuTitleWithCFString);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          CFStringRefObj_Convert, &inString))
        return NULL;
    _err = SetMenuTitleWithCFString(_self->ob_itself,
                                    inString);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_InvalidateMenuSize(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
#ifndef InvalidateMenuSize
    PyMac_PRECHECK(InvalidateMenuSize);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = InvalidateMenuSize(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_IsMenuSizeInvalid(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
#ifndef IsMenuSizeInvalid
    PyMac_PRECHECK(IsMenuSizeInvalid);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = IsMenuSizeInvalid(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MenuObj_MacAppendMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Str255 data;
#ifndef MacAppendMenu
    PyMac_PRECHECK(MacAppendMenu);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetStr255, data))
        return NULL;
    MacAppendMenu(_self->ob_itself,
                  data);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_InsertResMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ResType theType;
    short afterItem;
#ifndef InsertResMenu
    PyMac_PRECHECK(InsertResMenu);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          PyMac_GetOSType, &theType,
                          &afterItem))
        return NULL;
    InsertResMenu(_self->ob_itself,
                  theType,
                  afterItem);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_AppendResMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ResType theType;
#ifndef AppendResMenu
    PyMac_PRECHECK(AppendResMenu);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetOSType, &theType))
        return NULL;
    AppendResMenu(_self->ob_itself,
                  theType);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_MacInsertMenuItem(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Str255 itemString;
    short afterItem;
#ifndef MacInsertMenuItem
    PyMac_PRECHECK(MacInsertMenuItem);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          PyMac_GetStr255, itemString,
                          &afterItem))
        return NULL;
    MacInsertMenuItem(_self->ob_itself,
                      itemString,
                      afterItem);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_DeleteMenuItem(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
#ifndef DeleteMenuItem
    PyMac_PRECHECK(DeleteMenuItem);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    DeleteMenuItem(_self->ob_itself,
                   item);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_InsertFontResMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short afterItem;
    short scriptFilter;
#ifndef InsertFontResMenu
    PyMac_PRECHECK(InsertFontResMenu);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &afterItem,
                          &scriptFilter))
        return NULL;
    InsertFontResMenu(_self->ob_itself,
                      afterItem,
                      scriptFilter);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_InsertIntlResMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ResType theType;
    short afterItem;
    short scriptFilter;
#ifndef InsertIntlResMenu
    PyMac_PRECHECK(InsertIntlResMenu);
#endif
    if (!PyArg_ParseTuple(_args, "O&hh",
                          PyMac_GetOSType, &theType,
                          &afterItem,
                          &scriptFilter))
        return NULL;
    InsertIntlResMenu(_self->ob_itself,
                      theType,
                      afterItem,
                      scriptFilter);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_AppendMenuItemText(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    Str255 inString;
#ifndef AppendMenuItemText
    PyMac_PRECHECK(AppendMenuItemText);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetStr255, inString))
        return NULL;
    _err = AppendMenuItemText(_self->ob_itself,
                              inString);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_InsertMenuItemText(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    Str255 inString;
    MenuItemIndex afterItem;
#ifndef InsertMenuItemText
    PyMac_PRECHECK(InsertMenuItemText);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          PyMac_GetStr255, inString,
                          &afterItem))
        return NULL;
    _err = InsertMenuItemText(_self->ob_itself,
                              inString,
                              afterItem);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_CopyMenuItems(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inFirstItem;
    ItemCount inNumItems;
    MenuHandle inDestMenu;
    MenuItemIndex inInsertAfter;
#ifndef CopyMenuItems
    PyMac_PRECHECK(CopyMenuItems);
#endif
    if (!PyArg_ParseTuple(_args, "hlO&h",
                          &inFirstItem,
                          &inNumItems,
                          MenuObj_Convert, &inDestMenu,
                          &inInsertAfter))
        return NULL;
    _err = CopyMenuItems(_self->ob_itself,
                         inFirstItem,
                         inNumItems,
                         inDestMenu,
                         inInsertAfter);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_DeleteMenuItems(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inFirstItem;
    ItemCount inNumItems;
#ifndef DeleteMenuItems
    PyMac_PRECHECK(DeleteMenuItems);
#endif
    if (!PyArg_ParseTuple(_args, "hl",
                          &inFirstItem,
                          &inNumItems))
        return NULL;
    _err = DeleteMenuItems(_self->ob_itself,
                           inFirstItem,
                           inNumItems);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_AppendMenuItemTextWithCFString(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    CFStringRef inString;
    MenuItemAttributes inAttributes;
    MenuCommand inCommandID;
    MenuItemIndex outNewItem;
#ifndef AppendMenuItemTextWithCFString
    PyMac_PRECHECK(AppendMenuItemTextWithCFString);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          CFStringRefObj_Convert, &inString,
                          &inAttributes,
                          &inCommandID))
        return NULL;
    _err = AppendMenuItemTextWithCFString(_self->ob_itself,
                                          inString,
                                          inAttributes,
                                          inCommandID,
                                          &outNewItem);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         outNewItem);
    return _res;
}

static PyObject *MenuObj_InsertMenuItemTextWithCFString(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    CFStringRef inString;
    MenuItemIndex inAfterItem;
    MenuItemAttributes inAttributes;
    MenuCommand inCommandID;
#ifndef InsertMenuItemTextWithCFString
    PyMac_PRECHECK(InsertMenuItemTextWithCFString);
#endif
    if (!PyArg_ParseTuple(_args, "O&hll",
                          CFStringRefObj_Convert, &inString,
                          &inAfterItem,
                          &inAttributes,
                          &inCommandID))
        return NULL;
    _err = InsertMenuItemTextWithCFString(_self->ob_itself,
                                          inString,
                                          inAfterItem,
                                          inAttributes,
                                          inCommandID);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_PopUpMenuSelect(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    short top;
    short left;
    short popUpItem;
#ifndef PopUpMenuSelect
    PyMac_PRECHECK(PopUpMenuSelect);
#endif
    if (!PyArg_ParseTuple(_args, "hhh",
                          &top,
                          &left,
                          &popUpItem))
        return NULL;
    _rv = PopUpMenuSelect(_self->ob_itself,
                          top,
                          left,
                          popUpItem);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MenuObj_InvalidateMenuEnabling(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
#ifndef InvalidateMenuEnabling
    PyMac_PRECHECK(InvalidateMenuEnabling);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = InvalidateMenuEnabling(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_IsMenuBarInvalid(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
#ifndef IsMenuBarInvalid
    PyMac_PRECHECK(IsMenuBarInvalid);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = IsMenuBarInvalid(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MenuObj_MacInsertMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuID beforeID;
#ifndef MacInsertMenu
    PyMac_PRECHECK(MacInsertMenu);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &beforeID))
        return NULL;
    MacInsertMenu(_self->ob_itself,
                  beforeID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_SetRootMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
#ifndef SetRootMenu
    PyMac_PRECHECK(SetRootMenu);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = SetRootMenu(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_MacCheckMenuItem(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    Boolean checked;
#ifndef MacCheckMenuItem
    PyMac_PRECHECK(MacCheckMenuItem);
#endif
    if (!PyArg_ParseTuple(_args, "hb",
                          &item,
                          &checked))
        return NULL;
    MacCheckMenuItem(_self->ob_itself,
                     item,
                     checked);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_SetMenuItemText(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    Str255 itemString;
#ifndef SetMenuItemText
    PyMac_PRECHECK(SetMenuItemText);
#endif
    if (!PyArg_ParseTuple(_args, "hO&",
                          &item,
                          PyMac_GetStr255, itemString))
        return NULL;
    SetMenuItemText(_self->ob_itself,
                    item,
                    itemString);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemText(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    Str255 itemString;
#ifndef GetMenuItemText
    PyMac_PRECHECK(GetMenuItemText);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    GetMenuItemText(_self->ob_itself,
                    item,
                    itemString);
    _res = Py_BuildValue("O&",
                         PyMac_BuildStr255, itemString);
    return _res;
}

static PyObject *MenuObj_SetItemMark(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    CharParameter markChar;
#ifndef SetItemMark
    PyMac_PRECHECK(SetItemMark);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &item,
                          &markChar))
        return NULL;
    SetItemMark(_self->ob_itself,
                item,
                markChar);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetItemMark(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    CharParameter markChar;
#ifndef GetItemMark
    PyMac_PRECHECK(GetItemMark);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    GetItemMark(_self->ob_itself,
                item,
                &markChar);
    _res = Py_BuildValue("h",
                         markChar);
    return _res;
}

static PyObject *MenuObj_SetItemCmd(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    CharParameter cmdChar;
#ifndef SetItemCmd
    PyMac_PRECHECK(SetItemCmd);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &item,
                          &cmdChar))
        return NULL;
    SetItemCmd(_self->ob_itself,
               item,
               cmdChar);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetItemCmd(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    CharParameter cmdChar;
#ifndef GetItemCmd
    PyMac_PRECHECK(GetItemCmd);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    GetItemCmd(_self->ob_itself,
               item,
               &cmdChar);
    _res = Py_BuildValue("h",
                         cmdChar);
    return _res;
}

static PyObject *MenuObj_SetItemIcon(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    short iconIndex;
#ifndef SetItemIcon
    PyMac_PRECHECK(SetItemIcon);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &item,
                          &iconIndex))
        return NULL;
    SetItemIcon(_self->ob_itself,
                item,
                iconIndex);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetItemIcon(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    short iconIndex;
#ifndef GetItemIcon
    PyMac_PRECHECK(GetItemIcon);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    GetItemIcon(_self->ob_itself,
                item,
                &iconIndex);
    _res = Py_BuildValue("h",
                         iconIndex);
    return _res;
}

static PyObject *MenuObj_SetItemStyle(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    StyleParameter chStyle;
#ifndef SetItemStyle
    PyMac_PRECHECK(SetItemStyle);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &item,
                          &chStyle))
        return NULL;
    SetItemStyle(_self->ob_itself,
                 item,
                 chStyle);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetItemStyle(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    Style chStyle;
#ifndef GetItemStyle
    PyMac_PRECHECK(GetItemStyle);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    GetItemStyle(_self->ob_itself,
                 item,
                 &chStyle);
    _res = Py_BuildValue("b",
                         chStyle);
    return _res;
}

static PyObject *MenuObj_SetMenuItemCommandID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    MenuCommand inCommandID;
#ifndef SetMenuItemCommandID
    PyMac_PRECHECK(SetMenuItemCommandID);
#endif
    if (!PyArg_ParseTuple(_args, "hl",
                          &inItem,
                          &inCommandID))
        return NULL;
    _err = SetMenuItemCommandID(_self->ob_itself,
                                inItem,
                                inCommandID);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemCommandID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    MenuCommand outCommandID;
#ifndef GetMenuItemCommandID
    PyMac_PRECHECK(GetMenuItemCommandID);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemCommandID(_self->ob_itself,
                                inItem,
                                &outCommandID);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outCommandID);
    return _res;
}

static PyObject *MenuObj_SetMenuItemModifiers(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    UInt8 inModifiers;
#ifndef SetMenuItemModifiers
    PyMac_PRECHECK(SetMenuItemModifiers);
#endif
    if (!PyArg_ParseTuple(_args, "hb",
                          &inItem,
                          &inModifiers))
        return NULL;
    _err = SetMenuItemModifiers(_self->ob_itself,
                                inItem,
                                inModifiers);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemModifiers(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    UInt8 outModifiers;
#ifndef GetMenuItemModifiers
    PyMac_PRECHECK(GetMenuItemModifiers);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemModifiers(_self->ob_itself,
                                inItem,
                                &outModifiers);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("b",
                         outModifiers);
    return _res;
}

static PyObject *MenuObj_SetMenuItemIconHandle(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    UInt8 inIconType;
    Handle inIconHandle;
#ifndef SetMenuItemIconHandle
    PyMac_PRECHECK(SetMenuItemIconHandle);
#endif
    if (!PyArg_ParseTuple(_args, "hbO&",
                          &inItem,
                          &inIconType,
                          ResObj_Convert, &inIconHandle))
        return NULL;
    _err = SetMenuItemIconHandle(_self->ob_itself,
                                 inItem,
                                 inIconType,
                                 inIconHandle);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemIconHandle(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    UInt8 outIconType;
    Handle outIconHandle;
#ifndef GetMenuItemIconHandle
    PyMac_PRECHECK(GetMenuItemIconHandle);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemIconHandle(_self->ob_itself,
                                 inItem,
                                 &outIconType,
                                 &outIconHandle);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("bO&",
                         outIconType,
                         ResObj_New, outIconHandle);
    return _res;
}

static PyObject *MenuObj_SetMenuItemTextEncoding(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    TextEncoding inScriptID;
#ifndef SetMenuItemTextEncoding
    PyMac_PRECHECK(SetMenuItemTextEncoding);
#endif
    if (!PyArg_ParseTuple(_args, "hl",
                          &inItem,
                          &inScriptID))
        return NULL;
    _err = SetMenuItemTextEncoding(_self->ob_itself,
                                   inItem,
                                   inScriptID);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemTextEncoding(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    TextEncoding outScriptID;
#ifndef GetMenuItemTextEncoding
    PyMac_PRECHECK(GetMenuItemTextEncoding);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemTextEncoding(_self->ob_itself,
                                   inItem,
                                   &outScriptID);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outScriptID);
    return _res;
}

static PyObject *MenuObj_SetMenuItemHierarchicalID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    MenuID inHierID;
#ifndef SetMenuItemHierarchicalID
    PyMac_PRECHECK(SetMenuItemHierarchicalID);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &inItem,
                          &inHierID))
        return NULL;
    _err = SetMenuItemHierarchicalID(_self->ob_itself,
                                     inItem,
                                     inHierID);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemHierarchicalID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    MenuID outHierID;
#ifndef GetMenuItemHierarchicalID
    PyMac_PRECHECK(GetMenuItemHierarchicalID);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemHierarchicalID(_self->ob_itself,
                                     inItem,
                                     &outHierID);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         outHierID);
    return _res;
}

static PyObject *MenuObj_SetMenuItemFontID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    SInt16 inFontID;
#ifndef SetMenuItemFontID
    PyMac_PRECHECK(SetMenuItemFontID);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &inItem,
                          &inFontID))
        return NULL;
    _err = SetMenuItemFontID(_self->ob_itself,
                             inItem,
                             inFontID);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemFontID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    SInt16 outFontID;
#ifndef GetMenuItemFontID
    PyMac_PRECHECK(GetMenuItemFontID);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemFontID(_self->ob_itself,
                             inItem,
                             &outFontID);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         outFontID);
    return _res;
}

static PyObject *MenuObj_SetMenuItemRefCon(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    UInt32 inRefCon;
#ifndef SetMenuItemRefCon
    PyMac_PRECHECK(SetMenuItemRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "hl",
                          &inItem,
                          &inRefCon))
        return NULL;
    _err = SetMenuItemRefCon(_self->ob_itself,
                             inItem,
                             inRefCon);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemRefCon(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    UInt32 outRefCon;
#ifndef GetMenuItemRefCon
    PyMac_PRECHECK(GetMenuItemRefCon);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemRefCon(_self->ob_itself,
                             inItem,
                             &outRefCon);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outRefCon);
    return _res;
}

static PyObject *MenuObj_SetMenuItemKeyGlyph(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    SInt16 inGlyph;
#ifndef SetMenuItemKeyGlyph
    PyMac_PRECHECK(SetMenuItemKeyGlyph);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &inItem,
                          &inGlyph))
        return NULL;
    _err = SetMenuItemKeyGlyph(_self->ob_itself,
                               inItem,
                               inGlyph);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemKeyGlyph(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSErr _err;
    SInt16 inItem;
    SInt16 outGlyph;
#ifndef GetMenuItemKeyGlyph
    PyMac_PRECHECK(GetMenuItemKeyGlyph);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemKeyGlyph(_self->ob_itself,
                               inItem,
                               &outGlyph);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         outGlyph);
    return _res;
}

static PyObject *MenuObj_MacEnableMenuItem(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuItemIndex item;
#ifndef MacEnableMenuItem
    PyMac_PRECHECK(MacEnableMenuItem);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    MacEnableMenuItem(_self->ob_itself,
                      item);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_DisableMenuItem(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuItemIndex item;
#ifndef DisableMenuItem
    PyMac_PRECHECK(DisableMenuItem);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    DisableMenuItem(_self->ob_itself,
                    item);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_IsMenuItemEnabled(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
    MenuItemIndex item;
#ifndef IsMenuItemEnabled
    PyMac_PRECHECK(IsMenuItemEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    _rv = IsMenuItemEnabled(_self->ob_itself,
                            item);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MenuObj_EnableMenuItemIcon(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuItemIndex item;
#ifndef EnableMenuItemIcon
    PyMac_PRECHECK(EnableMenuItemIcon);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    EnableMenuItemIcon(_self->ob_itself,
                       item);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_DisableMenuItemIcon(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuItemIndex item;
#ifndef DisableMenuItemIcon
    PyMac_PRECHECK(DisableMenuItemIcon);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    DisableMenuItemIcon(_self->ob_itself,
                        item);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_IsMenuItemIconEnabled(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
    MenuItemIndex item;
#ifndef IsMenuItemIconEnabled
    PyMac_PRECHECK(IsMenuItemIconEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    _rv = IsMenuItemIconEnabled(_self->ob_itself,
                                item);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MenuObj_SetMenuItemHierarchicalMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inItem;
    MenuHandle inHierMenu;
#ifndef SetMenuItemHierarchicalMenu
    PyMac_PRECHECK(SetMenuItemHierarchicalMenu);
#endif
    if (!PyArg_ParseTuple(_args, "hO&",
                          &inItem,
                          MenuObj_Convert, &inHierMenu))
        return NULL;
    _err = SetMenuItemHierarchicalMenu(_self->ob_itself,
                                       inItem,
                                       inHierMenu);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemHierarchicalMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inItem;
    MenuHandle outHierMenu;
#ifndef GetMenuItemHierarchicalMenu
    PyMac_PRECHECK(GetMenuItemHierarchicalMenu);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemHierarchicalMenu(_self->ob_itself,
                                       inItem,
                                       &outHierMenu);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         OptMenuObj_New, outHierMenu);
    return _res;
}

static PyObject *MenuObj_CopyMenuItemTextAsCFString(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inItem;
    CFStringRef outString;
#ifndef CopyMenuItemTextAsCFString
    PyMac_PRECHECK(CopyMenuItemTextAsCFString);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = CopyMenuItemTextAsCFString(_self->ob_itself,
                                      inItem,
                                      &outString);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         CFStringRefObj_New, outString);
    return _res;
}

static PyObject *MenuObj_SetMenuItemTextWithCFString(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inItem;
    CFStringRef inString;
#ifndef SetMenuItemTextWithCFString
    PyMac_PRECHECK(SetMenuItemTextWithCFString);
#endif
    if (!PyArg_ParseTuple(_args, "hO&",
                          &inItem,
                          CFStringRefObj_Convert, &inString))
        return NULL;
    _err = SetMenuItemTextWithCFString(_self->ob_itself,
                                       inItem,
                                       inString);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemIndent(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inItem;
    UInt32 outIndent;
#ifndef GetMenuItemIndent
    PyMac_PRECHECK(GetMenuItemIndent);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _err = GetMenuItemIndent(_self->ob_itself,
                             inItem,
                             &outIndent);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outIndent);
    return _res;
}

static PyObject *MenuObj_SetMenuItemIndent(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inItem;
    UInt32 inIndent;
#ifndef SetMenuItemIndent
    PyMac_PRECHECK(SetMenuItemIndent);
#endif
    if (!PyArg_ParseTuple(_args, "hl",
                          &inItem,
                          &inIndent))
        return NULL;
    _err = SetMenuItemIndent(_self->ob_itself,
                             inItem,
                             inIndent);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemCommandKey(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inItem;
    Boolean inGetVirtualKey;
    UInt16 outKey;
#ifndef GetMenuItemCommandKey
    PyMac_PRECHECK(GetMenuItemCommandKey);
#endif
    if (!PyArg_ParseTuple(_args, "hb",
                          &inItem,
                          &inGetVirtualKey))
        return NULL;
    _err = GetMenuItemCommandKey(_self->ob_itself,
                                 inItem,
                                 inGetVirtualKey,
                                 &outKey);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("H",
                         outKey);
    return _res;
}

static PyObject *MenuObj_SetMenuItemCommandKey(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inItem;
    Boolean inSetVirtualKey;
    UInt16 inKey;
#ifndef SetMenuItemCommandKey
    PyMac_PRECHECK(SetMenuItemCommandKey);
#endif
    if (!PyArg_ParseTuple(_args, "hbH",
                          &inItem,
                          &inSetVirtualKey,
                          &inKey))
        return NULL;
    _err = SetMenuItemCommandKey(_self->ob_itself,
                                 inItem,
                                 inSetVirtualKey,
                                 inKey);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemPropertyAttributes(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex item;
    OSType propertyCreator;
    OSType propertyTag;
    UInt32 attributes;
#ifndef GetMenuItemPropertyAttributes
    PyMac_PRECHECK(GetMenuItemPropertyAttributes);
#endif
    if (!PyArg_ParseTuple(_args, "hO&O&",
                          &item,
                          PyMac_GetOSType, &propertyCreator,
                          PyMac_GetOSType, &propertyTag))
        return NULL;
    _err = GetMenuItemPropertyAttributes(_self->ob_itself,
                                         item,
                                         propertyCreator,
                                         propertyTag,
                                         &attributes);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         attributes);
    return _res;
}

static PyObject *MenuObj_ChangeMenuItemPropertyAttributes(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex item;
    OSType propertyCreator;
    OSType propertyTag;
    UInt32 attributesToSet;
    UInt32 attributesToClear;
#ifndef ChangeMenuItemPropertyAttributes
    PyMac_PRECHECK(ChangeMenuItemPropertyAttributes);
#endif
    if (!PyArg_ParseTuple(_args, "hO&O&ll",
                          &item,
                          PyMac_GetOSType, &propertyCreator,
                          PyMac_GetOSType, &propertyTag,
                          &attributesToSet,
                          &attributesToClear))
        return NULL;
    _err = ChangeMenuItemPropertyAttributes(_self->ob_itself,
                                            item,
                                            propertyCreator,
                                            propertyTag,
                                            attributesToSet,
                                            attributesToClear);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuAttributes(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuAttributes outAttributes;
#ifndef GetMenuAttributes
    PyMac_PRECHECK(GetMenuAttributes);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMenuAttributes(_self->ob_itself,
                             &outAttributes);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outAttributes);
    return _res;
}

static PyObject *MenuObj_ChangeMenuAttributes(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuAttributes setTheseAttributes;
    MenuAttributes clearTheseAttributes;
#ifndef ChangeMenuAttributes
    PyMac_PRECHECK(ChangeMenuAttributes);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &setTheseAttributes,
                          &clearTheseAttributes))
        return NULL;
    _err = ChangeMenuAttributes(_self->ob_itself,
                                setTheseAttributes,
                                clearTheseAttributes);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuItemAttributes(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex item;
    MenuItemAttributes outAttributes;
#ifndef GetMenuItemAttributes
    PyMac_PRECHECK(GetMenuItemAttributes);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    _err = GetMenuItemAttributes(_self->ob_itself,
                                 item,
                                 &outAttributes);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outAttributes);
    return _res;
}

static PyObject *MenuObj_ChangeMenuItemAttributes(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex item;
    MenuItemAttributes setTheseAttributes;
    MenuItemAttributes clearTheseAttributes;
#ifndef ChangeMenuItemAttributes
    PyMac_PRECHECK(ChangeMenuItemAttributes);
#endif
    if (!PyArg_ParseTuple(_args, "hll",
                          &item,
                          &setTheseAttributes,
                          &clearTheseAttributes))
        return NULL;
    _err = ChangeMenuItemAttributes(_self->ob_itself,
                                    item,
                                    setTheseAttributes,
                                    clearTheseAttributes);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_DisableAllMenuItems(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef DisableAllMenuItems
    PyMac_PRECHECK(DisableAllMenuItems);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    DisableAllMenuItems(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_EnableAllMenuItems(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef EnableAllMenuItems
    PyMac_PRECHECK(EnableAllMenuItems);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    EnableAllMenuItems(_self->ob_itself);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_MenuHasEnabledItems(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
#ifndef MenuHasEnabledItems
    PyMac_PRECHECK(MenuHasEnabledItems);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MenuHasEnabledItems(_self->ob_itself);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MenuObj_GetMenuType(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    UInt16 outType;
#ifndef GetMenuType
    PyMac_PRECHECK(GetMenuType);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = GetMenuType(_self->ob_itself,
                       &outType);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("H",
                         outType);
    return _res;
}

static PyObject *MenuObj_CountMenuItemsWithCommandID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ItemCount _rv;
    MenuCommand inCommandID;
#ifndef CountMenuItemsWithCommandID
    PyMac_PRECHECK(CountMenuItemsWithCommandID);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &inCommandID))
        return NULL;
    _rv = CountMenuItemsWithCommandID(_self->ob_itself,
                                      inCommandID);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *MenuObj_GetIndMenuItemWithCommandID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuCommand inCommandID;
    UInt32 inItemIndex;
    MenuHandle outMenu;
    MenuItemIndex outIndex;
#ifndef GetIndMenuItemWithCommandID
    PyMac_PRECHECK(GetIndMenuItemWithCommandID);
#endif
    if (!PyArg_ParseTuple(_args, "ll",
                          &inCommandID,
                          &inItemIndex))
        return NULL;
    _err = GetIndMenuItemWithCommandID(_self->ob_itself,
                                       inCommandID,
                                       inItemIndex,
                                       &outMenu,
                                       &outIndex);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&h",
                         MenuObj_New, outMenu,
                         outIndex);
    return _res;
}

static PyObject *MenuObj_EnableMenuCommand(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuCommand inCommandID;
#ifndef EnableMenuCommand
    PyMac_PRECHECK(EnableMenuCommand);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &inCommandID))
        return NULL;
    EnableMenuCommand(_self->ob_itself,
                      inCommandID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_DisableMenuCommand(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuCommand inCommandID;
#ifndef DisableMenuCommand
    PyMac_PRECHECK(DisableMenuCommand);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &inCommandID))
        return NULL;
    DisableMenuCommand(_self->ob_itself,
                       inCommandID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_IsMenuCommandEnabled(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
    MenuCommand inCommandID;
#ifndef IsMenuCommandEnabled
    PyMac_PRECHECK(IsMenuCommandEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &inCommandID))
        return NULL;
    _rv = IsMenuCommandEnabled(_self->ob_itself,
                               inCommandID);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MenuObj_SetMenuCommandMark(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuCommand inCommandID;
    UniChar inMark;
#ifndef SetMenuCommandMark
    PyMac_PRECHECK(SetMenuCommandMark);
#endif
    if (!PyArg_ParseTuple(_args, "lh",
                          &inCommandID,
                          &inMark))
        return NULL;
    _err = SetMenuCommandMark(_self->ob_itself,
                              inCommandID,
                              inMark);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_GetMenuCommandMark(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuCommand inCommandID;
    UniChar outMark;
#ifndef GetMenuCommandMark
    PyMac_PRECHECK(GetMenuCommandMark);
#endif
    if (!PyArg_ParseTuple(_args, "l",
                          &inCommandID))
        return NULL;
    _err = GetMenuCommandMark(_self->ob_itself,
                              inCommandID,
                              &outMark);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         outMark);
    return _res;
}

static PyObject *MenuObj_GetMenuCommandPropertySize(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuCommand inCommandID;
    OSType inPropertyCreator;
    OSType inPropertyTag;
    ByteCount outSize;
#ifndef GetMenuCommandPropertySize
    PyMac_PRECHECK(GetMenuCommandPropertySize);
#endif
    if (!PyArg_ParseTuple(_args, "lO&O&",
                          &inCommandID,
                          PyMac_GetOSType, &inPropertyCreator,
                          PyMac_GetOSType, &inPropertyTag))
        return NULL;
    _err = GetMenuCommandPropertySize(_self->ob_itself,
                                      inCommandID,
                                      inPropertyCreator,
                                      inPropertyTag,
                                      &outSize);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outSize);
    return _res;
}

static PyObject *MenuObj_RemoveMenuCommandProperty(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuCommand inCommandID;
    OSType inPropertyCreator;
    OSType inPropertyTag;
#ifndef RemoveMenuCommandProperty
    PyMac_PRECHECK(RemoveMenuCommandProperty);
#endif
    if (!PyArg_ParseTuple(_args, "lO&O&",
                          &inCommandID,
                          PyMac_GetOSType, &inPropertyCreator,
                          PyMac_GetOSType, &inPropertyTag))
        return NULL;
    _err = RemoveMenuCommandProperty(_self->ob_itself,
                                     inCommandID,
                                     inPropertyCreator,
                                     inPropertyTag);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_IsMenuItemInvalid(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
    MenuItemIndex inItem;
#ifndef IsMenuItemInvalid
    PyMac_PRECHECK(IsMenuItemInvalid);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &inItem))
        return NULL;
    _rv = IsMenuItemInvalid(_self->ob_itself,
                            inItem);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *MenuObj_InvalidateMenuItems(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex inFirstItem;
    ItemCount inNumItems;
#ifndef InvalidateMenuItems
    PyMac_PRECHECK(InvalidateMenuItems);
#endif
    if (!PyArg_ParseTuple(_args, "hl",
                          &inFirstItem,
                          &inNumItems))
        return NULL;
    _err = InvalidateMenuItems(_self->ob_itself,
                               inFirstItem,
                               inNumItems);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_UpdateInvalidMenuItems(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
#ifndef UpdateInvalidMenuItems
    PyMac_PRECHECK(UpdateInvalidMenuItems);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = UpdateInvalidMenuItems(_self->ob_itself);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_CreateStandardFontMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex afterItem;
    MenuID firstHierMenuID;
    OptionBits options;
    ItemCount outHierMenuCount;
#ifndef CreateStandardFontMenu
    PyMac_PRECHECK(CreateStandardFontMenu);
#endif
    if (!PyArg_ParseTuple(_args, "hhl",
                          &afterItem,
                          &firstHierMenuID,
                          &options))
        return NULL;
    _err = CreateStandardFontMenu(_self->ob_itself,
                                  afterItem,
                                  firstHierMenuID,
                                  options,
                                  &outHierMenuCount);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outHierMenuCount);
    return _res;
}

static PyObject *MenuObj_UpdateStandardFontMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    ItemCount outHierMenuCount;
#ifndef UpdateStandardFontMenu
    PyMac_PRECHECK(UpdateStandardFontMenu);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = UpdateStandardFontMenu(_self->ob_itself,
                                  &outHierMenuCount);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outHierMenuCount);
    return _res;
}

static PyObject *MenuObj_GetFontFamilyFromMenuSelection(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuItemIndex item;
    FMFontFamily outFontFamily;
    FMFontStyle outStyle;
#ifndef GetFontFamilyFromMenuSelection
    PyMac_PRECHECK(GetFontFamilyFromMenuSelection);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &item))
        return NULL;
    _err = GetFontFamilyFromMenuSelection(_self->ob_itself,
                                          item,
                                          &outFontFamily,
                                          &outStyle);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("hh",
                         outFontFamily,
                         outStyle);
    return _res;
}

static PyObject *MenuObj_GetMenuID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuID _rv;
#ifndef GetMenuID
    PyMac_PRECHECK(GetMenuID);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMenuID(_self->ob_itself);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *MenuObj_GetMenuWidth(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    SInt16 _rv;
#ifndef GetMenuWidth
    PyMac_PRECHECK(GetMenuWidth);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMenuWidth(_self->ob_itself);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *MenuObj_GetMenuHeight(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    SInt16 _rv;
#ifndef GetMenuHeight
    PyMac_PRECHECK(GetMenuHeight);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMenuHeight(_self->ob_itself);
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *MenuObj_SetMenuID(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuID menuID;
#ifndef SetMenuID
    PyMac_PRECHECK(SetMenuID);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &menuID))
        return NULL;
    SetMenuID(_self->ob_itself,
              menuID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_SetMenuWidth(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    SInt16 width;
#ifndef SetMenuWidth
    PyMac_PRECHECK(SetMenuWidth);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &width))
        return NULL;
    SetMenuWidth(_self->ob_itself,
                 width);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_SetMenuHeight(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    SInt16 height;
#ifndef SetMenuHeight
    PyMac_PRECHECK(SetMenuHeight);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &height))
        return NULL;
    SetMenuHeight(_self->ob_itself,
                  height);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_as_Resource(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Handle _rv;
#ifndef as_Resource
    PyMac_PRECHECK(as_Resource);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = as_Resource(_self->ob_itself);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *MenuObj_AppendMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Str255 data;
#ifndef AppendMenu
    PyMac_PRECHECK(AppendMenu);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetStr255, data))
        return NULL;
    AppendMenu(_self->ob_itself,
               data);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_InsertMenu(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short beforeID;
#ifndef InsertMenu
    PyMac_PRECHECK(InsertMenu);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &beforeID))
        return NULL;
    InsertMenu(_self->ob_itself,
               beforeID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_InsertMenuItem(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Str255 itemString;
    short afterItem;
#ifndef InsertMenuItem
    PyMac_PRECHECK(InsertMenuItem);
#endif
    if (!PyArg_ParseTuple(_args, "O&h",
                          PyMac_GetStr255, itemString,
                          &afterItem))
        return NULL;
    InsertMenuItem(_self->ob_itself,
                   itemString,
                   afterItem);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_EnableMenuItem(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    UInt16 item;
#ifndef EnableMenuItem
    PyMac_PRECHECK(EnableMenuItem);
#endif
    if (!PyArg_ParseTuple(_args, "H",
                          &item))
        return NULL;
    EnableMenuItem(_self->ob_itself,
                   item);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *MenuObj_CheckMenuItem(MenuObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short item;
    Boolean checked;
#ifndef CheckMenuItem
    PyMac_PRECHECK(CheckMenuItem);
#endif
    if (!PyArg_ParseTuple(_args, "hb",
                          &item,
                          &checked))
        return NULL;
    CheckMenuItem(_self->ob_itself,
                  item,
                  checked);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyMethodDef MenuObj_methods[] = {
    {"DisposeMenu", (PyCFunction)MenuObj_DisposeMenu, 1,
     PyDoc_STR("() -> None")},
    {"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1,
     PyDoc_STR("() -> None")},
    {"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1,
     PyDoc_STR("() -> (UInt16 _rv)")},
    {"GetMenuFont", (PyCFunction)MenuObj_GetMenuFont, 1,
     PyDoc_STR("() -> (SInt16 outFontID, UInt16 outFontSize)")},
    {"SetMenuFont", (PyCFunction)MenuObj_SetMenuFont, 1,
     PyDoc_STR("(SInt16 inFontID, UInt16 inFontSize) -> None")},
    {"GetMenuExcludesMarkColumn", (PyCFunction)MenuObj_GetMenuExcludesMarkColumn, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"SetMenuExcludesMarkColumn", (PyCFunction)MenuObj_SetMenuExcludesMarkColumn, 1,
     PyDoc_STR("(Boolean excludesMark) -> None")},
    {"IsValidMenu", (PyCFunction)MenuObj_IsValidMenu, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"GetMenuRetainCount", (PyCFunction)MenuObj_GetMenuRetainCount, 1,
     PyDoc_STR("() -> (ItemCount _rv)")},
    {"RetainMenu", (PyCFunction)MenuObj_RetainMenu, 1,
     PyDoc_STR("() -> None")},
    {"ReleaseMenu", (PyCFunction)MenuObj_ReleaseMenu, 1,
     PyDoc_STR("() -> None")},
    {"DuplicateMenu", (PyCFunction)MenuObj_DuplicateMenu, 1,
     PyDoc_STR("() -> (MenuHandle outMenu)")},
    {"CopyMenuTitleAsCFString", (PyCFunction)MenuObj_CopyMenuTitleAsCFString, 1,
     PyDoc_STR("() -> (CFStringRef outString)")},
    {"SetMenuTitleWithCFString", (PyCFunction)MenuObj_SetMenuTitleWithCFString, 1,
     PyDoc_STR("(CFStringRef inString) -> None")},
    {"InvalidateMenuSize", (PyCFunction)MenuObj_InvalidateMenuSize, 1,
     PyDoc_STR("() -> None")},
    {"IsMenuSizeInvalid", (PyCFunction)MenuObj_IsMenuSizeInvalid, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"MacAppendMenu", (PyCFunction)MenuObj_MacAppendMenu, 1,
     PyDoc_STR("(Str255 data) -> None")},
    {"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1,
     PyDoc_STR("(ResType theType, short afterItem) -> None")},
    {"AppendResMenu", (PyCFunction)MenuObj_AppendResMenu, 1,
     PyDoc_STR("(ResType theType) -> None")},
    {"MacInsertMenuItem", (PyCFunction)MenuObj_MacInsertMenuItem, 1,
     PyDoc_STR("(Str255 itemString, short afterItem) -> None")},
    {"DeleteMenuItem", (PyCFunction)MenuObj_DeleteMenuItem, 1,
     PyDoc_STR("(short item) -> None")},
    {"InsertFontResMenu", (PyCFunction)MenuObj_InsertFontResMenu, 1,
     PyDoc_STR("(short afterItem, short scriptFilter) -> None")},
    {"InsertIntlResMenu", (PyCFunction)MenuObj_InsertIntlResMenu, 1,
     PyDoc_STR("(ResType theType, short afterItem, short scriptFilter) -> None")},
    {"AppendMenuItemText", (PyCFunction)MenuObj_AppendMenuItemText, 1,
     PyDoc_STR("(Str255 inString) -> None")},
    {"InsertMenuItemText", (PyCFunction)MenuObj_InsertMenuItemText, 1,
     PyDoc_STR("(Str255 inString, MenuItemIndex afterItem) -> None")},
    {"CopyMenuItems", (PyCFunction)MenuObj_CopyMenuItems, 1,
     PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems, MenuHandle inDestMenu, MenuItemIndex inInsertAfter) -> None")},
    {"DeleteMenuItems", (PyCFunction)MenuObj_DeleteMenuItems, 1,
     PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None")},
    {"AppendMenuItemTextWithCFString", (PyCFunction)MenuObj_AppendMenuItemTextWithCFString, 1,
     PyDoc_STR("(CFStringRef inString, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> (MenuItemIndex outNewItem)")},
    {"InsertMenuItemTextWithCFString", (PyCFunction)MenuObj_InsertMenuItemTextWithCFString, 1,
     PyDoc_STR("(CFStringRef inString, MenuItemIndex inAfterItem, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> None")},
    {"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1,
     PyDoc_STR("(short top, short left, short popUpItem) -> (long _rv)")},
    {"InvalidateMenuEnabling", (PyCFunction)MenuObj_InvalidateMenuEnabling, 1,
     PyDoc_STR("() -> None")},
    {"IsMenuBarInvalid", (PyCFunction)MenuObj_IsMenuBarInvalid, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"MacInsertMenu", (PyCFunction)MenuObj_MacInsertMenu, 1,
     PyDoc_STR("(MenuID beforeID) -> None")},
    {"SetRootMenu", (PyCFunction)MenuObj_SetRootMenu, 1,
     PyDoc_STR("() -> None")},
    {"MacCheckMenuItem", (PyCFunction)MenuObj_MacCheckMenuItem, 1,
     PyDoc_STR("(short item, Boolean checked) -> None")},
    {"SetMenuItemText", (PyCFunction)MenuObj_SetMenuItemText, 1,
     PyDoc_STR("(short item, Str255 itemString) -> None")},
    {"GetMenuItemText", (PyCFunction)MenuObj_GetMenuItemText, 1,
     PyDoc_STR("(short item) -> (Str255 itemString)")},
    {"SetItemMark", (PyCFunction)MenuObj_SetItemMark, 1,
     PyDoc_STR("(short item, CharParameter markChar) -> None")},
    {"GetItemMark", (PyCFunction)MenuObj_GetItemMark, 1,
     PyDoc_STR("(short item) -> (CharParameter markChar)")},
    {"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1,
     PyDoc_STR("(short item, CharParameter cmdChar) -> None")},
    {"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1,
     PyDoc_STR("(short item) -> (CharParameter cmdChar)")},
    {"SetItemIcon", (PyCFunction)MenuObj_SetItemIcon, 1,
     PyDoc_STR("(short item, short iconIndex) -> None")},
    {"GetItemIcon", (PyCFunction)MenuObj_GetItemIcon, 1,
     PyDoc_STR("(short item) -> (short iconIndex)")},
    {"SetItemStyle", (PyCFunction)MenuObj_SetItemStyle, 1,
     PyDoc_STR("(short item, StyleParameter chStyle) -> None")},
    {"GetItemStyle", (PyCFunction)MenuObj_GetItemStyle, 1,
     PyDoc_STR("(short item) -> (Style chStyle)")},
    {"SetMenuItemCommandID", (PyCFunction)MenuObj_SetMenuItemCommandID, 1,
     PyDoc_STR("(SInt16 inItem, MenuCommand inCommandID) -> None")},
    {"GetMenuItemCommandID", (PyCFunction)MenuObj_GetMenuItemCommandID, 1,
     PyDoc_STR("(SInt16 inItem) -> (MenuCommand outCommandID)")},
    {"SetMenuItemModifiers", (PyCFunction)MenuObj_SetMenuItemModifiers, 1,
     PyDoc_STR("(SInt16 inItem, UInt8 inModifiers) -> None")},
    {"GetMenuItemModifiers", (PyCFunction)MenuObj_GetMenuItemModifiers, 1,
     PyDoc_STR("(SInt16 inItem) -> (UInt8 outModifiers)")},
    {"SetMenuItemIconHandle", (PyCFunction)MenuObj_SetMenuItemIconHandle, 1,
     PyDoc_STR("(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None")},
    {"GetMenuItemIconHandle", (PyCFunction)MenuObj_GetMenuItemIconHandle, 1,
     PyDoc_STR("(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)")},
    {"SetMenuItemTextEncoding", (PyCFunction)MenuObj_SetMenuItemTextEncoding, 1,
     PyDoc_STR("(SInt16 inItem, TextEncoding inScriptID) -> None")},
    {"GetMenuItemTextEncoding", (PyCFunction)MenuObj_GetMenuItemTextEncoding, 1,
     PyDoc_STR("(SInt16 inItem) -> (TextEncoding outScriptID)")},
    {"SetMenuItemHierarchicalID", (PyCFunction)MenuObj_SetMenuItemHierarchicalID, 1,
     PyDoc_STR("(SInt16 inItem, MenuID inHierID) -> None")},
    {"GetMenuItemHierarchicalID", (PyCFunction)MenuObj_GetMenuItemHierarchicalID, 1,
     PyDoc_STR("(SInt16 inItem) -> (MenuID outHierID)")},
    {"SetMenuItemFontID", (PyCFunction)MenuObj_SetMenuItemFontID, 1,
     PyDoc_STR("(SInt16 inItem, SInt16 inFontID) -> None")},
    {"GetMenuItemFontID", (PyCFunction)MenuObj_GetMenuItemFontID, 1,
     PyDoc_STR("(SInt16 inItem) -> (SInt16 outFontID)")},
    {"SetMenuItemRefCon", (PyCFunction)MenuObj_SetMenuItemRefCon, 1,
     PyDoc_STR("(SInt16 inItem, UInt32 inRefCon) -> None")},
    {"GetMenuItemRefCon", (PyCFunction)MenuObj_GetMenuItemRefCon, 1,
     PyDoc_STR("(SInt16 inItem) -> (UInt32 outRefCon)")},
    {"SetMenuItemKeyGlyph", (PyCFunction)MenuObj_SetMenuItemKeyGlyph, 1,
     PyDoc_STR("(SInt16 inItem, SInt16 inGlyph) -> None")},
    {"GetMenuItemKeyGlyph", (PyCFunction)MenuObj_GetMenuItemKeyGlyph, 1,
     PyDoc_STR("(SInt16 inItem) -> (SInt16 outGlyph)")},
    {"MacEnableMenuItem", (PyCFunction)MenuObj_MacEnableMenuItem, 1,
     PyDoc_STR("(MenuItemIndex item) -> None")},
    {"DisableMenuItem", (PyCFunction)MenuObj_DisableMenuItem, 1,
     PyDoc_STR("(MenuItemIndex item) -> None")},
    {"IsMenuItemEnabled", (PyCFunction)MenuObj_IsMenuItemEnabled, 1,
     PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")},
    {"EnableMenuItemIcon", (PyCFunction)MenuObj_EnableMenuItemIcon, 1,
     PyDoc_STR("(MenuItemIndex item) -> None")},
    {"DisableMenuItemIcon", (PyCFunction)MenuObj_DisableMenuItemIcon, 1,
     PyDoc_STR("(MenuItemIndex item) -> None")},
    {"IsMenuItemIconEnabled", (PyCFunction)MenuObj_IsMenuItemIconEnabled, 1,
     PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")},
    {"SetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_SetMenuItemHierarchicalMenu, 1,
     PyDoc_STR("(MenuItemIndex inItem, MenuHandle inHierMenu) -> None")},
    {"GetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_GetMenuItemHierarchicalMenu, 1,
     PyDoc_STR("(MenuItemIndex inItem) -> (MenuHandle outHierMenu)")},
    {"CopyMenuItemTextAsCFString", (PyCFunction)MenuObj_CopyMenuItemTextAsCFString, 1,
     PyDoc_STR("(MenuItemIndex inItem) -> (CFStringRef outString)")},
    {"SetMenuItemTextWithCFString", (PyCFunction)MenuObj_SetMenuItemTextWithCFString, 1,
     PyDoc_STR("(MenuItemIndex inItem, CFStringRef inString) -> None")},
    {"GetMenuItemIndent", (PyCFunction)MenuObj_GetMenuItemIndent, 1,
     PyDoc_STR("(MenuItemIndex inItem) -> (UInt32 outIndent)")},
    {"SetMenuItemIndent", (PyCFunction)MenuObj_SetMenuItemIndent, 1,
     PyDoc_STR("(MenuItemIndex inItem, UInt32 inIndent) -> None")},
    {"GetMenuItemCommandKey", (PyCFunction)MenuObj_GetMenuItemCommandKey, 1,
     PyDoc_STR("(MenuItemIndex inItem, Boolean inGetVirtualKey) -> (UInt16 outKey)")},
    {"SetMenuItemCommandKey", (PyCFunction)MenuObj_SetMenuItemCommandKey, 1,
     PyDoc_STR("(MenuItemIndex inItem, Boolean inSetVirtualKey, UInt16 inKey) -> None")},
    {"GetMenuItemPropertyAttributes", (PyCFunction)MenuObj_GetMenuItemPropertyAttributes, 1,
     PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")},
    {"ChangeMenuItemPropertyAttributes", (PyCFunction)MenuObj_ChangeMenuItemPropertyAttributes, 1,
     PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")},
    {"GetMenuAttributes", (PyCFunction)MenuObj_GetMenuAttributes, 1,
     PyDoc_STR("() -> (MenuAttributes outAttributes)")},
    {"ChangeMenuAttributes", (PyCFunction)MenuObj_ChangeMenuAttributes, 1,
     PyDoc_STR("(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None")},
    {"GetMenuItemAttributes", (PyCFunction)MenuObj_GetMenuItemAttributes, 1,
     PyDoc_STR("(MenuItemIndex item) -> (MenuItemAttributes outAttributes)")},
    {"ChangeMenuItemAttributes", (PyCFunction)MenuObj_ChangeMenuItemAttributes, 1,
     PyDoc_STR("(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None")},
    {"DisableAllMenuItems", (PyCFunction)MenuObj_DisableAllMenuItems, 1,
     PyDoc_STR("() -> None")},
    {"EnableAllMenuItems", (PyCFunction)MenuObj_EnableAllMenuItems, 1,
     PyDoc_STR("() -> None")},
    {"MenuHasEnabledItems", (PyCFunction)MenuObj_MenuHasEnabledItems, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"GetMenuType", (PyCFunction)MenuObj_GetMenuType, 1,
     PyDoc_STR("() -> (UInt16 outType)")},
    {"CountMenuItemsWithCommandID", (PyCFunction)MenuObj_CountMenuItemsWithCommandID, 1,
     PyDoc_STR("(MenuCommand inCommandID) -> (ItemCount _rv)")},
    {"GetIndMenuItemWithCommandID", (PyCFunction)MenuObj_GetIndMenuItemWithCommandID, 1,
     PyDoc_STR("(MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")},
    {"EnableMenuCommand", (PyCFunction)MenuObj_EnableMenuCommand, 1,
     PyDoc_STR("(MenuCommand inCommandID) -> None")},
    {"DisableMenuCommand", (PyCFunction)MenuObj_DisableMenuCommand, 1,
     PyDoc_STR("(MenuCommand inCommandID) -> None")},
    {"IsMenuCommandEnabled", (PyCFunction)MenuObj_IsMenuCommandEnabled, 1,
     PyDoc_STR("(MenuCommand inCommandID) -> (Boolean _rv)")},
    {"SetMenuCommandMark", (PyCFunction)MenuObj_SetMenuCommandMark, 1,
     PyDoc_STR("(MenuCommand inCommandID, UniChar inMark) -> None")},
    {"GetMenuCommandMark", (PyCFunction)MenuObj_GetMenuCommandMark, 1,
     PyDoc_STR("(MenuCommand inCommandID) -> (UniChar outMark)")},
    {"GetMenuCommandPropertySize", (PyCFunction)MenuObj_GetMenuCommandPropertySize, 1,
     PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")},
    {"RemoveMenuCommandProperty", (PyCFunction)MenuObj_RemoveMenuCommandProperty, 1,
     PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")},
    {"IsMenuItemInvalid", (PyCFunction)MenuObj_IsMenuItemInvalid, 1,
     PyDoc_STR("(MenuItemIndex inItem) -> (Boolean _rv)")},
    {"InvalidateMenuItems", (PyCFunction)MenuObj_InvalidateMenuItems, 1,
     PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None")},
    {"UpdateInvalidMenuItems", (PyCFunction)MenuObj_UpdateInvalidMenuItems, 1,
     PyDoc_STR("() -> None")},
    {"CreateStandardFontMenu", (PyCFunction)MenuObj_CreateStandardFontMenu, 1,
     PyDoc_STR("(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)")},
    {"UpdateStandardFontMenu", (PyCFunction)MenuObj_UpdateStandardFontMenu, 1,
     PyDoc_STR("() -> (ItemCount outHierMenuCount)")},
    {"GetFontFamilyFromMenuSelection", (PyCFunction)MenuObj_GetFontFamilyFromMenuSelection, 1,
     PyDoc_STR("(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)")},
    {"GetMenuID", (PyCFunction)MenuObj_GetMenuID, 1,
     PyDoc_STR("() -> (MenuID _rv)")},
    {"GetMenuWidth", (PyCFunction)MenuObj_GetMenuWidth, 1,
     PyDoc_STR("() -> (SInt16 _rv)")},
    {"GetMenuHeight", (PyCFunction)MenuObj_GetMenuHeight, 1,
     PyDoc_STR("() -> (SInt16 _rv)")},
    {"SetMenuID", (PyCFunction)MenuObj_SetMenuID, 1,
     PyDoc_STR("(MenuID menuID) -> None")},
    {"SetMenuWidth", (PyCFunction)MenuObj_SetMenuWidth, 1,
     PyDoc_STR("(SInt16 width) -> None")},
    {"SetMenuHeight", (PyCFunction)MenuObj_SetMenuHeight, 1,
     PyDoc_STR("(SInt16 height) -> None")},
    {"as_Resource", (PyCFunction)MenuObj_as_Resource, 1,
     PyDoc_STR("() -> (Handle _rv)")},
    {"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1,
     PyDoc_STR("(Str255 data) -> None")},
    {"InsertMenu", (PyCFunction)MenuObj_InsertMenu, 1,
     PyDoc_STR("(short beforeID) -> None")},
    {"InsertMenuItem", (PyCFunction)MenuObj_InsertMenuItem, 1,
     PyDoc_STR("(Str255 itemString, short afterItem) -> None")},
    {"EnableMenuItem", (PyCFunction)MenuObj_EnableMenuItem, 1,
     PyDoc_STR("(UInt16 item) -> None")},
    {"CheckMenuItem", (PyCFunction)MenuObj_CheckMenuItem, 1,
     PyDoc_STR("(short item, Boolean checked) -> None")},
    {NULL, NULL, 0}
};

#define MenuObj_getsetlist NULL


#define MenuObj_compare NULL

#define MenuObj_repr NULL

#define MenuObj_hash NULL
#define MenuObj_tp_init 0

#define MenuObj_tp_alloc PyType_GenericAlloc

static PyObject *MenuObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
    PyObject *_self;
    MenuHandle itself;
    char *kw[] = {"itself", 0};

    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, MenuObj_Convert, &itself)) return NULL;
    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    ((MenuObject *)_self)->ob_itself = itself;
    return _self;
}

#define MenuObj_tp_free PyObject_Del


PyTypeObject Menu_Type = {
    PyObject_HEAD_INIT(NULL)
    0, /*ob_size*/
    "_Menu.Menu", /*tp_name*/
    sizeof(MenuObject), /*tp_basicsize*/
    0, /*tp_itemsize*/
    /* methods */
    (destructor) MenuObj_dealloc, /*tp_dealloc*/
    0, /*tp_print*/
    (getattrfunc)0, /*tp_getattr*/
    (setattrfunc)0, /*tp_setattr*/
    (cmpfunc) MenuObj_compare, /*tp_compare*/
    (reprfunc) MenuObj_repr, /*tp_repr*/
    (PyNumberMethods *)0, /* tp_as_number */
    (PySequenceMethods *)0, /* tp_as_sequence */
    (PyMappingMethods *)0, /* tp_as_mapping */
    (hashfunc) MenuObj_hash, /*tp_hash*/
    0, /*tp_call*/
    0, /*tp_str*/
    PyObject_GenericGetAttr, /*tp_getattro*/
    PyObject_GenericSetAttr, /*tp_setattro */
    0, /*tp_as_buffer*/
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    0, /*tp_doc*/
    0, /*tp_traverse*/
    0, /*tp_clear*/
    0, /*tp_richcompare*/
    0, /*tp_weaklistoffset*/
    0, /*tp_iter*/
    0, /*tp_iternext*/
    MenuObj_methods, /* tp_methods */
    0, /*tp_members*/
    MenuObj_getsetlist, /*tp_getset*/
    0, /*tp_base*/
    0, /*tp_dict*/
    0, /*tp_descr_get*/
    0, /*tp_descr_set*/
    0, /*tp_dictoffset*/
    MenuObj_tp_init, /* tp_init */
    MenuObj_tp_alloc, /* tp_alloc */
    MenuObj_tp_new, /* tp_new */
    MenuObj_tp_free, /* tp_free */
};

/* ---------------------- End object type Menu ---------------------- */


static PyObject *Menu_NewMenu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuHandle _rv;
    MenuID menuID;
    Str255 menuTitle;
#ifndef NewMenu
    PyMac_PRECHECK(NewMenu);
#endif
    if (!PyArg_ParseTuple(_args, "hO&",
                          &menuID,
                          PyMac_GetStr255, menuTitle))
        return NULL;
    _rv = NewMenu(menuID,
                  menuTitle);
    _res = Py_BuildValue("O&",
                         MenuObj_New, _rv);
    return _res;
}

static PyObject *Menu_MacGetMenu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuHandle _rv;
    short resourceID;
#ifndef MacGetMenu
    PyMac_PRECHECK(MacGetMenu);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &resourceID))
        return NULL;
    _rv = MacGetMenu(resourceID);
    _res = Py_BuildValue("O&",
                         MenuObj_New, _rv);
    return _res;
}

static PyObject *Menu_CreateNewMenu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuID inMenuID;
    MenuAttributes inMenuAttributes;
    MenuHandle outMenuRef;
#ifndef CreateNewMenu
    PyMac_PRECHECK(CreateNewMenu);
#endif
    if (!PyArg_ParseTuple(_args, "hl",
                          &inMenuID,
                          &inMenuAttributes))
        return NULL;
    _err = CreateNewMenu(inMenuID,
                         inMenuAttributes,
                         &outMenuRef);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         MenuObj_New, outMenuRef);
    return _res;
}

static PyObject *Menu_MenuKey(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    CharParameter ch;
#ifndef MenuKey
    PyMac_PRECHECK(MenuKey);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &ch))
        return NULL;
    _rv = MenuKey(ch);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Menu_MenuSelect(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
    Point startPt;
#ifndef MenuSelect
    PyMac_PRECHECK(MenuSelect);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetPoint, &startPt))
        return NULL;
    _rv = MenuSelect(startPt);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Menu_MenuChoice(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    long _rv;
#ifndef MenuChoice
    PyMac_PRECHECK(MenuChoice);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = MenuChoice();
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Menu_MenuEvent(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    UInt32 _rv;
    EventRecord inEvent;
#ifndef MenuEvent
    PyMac_PRECHECK(MenuEvent);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetEventRecord, &inEvent))
        return NULL;
    _rv = MenuEvent(&inEvent);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Menu_GetMBarHeight(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short _rv;
#ifndef GetMBarHeight
    PyMac_PRECHECK(GetMBarHeight);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMBarHeight();
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *Menu_MacDrawMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef MacDrawMenuBar
    PyMac_PRECHECK(MacDrawMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    MacDrawMenuBar();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_InvalMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef InvalMenuBar
    PyMac_PRECHECK(InvalMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    InvalMenuBar();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_HiliteMenu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuID menuID;
#ifndef HiliteMenu
    PyMac_PRECHECK(HiliteMenu);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &menuID))
        return NULL;
    HiliteMenu(menuID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_GetNewMBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuBarHandle _rv;
    short menuBarID;
#ifndef GetNewMBar
    PyMac_PRECHECK(GetNewMBar);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &menuBarID))
        return NULL;
    _rv = GetNewMBar(menuBarID);
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *Menu_GetMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuBarHandle _rv;
#ifndef GetMenuBar
    PyMac_PRECHECK(GetMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = GetMenuBar();
    _res = Py_BuildValue("O&",
                         ResObj_New, _rv);
    return _res;
}

static PyObject *Menu_SetMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuBarHandle mbar;
#ifndef SetMenuBar
    PyMac_PRECHECK(SetMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &mbar))
        return NULL;
    SetMenuBar(mbar);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_DuplicateMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuBarHandle inMbar;
    MenuBarHandle outMbar;
#ifndef DuplicateMenuBar
    PyMac_PRECHECK(DuplicateMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &inMbar))
        return NULL;
    _err = DuplicateMenuBar(inMbar,
                            &outMbar);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&",
                         ResObj_New, outMbar);
    return _res;
}

static PyObject *Menu_DisposeMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuBarHandle inMbar;
#ifndef DisposeMenuBar
    PyMac_PRECHECK(DisposeMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &inMbar))
        return NULL;
    _err = DisposeMenuBar(inMbar);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_GetMenuHandle(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuHandle _rv;
    MenuID menuID;
#ifndef GetMenuHandle
    PyMac_PRECHECK(GetMenuHandle);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &menuID))
        return NULL;
    _rv = GetMenuHandle(menuID);
    _res = Py_BuildValue("O&",
                         MenuObj_New, _rv);
    return _res;
}

static PyObject *Menu_MacDeleteMenu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuID menuID;
#ifndef MacDeleteMenu
    PyMac_PRECHECK(MacDeleteMenu);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &menuID))
        return NULL;
    MacDeleteMenu(menuID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_ClearMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef ClearMenuBar
    PyMac_PRECHECK(ClearMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    ClearMenuBar();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_SetMenuFlashCount(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short count;
#ifndef SetMenuFlashCount
    PyMac_PRECHECK(SetMenuFlashCount);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &count))
        return NULL;
    SetMenuFlashCount(count);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_FlashMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuID menuID;
#ifndef FlashMenuBar
    PyMac_PRECHECK(FlashMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &menuID))
        return NULL;
    FlashMenuBar(menuID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_IsMenuBarVisible(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
#ifndef IsMenuBarVisible
    PyMac_PRECHECK(IsMenuBarVisible);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = IsMenuBarVisible();
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *Menu_ShowMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef ShowMenuBar
    PyMac_PRECHECK(ShowMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    ShowMenuBar();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_HideMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef HideMenuBar
    PyMac_PRECHECK(HideMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    HideMenuBar();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_AcquireRootMenu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuHandle _rv;
#ifndef AcquireRootMenu
    PyMac_PRECHECK(AcquireRootMenu);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = AcquireRootMenu();
    _res = Py_BuildValue("O&",
                         MenuObj_New, _rv);
    return _res;
}

static PyObject *Menu_DeleteMCEntries(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuID menuID;
    short menuItem;
#ifndef DeleteMCEntries
    PyMac_PRECHECK(DeleteMCEntries);
#endif
    if (!PyArg_ParseTuple(_args, "hh",
                          &menuID,
                          &menuItem))
        return NULL;
    DeleteMCEntries(menuID,
                    menuItem);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_InitContextualMenus(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
#ifndef InitContextualMenus
    PyMac_PRECHECK(InitContextualMenus);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _err = InitContextualMenus();
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_IsShowContextualMenuClick(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
    EventRecord inEvent;
#ifndef IsShowContextualMenuClick
    PyMac_PRECHECK(IsShowContextualMenuClick);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          PyMac_GetEventRecord, &inEvent))
        return NULL;
    _rv = IsShowContextualMenuClick(&inEvent);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *Menu_LMGetTheMenu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    SInt16 _rv;
#ifndef LMGetTheMenu
    PyMac_PRECHECK(LMGetTheMenu);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    _rv = LMGetTheMenu();
    _res = Py_BuildValue("h",
                         _rv);
    return _res;
}

static PyObject *Menu_as_Menu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuHandle _rv;
    Handle h;
#ifndef as_Menu
    PyMac_PRECHECK(as_Menu);
#endif
    if (!PyArg_ParseTuple(_args, "O&",
                          ResObj_Convert, &h))
        return NULL;
    _rv = as_Menu(h);
    _res = Py_BuildValue("O&",
                         MenuObj_New, _rv);
    return _res;
}

static PyObject *Menu_GetMenu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuHandle _rv;
    short resourceID;
#ifndef GetMenu
    PyMac_PRECHECK(GetMenu);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &resourceID))
        return NULL;
    _rv = GetMenu(resourceID);
    _res = Py_BuildValue("O&",
                         MenuObj_New, _rv);
    return _res;
}

static PyObject *Menu_DeleteMenu(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    short menuID;
#ifndef DeleteMenu
    PyMac_PRECHECK(DeleteMenu);
#endif
    if (!PyArg_ParseTuple(_args, "h",
                          &menuID))
        return NULL;
    DeleteMenu(menuID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_DrawMenuBar(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
#ifndef DrawMenuBar
    PyMac_PRECHECK(DrawMenuBar);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    DrawMenuBar();
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_CountMenuItemsWithCommandID(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    ItemCount _rv;
    MenuHandle inMenu;
    MenuCommand inCommandID;
#ifndef CountMenuItemsWithCommandID
    PyMac_PRECHECK(CountMenuItemsWithCommandID);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          OptMenuObj_Convert, &inMenu,
                          &inCommandID))
        return NULL;
    _rv = CountMenuItemsWithCommandID(inMenu,
                                      inCommandID);
    _res = Py_BuildValue("l",
                         _rv);
    return _res;
}

static PyObject *Menu_GetIndMenuItemWithCommandID(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuHandle inMenu;
    MenuCommand inCommandID;
    UInt32 inItemIndex;
    MenuHandle outMenu;
    MenuItemIndex outIndex;
#ifndef GetIndMenuItemWithCommandID
    PyMac_PRECHECK(GetIndMenuItemWithCommandID);
#endif
    if (!PyArg_ParseTuple(_args, "O&ll",
                          OptMenuObj_Convert, &inMenu,
                          &inCommandID,
                          &inItemIndex))
        return NULL;
    _err = GetIndMenuItemWithCommandID(inMenu,
                                       inCommandID,
                                       inItemIndex,
                                       &outMenu,
                                       &outIndex);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("O&h",
                         MenuObj_New, outMenu,
                         outIndex);
    return _res;
}

static PyObject *Menu_EnableMenuCommand(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuHandle inMenu;
    MenuCommand inCommandID;
#ifndef EnableMenuCommand
    PyMac_PRECHECK(EnableMenuCommand);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          OptMenuObj_Convert, &inMenu,
                          &inCommandID))
        return NULL;
    EnableMenuCommand(inMenu,
                      inCommandID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_DisableMenuCommand(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    MenuHandle inMenu;
    MenuCommand inCommandID;
#ifndef DisableMenuCommand
    PyMac_PRECHECK(DisableMenuCommand);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          OptMenuObj_Convert, &inMenu,
                          &inCommandID))
        return NULL;
    DisableMenuCommand(inMenu,
                       inCommandID);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_IsMenuCommandEnabled(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    Boolean _rv;
    MenuHandle inMenu;
    MenuCommand inCommandID;
#ifndef IsMenuCommandEnabled
    PyMac_PRECHECK(IsMenuCommandEnabled);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          OptMenuObj_Convert, &inMenu,
                          &inCommandID))
        return NULL;
    _rv = IsMenuCommandEnabled(inMenu,
                               inCommandID);
    _res = Py_BuildValue("b",
                         _rv);
    return _res;
}

static PyObject *Menu_SetMenuCommandMark(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuHandle inMenu;
    MenuCommand inCommandID;
    UniChar inMark;
#ifndef SetMenuCommandMark
    PyMac_PRECHECK(SetMenuCommandMark);
#endif
    if (!PyArg_ParseTuple(_args, "O&lh",
                          OptMenuObj_Convert, &inMenu,
                          &inCommandID,
                          &inMark))
        return NULL;
    _err = SetMenuCommandMark(inMenu,
                              inCommandID,
                              inMark);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}

static PyObject *Menu_GetMenuCommandMark(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuHandle inMenu;
    MenuCommand inCommandID;
    UniChar outMark;
#ifndef GetMenuCommandMark
    PyMac_PRECHECK(GetMenuCommandMark);
#endif
    if (!PyArg_ParseTuple(_args, "O&l",
                          OptMenuObj_Convert, &inMenu,
                          &inCommandID))
        return NULL;
    _err = GetMenuCommandMark(inMenu,
                              inCommandID,
                              &outMark);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("h",
                         outMark);
    return _res;
}

static PyObject *Menu_GetMenuCommandPropertySize(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuHandle inMenu;
    MenuCommand inCommandID;
    OSType inPropertyCreator;
    OSType inPropertyTag;
    ByteCount outSize;
#ifndef GetMenuCommandPropertySize
    PyMac_PRECHECK(GetMenuCommandPropertySize);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&O&",
                          OptMenuObj_Convert, &inMenu,
                          &inCommandID,
                          PyMac_GetOSType, &inPropertyCreator,
                          PyMac_GetOSType, &inPropertyTag))
        return NULL;
    _err = GetMenuCommandPropertySize(inMenu,
                                      inCommandID,
                                      inPropertyCreator,
                                      inPropertyTag,
                                      &outSize);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         outSize);
    return _res;
}

static PyObject *Menu_RemoveMenuCommandProperty(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    OSStatus _err;
    MenuHandle inMenu;
    MenuCommand inCommandID;
    OSType inPropertyCreator;
    OSType inPropertyTag;
#ifndef RemoveMenuCommandProperty
    PyMac_PRECHECK(RemoveMenuCommandProperty);
#endif
    if (!PyArg_ParseTuple(_args, "O&lO&O&",
                          OptMenuObj_Convert, &inMenu,
                          &inCommandID,
                          PyMac_GetOSType, &inPropertyCreator,
                          PyMac_GetOSType, &inPropertyTag))
        return NULL;
    _err = RemoveMenuCommandProperty(inMenu,
                                     inCommandID,
                                     inPropertyCreator,
                                     inPropertyTag);
    if (_err != noErr) return PyMac_Error(_err);
    Py_INCREF(Py_None);
    _res = Py_None;
    return _res;
}
#endif /* __LP64__ */

static PyMethodDef Menu_methods[] = {
#ifndef __LP64__
    {"NewMenu", (PyCFunction)Menu_NewMenu, 1,
     PyDoc_STR("(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)")},
    {"MacGetMenu", (PyCFunction)Menu_MacGetMenu, 1,
     PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")},
    {"CreateNewMenu", (PyCFunction)Menu_CreateNewMenu, 1,
     PyDoc_STR("(MenuID inMenuID, MenuAttributes inMenuAttributes) -> (MenuHandle outMenuRef)")},
    {"MenuKey", (PyCFunction)Menu_MenuKey, 1,
     PyDoc_STR("(CharParameter ch) -> (long _rv)")},
    {"MenuSelect", (PyCFunction)Menu_MenuSelect, 1,
     PyDoc_STR("(Point startPt) -> (long _rv)")},
    {"MenuChoice", (PyCFunction)Menu_MenuChoice, 1,
     PyDoc_STR("() -> (long _rv)")},
    {"MenuEvent", (PyCFunction)Menu_MenuEvent, 1,
     PyDoc_STR("(EventRecord inEvent) -> (UInt32 _rv)")},
    {"GetMBarHeight", (PyCFunction)Menu_GetMBarHeight, 1,
     PyDoc_STR("() -> (short _rv)")},
    {"MacDrawMenuBar", (PyCFunction)Menu_MacDrawMenuBar, 1,
     PyDoc_STR("() -> None")},
    {"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1,
     PyDoc_STR("() -> None")},
    {"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1,
     PyDoc_STR("(MenuID menuID) -> None")},
    {"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1,
     PyDoc_STR("(short menuBarID) -> (MenuBarHandle _rv)")},
    {"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1,
     PyDoc_STR("() -> (MenuBarHandle _rv)")},
    {"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1,
     PyDoc_STR("(MenuBarHandle mbar) -> None")},
    {"DuplicateMenuBar", (PyCFunction)Menu_DuplicateMenuBar, 1,
     PyDoc_STR("(MenuBarHandle inMbar) -> (MenuBarHandle outMbar)")},
    {"DisposeMenuBar", (PyCFunction)Menu_DisposeMenuBar, 1,
     PyDoc_STR("(MenuBarHandle inMbar) -> None")},
    {"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1,
     PyDoc_STR("(MenuID menuID) -> (MenuHandle _rv)")},
    {"MacDeleteMenu", (PyCFunction)Menu_MacDeleteMenu, 1,
     PyDoc_STR("(MenuID menuID) -> None")},
    {"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1,
     PyDoc_STR("() -> None")},
    {"SetMenuFlashCount", (PyCFunction)Menu_SetMenuFlashCount, 1,
     PyDoc_STR("(short count) -> None")},
    {"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1,
     PyDoc_STR("(MenuID menuID) -> None")},
    {"IsMenuBarVisible", (PyCFunction)Menu_IsMenuBarVisible, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"ShowMenuBar", (PyCFunction)Menu_ShowMenuBar, 1,
     PyDoc_STR("() -> None")},
    {"HideMenuBar", (PyCFunction)Menu_HideMenuBar, 1,
     PyDoc_STR("() -> None")},
    {"AcquireRootMenu", (PyCFunction)Menu_AcquireRootMenu, 1,
     PyDoc_STR("() -> (MenuHandle _rv)")},
    {"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1,
     PyDoc_STR("(MenuID menuID, short menuItem) -> None")},
    {"InitContextualMenus", (PyCFunction)Menu_InitContextualMenus, 1,
     PyDoc_STR("() -> None")},
    {"IsShowContextualMenuClick", (PyCFunction)Menu_IsShowContextualMenuClick, 1,
     PyDoc_STR("(EventRecord inEvent) -> (Boolean _rv)")},
    {"LMGetTheMenu", (PyCFunction)Menu_LMGetTheMenu, 1,
     PyDoc_STR("() -> (SInt16 _rv)")},
    {"as_Menu", (PyCFunction)Menu_as_Menu, 1,
     PyDoc_STR("(Handle h) -> (MenuHandle _rv)")},
    {"GetMenu", (PyCFunction)Menu_GetMenu, 1,
     PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")},
    {"DeleteMenu", (PyCFunction)Menu_DeleteMenu, 1,
     PyDoc_STR("(short menuID) -> None")},
    {"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1,
     PyDoc_STR("() -> None")},
    {"CountMenuItemsWithCommandID", (PyCFunction)Menu_CountMenuItemsWithCommandID, 1,
     PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (ItemCount _rv)")},
    {"GetIndMenuItemWithCommandID", (PyCFunction)Menu_GetIndMenuItemWithCommandID, 1,
     PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")},
    {"EnableMenuCommand", (PyCFunction)Menu_EnableMenuCommand, 1,
     PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")},
    {"DisableMenuCommand", (PyCFunction)Menu_DisableMenuCommand, 1,
     PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")},
    {"IsMenuCommandEnabled", (PyCFunction)Menu_IsMenuCommandEnabled, 1,
     PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (Boolean _rv)")},
    {"SetMenuCommandMark", (PyCFunction)Menu_SetMenuCommandMark, 1,
     PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UniChar inMark) -> None")},
    {"GetMenuCommandMark", (PyCFunction)Menu_GetMenuCommandMark, 1,
     PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (UniChar outMark)")},
    {"GetMenuCommandPropertySize", (PyCFunction)Menu_GetMenuCommandPropertySize, 1,
     PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")},
    {"RemoveMenuCommandProperty", (PyCFunction)Menu_RemoveMenuCommandProperty, 1,
     PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")},
#endif /* __LP64__ */
    {NULL, NULL, 0}
};




void init_Menu(void)
{
    PyObject *m;
#ifndef __LP64__
    PyObject *d;



        PyMac_INIT_TOOLBOX_OBJECT_NEW(MenuHandle, MenuObj_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(MenuHandle, MenuObj_Convert);
#endif /* __LP64__ */


    m = Py_InitModule("_Menu", Menu_methods);
#ifndef __LP64__
    d = PyModule_GetDict(m);
    Menu_Error = PyMac_GetOSErrException();
    if (Menu_Error == NULL ||
        PyDict_SetItemString(d, "Error", Menu_Error) != 0)
        return;
    Menu_Type.ob_type = &PyType_Type;
    if (PyType_Ready(&Menu_Type) < 0) return;
    Py_INCREF(&Menu_Type);
    PyModule_AddObject(m, "Menu", (PyObject *)&Menu_Type);
    /* Backward-compatible name */
    Py_INCREF(&Menu_Type);
    PyModule_AddObject(m, "MenuType", (PyObject *)&Menu_Type);
#endif /* __LP64__ */
}

/* ======================== End module _Menu ======================== */

