diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/menu/_Menumodule.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/menu/_Menumodule.c Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,3477 @@ + +/* ========================== 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 + + +#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 ======================== */ +