supermario/base/SuperMarioProj.1994-02-09/ProcessMgr/MenuMgrPatches.c

/*
	File:		MenuMgrPatches.c

	Contains:	Routines which patch the Menu Manager traps.

	Written by:	Erich Ringewald

	Copyright:	© 1986-1992 by Apple Computer, Inc., all rights reserved.

	Change History (most recent first):
	 
		<10>	 9/25/92	DRF		Eliminate superflous prototype for MyGestalt()
		 <9>	 3/20/92	DCL		#1025005,<KSM>:
									Included Script.h because: For New IM: Moved some declarations
									and routines from Packages.[ph] to Script.[ph] #1025005
		 <8>	  2/2/91	DFH		csd,WhiteBoard:AdjustApplicationMenu now allows for the case
									when the pTitleProc does not yet have a layer. This can happen
									when we are called from ExitToShell with pTitleProc being a
									nascent application that has not yet called InitWindows (wherein
									we add the app name to the application menu).
		 <6>	 1/28/91	DFH		JSM,#81425: Removed inhibit_DAs mechanism. Removed
									DisableSwitching and EnableSwitching calls from our MenuSelect
									and PopupMenuSelect patches since it is already taken care of
									by the WaitMouseUp patch. This meant the PopUpMenuSelect
									patch was no longer needed!
		 <5>	 1/21/91	DFH		(KSM) Process Menu is now called Application Menu.
		 <3>	12/17/90	DFH		Rename CheckForCutCopy to CheckForCutCopyMenuKey.
		 <2>	12/10/90	DFH		Adding support for custom icons (i.e. the ones the user can
									specify).
		 <0>	 x/xx/86	ELR		New Today.

*/  
 
#include <types.h>
#include <memory.h>
#include <quickdraw.h>
#include <fonts.h>
#include <events.h>
#include <desk.h>
#include <resources.h>
#include <osutils.h>
#include <retrace.h>
#include <menus.h>
#include <windows.h>
#include <files.h>
#include <toolutils.h>
#include <segload.h>
#include <errors.h>
#include <EPPC.h>
#include <AppleEventsInternal.h>
#include <MFPrivate.h>
#include <GestaltEqu.h>
#include <Icons.h>
#include <IconUtilsPriv.h>
#include <Windows.h>
#include <ScriptPriv.h>
#include <IntlUtilsPriv.h>
#include <MenuMgrPriv.h>

#include "Patches.h"
#include "Glue.h"
#include "HList.h"
#include "Lomem.h"
#include "Data.h"
#include "SysMisc.h"
#include "Puppet.h"
#include "OSDispatchPrivate.h"
#include "AppleEventExtensions.h"
#include "Script.h"
#include "Language.h"

/* -----------------------------------------------------------------------------
 *
 *								Data and prototypes.
 *
 * -----------------------------------------------------------------------------*/

/* Some function prototypes that should be in (yet another) header file */
StringPtr		StripLeadingNulls(pString);
Handle			NewMungedString(StringPtr, StringPtr);
short			GetIconIDFromBundle(OSType, unsigned long);

/* Function prototypes internal to this file */
Boolean			IsEnabledItem(long);
Ptr				MenuItemAddress(MenuHandle, short);
pascal short	MyIUTextOrder(StringPtr, StringPtr, ScriptCode, ScriptCode);
Boolean			IsMenuItemForNamePrefix(MenuHandle, short, StringPtr);
long			MenuSelectionGivenName(MenuHandle, StringPtr);
void			ApplyToAllAppleMenus(HListElemFnc *);
void			CheckItemNameAndCharForCutCopy(long, short *);
void			InitAppleMenuList(void);
pascal Handle	GetProcessIcon(ResType, long);
void			ChangeIconicTitle(MenuHandle, Handle);
short			MyPrefixRelString(StringPtr, StringPtr);
void			InsertCustomItem(MenuHandle, short, AppleItemHdl);
void			InsertCustomItemSorted(MenuHandle);
OSErr			DeleteAppleItem(PEntryPtr, long);
void			DeleteCustomItem(AppleItemHdl);
void			DeleteCustomItemFromMenu(MenuHandle);
PEntryPtr		PEntryFromApplicationMenuItem(short);
unsigned short	ApplicationMenuItemFromPEntry(PEntryPtr);
unsigned short	ItemNumFromItemPtr(MenuHandle, Ptr);
AppleItemHdl	StringToAppleItemHdl(StringPtr);

/* The resource type we use to identify Apple menus in _AddResMenu patch */
#define DA_RESOURCE_TYPE		'DRVR'

/* Menu item text strings can have up to this many characters */
#define MENU_ITEM_MAX_LENGTH	(255)
#define IS_ADDED_ITEM_NAME(pText)	( ((StringByte(pText, 0) == NULL) && (StringByte(pText, 1) == NULL)) \
										|| (Length(pText) == MENU_ITEM_MAX_LENGTH) )
#define IS_DA_NAME(pText)			((StringByte(pText, 0) == NULL) && (StringByte(pText, 1) != NULL))
#define IS_ADDED_OR_DA_NAME(pText)	((StringByte(pText, 0) == NULL) || (Length(pText) == MENU_ITEM_MAX_LENGTH))

/* Cheater way to see whether the title of a menu is the AppleMark */
#define APPLE_MENU_TITLE			0x0114
#define HAS_APPLE_TITLE(theMenu)	(*((short *) &((*(theMenu))->menuData)) == APPLE_MENU_TITLE)

/* Apple Item to insert/delete in DA menu */
AppleItemHdl		hAppleItemShare;

#define pAppleMenuProcessList		(pNullProcess->nextAppleMenuProc)
#define pApplicationMenuProcessList	(pNullProcess->nextApplicationMenuProc)

/* -----------------------------------------------------------------------------
 *
 *								Internal utilities.
 *
 * -----------------------------------------------------------------------------*/
#pragma segment Main
	
/* IsEnabledItem.  Return whether the selected menu item is enabled.
 * NOTE: Allows for menu manager weakness that limits the range of items that can
 * really be enabled or disabled (i.e. items 1 through MAX_ENABLEFLAG_INDEX).  As
 * per Inside Mac, higher numbered items are always enabled.
 */
Boolean
IsEnabledItem(long menuSelection)
	{
	MenuHandle		menuHdl;
	short			itemNum;
	
	/* Assume disabled if the selection isn't for a current menu (!) */
	if ((menuHdl = GetMHandle(MENU_ID_OF_SELECTION(menuSelection))) == nil)
		return (false);
	
	/* Extract item number, make range check */
	itemNum = ITEM_ID_OF_SELECTION(menuSelection);
	assert(itemNum > 0 && itemNum <= CountMItems(menuHdl));
	if (itemNum > MAX_ENABLEFLAG_INDEX)
		return (true);
	
	/* Return whether flag is on */
	return (((*menuHdl)->enableFlags & (1<<itemNum)) != 0);
	}

/* MyIUTextOrder.  For my eyes.  Extracts string lengths, and defaults the language.
 * This also saves a little code compared to the inline equivalent when the string
 * address is complex, since that address is only calculated once here, but twice
 * there.
 * NOTE: IUTextOrder can call RecoverHandle, which requires proper setting of THEZONE.
 */
pascal short
MyIUTextOrder(StringPtr aStr, StringPtr bStr, ScriptCode aScript, ScriptCode bScript)
	{
	assert(THEZONE != ProcessMgrZone);
	
	return (IUTextOrderSys(&StringByte(aStr, 0), &StringByte(bStr, 0),
				(short) Length(aStr), (short) Length(bStr),
				aScript, bScript,
				iuScriptDefLang, iuScriptDefLang));
	}

/* IsMenuItemForNamePrefix.  Return whether the given string prefixes the item name. */
Boolean
IsMenuItemForNamePrefix(MenuHandle menuHdl, short iItem, StringPtr pStrPrefix)
	{
	Str255			strItemName;
	
	assert(menuHdl != nil);
	
	GetItem(menuHdl, iItem, &strItemName);
	return ((Boolean)(MyPrefixRelString(pStrPrefix, &strItemName) == 0));
	}

/* MenuItemAddress.  Gets the address of the specified menu item.  Useful when
 * beginning to crawl menu structure from the middle.
 */
Ptr
MenuItemAddress(MenuHandle hMenu, short item)
	{
	Ptr		pMenuItem;
	
	/* locate menu data */
	pMenuItem = (Ptr) &((*hMenu)->menuData);
	
	/* skip menu title to get to first item */
	pMenuItem += Length(pMenuItem) + 1;
	
	/* iterate through menu items */
	while ( (IS_NOT_LAST_MENUITEM(pMenuItem)) && (--item > 0) )
		{
		INC_MENU_ITEMPTR(pMenuItem);
		}
	
	/* return nil if search failed */
	return(IS_NOT_LAST_MENUITEM(pMenuItem) ? pMenuItem : nil);
	}

/* MenuSelectionGivenName.  Given a menu handle and item name, return the menu
 * selection, or 0 if the item cannot be found.
 */
long
MenuSelectionGivenName(MenuHandle menuHdl, StringPtr itemNamePtr)
	{
	short		item;
	Ptr			posInMenu;
		
	/* Can do nothing of there is no menu to look at! */
	if (menuHdl == nil)
		return (0);
		
	/* Skip menu title to get to first item */
	posInMenu = (Ptr) &((*menuHdl)->menuData);
	posInMenu += Length(posInMenu) + 1;
	
	/* Iterate through menu items to match the specified name */
	item = 1;
	while (IS_NOT_LAST_MENUITEM(posInMenu))
		{
		if (MyRelString(posInMenu, itemNamePtr) == sortsEqual)
			return (BUILD_MENUSELECTION((*menuHdl)->menuID, item));
		
		INC_MENU_ITEMPTR(posInMenu);
		item++;
		}

	/* Falling out of loop means no-find */
	return (0);
	}

/* ApplyToAllAppleMenus.  Handy routine that calls the given HList function against all
 * Apple menu handles on the system.  For each process, it uses ApplyToHListElems on the
 * p_applemenuhlisthdl.  The only parameter to the function call is the menu handle,
 * so any other data must be passed in globals.
 */
void
ApplyToAllAppleMenus(HListElemFnc *pHListElemFnc)
	{
	HListHdl				hMenuList;
	register PEntryPtr		pCurProc;

	/* Traverse the process descriptor list. */
	pCurProc = pAppleMenuProcessList;
	while (pCurProc != nil)
		{
		hMenuList = pCurProc->p_applemenuhlisthdl;
		if (HListExists(hMenuList))
			ApplyToHListElems(hMenuList, pHListElemFnc);
		pCurProc = pCurProc->nextAppleMenuProc;
		}
	}

/* -----------------------------------------------------------------------------
 *
 *								Patches to existing traps.
 *
 * -----------------------------------------------------------------------------*/
 
#pragma segment Main

/* c_addresmenu.  Check if adding DAs to Apple menu.  If so, use the opportunity to
 * add all of our stuff, too.  Our definition of Apple menu is it's the one with
 * the DAs (i.e. the menu resource type is DA_RESOURCE_TYPE).
 * NOTE:  An application can have more than one Apple menu.  Ex:  Excel.
 */
pascal void
c_addresmenu(MenuHandle menuHdl, ResType resType)
	{
	short				cMItems, checkItem, currItem;
	HListHdl			menuHdlHListHdl;
	unsigned long		str2Divider = TWO_CHAR_STRING('(','-');
	unsigned short		emptyName = ONE_CHAR_STRING(' ');
	AppleItemHdl		hAppleItem;
	unsigned long		olda5;
	Str255				tempString;
	Addresmenu_ptr		oldtrap;
	
	olda5 = ProcessMgrA5Setup();
	oldtrap = (Addresmenu_ptr) (patchtraps[ADDRESMENU].oldtrap);

	/* Add this menu to the list of AppleMenus */
	if ((resType == DA_RESOURCE_TYPE) && (menuHdl != nil))
		{
		/* Create the recording list, if necessary */
		if (!HListExists(pCurrentProcess->p_applemenuhlisthdl))
			{
			pCurrentProcess->p_applemenuhlisthdl = CreateHList(0);

			/* Link PEntry into list of similar apps */
			pCurrentProcess->nextAppleMenuProc = pAppleMenuProcessList;
			pAppleMenuProcessList = pCurrentProcess;
			}
			
		menuHdlHListHdl = pCurrentProcess->p_applemenuhlisthdl;
		
		/* Stick menu handle in list of menu handles for this process */
		(void)AddToHList(menuHdlHListHdl, (HListElem)menuHdl);

		/* Ensure the standard mdefproc */
		(*menuHdl)->menuProc = standardMenuDefProcRsrc;
			
		/* Add a dashed line at the end (unless the app already has one there). */
		Length(&tempString) = 0;
		if ((cMItems = CountMItems(menuHdl)) > 0)
			GetItem(menuHdl, cMItems, &tempString);
		
		if (IS_DASH_STRING(&tempString) == false)
			{
			AppendMenu(menuHdl, (StringPtr) &str2Divider);
			cMItems++;
			}
		}
		
	/* Do ROM routine to get all the items */
	CALL_FNC_PTR(Addresmenu_ptr, oldtrap, (menuHdl,resType));

	/* Append remainder of Process Mgr items if this is the Apple menu */
	if ((resType == DA_RESOURCE_TYPE) && (menuHdl != nil))
		{	
		/* Remember position before add, and get new size */
		currItem = checkItem = cMItems;
		cMItems = CountMItems(menuHdl);
		
		/* If there are no DAs and no added items, remove the dashed item we added */
		hAppleItem = FirstAppleItem;
		if ((hAppleItem == nil) && (currItem == cMItems))
			DelMenuItem(menuHdl, currItem);

		/* Insert items or item runs until no more or off end of menu.
		 * We use checkItem (current insertion point candidate) and
		 * cMItems (size of menu) to traverse the menu.  checkItem is
		 * incremented each time a new item is fetched or inserted,
		 * cMItems is incremented when the list size is increased.
		 * Ignores the leading NULLs.
		 */
		while ( (hAppleItem != nil) && (++checkItem <= cMItems) )
			{
			StringPtr	pDAName, pAMIName;
			
			GetItem(menuHdl, checkItem, &tempString);
			pDAName = StripLeadingNulls(&tempString);
			
			while (hAppleItem != nil)
				{
				short			compResult;
				
				pAMIName = StripLeadingNulls(&(*hAppleItem)->aiNameStorage);
				compResult = MyIUTextOrder(pAMIName, pDAName, (*hAppleItem)->aiScript, iuSystemScript);
				
				/* Restore NULL (it was replaced by a length byte) */
				Length(pAMIName) = NULL;
				if (compResult >= sortsEqual)
					break;
					
				InsertCustomItem(menuHdl, checkItem-1, hAppleItem);
				cMItems++;
				checkItem++;
				hAppleItem = (*hAppleItem)->aiNext;
				}
			}
			
		/* home stretch ... append remainder of list, if any */
		while (hAppleItem != nil)
			{
			InsertCustomItem(menuHdl, cMItems++, hAppleItem);
			hAppleItem = (*hAppleItem)->aiNext;
			}

		}
		
	A5Restore(olda5);
	}

/* CheckItemNameAndCharForCutCopy.  Update our global scrap coercion counter of
 * cuts/copies vs pastes, based on the specified menu selection.  Examines both
 * the item text and the command key equivalent to see which, if any, of these
 * actions is occurring.
 */
void
CheckItemNameAndCharForCutCopy(long menuSelection, short *pCutCopyCount)
	{
	MenuHandle	menuHdl;
	Str255		strItemName;
	short		ch;
	
	if (VALID_MENUSELECTION(menuSelection))
		{
		if ((menuHdl = GetMHandle(MENU_ID_OF_SELECTION(menuSelection))) != nil)
			{
			/* Force 'copy' designation if the item text prefixes any predefined ones.
			 * Otherwise, act on whether the command key indicates cut or copy. 
			 */
			GetItem(menuHdl, ITEM_ID_OF_SELECTION(menuSelection), &strItemName);
			if (StrInStrList(&strItemName, &pStrListCopyNamePrefix->pStrings[0], pStrListCopyNamePrefix->cStrings, MyPrefixRelString) != nil)
				ch = 'C';
			else
				GetItemCmd(menuHdl, ITEM_ID_OF_SELECTION(menuSelection), &ch);
				
			CheckForCutCopyMenuKey(ch, pCutCopyCount);		
			}
		}
	}

/* c_menuselect.  Take advantage of the application's calling MenuSelect to further
 * our cause in a) puppet strings, b) scrap coercion, or c) layer hiding.    Uses
 * caller's A5 and graphics world when calling though.
 * NOTE: FullWrite never calls this trap.  So anything you depend on here may need
 * to be duplicated elsewhere if you want FullWrite to use it.
 */
pascal long
c_menuselect(Point startPt)
	{
	long			retval;
	Menuselect_ptr	oldtrap;
	unsigned long	olda5;

	olda5 = ProcessMgrA5Setup();
	
	/* Return selection forced by puppet string, if any.  Cancel the puppet show if that
	 * item is no longer available.  In any case, reset the forced selection.
	 */
	retval = 0;
	if (forcedPupStrMenuSelection != 0)
		{
		if (IsEnabledItem(forcedPupStrMenuSelection))
			{
			CheckItemNameAndCharForCutCopy(forcedPupStrMenuSelection, &cutCopyCount);
			retval = forcedPupStrMenuSelection;
			}
		else
			CancelSwitchWithError();

		forcedPupStrMenuSelection = 0;
		}
	
	/* Call the old trap.  Disallow process switching during this critical time.
	 * Use caller's A5 and graphics world.
	 */
	else
		{		
		oldtrap = (Menuselect_ptr) (patchtraps[MENUSELECT].oldtrap);	
		A5Restore(olda5);
		retval = CALL_FNC_PTR(Menuselect_ptr, oldtrap, (startPt));
		olda5 = ProcessMgrA5Setup();
		
		/* See if we should adjust the global scrap cut/copy count. */
		if (VALID_MENUSELECTION(retval))
			CheckItemNameAndCharForCutCopy(retval, &cutCopyCount);
		}
		
	A5Restore(olda5);
	return (retval);
	}

/* c_menukey.  Patch to MenuKey to keep our scrap coercion cut/copy counter up to date. */	
pascal long
c_menukey(short ch)
	{
	u_long		retval, olda5;
	
	/* call the old trap */
	olda5 = ProcessMgrA5Setup();
	retval = CALL_FNC_PTR(Menukey_ptr, patchtraps[MENUKEY].oldtrap, (ch));
	
	/* Synch up only if we're not in middle of coercion, and the key actually
	 * was a key equivalent for a menu item.
	 */
	if ((coercionState == CS_DONE) && (VALID_MENUSELECTION(retval)))
		CheckForCutCopyMenuKey(ch, &cutCopyCount);
		
	A5Restore(olda5);
	return (retval);
	}

/* c_setcursor.  Don't allow _SetCursor thru unless frontmost.
 * NOTE: This can have unintended effect if the app was JUST switched to the back
 * and really needs to reset the cursor.
 */
pascal void
c_setcursor(Ptr cursorDataPtr)
	{
	unsigned long		olda5;
	Setcursor_ptr		oldtrap;
	Boolean				frontmost;
	
	olda5 = ProcessMgrA5SimpleSetup();
	oldtrap = (Setcursor_ptr) (patchtraps[SETCURSOR].oldtrap);
	frontmost = (pCurrentProcess == pFrontProcess);
	A5SimpleRestore(olda5);
	
	if (frontmost)
		CALL_FNC_PTR(Setcursor_ptr, oldtrap, (cursorDataPtr));
	}

/* -----------------------------------------------------------------------------
 *
 *					Auxiliary item information for Apple menu.
 *
 * -----------------------------------------------------------------------------*/

/* ItemNumFromItemPtr.  Return the item number of the entry pointed to by pItemEntry. */
unsigned short
ItemNumFromItemPtr(MenuHandle menuHdl, Ptr pItemEntry)
	{
	short		item;
	Ptr			posInMenu;
	
	posInMenu = (Ptr) StripAddress(&((*menuHdl)->menuData));
	posInMenu += Length(posInMenu) + 1;
	item = 0;
	while (IS_NOT_LAST_MENUITEM(posInMenu))
		{
		item += 1;
		if (posInMenu == pItemEntry)
			break;
		INC_MENU_ITEMPTR(posInMenu);
		}
		
	return(item);
	}

/* StringToAppleItemHdl.  Given a string pointer, return the associated AppleItemHdl,
 * or nil.  Relies on the fact that all AppleItem names (aiNameStorage) have preceding
 * NULLs.  If the given string has no such null, we return nil without having to scan
 * the list.  Notice that the check will let an empty string through to the loop, but
 * the loop will never find a match in this (uncommon) case.  An even less likely case
 * that we DO have to check for is if the item was too long to have NULLs prepended to it.
 */
AppleItemHdl
StringToAppleItemHdl(StringPtr itemText)
	{
	AppleItemHdl	elemHdl;
	
	/* Check only if it has basic appearance of item we added. */
	elemHdl = nil;
	if (IS_ADDED_ITEM_NAME(itemText))
		{	
		elemHdl = FirstAppleItem;
		while (elemHdl != nil)
			{
			if (MyRelString(&(*elemHdl)->aiNameStorage, itemText) == sortsEqual)
				break;
			elemHdl = (*elemHdl)->aiNext;
			}
		}
	
	return (elemHdl);
	}


/* c_getauxmenuitem.  Trap that MDEF/MBDF can call to get more information than can
 * be stored concurrently in a menu item.  Return noTypeErr if this menu seems to not
 * have any items that need auxiliary information.  This allows Menu Mgr/MDEF/MBDF to
 * avoid calling us any more for this menu.
 */
#define SIZEOF_SMALLEST_AUXMENUITEMREC		(3*sizeof(short) + 2*sizeof(long))
pascal OSErr
c_getauxmenuitem(MenuHandle theMenu, unsigned char *pItemEntry, AuxMenuItemRecPtr theStorage, unsigned long recLength)
	{
	StringPtr		pItemName;
	AppleItemPtr	elemPtr;
	AppleItemHdl	elemHdl;
	PEntryPtr		pProc;
	u_long			olda5;
	OSErr			retval;
	
	/* Are we even in a menu we do anything about? */
	olda5 = ProcessMgrA5SimpleSetup();
	retval = noErr;	
	theMenu = (MenuHandle) StripAddress(theMenu);
	
	/* Is length at least as big as the smallest record we ever return? */
	if ((recLength < SIZEOF_SMALLEST_AUXMENUITEMREC) || (theMenu == nil))
		return (paramErr);
	
	/* Is this the Application Menu? */
	if (theMenu == ApplicationMenuHdl)
		{
		short		itemNum;
		
		if ( ((itemNum = ItemNumFromItemPtr(theMenu, (Ptr) StripAddress(pItemEntry))) > APPLICATION_MENU_COUNT) 
			&& ((pProc = PEntryFromApplicationMenuItem(itemNum)) != nil) )
			{
			theStorage->auxMenuIconHandle = pProc->iconCacheHdl;
			theStorage->auxMenuIconSize = familyIconCmd;
			theStorage->auxMenuIconGray = (((LayerPeek) (pProc->p_layer))->visible == false);
			theStorage->auxMenuScript = pProc->p_nameScript;
			theStorage->auxMenuHelpString = nil;
			}
		}

	/* Is this the Keyboard menu? */
	else if ((*theMenu)->menuID == kScriptMenuID)
		{
		retval = SetKbdMenuInfo(theMenu, ItemNumFromItemPtr(theMenu, (Ptr) StripAddress(pItemEntry)), theStorage);
		}

	/* Is this an Apple menu?  Avoid longer check if the menu title is an AppleMark.
	 * NOTE: This also fixes an app that calls _AddResMenu('DRVR'), then copies that
	 * menu to another one.  This happens with SuperCard.
	 */
	else if ( (HAS_APPLE_TITLE(theMenu)) ||
		(InHList(pCurrentProcess->p_applemenuhlisthdl, (HListElem) theMenu) == noErr) )
		{	
		/* Item name is first thing in an entry */
		pItemName = (StringPtr) pItemEntry;
	
		/* Is item one that as added by AddAppleMenuItem? */
		if ((elemHdl = StringToAppleItemHdl(pItemName)) != nil)
			{
			elemPtr = *elemHdl;
			theStorage->auxMenuIconSize = ((theStorage->auxMenuIconHandle = elemPtr->aiIcon) != nil)
				? familyIconCmd : 0;
			theStorage->auxMenuIconGray = false;
			theStorage->auxMenuScript = elemPtr->aiScript;
			theStorage->auxMenuHelpString = elemPtr->aiHelpString;
			}
		
		/* Is it a DA from the System file? */
		else if (IS_DA_NAME(pItemName))
			{
			theStorage->auxMenuIconHandle = hGenericDAIconSuite;
			theStorage->auxMenuIconSize = familyIconCmd;
			theStorage->auxMenuIconGray = false;
			theStorage->auxMenuScript = iuSystemScript;
			theStorage->auxMenuHelpString = nil;
			}
		}
	else
		retval = noTypeErr;
		
	A5SimpleRestore(olda5);
	return (retval);
	}

/* -----------------------------------------------------------------------------
 *
 *								Apple menu control.
 *
 * -----------------------------------------------------------------------------*/

#pragma segment INIT

/* InitAppleMenuList.  Initialize Apple menu list, a tough job for anyone.
 * NOTE: assumes a5 == PROCESSMGRGLOBALS, THEZONE == ProcessMgrZone
 */
void
InitAppleMenuList(void)
	{	
	/* initialize list of Apple menu items */
	FirstAppleItem = nil;
	}	

#pragma segment kernel_segment

/* InsertCustomItem.  Insert custom item into menu. */
void
InsertCustomItem(MenuHandle menuHdl, short insertAfter, AppleItemHdl hDesc)
	{
	unsigned short		emptyName = ONE_CHAR_STRING(' ');
	Style				theStyle;
	char				theMark;

	InsMenuItem(menuHdl, (StringPtr) &emptyName, insertAfter++);
	SetItem(menuHdl, insertAfter, &(*hDesc)->aiNameStorage);
	
	if ((theStyle = (*hDesc)->aiStyle) != (Style) 0)
		SetItemStyle(menuHdl, insertAfter, theStyle);
	
	if ((theMark = (*hDesc)->aiMark) != noMark)
		SetItemMark(menuHdl, insertAfter, theMark);
	}

/* InsertCustomItemSorted.  Insert item in (alphabetical) DA portion of Apple menu.
 * Hard part is determining which item number to use.  Can move or purge memory.
 */
void
InsertCustomItemSorted(MenuHandle menuHdl)
	{
	short			item;
	unsigned long	str2Divider;
	Ptr				posInMenu, pPrevItem;
	StringPtr		pDAName, pAMIName;
	AppleItemHdl	aiHdl;
	ScriptCode		daScript;

	/* Can't do it if there's no menu */
	if (menuHdl == nil)
		return;

	/* iterate through menu items to find the first of our items, if any, after app items */
	posInMenu = (Ptr) &((*menuHdl)->menuData);
	posInMenu += Length(posInMenu) + 1;
	pPrevItem = nil;
	item = 1;
	while (IS_NOT_LAST_MENUITEM(posInMenu))
		{
		if (IS_ADDED_OR_DA_NAME(((StringPtr) posInMenu)))
			break;
		
		pPrevItem = posInMenu;
		INC_MENU_ITEMPTR(posInMenu);
		item += 1;
		}
	
	/* Insert dashed line if there isn't one */
	if ((pPrevItem == nil) || (IS_DASH_STRING(pPrevItem) == false))
		{
		str2Divider = TWO_CHAR_STRING('(','-');
		InsMenuItem(menuHdl, (StringPtr) &str2Divider, item);
		posInMenu = MenuItemAddress(menuHdl, item);
		INC_MENU_ITEMPTR(posInMenu);
		}
	
	/* Item now at preexisting dashed line, search for insertion point.  Ignore the
	 * leading NULL found at the beginning of an actual DA name.  This keeps things
	 * ordered properly regardless of whether the installer of the new item was savvy
	 * about DA names or has mixed and matched names himself.
	 */
	else
		{
		HLock(hAppleItemShare);
		pAMIName = StripLeadingNulls(&(*hAppleItemShare)->aiNameStorage);

		while (IS_NOT_LAST_MENUITEM(posInMenu))
			{		
			short		compResult;
			
			/* Get script code of this item */
			daScript = ((aiHdl = StringToAppleItemHdl(posInMenu)) != nil) ? (*aiHdl)->aiScript : iuSystemScript;
			
			/* Ignore leading NULLs */
			pDAName = StripLeadingNulls(posInMenu);
	
			/* Compare! */
			compResult = MyIUTextOrder(pAMIName, pDAName, (*hAppleItemShare)->aiScript, daScript);
		
			/* Restore NULL (it was replaced by a length byte) */
			if (pDAName != posInMenu)
				Length(pDAName) = NULL;
			
			if (compResult < sortsEqual)
				break;
				
			/* Stay up to date */
			++item;
			INC_MENU_ITEMPTR(posInMenu);
			}
		
		/* Restore NULL (it was replaced by a length byte) */
		Length(pAMIName) = NULL;
		HUnlock(hAppleItemShare);
		
		/* item now after insertion point or off the end, so back off by one */
		--item;
		}

	/* Insert the item (finally!) */
	InsertCustomItem(menuHdl, item, hAppleItemShare);
	}

/* c_AddAppleMenuItem.  Trap that adds a speciality item to the Apple menu. */
pascal OSErr
c_AddAppleMenuItem(StringPtr itemName, ScriptCode itemScript, short itemStyle, Handle itemIcon, short itemMark, StringPtr itemHelpString, unsigned long itemRefCon)
	{
	long					olda5;
	THz						currZone = nil;
	AppleItemPtr			stackItemPtr;
	register AppleItemPtr	itemPtr;
	AppleItemHdl			itemHdl, elemHdl, compHdl;
	StringHandle			hHelpString;
	unsigned short			numNulls;
	short					compResult;
	short					retval;
	Str255					tempString;

	/* eliminate bozos */
	if (itemName == nil || Length(itemName) == 0 || itemRefCon == DELETE_ALL_ITEMS)
		return (paramErr);
	
	/* requisite set up */
	olda5 = ProcessMgrA5Setup();
	assert(THEZONE != ProcessMgrZone);
	
	/* remove existing duplicate item, ignore error (no find) */
	(void) DeleteAppleItem(pCurrentProcess, itemRefCon);

	/* Make sure item starts with at least two NULLs */
	*((long *) &tempString) = TWO_CHAR_STRING(NULL, NULL);
	Length(&tempString) = Length(itemName);
	numNulls = 2;
	while ((unsigned short) (Length(&tempString) + numNulls) > 255)
		numNulls -= 1;
	Length(&tempString) += numNulls;
	
	BlockMove(&StringByte(itemName, 0), &StringByte(&tempString, numNulls), Length(itemName));

	stackItemPtr = &FirstAppleItem;
	elemHdl = &stackItemPtr;
	while ((compHdl = (*elemHdl)->aiNext) != nil)
		{
		if ( (compResult = MyIUTextOrder(&tempString, &(*compHdl)->aiNameStorage, itemScript, (*compHdl)->aiScript)) < sortsEqual )
			break;

		if (compResult == sortsEqual)
			{
			A5Restore(olda5);
			return (protocolErr);
			}
			
		elemHdl = compHdl;
		}

	/* Allocate descriptors from our own heap
	 * NOTE: Assumes THEZONE != ProcessMgrZone, in that it restores THEZONE unconditionally,
	 * instead of using SafeSetZone and RestoreZone.
	 */
	currZone = THEZONE;
	THEZONE = ProcessMgrZone;
		
	/* allocate a new descriptor */
	if ((itemHdl = NewHandle(sizeof(AppleItem)+Length(&tempString)+1)) == nil)
		goto memError2;
		
	/* Copy help string to our heap */
	hHelpString = nil;
	if ((itemHelpString != nil) && ((hHelpString = NewString(itemHelpString)) == nil))
		goto memError1;
	
	/* fill in the descriptor */
	itemPtr = *itemHdl;
	BlockMove(&tempString, &itemPtr->aiNameStorage, Length(&tempString)+1);
	itemPtr->aiScript = itemScript;
	itemPtr->aiStyle = itemStyle;
	itemPtr->aiIcon = itemIcon;
	itemPtr->aiMark = (char) itemMark;
	itemPtr->aiHelpString = hHelpString;
	itemPtr->aiRefCon = itemRefCon;
	itemPtr->aiProcess = pCurrentProcess;
	
	/* Link the new element into the existing list at previously determined location.
	 * elemHdl refers to the element before the place for the new one, or to the
	 * list head itself.  We treat these cases equivalently because the link field
	 * is in the 0th position.
	 */
	itemPtr->aiNext = (*elemHdl)->aiNext;
	(*elemHdl)->aiNext = itemHdl;
	
	/* Now that all the red tape is out of the way, actually make the item appear
	 * in everyone's Apple menus (including current app).  We make sure to restore
	 * THEZONE beforehand, because MyIUTextOrder can load sysHeap resources.
	 */
	THEZONE = currZone;
	hAppleItemShare = itemHdl;
	ApplyToAllAppleMenus(InsertCustomItemSorted);
	
	/* clean up and leave */
	A5Restore(olda5);
	return (noErr);
	
	/* Combine error recovery so we don't have to duplicate code.
	 * NOTE: This would be less tacky if done with exception handling instead of GOTOs.
	 */
memError1:
	DisposHandle(itemHdl);
memError2:
	retval = memFullErr;
	THEZONE = currZone;
	A5Restore(olda5);
	return (retval);
	}

/* DeleteCustomItemFromMenu.  Remove custom item from given menu.  If it is the
 * last item in the DA/Dustom section, remove the dashed line at the beginning
 * of that (now empty) section.
 */
void
DeleteCustomItemFromMenu(MenuHandle menuHdl)
	{
	register short		itemNum;
	Boolean				dumpTheDash;
	Ptr					itemPtr;
	
	/* Find the number of the item in this menu */
	if ((itemNum = MenuSelectionGivenName(menuHdl, &((*hAppleItemShare)->aiNameStorage))) == 0)
		return;
	
	/* Dump the item */
	DelMenuItem(menuHdl, itemNum);
	
	/* See if we should dump the dash */
	itemPtr = MenuItemAddress(menuHdl, --itemNum);
	if ( (itemPtr == nil) || (IS_DASH_STRING(itemPtr) == false) )
		return;

	/* Item before is a dash.  Is item after a dash or the end of menu? */
	INC_MENU_ITEMPTR(itemPtr)
	dumpTheDash = ( (IS_LAST_MENUITEM(itemPtr)) || (IS_DASH_STRING(itemPtr)) );
		
	if (dumpTheDash)
		DelMenuItem(menuHdl, itemNum);
	}

/* DeleteCustomItem.  Removes specified item from all Apple menus. */
void
DeleteCustomItem(AppleItemHdl targetHdl)
	{
	PEntryPtr		pProc;
	
	if (Colorized)
		(*pCurrentProcess->p_pcb)->menucinfo = MENUCINFO;
	
	/* loop through all processes to remove menu item from all Apple menus */
	hAppleItemShare = targetHdl;
	pProc = pAppleMenuProcessList;
	while (pProc != nil)
		{		
		/* Can't do menu operations unless correct lomem in place */
		if (Colorized)
			MENUCINFO = (*pProc->p_pcb)->menucinfo;
			
		/* Get all Apple menus */
		if (HListExists(pProc->p_applemenuhlisthdl))	
			ApplyToHListElems(pProc->p_applemenuhlisthdl, &DeleteCustomItemFromMenu);
		
		pProc = pProc->nextAppleMenuProc;
		}

	if (Colorized)
		MENUCINFO = (*pCurrentProcess->p_pcb)->menucinfo;
	}

/* DeleteAppleItem.  Do the work of speciality item removal.  If the refcon is
 * DELETE_ALL_ITEMS, we delete all AppleItems that were made by the given process.
 * Assumes a5 == PROCESSMGRGLOBALS
 */
OSErr
DeleteAppleItem(PEntryPtr pProc, long itemRefCon)
	{
	AppleItemPtr	targetPtr, elemPtr;
	AppleItemHdl	targetHdl, elemHdl;
	Handle			hdl;
	Boolean			deleteAll = (itemRefCon == DELETE_ALL_ITEMS);
	THz				currZone;
	OSErr			retVal = noErr;
	
	/* Switch to our zone for disposes */
	SafeSetZone(currZone, ProcessMgrZone);

	/* major loop -- do each menu item */
	elemPtr = &FirstAppleItem;
	elemHdl = &elemPtr;
	do
		{
		/* minor loop -- locate specified item in registry */
		while ((targetHdl = (*elemHdl)->aiNext) != nil)
			{
			targetPtr = *targetHdl;
			if ((targetPtr->aiProcess == pProc)
				&& (deleteAll || targetPtr->aiRefCon == itemRefCon))
				break;
			elemHdl = targetHdl;
			}
		
		/* no find means we're done, give error if specific delete requested */
		if (targetHdl == nil)
			{
			if (deleteAll == false)
				retVal = paramErr;
			break;
			}
		
		/* Delink the target.  elemHdl refers to the element before the target, or
		 * to the list head itself.  We delink these cases equivalently because the
		 * descriptor link field is in the 0th position.
		 */
		(*elemHdl)->aiNext = targetPtr->aiNext;
	
		/* Remove item from everyone's Apple menu */
		DeleteCustomItem(targetHdl);

		/* Dispose the storage we'd used */
		if ((hdl = (*targetHdl)->aiHelpString) != nil)
			DisposHandle(hdl);
		if ((hdl = (*targetHdl)->aiIcon) != nil)
			(void) DisposeIconSuite(hdl, true);
		DisposHandle(targetHdl);
		}
	while (deleteAll);

	/* Restore the zone */
	SafeRestoreZone(currZone);
	return(retVal);
	}

/* c_DeleteAppleMenuItem.  Trap that removes from the Apple menu one or all speciality
 * item(s) associated with the current process.  A refcon of DELETE_ALL_ITEMS means "all".
 */
pascal OSErr
c_DeleteAppleMenuItem(long itemRefCon)
	{
	long	olda5;
	short	retVal;

	olda5 = ProcessMgrA5Setup();
	retVal = DeleteAppleItem(pCurrentProcess, itemRefCon);
	A5Restore(olda5);
	return (retVal);
	}

/* Message format for aeAppleMenuItemSelect we send */
typedef struct AppleMenuSelectMsg {
	AETFHeader				messageHeader;
	KeyWord					metaDataMark;
	AETFParameter			amsHdr;
	unsigned long			amsRefCon;
} AppleMenuSelectMsg;

/* SendAppleMenuSelectMsg.  Send an AppleEvent for Apple menu item selection to the
 * application that installed the item.
 */
void
SendAppleMenuSelectMsg(AppleItemHdl chosenOne)
	{
	HighLevelEventRecord	theEvent;
	ProcessSerialNumber		receiverPSN;
	AppleMenuSelectMsg		msgStorage;
	OSErr					result;

	/* Set up params.  Refcon is copied to the stack for use as message body,
	 * so we don't have to lock the item descriptor.
	 */
	receiverPSN = ((*chosenOne)->aiProcess)->p_serialNumber;

	SetAppleEvent(aeAppleMenuItemSelect, &theEvent);
	GenericAEMessage(&msgStorage.messageHeader);
	msgStorage.metaDataMark = aeEndOfMetaDataKeyword;
	SetAEParmHeader(&msgStorage.amsHdr, aeAppleMenuItemKeyword, aeLongintParamType, sizeof(long));
	msgStorage.amsRefCon = ((*chosenOne)->aiRefCon);
	
	/* Post the event */
	(void) BeginSystemMode();
	result = PostHighLevelEvent((EventRecord *) &theEvent, (u_long) &receiverPSN, 0, &msgStorage, sizeof(AppleMenuSelectMsg), receiverIDisPSN);
	(void) EndSystemMode();
	assert(result == noErr);
	}

/* AppleMenuCleanup.  Deal with death of pProc as it relates to the Apple Menu. */
void
AppleMenuCleanup(PEntryPtr pProc)
	{
	register PEntryPtr	pPrev, pCurr;

	/* Remove this process from list of processes with Apple Menus */
	pPrev = pNullProcess;
	pCurr = pAppleMenuProcessList;
	while (pCurr != nil)
		{
		if (pCurr == pProc)
			{
			pPrev->nextAppleMenuProc = pProc->nextAppleMenuProc;
			break;
			}
		
		pPrev = pCurr;
		pCurr = pCurr->nextAppleMenuProc;
		}
	
	/* Remove any items added by this process */
	(void) DeleteAppleItem(pProc, DELETE_ALL_ITEMS);
	}

/* -----------------------------------------------------------------------------
 *
 *							Application Menu
 *
 * -----------------------------------------------------------------------------*/

pascal void HMInitHelpMenu(void)
		= {0x303C, 0xFFFD, 0xA830};
/*	move.w	xx, d0
 * 	_Pack14
 */

#pragma segment INIT
/* InitSystemMenus.  Install the system menus in the right-hand end of the menu bar. */
void
InitSystemMenus(void)
	{
	register MenuHandle		menuHdl;
	Str255					itemText;

	/* Reach an understanding with the Menu Mgr */
	InitMenus();
	
	/* Set up the Apple menus list */
	InitAppleMenuList();

	/* Let the Help Mgr install the Help menu */
	HMInitHelpMenu();

	/* Let international install the Keyboard menu */
	(void) InitKeybdMenu();
	
	/* Get process list menu */
	if ((ApplicationMenuHdl = menuHdl = GetResource('MENU', kApplicationMenuID)) == nil)
		{
		assert(RESERR == memFullErr);
		SysError(dsMemFullErr);
		}

	/* Ensure the standard mdefproc */
	(*menuHdl)->menuProc = standardMenuDefProcRsrc;
	
	/* Get menu item string for hiding current application */
	GetItem(menuHdl, HIDE_APP_ITEM, &itemText);
	hHideCurrent = NewString(itemText);
	
	/* Place it in the bar as the far right-hand (system) menu */
	InsertMenu(menuHdl, 0);
	
	/* Set up the suites for the generic icons (we only ever need small icons) */
	SetResLoad(false);
	(void) GetIconSuite(&hGenericAppIconSuite, genericApplicationIconResource, svAllSmallData);
	(void) GetIconSuite(&hGenericDAIconSuite, genericDeskAccessoryIconResource, svAllSmallData);
	SetResLoad(true);
	}
	
#pragma segment Main

/* FlushIcon.  Dispose the icon, and nil its holder in the cache. */
pascal OSErr
FlushIcon(ResType theType, Handle *theIcon, void *myDataPtr)
	{
#pragma unused (theType, myDataPtr)
	register Handle		localHandle;
	
	if ((localHandle = *theIcon) != nil)
		{
		*theIcon = nil;
		DisposHandle(localHandle);
		}
		
	return(noErr);
	}

/* GetProcessIcon. Switch to process' application file in its resource chain to fetch
 * an icon.  This routine is called by the icon cache utilities when an icon of a new
 * depth is needed.  We only deal with one depth at a time (since our icons are displayed
 * only on the main screen), so we can flush any earlier non-1 bit data.
 */
pascal Handle
GetProcessIcon(ResType theType, long refCon)
	{
	PEntryPtr		pProc;
	PCB				*pPCB;
	THz				saveZone;
	short			saveFile;
	Handle			saveTopMap;
	Boolean			lomemNotHis;
	Handle			retHdl;
	unsigned long	olda5;
	
	/* make mini-swap if the process does not have it's info in lomem */
	olda5 = ProcessMgrA5SimpleSetup();
	pProc = (PEntryPtr) refCon;
	pPCB = *(pProc->p_pcb);
	if (lomemNotHis = (pProc != pCurrentProcess))
		{
		saveTopMap = TOPMAPHANDLE;
		TOPMAPHANDLE = pPCB->topmaphandle;
		}

	saveFile = CURMAP;
 	CURMAP = pPCB->p_fileRefNum;
	SafeSetZone(saveZone, pProc->p_zone);
	
	if ((retHdl = GetResource(theType, pProc->iconResourceID)) != nil)
		if (HandToHand(&retHdl) != noErr)
			retHdl = nil;

	/* Dump all non-B&W data */
	(void) ForEachIconDo(pProc->iconCacheHdl, (svAllAvailableData ^ svAll1BitData), &FlushIcon, (void *) nil);

	/* restore lomem if we changed it */
	CURMAP = saveFile;
	SafeRestoreZone(saveZone);
	if (lomemNotHis)
		TOPMAPHANDLE = saveTopMap;
	
	A5SimpleRestore(olda5);
	return(retHdl);
	}
 
/* ChangeIconicTitle.  Changes the title icon to the specified one.  The title must
 * already be exactly five characters in length.
 */
void
ChangeIconicTitle(MenuHandle menuHdl, Handle theCacheHandle)
	{
	register Ptr		pChar;
	
	pChar = &(StringByte(&((*menuHdl)->menuData), 0));
	*pChar = 1;
	*((long *) (++pChar)) = theCacheHandle;
	}

/* AdjustApplicationMenu.  Routine to ensure that the Application Menu items are set
 * correctly for the front application (or the specified one).  The PEntry specification
 * is needed during layer switching because we want to set up the menu and draw the
 * menu bar BEFORE bringing the layer forward.
 * NOTE: This is a pretty brute force kinda' routine.
 */
void
AdjustApplicationMenu(PEntryPtr pTitleProc)
	{	
	register MenuHandle		menuHdl;
	register Ptr			pMenuData;
	register PEntryPtr		pProc;
	Boolean					showAll, showHideSome;
	short					checkItemNum;
	short					toDo;

	/* Cache menu handle in a register */
	menuHdl = ApplicationMenuHdl;
	
	if (pTitleProc == nil)
		pTitleProc = LayerOwner(GetFrontAppLayer());

	/* Set the title to be the application's icon 
	 * NOTE: This will be nil if pTitleProc has not yet called InitWindows.
	 */
	ChangeIconicTitle(menuHdl, pTitleProc->iconCacheHdl);
	
	/* Get out now if this application has no corresponding item in the app menu
	 * (we don't need to mark it, since the app can not yet call DrawMenuBar).
	 */
	if (pTitleProc->p_layer == nil)
		return;
	
	/* Ensure hiding item has the front (or soon to be front) application's name */
	SetItem(menuHdl, HIDE_APP_ITEM, *(pTitleProc->p_hideCurrentStr));

	/* Figure out which show/hide items are appropriate */
	showAll = showHideSome = false;
	pProc = pApplicationMenuProcessList;
	while ( (pProc != nil) && ((showAll == false) || (showHideSome == false)) )
		{
		if (pProc != pTitleProc)
			{
			if (((LayerPeek) (pProc->p_layer))->visible)
				showHideSome = true;
			else
				showAll = true;
			}
		
		pProc = pProc->nextApplicationMenuProc;
		}

	/* Enable HIDE_APP_ITEM and HIDE_OTHERS_ITEM iff there are other visible layers */
	if (showHideSome)
		{
		EnableItem(menuHdl, HIDE_APP_ITEM);
		EnableItem(menuHdl, HIDE_OTHERS_ITEM);
		}
	else
		{
		DisableItem(menuHdl, HIDE_APP_ITEM);
		DisableItem(menuHdl, HIDE_OTHERS_ITEM);
		}

	/* Enable SHOW_ALL_ITEM iff there are other invisible layers */
	if (showAll)
		EnableItem(menuHdl, SHOW_ALL_ITEM);
	else
		DisableItem(menuHdl, SHOW_ALL_ITEM);

	/* Move check mark from old to new place */
	pMenuData = MenuItemAddress(menuHdl, APPLICATION_MENU_COUNT+1);
	assert(pMenuData != nil);
	checkItemNum = ApplicationMenuItemFromPEntry(pTitleProc) - APPLICATION_MENU_COUNT;
	toDo = 2;	
	while ((IS_NOT_LAST_MENUITEM(pMenuData)) && (toDo > 0))
		{
		SKIP_TO_MENU_ATTRIBUTES(pMenuData);
		if (((MenuItemAttributes *) pMenuData)->itemMark == checkMark)
			{
			((MenuItemAttributes *) pMenuData)->itemMark = noMark;
			toDo -= 1;
			}
		
		if (--checkItemNum == 0)
			{
			((MenuItemAttributes *) pMenuData)->itemMark = checkMark;
			toDo -= 1;
			}
			
		FROM_MENU_ATTRIBUTES_TO_NEXT_ITEM(pMenuData);
		}
	}
	
/* GetProcessIconCache.  Set the iconCacheHdl.  Set iconResourceID so GetProcessIcon can
 * get the correct resource when it's called by the cache plotter.
 */
void
GetProcessIconCache(PEntryPtr pProc)
	{
	register short	iconID;
	register short	saveFile;
	Handle			hCache;

	/* No need for icons of BG-only app, since only facefull apps are shown in the
	 * Application Menu title and application list menu items.
	 */
	if ((pProc->p_taskmode & modeOnlyBackground) != 0)
		return;
	
	/* Determine ID of icon family for this application or DA.  iconResourceID may have
	 * already been set from the Finder information about the file.
	 */
	if ((iconID = pProc->iconResourceID) == 0)
		{
		saveFile = CURMAP;
		if ((CURMAP = (*pProc->p_pcb)->p_fileRefNum) != SYSMAP)
			iconID = GetIconIDFromBundle(pProc->p_type, pProc->p_signature);
		CURMAP = saveFile;
		}

	/* Use default if there is no special ID, or the special cache can not be made */
	if ((iconID == 0) || (MakeIconCache(&hCache, &GetProcessIcon, (void *) pProc) != noErr) )
		{
		iconID = 0;
		hCache = ((pProc->p_taskmode & modeDeskAccessory) == 0)
			? hGenericAppIconSuite : hGenericDAIconSuite;
		}
	
	/* Use the cache handle we nabbed */
	pProc->iconResourceID = iconID;
	pProc->iconCacheHdl = hCache;
	}

/* MakeHidingString.  Allocate the p_hideCurrentStr for the specified process.
 * NOTE: Assumes that hHideCurrent is not in the current heap, since hHideCurrent
 * does not get locked across call to NewMungedString.
 */
OSErr
MakeHidingString(PEntryPtr pProc, StringPtr pName)
	{
	/* Don't bother if the application is a type that is not put in the menu */
	if ((pProc->p_taskmode & modeOnlyBackground) != 0)
		return(noErr);

	/* Make the string for application hiding Application Menu item */
	return ((pProc->p_hideCurrentStr = NewMungedString(pName, *hHideCurrent)) != nil) ? noErr : appMemFullErr;
	}
	
/* InsertAppInApplicationMenu.  Add current app name to right-hand menu.  This can not be
 * called without a reasonable menu world (i.e. current process had to InitMenus).
 * Should not be called during Launch, since launcher might be BG-only.
 * NOTE: You'll see that, in the case of duplicate names, the new app will go at
 * the end of the section of duplicates.  This is a *little* extra effort for us,
 * but is a) a minor nicety for the user (i.e. it makes sense to go at the end), and
 * b) the Notification Mgr relies on it to find the application name in the menu (it
 * assumes that duplicates are in ascending order of PSN).
 */
void
InsertAppInApplicationMenu(void)
	{
	register PEntryPtr		pCurr, pPrev;
	register MenuHandle		menuHdl;
	StringPtr				pCurApName, pThisAppName;
	short					insertAfter;
	unsigned short			emptyName = ONE_CHAR_STRING(' ');
	Str63					thisAppName;
		
	/* Find insertion point */
	pPrev = pNullProcess;
	pCurr = pApplicationMenuProcessList;
	insertAfter = APPLICATION_MENU_COUNT;
	pCurApName = StripLeadingNulls(CURAPNAME);
	while (pCurr != nil)
		{
		pThisAppName = &(*(pCurr->p_pcb))->curapname;
		BlockMove(pThisAppName, &thisAppName, Length(pThisAppName)+1);
		pThisAppName = StripLeadingNulls(&thisAppName);
		if (MyIUTextOrder(pCurApName, pThisAppName, pCurrentProcess->p_nameScript, pCurr->p_nameScript) < sortsEqual)
			break;
			
		insertAfter += 1;
		pPrev = pCurr;
		pCurr = pCurr->nextApplicationMenuProc;
		};
		
	/* Restore NULL (it was replaced by a length byte) */
	if (pCurApName != CURAPNAME)
		Length(pCurApName) = NULL;
	
	/* Two-step to avoid meta-character evaluation */
	menuHdl = ApplicationMenuHdl;
	InsMenuItem(menuHdl,(StringPtr) &emptyName, insertAfter);
	SetItem(menuHdl, ++insertAfter, CURAPNAME);
	
	/* Add to list now that position in menu is assured. */
	pCurrentProcess->nextApplicationMenuProc = pPrev->nextApplicationMenuProc;
	pPrev->nextApplicationMenuProc = pCurrentProcess;
	}

/* DeleteAppFromApplicationMenu.  Delete app name from right-hand menu.  This can not be
 * called without a reasonable menu world (i.e. current process had to InitMenus).
 */
void
DeleteAppFromApplicationMenu(PEntryPtr pProc)
	{
	register PEntryPtr		pPrev, pCurr;
	unsigned short			itemNum;
	
	if ((pProc->p_taskmode & modeOnlyBackground) != 0)
		return;
	
	/* Remove this process from list of processes with Apple Menus */
	pPrev = pNullProcess;
	pCurr = pApplicationMenuProcessList;
	itemNum = APPLICATION_MENU_COUNT + 1;
	while (pCurr != nil)
		{
		/* Remove the menu item */
		if (pCurr == pProc)
			{
			pPrev->nextApplicationMenuProc = pProc->nextApplicationMenuProc;
			DelMenuItem(ApplicationMenuHdl, itemNum); 
			break;
			}
		
		++itemNum;
		pPrev = pCurr;
		pCurr = pCurr->nextApplicationMenuProc;
		}
	}

/* PEntryFromApplicationMenuItem.  Locate process corresponding to the given item in the
 * Application Menu.
 */
PEntryPtr
PEntryFromApplicationMenuItem(short itemNum)
	{
	PEntryPtr			pProc;
	
	itemNum -= APPLICATION_MENU_COUNT;
	pProc = pApplicationMenuProcessList;
	while (--itemNum > 0)
		{
		assert(pProc != nil);
		pProc = pProc->nextApplicationMenuProc;
		}
		
	return(pProc);
	}

/* ApplicationMenuItemFromPEntry.  Return the index of the Application Menu item naming
 * the specified process.
 * NOTE: This will be an infinite loop if the PEntry is not in the nextApplicationMenuProc list.
 */
unsigned short
ApplicationMenuItemFromPEntry(PEntryPtr pProc)
	{
	unsigned short		itemNum;
	PEntryPtr			pCurr;
	
	itemNum = APPLICATION_MENU_COUNT + 1;
	pCurr = pApplicationMenuProcessList;
	while (pCurr != pProc)
		{
		pCurr = pCurr->nextApplicationMenuProc;
		++itemNum;
		}
		
	return(itemNum);
	}

/* -----------------------------------------------------------------------------
 *
 *								External utilities.
 *
 * -----------------------------------------------------------------------------*/
	
#pragma segment Main

/* GetApplicationMenuLeftCoord.  Return the point representing the lower lefthand
 * corner of the Proces menu title.
 * NOTE: The vertical offset is taken directly from MBARHEIGHT.  Be aware that
 * someone may have zeroed it.
 */
Point
GetApplicationMenuLeftCoord(void)
	{
	Point					appleMenuLeftCoord;
	register MenuPair		*pMenuPair;
	register MenuListPtr	pMenuList;
	
	appleMenuLeftCoord.h = 0;
	appleMenuLeftCoord.v = MBARHEIGHT;

	pMenuList = (MenuListPtr) StripAddress(*MENULIST);
	pMenuPair = (Ptr) pMenuList + pMenuList->lastMenu;
	while (pMenuPair >= &(pMenuList->menuPairs[0]))
		{
		if (StripAddress(pMenuPair->menuHdl) == ApplicationMenuHdl)
			{
			appleMenuLeftCoord.h = pMenuPair->leftEdge;
			break;
			}
		--pMenuPair;
		}

	return (appleMenuLeftCoord);
	}

/* RemoveFromAppleMenuList.  Check if this handle is a menu handle in the Apple menu
 * list of the current task.  If so, remove him from the list.  Called by patch to
 * ReleaseResource so we don't continue to operate on bad handle.
 * NOTE: Can't just make this a _Munger call because no way to guarantee that the match
 * is made on sizeof(Handle) boundaries (need a step param for _Munger).
 */
void
RemoveFromAppleMenuList(Handle hdl)
	{
	HListHdl		appleMenuListHdl;

	appleMenuListHdl = pCurrentProcess->p_applemenuhlisthdl;
	if (HListExists(appleMenuListHdl))
		RemoveFromHList(appleMenuListHdl, (HListElem) hdl);
	}