1 

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

     3 

     4 #include "Python.h"

     5 

     6 #ifndef __LP64__

     7 

     8 

     9 #include "pymactoolbox.h"

    10 

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

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

    13         PyErr_SetString(PyExc_NotImplementedError, \

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

    15         return NULL; \

    16     }} while(0)

    17 

    18 

    19 #include <Carbon/Carbon.h>

    20 

    21 

    22 #ifdef USE_TOOLBOX_OBJECT_GLUE

    23 

    24 extern PyObject *_MenuObj_New(MenuHandle);

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

    26 

    27 #define MenuObj_New _MenuObj_New

    28 #define MenuObj_Convert _MenuObj_Convert

    29 #endif

    30 

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

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

    33 

    34 

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

    36 PyObject *OptMenuObj_New(MenuRef itself)

    37 {

    38         if (itself == NULL) {

    39                 Py_INCREF(Py_None);

    40                 return Py_None;

    41         }

    42         return MenuObj_New(itself);

    43 }

    44 

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

    46 int OptMenuObj_Convert(PyObject *v, MenuRef *p_itself)

    47 {

    48         if ( v == Py_None ) {

    49                 *p_itself = NULL;

    50                 return 1;

    51         }

    52         return MenuObj_Convert(v, p_itself);

    53 }

    54 

    55 static PyObject *Menu_Error;

    56 

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

    58 

    59 PyTypeObject Menu_Type;

    60 

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

    62 

    63 typedef struct MenuObject {

    64 	PyObject_HEAD

    65 	MenuHandle ob_itself;

    66 } MenuObject;

    67 

    68 PyObject *MenuObj_New(MenuHandle itself)

    69 {

    70 	MenuObject *it;

    71 	it = PyObject_NEW(MenuObject, &Menu_Type);

    72 	if (it == NULL) return NULL;

    73 	it->ob_itself = itself;

    74 	return (PyObject *)it;

    75 }

    76 

    77 int MenuObj_Convert(PyObject *v, MenuHandle *p_itself)

    78 {

    79 	if (!MenuObj_Check(v))

    80 	{

    81 		PyErr_SetString(PyExc_TypeError, "Menu required");

    82 		return 0;

    83 	}

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

    85 	return 1;

    86 }

    87 

    88 static void MenuObj_dealloc(MenuObject *self)

    89 {

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

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

    92 }

    93 

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

    95 {

    96 	PyObject *_res = NULL;

    97 #ifndef DisposeMenu

    98 	PyMac_PRECHECK(DisposeMenu);

    99 #endif

   100 	if (!PyArg_ParseTuple(_args, ""))

   101 		return NULL;

   102 	DisposeMenu(_self->ob_itself);

   103 	Py_INCREF(Py_None);

   104 	_res = Py_None;

   105 	return _res;

   106 }

   107 

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

   109 {

   110 	PyObject *_res = NULL;

   111 #ifndef CalcMenuSize

   112 	PyMac_PRECHECK(CalcMenuSize);

   113 #endif

   114 	if (!PyArg_ParseTuple(_args, ""))

   115 		return NULL;

   116 	CalcMenuSize(_self->ob_itself);

   117 	Py_INCREF(Py_None);

   118 	_res = Py_None;

   119 	return _res;

   120 }

   121 

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

   123 {

   124 	PyObject *_res = NULL;

   125 	UInt16 _rv;

   126 #ifndef CountMenuItems

   127 	PyMac_PRECHECK(CountMenuItems);

   128 #endif

   129 	if (!PyArg_ParseTuple(_args, ""))

   130 		return NULL;

   131 	_rv = CountMenuItems(_self->ob_itself);

   132 	_res = Py_BuildValue("H",

   133 	                     _rv);

   134 	return _res;

   135 }

   136 

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

   138 {

   139 	PyObject *_res = NULL;

   140 	OSStatus _err;

   141 	SInt16 outFontID;

   142 	UInt16 outFontSize;

   143 #ifndef GetMenuFont

   144 	PyMac_PRECHECK(GetMenuFont);

   145 #endif

   146 	if (!PyArg_ParseTuple(_args, ""))

   147 		return NULL;

   148 	_err = GetMenuFont(_self->ob_itself,

   149 	                   &outFontID,

   150 	                   &outFontSize);

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

   152 	_res = Py_BuildValue("hH",

   153 	                     outFontID,

   154 	                     outFontSize);

   155 	return _res;

   156 }

   157 

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

   159 {

   160 	PyObject *_res = NULL;

   161 	OSStatus _err;

   162 	SInt16 inFontID;

   163 	UInt16 inFontSize;

   164 #ifndef SetMenuFont

   165 	PyMac_PRECHECK(SetMenuFont);

   166 #endif

   167 	if (!PyArg_ParseTuple(_args, "hH",

   168 	                      &inFontID,

   169 	                      &inFontSize))

   170 		return NULL;

   171 	_err = SetMenuFont(_self->ob_itself,

   172 	                   inFontID,

   173 	                   inFontSize);

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

   175 	Py_INCREF(Py_None);

   176 	_res = Py_None;

   177 	return _res;

   178 }

   179 

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

   181 {

   182 	PyObject *_res = NULL;

   183 	Boolean _rv;

   184 #ifndef GetMenuExcludesMarkColumn

   185 	PyMac_PRECHECK(GetMenuExcludesMarkColumn);

   186 #endif

   187 	if (!PyArg_ParseTuple(_args, ""))

   188 		return NULL;

   189 	_rv = GetMenuExcludesMarkColumn(_self->ob_itself);

   190 	_res = Py_BuildValue("b",

   191 	                     _rv);

   192 	return _res;

   193 }

   194 

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

   196 {

   197 	PyObject *_res = NULL;

   198 	OSStatus _err;

   199 	Boolean excludesMark;

   200 #ifndef SetMenuExcludesMarkColumn

   201 	PyMac_PRECHECK(SetMenuExcludesMarkColumn);

   202 #endif

   203 	if (!PyArg_ParseTuple(_args, "b",

   204 	                      &excludesMark))

   205 		return NULL;

   206 	_err = SetMenuExcludesMarkColumn(_self->ob_itself,

   207 	                                 excludesMark);

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

   209 	Py_INCREF(Py_None);

   210 	_res = Py_None;

   211 	return _res;

   212 }

   213 

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

   215 {

   216 	PyObject *_res = NULL;

   217 	Boolean _rv;

   218 #ifndef IsValidMenu

   219 	PyMac_PRECHECK(IsValidMenu);

   220 #endif

   221 	if (!PyArg_ParseTuple(_args, ""))

   222 		return NULL;

   223 	_rv = IsValidMenu(_self->ob_itself);

   224 	_res = Py_BuildValue("b",

   225 	                     _rv);

   226 	return _res;

   227 }

   228 

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

   230 {

   231 	PyObject *_res = NULL;

   232 	ItemCount _rv;

   233 #ifndef GetMenuRetainCount

   234 	PyMac_PRECHECK(GetMenuRetainCount);

   235 #endif

   236 	if (!PyArg_ParseTuple(_args, ""))

   237 		return NULL;

   238 	_rv = GetMenuRetainCount(_self->ob_itself);

   239 	_res = Py_BuildValue("l",

   240 	                     _rv);

   241 	return _res;

   242 }

   243 

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

   245 {

   246 	PyObject *_res = NULL;

   247 	OSStatus _err;

   248 #ifndef RetainMenu

   249 	PyMac_PRECHECK(RetainMenu);

   250 #endif

   251 	if (!PyArg_ParseTuple(_args, ""))

   252 		return NULL;

   253 	_err = RetainMenu(_self->ob_itself);

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

   255 	Py_INCREF(Py_None);

   256 	_res = Py_None;

   257 	return _res;

   258 }

   259 

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

   261 {

   262 	PyObject *_res = NULL;

   263 	OSStatus _err;

   264 #ifndef ReleaseMenu

   265 	PyMac_PRECHECK(ReleaseMenu);

   266 #endif

   267 	if (!PyArg_ParseTuple(_args, ""))

   268 		return NULL;

   269 	_err = ReleaseMenu(_self->ob_itself);

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

   271 	Py_INCREF(Py_None);

   272 	_res = Py_None;

   273 	return _res;

   274 }

   275 

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

   277 {

   278 	PyObject *_res = NULL;

   279 	OSStatus _err;

   280 	MenuHandle outMenu;

   281 #ifndef DuplicateMenu

   282 	PyMac_PRECHECK(DuplicateMenu);

   283 #endif

   284 	if (!PyArg_ParseTuple(_args, ""))

   285 		return NULL;

   286 	_err = DuplicateMenu(_self->ob_itself,

   287 	                     &outMenu);

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

   289 	_res = Py_BuildValue("O&",

   290 	                     MenuObj_New, outMenu);

   291 	return _res;

   292 }

   293 

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

   295 {

   296 	PyObject *_res = NULL;

   297 	OSStatus _err;

   298 	CFStringRef outString;

   299 #ifndef CopyMenuTitleAsCFString

   300 	PyMac_PRECHECK(CopyMenuTitleAsCFString);

   301 #endif

   302 	if (!PyArg_ParseTuple(_args, ""))

   303 		return NULL;

   304 	_err = CopyMenuTitleAsCFString(_self->ob_itself,

   305 	                               &outString);

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

   307 	_res = Py_BuildValue("O&",

   308 	                     CFStringRefObj_New, outString);

   309 	return _res;

   310 }

   311 

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

   313 {

   314 	PyObject *_res = NULL;

   315 	OSStatus _err;

   316 	CFStringRef inString;

   317 #ifndef SetMenuTitleWithCFString

   318 	PyMac_PRECHECK(SetMenuTitleWithCFString);

   319 #endif

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

   321 	                      CFStringRefObj_Convert, &inString))

   322 		return NULL;

   323 	_err = SetMenuTitleWithCFString(_self->ob_itself,

   324 	                                inString);

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

   326 	Py_INCREF(Py_None);

   327 	_res = Py_None;

   328 	return _res;

   329 }

   330 

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

   332 {

   333 	PyObject *_res = NULL;

   334 	OSStatus _err;

   335 #ifndef InvalidateMenuSize

   336 	PyMac_PRECHECK(InvalidateMenuSize);

   337 #endif

   338 	if (!PyArg_ParseTuple(_args, ""))

   339 		return NULL;

   340 	_err = InvalidateMenuSize(_self->ob_itself);

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

   342 	Py_INCREF(Py_None);

   343 	_res = Py_None;

   344 	return _res;

   345 }

   346 

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

   348 {

   349 	PyObject *_res = NULL;

   350 	Boolean _rv;

   351 #ifndef IsMenuSizeInvalid

   352 	PyMac_PRECHECK(IsMenuSizeInvalid);

   353 #endif

   354 	if (!PyArg_ParseTuple(_args, ""))

   355 		return NULL;

   356 	_rv = IsMenuSizeInvalid(_self->ob_itself);

   357 	_res = Py_BuildValue("b",

   358 	                     _rv);

   359 	return _res;

   360 }

   361 

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

   363 {

   364 	PyObject *_res = NULL;

   365 	Str255 data;

   366 #ifndef MacAppendMenu

   367 	PyMac_PRECHECK(MacAppendMenu);

   368 #endif

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

   370 	                      PyMac_GetStr255, data))

   371 		return NULL;

   372 	MacAppendMenu(_self->ob_itself,

   373 	              data);

   374 	Py_INCREF(Py_None);

   375 	_res = Py_None;

   376 	return _res;

   377 }

   378 

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

   380 {

   381 	PyObject *_res = NULL;

   382 	ResType theType;

   383 	short afterItem;

   384 #ifndef InsertResMenu

   385 	PyMac_PRECHECK(InsertResMenu);

   386 #endif

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

   388 	                      PyMac_GetOSType, &theType,

   389 	                      &afterItem))

   390 		return NULL;

   391 	InsertResMenu(_self->ob_itself,

   392 	              theType,

   393 	              afterItem);

   394 	Py_INCREF(Py_None);

   395 	_res = Py_None;

   396 	return _res;

   397 }

   398 

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

   400 {

   401 	PyObject *_res = NULL;

   402 	ResType theType;

   403 #ifndef AppendResMenu

   404 	PyMac_PRECHECK(AppendResMenu);

   405 #endif

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

   407 	                      PyMac_GetOSType, &theType))

   408 		return NULL;

   409 	AppendResMenu(_self->ob_itself,

   410 	              theType);

   411 	Py_INCREF(Py_None);

   412 	_res = Py_None;

   413 	return _res;

   414 }

   415 

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

   417 {

   418 	PyObject *_res = NULL;

   419 	Str255 itemString;

   420 	short afterItem;

   421 #ifndef MacInsertMenuItem

   422 	PyMac_PRECHECK(MacInsertMenuItem);

   423 #endif

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

   425 	                      PyMac_GetStr255, itemString,

   426 	                      &afterItem))

   427 		return NULL;

   428 	MacInsertMenuItem(_self->ob_itself,

   429 	                  itemString,

   430 	                  afterItem);

   431 	Py_INCREF(Py_None);

   432 	_res = Py_None;

   433 	return _res;

   434 }

   435 

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

   437 {

   438 	PyObject *_res = NULL;

   439 	short item;

   440 #ifndef DeleteMenuItem

   441 	PyMac_PRECHECK(DeleteMenuItem);

   442 #endif

   443 	if (!PyArg_ParseTuple(_args, "h",

   444 	                      &item))

   445 		return NULL;

   446 	DeleteMenuItem(_self->ob_itself,

   447 	               item);

   448 	Py_INCREF(Py_None);

   449 	_res = Py_None;

   450 	return _res;

   451 }

   452 

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

   454 {

   455 	PyObject *_res = NULL;

   456 	short afterItem;

   457 	short scriptFilter;

   458 #ifndef InsertFontResMenu

   459 	PyMac_PRECHECK(InsertFontResMenu);

   460 #endif

   461 	if (!PyArg_ParseTuple(_args, "hh",

   462 	                      &afterItem,

   463 	                      &scriptFilter))

   464 		return NULL;

   465 	InsertFontResMenu(_self->ob_itself,

   466 	                  afterItem,

   467 	                  scriptFilter);

   468 	Py_INCREF(Py_None);

   469 	_res = Py_None;

   470 	return _res;

   471 }

   472 

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

   474 {

   475 	PyObject *_res = NULL;

   476 	ResType theType;

   477 	short afterItem;

   478 	short scriptFilter;

   479 #ifndef InsertIntlResMenu

   480 	PyMac_PRECHECK(InsertIntlResMenu);

   481 #endif

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

   483 	                      PyMac_GetOSType, &theType,

   484 	                      &afterItem,

   485 	                      &scriptFilter))

   486 		return NULL;

   487 	InsertIntlResMenu(_self->ob_itself,

   488 	                  theType,

   489 	                  afterItem,

   490 	                  scriptFilter);

   491 	Py_INCREF(Py_None);

   492 	_res = Py_None;

   493 	return _res;

   494 }

   495 

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

   497 {

   498 	PyObject *_res = NULL;

   499 	OSStatus _err;

   500 	Str255 inString;

   501 #ifndef AppendMenuItemText

   502 	PyMac_PRECHECK(AppendMenuItemText);

   503 #endif

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

   505 	                      PyMac_GetStr255, inString))

   506 		return NULL;

   507 	_err = AppendMenuItemText(_self->ob_itself,

   508 	                          inString);

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

   510 	Py_INCREF(Py_None);

   511 	_res = Py_None;

   512 	return _res;

   513 }

   514 

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

   516 {

   517 	PyObject *_res = NULL;

   518 	OSStatus _err;

   519 	Str255 inString;

   520 	MenuItemIndex afterItem;

   521 #ifndef InsertMenuItemText

   522 	PyMac_PRECHECK(InsertMenuItemText);

   523 #endif

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

   525 	                      PyMac_GetStr255, inString,

   526 	                      &afterItem))

   527 		return NULL;

   528 	_err = InsertMenuItemText(_self->ob_itself,

   529 	                          inString,

   530 	                          afterItem);

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

   532 	Py_INCREF(Py_None);

   533 	_res = Py_None;

   534 	return _res;

   535 }

   536 

   537 static PyObject *MenuObj_CopyMenuItems(MenuObject *_self, PyObject *_args)

   538 {

   539 	PyObject *_res = NULL;

   540 	OSStatus _err;

   541 	MenuItemIndex inFirstItem;

   542 	ItemCount inNumItems;

   543 	MenuHandle inDestMenu;

   544 	MenuItemIndex inInsertAfter;

   545 #ifndef CopyMenuItems

   546 	PyMac_PRECHECK(CopyMenuItems);

   547 #endif

   548 	if (!PyArg_ParseTuple(_args, "hlO&h",

   549 	                      &inFirstItem,

   550 	                      &inNumItems,

   551 	                      MenuObj_Convert, &inDestMenu,

   552 	                      &inInsertAfter))

   553 		return NULL;

   554 	_err = CopyMenuItems(_self->ob_itself,

   555 	                     inFirstItem,

   556 	                     inNumItems,

   557 	                     inDestMenu,

   558 	                     inInsertAfter);

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

   560 	Py_INCREF(Py_None);

   561 	_res = Py_None;

   562 	return _res;

   563 }

   564 

   565 static PyObject *MenuObj_DeleteMenuItems(MenuObject *_self, PyObject *_args)

   566 {

   567 	PyObject *_res = NULL;

   568 	OSStatus _err;

   569 	MenuItemIndex inFirstItem;

   570 	ItemCount inNumItems;

   571 #ifndef DeleteMenuItems

   572 	PyMac_PRECHECK(DeleteMenuItems);

   573 #endif

   574 	if (!PyArg_ParseTuple(_args, "hl",

   575 	                      &inFirstItem,

   576 	                      &inNumItems))

   577 		return NULL;

   578 	_err = DeleteMenuItems(_self->ob_itself,

   579 	                       inFirstItem,

   580 	                       inNumItems);

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

   582 	Py_INCREF(Py_None);

   583 	_res = Py_None;

   584 	return _res;

   585 }

   586 

   587 static PyObject *MenuObj_AppendMenuItemTextWithCFString(MenuObject *_self, PyObject *_args)

   588 {

   589 	PyObject *_res = NULL;

   590 	OSStatus _err;

   591 	CFStringRef inString;

   592 	MenuItemAttributes inAttributes;

   593 	MenuCommand inCommandID;

   594 	MenuItemIndex outNewItem;

   595 #ifndef AppendMenuItemTextWithCFString

   596 	PyMac_PRECHECK(AppendMenuItemTextWithCFString);

   597 #endif

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

   599 	                      CFStringRefObj_Convert, &inString,

   600 	                      &inAttributes,

   601 	                      &inCommandID))

   602 		return NULL;

   603 	_err = AppendMenuItemTextWithCFString(_self->ob_itself,

   604 	                                      inString,

   605 	                                      inAttributes,

   606 	                                      inCommandID,

   607 	                                      &outNewItem);

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

   609 	_res = Py_BuildValue("h",

   610 	                     outNewItem);

   611 	return _res;

   612 }

   613 

   614 static PyObject *MenuObj_InsertMenuItemTextWithCFString(MenuObject *_self, PyObject *_args)

   615 {

   616 	PyObject *_res = NULL;

   617 	OSStatus _err;

   618 	CFStringRef inString;

   619 	MenuItemIndex inAfterItem;

   620 	MenuItemAttributes inAttributes;

   621 	MenuCommand inCommandID;

   622 #ifndef InsertMenuItemTextWithCFString

   623 	PyMac_PRECHECK(InsertMenuItemTextWithCFString);

   624 #endif

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

   626 	                      CFStringRefObj_Convert, &inString,

   627 	                      &inAfterItem,

   628 	                      &inAttributes,

   629 	                      &inCommandID))

   630 		return NULL;

   631 	_err = InsertMenuItemTextWithCFString(_self->ob_itself,

   632 	                                      inString,

   633 	                                      inAfterItem,

   634 	                                      inAttributes,

   635 	                                      inCommandID);

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

   637 	Py_INCREF(Py_None);

   638 	_res = Py_None;

   639 	return _res;

   640 }

   641 

   642 static PyObject *MenuObj_PopUpMenuSelect(MenuObject *_self, PyObject *_args)

   643 {

   644 	PyObject *_res = NULL;

   645 	long _rv;

   646 	short top;

   647 	short left;

   648 	short popUpItem;

   649 #ifndef PopUpMenuSelect

   650 	PyMac_PRECHECK(PopUpMenuSelect);

   651 #endif

   652 	if (!PyArg_ParseTuple(_args, "hhh",

   653 	                      &top,

   654 	                      &left,

   655 	                      &popUpItem))

   656 		return NULL;

   657 	_rv = PopUpMenuSelect(_self->ob_itself,

   658 	                      top,

   659 	                      left,

   660 	                      popUpItem);

   661 	_res = Py_BuildValue("l",

   662 	                     _rv);

   663 	return _res;

   664 }

   665 

   666 static PyObject *MenuObj_InvalidateMenuEnabling(MenuObject *_self, PyObject *_args)

   667 {

   668 	PyObject *_res = NULL;

   669 	OSStatus _err;

   670 #ifndef InvalidateMenuEnabling

   671 	PyMac_PRECHECK(InvalidateMenuEnabling);

   672 #endif

   673 	if (!PyArg_ParseTuple(_args, ""))

   674 		return NULL;

   675 	_err = InvalidateMenuEnabling(_self->ob_itself);

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

   677 	Py_INCREF(Py_None);

   678 	_res = Py_None;

   679 	return _res;

   680 }

   681 

   682 static PyObject *MenuObj_IsMenuBarInvalid(MenuObject *_self, PyObject *_args)

   683 {

   684 	PyObject *_res = NULL;

   685 	Boolean _rv;

   686 #ifndef IsMenuBarInvalid

   687 	PyMac_PRECHECK(IsMenuBarInvalid);

   688 #endif

   689 	if (!PyArg_ParseTuple(_args, ""))

   690 		return NULL;

   691 	_rv = IsMenuBarInvalid(_self->ob_itself);

   692 	_res = Py_BuildValue("b",

   693 	                     _rv);

   694 	return _res;

   695 }

   696 

   697 static PyObject *MenuObj_MacInsertMenu(MenuObject *_self, PyObject *_args)

   698 {

   699 	PyObject *_res = NULL;

   700 	MenuID beforeID;

   701 #ifndef MacInsertMenu

   702 	PyMac_PRECHECK(MacInsertMenu);

   703 #endif

   704 	if (!PyArg_ParseTuple(_args, "h",

   705 	                      &beforeID))

   706 		return NULL;

   707 	MacInsertMenu(_self->ob_itself,

   708 	              beforeID);

   709 	Py_INCREF(Py_None);

   710 	_res = Py_None;

   711 	return _res;

   712 }

   713 

   714 static PyObject *MenuObj_SetRootMenu(MenuObject *_self, PyObject *_args)

   715 {

   716 	PyObject *_res = NULL;

   717 	OSStatus _err;

   718 #ifndef SetRootMenu

   719 	PyMac_PRECHECK(SetRootMenu);

   720 #endif

   721 	if (!PyArg_ParseTuple(_args, ""))

   722 		return NULL;

   723 	_err = SetRootMenu(_self->ob_itself);

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

   725 	Py_INCREF(Py_None);

   726 	_res = Py_None;

   727 	return _res;

   728 }

   729 

   730 static PyObject *MenuObj_MacCheckMenuItem(MenuObject *_self, PyObject *_args)

   731 {

   732 	PyObject *_res = NULL;

   733 	short item;

   734 	Boolean checked;

   735 #ifndef MacCheckMenuItem

   736 	PyMac_PRECHECK(MacCheckMenuItem);

   737 #endif

   738 	if (!PyArg_ParseTuple(_args, "hb",

   739 	                      &item,

   740 	                      &checked))

   741 		return NULL;

   742 	MacCheckMenuItem(_self->ob_itself,

   743 	                 item,

   744 	                 checked);

   745 	Py_INCREF(Py_None);

   746 	_res = Py_None;

   747 	return _res;

   748 }

   749 

   750 static PyObject *MenuObj_SetMenuItemText(MenuObject *_self, PyObject *_args)

   751 {

   752 	PyObject *_res = NULL;

   753 	short item;

   754 	Str255 itemString;

   755 #ifndef SetMenuItemText

   756 	PyMac_PRECHECK(SetMenuItemText);

   757 #endif

   758 	if (!PyArg_ParseTuple(_args, "hO&",

   759 	                      &item,

   760 	                      PyMac_GetStr255, itemString))

   761 		return NULL;

   762 	SetMenuItemText(_self->ob_itself,

   763 	                item,

   764 	                itemString);

   765 	Py_INCREF(Py_None);

   766 	_res = Py_None;

   767 	return _res;

   768 }

   769 

   770 static PyObject *MenuObj_GetMenuItemText(MenuObject *_self, PyObject *_args)

   771 {

   772 	PyObject *_res = NULL;

   773 	short item;

   774 	Str255 itemString;

   775 #ifndef GetMenuItemText

   776 	PyMac_PRECHECK(GetMenuItemText);

   777 #endif

   778 	if (!PyArg_ParseTuple(_args, "h",

   779 	                      &item))

   780 		return NULL;

   781 	GetMenuItemText(_self->ob_itself,

   782 	                item,

   783 	                itemString);

   784 	_res = Py_BuildValue("O&",

   785 	                     PyMac_BuildStr255, itemString);

   786 	return _res;

   787 }

   788 

   789 static PyObject *MenuObj_SetItemMark(MenuObject *_self, PyObject *_args)

   790 {

   791 	PyObject *_res = NULL;

   792 	short item;

   793 	CharParameter markChar;

   794 #ifndef SetItemMark

   795 	PyMac_PRECHECK(SetItemMark);

   796 #endif

   797 	if (!PyArg_ParseTuple(_args, "hh",

   798 	                      &item,

   799 	                      &markChar))

   800 		return NULL;

   801 	SetItemMark(_self->ob_itself,

   802 	            item,

   803 	            markChar);

   804 	Py_INCREF(Py_None);

   805 	_res = Py_None;

   806 	return _res;

   807 }

   808 

   809 static PyObject *MenuObj_GetItemMark(MenuObject *_self, PyObject *_args)

   810 {

   811 	PyObject *_res = NULL;

   812 	short item;

   813 	CharParameter markChar;

   814 #ifndef GetItemMark

   815 	PyMac_PRECHECK(GetItemMark);

   816 #endif

   817 	if (!PyArg_ParseTuple(_args, "h",

   818 	                      &item))

   819 		return NULL;

   820 	GetItemMark(_self->ob_itself,

   821 	            item,

   822 	            &markChar);

   823 	_res = Py_BuildValue("h",

   824 	                     markChar);

   825 	return _res;

   826 }

   827 

   828 static PyObject *MenuObj_SetItemCmd(MenuObject *_self, PyObject *_args)

   829 {

   830 	PyObject *_res = NULL;

   831 	short item;

   832 	CharParameter cmdChar;

   833 #ifndef SetItemCmd

   834 	PyMac_PRECHECK(SetItemCmd);

   835 #endif

   836 	if (!PyArg_ParseTuple(_args, "hh",

   837 	                      &item,

   838 	                      &cmdChar))

   839 		return NULL;

   840 	SetItemCmd(_self->ob_itself,

   841 	           item,

   842 	           cmdChar);

   843 	Py_INCREF(Py_None);

   844 	_res = Py_None;

   845 	return _res;

   846 }

   847 

   848 static PyObject *MenuObj_GetItemCmd(MenuObject *_self, PyObject *_args)

   849 {

   850 	PyObject *_res = NULL;

   851 	short item;

   852 	CharParameter cmdChar;

   853 #ifndef GetItemCmd

   854 	PyMac_PRECHECK(GetItemCmd);

   855 #endif

   856 	if (!PyArg_ParseTuple(_args, "h",

   857 	                      &item))

   858 		return NULL;

   859 	GetItemCmd(_self->ob_itself,

   860 	           item,

   861 	           &cmdChar);

   862 	_res = Py_BuildValue("h",

   863 	                     cmdChar);

   864 	return _res;

   865 }

   866 

   867 static PyObject *MenuObj_SetItemIcon(MenuObject *_self, PyObject *_args)

   868 {

   869 	PyObject *_res = NULL;

   870 	short item;

   871 	short iconIndex;

   872 #ifndef SetItemIcon

   873 	PyMac_PRECHECK(SetItemIcon);

   874 #endif

   875 	if (!PyArg_ParseTuple(_args, "hh",

   876 	                      &item,

   877 	                      &iconIndex))

   878 		return NULL;

   879 	SetItemIcon(_self->ob_itself,

   880 	            item,

   881 	            iconIndex);

   882 	Py_INCREF(Py_None);

   883 	_res = Py_None;

   884 	return _res;

   885 }

   886 

   887 static PyObject *MenuObj_GetItemIcon(MenuObject *_self, PyObject *_args)

   888 {

   889 	PyObject *_res = NULL;

   890 	short item;

   891 	short iconIndex;

   892 #ifndef GetItemIcon

   893 	PyMac_PRECHECK(GetItemIcon);

   894 #endif

   895 	if (!PyArg_ParseTuple(_args, "h",

   896 	                      &item))

   897 		return NULL;

   898 	GetItemIcon(_self->ob_itself,

   899 	            item,

   900 	            &iconIndex);

   901 	_res = Py_BuildValue("h",

   902 	                     iconIndex);

   903 	return _res;

   904 }

   905 

   906 static PyObject *MenuObj_SetItemStyle(MenuObject *_self, PyObject *_args)

   907 {

   908 	PyObject *_res = NULL;

   909 	short item;

   910 	StyleParameter chStyle;

   911 #ifndef SetItemStyle

   912 	PyMac_PRECHECK(SetItemStyle);

   913 #endif

   914 	if (!PyArg_ParseTuple(_args, "hh",

   915 	                      &item,

   916 	                      &chStyle))

   917 		return NULL;

   918 	SetItemStyle(_self->ob_itself,

   919 	             item,

   920 	             chStyle);

   921 	Py_INCREF(Py_None);

   922 	_res = Py_None;

   923 	return _res;

   924 }

   925 

   926 static PyObject *MenuObj_GetItemStyle(MenuObject *_self, PyObject *_args)

   927 {

   928 	PyObject *_res = NULL;

   929 	short item;

   930 	Style chStyle;

   931 #ifndef GetItemStyle

   932 	PyMac_PRECHECK(GetItemStyle);

   933 #endif

   934 	if (!PyArg_ParseTuple(_args, "h",

   935 	                      &item))

   936 		return NULL;

   937 	GetItemStyle(_self->ob_itself,

   938 	             item,

   939 	             &chStyle);

   940 	_res = Py_BuildValue("b",

   941 	                     chStyle);

   942 	return _res;

   943 }

   944 

   945 static PyObject *MenuObj_SetMenuItemCommandID(MenuObject *_self, PyObject *_args)

   946 {

   947 	PyObject *_res = NULL;

   948 	OSErr _err;

   949 	SInt16 inItem;

   950 	MenuCommand inCommandID;

   951 #ifndef SetMenuItemCommandID

   952 	PyMac_PRECHECK(SetMenuItemCommandID);

   953 #endif

   954 	if (!PyArg_ParseTuple(_args, "hl",

   955 	                      &inItem,

   956 	                      &inCommandID))

   957 		return NULL;

   958 	_err = SetMenuItemCommandID(_self->ob_itself,

   959 	                            inItem,

   960 	                            inCommandID);

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

   962 	Py_INCREF(Py_None);

   963 	_res = Py_None;

   964 	return _res;

   965 }

   966 

   967 static PyObject *MenuObj_GetMenuItemCommandID(MenuObject *_self, PyObject *_args)

   968 {

   969 	PyObject *_res = NULL;

   970 	OSErr _err;

   971 	SInt16 inItem;

   972 	MenuCommand outCommandID;

   973 #ifndef GetMenuItemCommandID

   974 	PyMac_PRECHECK(GetMenuItemCommandID);

   975 #endif

   976 	if (!PyArg_ParseTuple(_args, "h",

   977 	                      &inItem))

   978 		return NULL;

   979 	_err = GetMenuItemCommandID(_self->ob_itself,

   980 	                            inItem,

   981 	                            &outCommandID);

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

   983 	_res = Py_BuildValue("l",

   984 	                     outCommandID);

   985 	return _res;

   986 }

   987 

   988 static PyObject *MenuObj_SetMenuItemModifiers(MenuObject *_self, PyObject *_args)

   989 {

   990 	PyObject *_res = NULL;

   991 	OSErr _err;

   992 	SInt16 inItem;

   993 	UInt8 inModifiers;

   994 #ifndef SetMenuItemModifiers

   995 	PyMac_PRECHECK(SetMenuItemModifiers);

   996 #endif

   997 	if (!PyArg_ParseTuple(_args, "hb",

   998 	                      &inItem,

   999 	                      &inModifiers))

  1000 		return NULL;

  1001 	_err = SetMenuItemModifiers(_self->ob_itself,

  1002 	                            inItem,

  1003 	                            inModifiers);

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

  1005 	Py_INCREF(Py_None);

  1006 	_res = Py_None;

  1007 	return _res;

  1008 }

  1009 

  1010 static PyObject *MenuObj_GetMenuItemModifiers(MenuObject *_self, PyObject *_args)

  1011 {

  1012 	PyObject *_res = NULL;

  1013 	OSErr _err;

  1014 	SInt16 inItem;

  1015 	UInt8 outModifiers;

  1016 #ifndef GetMenuItemModifiers

  1017 	PyMac_PRECHECK(GetMenuItemModifiers);

  1018 #endif

  1019 	if (!PyArg_ParseTuple(_args, "h",

  1020 	                      &inItem))

  1021 		return NULL;

  1022 	_err = GetMenuItemModifiers(_self->ob_itself,

  1023 	                            inItem,

  1024 	                            &outModifiers);

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

  1026 	_res = Py_BuildValue("b",

  1027 	                     outModifiers);

  1028 	return _res;

  1029 }

  1030 

  1031 static PyObject *MenuObj_SetMenuItemIconHandle(MenuObject *_self, PyObject *_args)

  1032 {

  1033 	PyObject *_res = NULL;

  1034 	OSErr _err;

  1035 	SInt16 inItem;

  1036 	UInt8 inIconType;

  1037 	Handle inIconHandle;

  1038 #ifndef SetMenuItemIconHandle

  1039 	PyMac_PRECHECK(SetMenuItemIconHandle);

  1040 #endif

  1041 	if (!PyArg_ParseTuple(_args, "hbO&",

  1042 	                      &inItem,

  1043 	                      &inIconType,

  1044 	                      ResObj_Convert, &inIconHandle))

  1045 		return NULL;

  1046 	_err = SetMenuItemIconHandle(_self->ob_itself,

  1047 	                             inItem,

  1048 	                             inIconType,

  1049 	                             inIconHandle);

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

  1051 	Py_INCREF(Py_None);

  1052 	_res = Py_None;

  1053 	return _res;

  1054 }

  1055 

  1056 static PyObject *MenuObj_GetMenuItemIconHandle(MenuObject *_self, PyObject *_args)

  1057 {

  1058 	PyObject *_res = NULL;

  1059 	OSErr _err;

  1060 	SInt16 inItem;

  1061 	UInt8 outIconType;

  1062 	Handle outIconHandle;

  1063 #ifndef GetMenuItemIconHandle

  1064 	PyMac_PRECHECK(GetMenuItemIconHandle);

  1065 #endif

  1066 	if (!PyArg_ParseTuple(_args, "h",

  1067 	                      &inItem))

  1068 		return NULL;

  1069 	_err = GetMenuItemIconHandle(_self->ob_itself,

  1070 	                             inItem,

  1071 	                             &outIconType,

  1072 	                             &outIconHandle);

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

  1074 	_res = Py_BuildValue("bO&",

  1075 	                     outIconType,

  1076 	                     ResObj_New, outIconHandle);

  1077 	return _res;

  1078 }

  1079 

  1080 static PyObject *MenuObj_SetMenuItemTextEncoding(MenuObject *_self, PyObject *_args)

  1081 {

  1082 	PyObject *_res = NULL;

  1083 	OSErr _err;

  1084 	SInt16 inItem;

  1085 	TextEncoding inScriptID;

  1086 #ifndef SetMenuItemTextEncoding

  1087 	PyMac_PRECHECK(SetMenuItemTextEncoding);

  1088 #endif

  1089 	if (!PyArg_ParseTuple(_args, "hl",

  1090 	                      &inItem,

  1091 	                      &inScriptID))

  1092 		return NULL;

  1093 	_err = SetMenuItemTextEncoding(_self->ob_itself,

  1094 	                               inItem,

  1095 	                               inScriptID);

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

  1097 	Py_INCREF(Py_None);

  1098 	_res = Py_None;

  1099 	return _res;

  1100 }

  1101 

  1102 static PyObject *MenuObj_GetMenuItemTextEncoding(MenuObject *_self, PyObject *_args)

  1103 {

  1104 	PyObject *_res = NULL;

  1105 	OSErr _err;

  1106 	SInt16 inItem;

  1107 	TextEncoding outScriptID;

  1108 #ifndef GetMenuItemTextEncoding

  1109 	PyMac_PRECHECK(GetMenuItemTextEncoding);

  1110 #endif

  1111 	if (!PyArg_ParseTuple(_args, "h",

  1112 	                      &inItem))

  1113 		return NULL;

  1114 	_err = GetMenuItemTextEncoding(_self->ob_itself,

  1115 	                               inItem,

  1116 	                               &outScriptID);

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

  1118 	_res = Py_BuildValue("l",

  1119 	                     outScriptID);

  1120 	return _res;

  1121 }

  1122 

  1123 static PyObject *MenuObj_SetMenuItemHierarchicalID(MenuObject *_self, PyObject *_args)

  1124 {

  1125 	PyObject *_res = NULL;

  1126 	OSErr _err;

  1127 	SInt16 inItem;

  1128 	MenuID inHierID;

  1129 #ifndef SetMenuItemHierarchicalID

  1130 	PyMac_PRECHECK(SetMenuItemHierarchicalID);

  1131 #endif

  1132 	if (!PyArg_ParseTuple(_args, "hh",

  1133 	                      &inItem,

  1134 	                      &inHierID))

  1135 		return NULL;