/* ========================== Module _Menu ========================== */ #include "Python.h" #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 #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; } static PyMethodDef Menu_methods[] = { {"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")}, {NULL, NULL, 0} }; void init_Menu(void) { PyObject *m; PyObject *d; PyMac_INIT_TOOLBOX_OBJECT_NEW(MenuHandle, MenuObj_New); PyMac_INIT_TOOLBOX_OBJECT_CONVERT(MenuHandle, MenuObj_Convert); m = Py_InitModule("_Menu", Menu_methods); 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); } /* ======================== End module _Menu ======================== */