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

#include "Python.h"

#ifndef __LP64__

#include "pymactoolbox.h"

/* Macro to test whether a weak-loaded CFM function exists */

#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

        PyErr_SetString(PyExc_NotImplementedError, \

        "Not available in this shared library/OS version"); \

        return NULL; \

    }} while(0)

#include <Carbon/Carbon.h>

#ifdef USE_TOOLBOX_OBJECT_GLUE

extern PyObject *_MenuObj_New(MenuHandle);

extern int _MenuObj_Convert(PyObject *, MenuHandle *);

#define MenuObj_New _MenuObj_New

#define MenuObj_Convert _MenuObj_Convert

#endif

#define as_Menu(h) ((MenuHandle)h)

#define as_Resource(h) ((Handle)h)

/* Alternative version of MenuObj_New, which returns None for NULL argument */

PyObject *OptMenuObj_New(MenuRef itself)

{

        if (itself == NULL) {

                Py_INCREF(Py_None);

                return Py_None;

        }

        return MenuObj_New(itself);

}

/* Alternative version of MenuObj_Convert, which returns NULL for a None argument */

int OptMenuObj_Convert(PyObject *v, MenuRef *p_itself)

{

        if ( v == Py_None ) {

                *p_itself = NULL;

                return 1;

        }

        return MenuObj_Convert(v, p_itself);

}

static PyObject *Menu_Error;

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

PyTypeObject Menu_Type;

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

typedef struct MenuObject {

	PyObject_HEAD

	MenuHandle ob_itself;

} MenuObject;

PyObject *MenuObj_New(MenuHandle itself)

{

	MenuObject *it;

	it = PyObject_NEW(MenuObject, &Menu_Type);

	if (it == NULL) return NULL;

	it->ob_itself = itself;

	return (PyObject *)it;

}

int MenuObj_Convert(PyObject *v, MenuHandle *p_itself)

{

	if (!MenuObj_Check(v))

	{

		PyErr_SetString(PyExc_TypeError, "Menu required");

		return 0;

	}

	*p_itself = ((MenuObject *)v)->ob_itself;

	return 1;

}

static void MenuObj_dealloc(MenuObject *self)

{

	/* Cleanup of self->ob_itself goes here */

	self->ob_type->tp_free((PyObject *)self);

}

static PyObject *MenuObj_DisposeMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

#ifndef DisposeMenu

	PyMac_PRECHECK(DisposeMenu);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	DisposeMenu(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_CalcMenuSize(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

#ifndef CalcMenuSize

	PyMac_PRECHECK(CalcMenuSize);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	CalcMenuSize(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_CountMenuItems(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	UInt16 _rv;

#ifndef CountMenuItems

	PyMac_PRECHECK(CountMenuItems);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CountMenuItems(_self->ob_itself);

	_res = Py_BuildValue("H",

	                     _rv);

	return _res;

}

static PyObject *MenuObj_GetMenuFont(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

	SInt16 outFontID;

	UInt16 outFontSize;

#ifndef GetMenuFont

	PyMac_PRECHECK(GetMenuFont);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = GetMenuFont(_self->ob_itself,

	                   &outFontID,

	                   &outFontSize);

	if (_err != noErr) return PyMac_Error(_err);

	_res = Py_BuildValue("hH",

	                     outFontID,

	                     outFontSize);

	return _res;

}

static PyObject *MenuObj_SetMenuFont(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

	SInt16 inFontID;

	UInt16 inFontSize;

#ifndef SetMenuFont

	PyMac_PRECHECK(SetMenuFont);

#endif

	if (!PyArg_ParseTuple(_args, "hH",

	                      &inFontID,

	                      &inFontSize))

		return NULL;

	_err = SetMenuFont(_self->ob_itself,

	                   inFontID,

	                   inFontSize);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_GetMenuExcludesMarkColumn(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Boolean _rv;

#ifndef GetMenuExcludesMarkColumn

	PyMac_PRECHECK(GetMenuExcludesMarkColumn);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = GetMenuExcludesMarkColumn(_self->ob_itself);

	_res = Py_BuildValue("b",

	                     _rv);

	return _res;

}

static PyObject *MenuObj_SetMenuExcludesMarkColumn(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

	Boolean excludesMark;

#ifndef SetMenuExcludesMarkColumn

	PyMac_PRECHECK(SetMenuExcludesMarkColumn);

#endif

	if (!PyArg_ParseTuple(_args, "b",

	                      &excludesMark))

		return NULL;

	_err = SetMenuExcludesMarkColumn(_self->ob_itself,

	                                 excludesMark);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_IsValidMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Boolean _rv;

#ifndef IsValidMenu

	PyMac_PRECHECK(IsValidMenu);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = IsValidMenu(_self->ob_itself);

	_res = Py_BuildValue("b",

	                     _rv);

	return _res;

}

static PyObject *MenuObj_GetMenuRetainCount(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ItemCount _rv;

#ifndef GetMenuRetainCount

	PyMac_PRECHECK(GetMenuRetainCount);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = GetMenuRetainCount(_self->ob_itself);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *MenuObj_RetainMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

#ifndef RetainMenu

	PyMac_PRECHECK(RetainMenu);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = RetainMenu(_self->ob_itself);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_ReleaseMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

#ifndef ReleaseMenu

	PyMac_PRECHECK(ReleaseMenu);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = ReleaseMenu(_self->ob_itself);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_DuplicateMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

	MenuHandle outMenu;

#ifndef DuplicateMenu

	PyMac_PRECHECK(DuplicateMenu);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = DuplicateMenu(_self->ob_itself,

	                     &outMenu);

	if (_err != noErr) return PyMac_Error(_err);

	_res = Py_BuildValue("O&",

	                     MenuObj_New, outMenu);

	return _res;

}

static PyObject *MenuObj_CopyMenuTitleAsCFString(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

	CFStringRef outString;

#ifndef CopyMenuTitleAsCFString

	PyMac_PRECHECK(CopyMenuTitleAsCFString);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = CopyMenuTitleAsCFString(_self->ob_itself,

	                               &outString);

	if (_err != noErr) return PyMac_Error(_err);

	_res = Py_BuildValue("O&",

	                     CFStringRefObj_New, outString);

	return _res;

}

static PyObject *MenuObj_SetMenuTitleWithCFString(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

	CFStringRef inString;

#ifndef SetMenuTitleWithCFString

	PyMac_PRECHECK(SetMenuTitleWithCFString);

#endif

	if (!PyArg_ParseTuple(_args, "O&",

	                      CFStringRefObj_Convert, &inString))

		return NULL;

	_err = SetMenuTitleWithCFString(_self->ob_itself,

	                                inString);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_InvalidateMenuSize(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

#ifndef InvalidateMenuSize

	PyMac_PRECHECK(InvalidateMenuSize);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = InvalidateMenuSize(_self->ob_itself);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_IsMenuSizeInvalid(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Boolean _rv;

#ifndef IsMenuSizeInvalid

	PyMac_PRECHECK(IsMenuSizeInvalid);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = IsMenuSizeInvalid(_self->ob_itself);

	_res = Py_BuildValue("b",

	                     _rv);

	return _res;

}

static PyObject *MenuObj_MacAppendMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Str255 data;

#ifndef MacAppendMenu

	PyMac_PRECHECK(MacAppendMenu);

#endif

	if (!PyArg_ParseTuple(_args, "O&",

	                      PyMac_GetStr255, data))

		return NULL;

	MacAppendMenu(_self->ob_itself,

	              data);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_InsertResMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ResType theType;

	short afterItem;

#ifndef InsertResMenu

	PyMac_PRECHECK(InsertResMenu);

#endif

	if (!PyArg_ParseTuple(_args, "O&h",

	                      PyMac_GetOSType, &theType,

	                      &afterItem))

		return NULL;

	InsertResMenu(_self->ob_itself,

	              theType,

	              afterItem);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_AppendResMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ResType theType;

#ifndef AppendResMenu

	PyMac_PRECHECK(AppendResMenu);

#endif

	if (!PyArg_ParseTuple(_args, "O&",

	                      PyMac_GetOSType, &theType))

		return NULL;

	AppendResMenu(_self->ob_itself,

	              theType);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_MacInsertMenuItem(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Str255 itemString;

	short afterItem;

#ifndef MacInsertMenuItem

	PyMac_PRECHECK(MacInsertMenuItem);

#endif

	if (!PyArg_ParseTuple(_args, "O&h",

	                      PyMac_GetStr255, itemString,

	                      &afterItem))

		return NULL;

	MacInsertMenuItem(_self->ob_itself,

	                  itemString,

	                  afterItem);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_DeleteMenuItem(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	short item;

#ifndef DeleteMenuItem

	PyMac_PRECHECK(DeleteMenuItem);

#endif

	if (!PyArg_ParseTuple(_args, "h",

	                      &item))

		return NULL;

	DeleteMenuItem(_self->ob_itself,

	               item);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_InsertFontResMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	short afterItem;

	short scriptFilter;

#ifndef InsertFontResMenu

	PyMac_PRECHECK(InsertFontResMenu);

#endif

	if (!PyArg_ParseTuple(_args, "hh",

	                      &afterItem,

	                      &scriptFilter))

		return NULL;

	InsertFontResMenu(_self->ob_itself,

	                  afterItem,

	                  scriptFilter);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_InsertIntlResMenu(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ResType theType;

	short afterItem;

	short scriptFilter;

#ifndef InsertIntlResMenu

	PyMac_PRECHECK(InsertIntlResMenu);

#endif

	if (!PyArg_ParseTuple(_args, "O&hh",

	                      PyMac_GetOSType, &theType,

	                      &afterItem,

	                      &scriptFilter))

		return NULL;

	InsertIntlResMenu(_self->ob_itself,

	                  theType,

	                  afterItem,

	                  scriptFilter);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_AppendMenuItemText(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

	Str255 inString;

#ifndef AppendMenuItemText

	PyMac_PRECHECK(AppendMenuItemText);

#endif

	if (!PyArg_ParseTuple(_args, "O&",

	                      PyMac_GetStr255, inString))

		return NULL;

	_err = AppendMenuItemText(_self->ob_itself,

	                          inString);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *MenuObj_InsertMenuItemText(MenuObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

	Str255 inString;

	MenuItemIndex afterItem;

#ifndef InsertMenuItemText

	PyMac_PRECHECK(InsertMenuItemText);

#endif

	if (!PyArg_ParseTuple(_args, "O&h",

	                      PyMac_GetStr255, inString,

	                      &afterItem))

		return NULL;

	_err = InsertMenuItemText(_self->ob_itself,