ResKnife/Carbon/Classes/Application.cpp

#include "Application.h"
#include "Asynchronous.h"	// for initing, idling, and disposing
#include "Errors.h"
#include "Files.h"			// for open & save etc.
#include "FileWindow.h"		// no particuar reason
#include "ResourceObject.h"
#include "Utility.h"

// set up prefs and globals
globals g;
prefs p;

/*** MAIN ***/
int main(int argc, char* argv[])
{
	#pragma unused(argc, argv)
	
	// get system version
	OSStatus error = Gestalt(gestaltSystemVersion, &g.systemVersion);		// this loads HIToolbox.framework on OS X
	if(error) return error;
	
	// initalise application
	error = InitToolbox();
	if(error) return error;
	error = InitMenubar();
	if(error) return error;
	error = InitAppleEvents();
	if(error) return error;
	error = InitCarbonEvents();
	if(error) return error;
	error = InitGlobals();
	if(error) return error;
			InitCursor();
	
	// check system version is at least 7.1
	if(g.systemVersion < kMacOS71)
	{
		DisplayError(kStringOSNotGoodEnough, kExplanationOSNotGoodEnough);
		QuitResKnife();
	}
	
#if TARGET_API_MAC_CARBON
	// check carbon version is at least 1.1
	error = Gestalt(gestaltCarbonVersion, &g.carbonVersion);
	if(g.carbonVersion < kCarbonLib11 || error)
	{
		DisplayError(kStringMinimumCarbonLib, kExplanationMinimumCarbonLib);
		QuitResKnife();
	}
	else if(g.carbonVersion < kCarbonLib131)
	{
		DisplayError(kStringRecommendedCarbonLib, kExplanationRecommendedCarbonLib);
	}
#endif
	
#if __profile__
	error = ProfilerInit(collectDetailed, bestTimeBase, 400, 40);
	if(error) DebugStr("\pProfiler initalisation failed");		// profiler failed
#endif

#if TARGET_API_MAC_CARBON
	// run event loop
	RunApplicationEventLoop();
#else
	EventRecord theEvent;
	while(!g.quitting)
	{
		WaitNextEvent(everyEvent, &theEvent, 20, null);
		if(IsDialogEvent(&theEvent))
			ParseDialogEvents(null, &theEvent, null);
		else ParseEvents(&theEvent);
	}
#endif
	
#if __profile__
	ProfilerDump("\pResKnife profile");
	ProfilerTerm();
#endif

#if !TARGET_API_MAC_CARBON
	QuitResKnife();
#endif

	return error;
}

/*** INIT TOOLBOX ***/
OSStatus InitToolbox(void)
{
#if !TARGET_API_MAC_CARBON
	InitGraf(&qd.thePort);
	InitFonts();
	FlushEvents(everyEvent, 0);
	InitWindows();
	InitMenus();
	TEInit();
	InitDialogs(0L);
#endif
	return noErr;
}

/*** INITALIZE MENUBAR ***/
OSStatus InitMenubar(void)
{
	OSStatus error = noErr;
	
#if USE_NIBS
	IBNibRef nibRef = null;
	
	// create a nib reference (only searches the application bundle)
	error = CreateNibReference(CFSTR("ResKnife"), &nibRef);
	if(error != noErr)
	{
		DisplayError("\pThe nib file reference could not be obtained.");
		return error;
	}
	
	// get menu bar
	error = SetMenuBarFromNib(nibRef, CFSTR("Menubar"));
	if(error != noErr)
	{
		DisplayError("\pMenus could not be obtained from nib file.");
		return error;
	}
	
	// dispose of nib ref
	DisposeNibReference(nibRef);
	
#else	/* ! USE_NIBS */
	
	Handle menuList = GetNewMBar(kClassicMenuBar);
	SetMenuBar(menuList);
	ReleaseResource(menuList);
	
	// delete quit and prefs on OS X
	long result;
	error = Gestalt(gestaltMenuMgrAttr, &result);
	if(!error && (result & gestaltMenuMgrAquaLayoutMask))
	{
		MenuRef fileMenu = GetMenuRef(kFileMenu);
		MenuRef editMenu = GetMenuRef(kEditMenu);
		DeleteMenuItem(fileMenu, kFileMenuQuitItem);
		DeleteMenuItem(fileMenu, kFileMenuQuitItem -1);
		DeleteMenuItem(editMenu, kEditMenuPreferencesItem);
		DeleteMenuItem(editMenu, kEditMenuPreferencesItem -1);
	}
	
	// set delete item character to the delete glyph
	MenuRef editMenu = GetMenuRef(kEditMenu);
	SetMenuItemKeyGlyph(editMenu, kEditMenuClearItem, kMenuDeleteLeftGlyph);
	
#if TARGET_API_MAC_CARBON
	MenuRef windowMenu;
	CreateStandardWindowMenu(0, &windowMenu);
	InsertMenu(windowMenu, kWindowMenu);
#else
	AppendResMenu(GetMenuRef(kAppleMenu), 'DRVR');
#endif	/* TARGET_CARBON */
	DrawMenuBar();
	
#endif	/* USE_NIBS */
	
	return error;
}

/*** INIT APPLE EVENTS ***/
OSStatus InitAppleEvents(void)
{
	AEEventHandlerUPP appleEventParser = NewAEEventHandlerUPP(ParseAppleEvents);
	AEInstallEventHandler(kCoreEventClass, kAEOpenApplication,   appleEventParser, 0, false);
	AEInstallEventHandler(kCoreEventClass, kAEReopenApplication, appleEventParser, 0, false);
	AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,     appleEventParser, 0, false);
	AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments,    appleEventParser, 0, false);
	AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,   appleEventParser, 0, false);
	return noErr;
}

/*** INIT CARBON EVENTS ***/
OSStatus InitCarbonEvents(void)
{
#if TARGET_API_MAC_CARBON
	EventHandlerUPP handler	= null;
	EventHandlerRef	ref		= null;
	EventTypeSpec	update	= { kEventClassMenu,    kEventMenuEnableItems };
	EventTypeSpec	process	= { kEventClassCommand, kEventCommandProcess };
	
	// install menu adjust handler
	handler	= NewEventHandlerUPP(CarbonEventUpdateMenus);
	InstallApplicationEventHandler(handler, 1, &update, null, &ref);
	
	// install menu selection handler
	handler	= NewEventHandlerUPP(CarbonEventParseMenuSelection);
	InstallApplicationEventHandler(handler, 1, &process, null, &ref);
	
	// install default idle timer <20> 200 millisecond interval - bug: this should be in a seperate thread and the cursor blink time
	EventLoopTimerUPP timerUPP = NewEventLoopTimerUPP(DefaultIdleTimer);
	OSStatus error = InstallEventLoopTimer(GetMainEventLoop(), kEventDurationNoWait, kEventDurationMillisecond * 200, timerUPP, null, &g.idleTimer);
	return error;
#else
	return noErr;
#endif
}

/*** INITALIZE GLOBALS ***/
OSStatus InitGlobals(void)
{
	OSStatus error = noErr;
	
	// general app globals
	g.quitting = false;
	g.cancelQuit = false;
	g.frontApp = true;
	g.appResFile = CurResFile();
	g.asyncSound = !(Boolean) SHInitSoundHelper(&g.callSH, kSHDefChannels);
	g.emergencyMemory = NewHandleClear(kEmergencyMemory);
	
	// files
	g.tempCount = 0;
	
	// debugging
	g.debug = false;
	g.surpressErrors = false;
	g.useAppleEvents = true;
	g.useSheets = (g.carbonVersion >= kCarbonLib11)? true:false;
	
	// prefs dialog
	g.prefsDialog = null;
	p.warnOnDelete = true;
	
	// colours
	SetColour(&g.white,       0xFFFF, 0xFFFF, 0xFFFF);
	SetColour(&g.bgColour,    0xEEEE, 0xEEEE, 0xEEEE);
	SetColour(&g.sortColour,  0xDDDD, 0xDDDD, 0xDDDD);
	SetColour(&g.bevelColour, 0xAAAA, 0xAAAA, 0xAAAA);
	SetColour(&g.textColour,  0x7777, 0x7777, 0x7777);
	SetColour(&g.frameColour, 0x5555, 0x5555, 0x5555);
	SetColour(&g.black,       0x0000, 0x0000, 0x0000);
	
#if TARGET_API_MAC_CARBON
	// window manager
	g.windowMgrAvailable = true;
	g.extendedWindowAttr = true;
	
	// drag manager
	g.dragAvailable = true;
	g.translucentDrag = true;
	
	// appearance manager
	g.appearanceAvailable = true;
	g.useAppearance = g.appearanceAvailable;			// assume if user has Appearence, s/he wants to use it
	if(g.useAppearance) RegisterAppearanceClient();	// register such with the OS
	
	// nav services
	g.navAvailable = true;
	g.useNavServices = g.navAvailable;		// assume if user has NavServices, s/he wants to use them
	if(g.navAvailable) NavLoad();			// preload for efficiency - ignored on OS X (always loaded)
#else
	// check for drag manager presence/attributes
	SInt32 result = null;
	error = Gestalt(gestaltDragMgrAttr, &result);
	if(!error) {
		g.dragAvailable = (Boolean) (result & (1 << gestaltDragMgrPresent));
		g.translucentDrag = (Boolean) (result & (1 << gestaltDragMgrHasImageSupport));
	} else {
		g.dragAvailable = false;
		g.translucentDrag = false;
	}
	
	// check appearance availablilty
	result = null;
	error = Gestalt(gestaltAppearanceAttr, &result);
	if(!error) {
		g.appearanceAvailable = (Boolean) (result & (1 << gestaltAppearanceExists));
		g.useAppearance = g.appearanceAvailable;		// assume if user has Appearence, s/he wants to use it
	} else {
		g.appearanceAvailable = false;
		g.useAppearance = false;
	}
	if(g.useAppearance) RegisterAppearanceClient();	// register such with the OS
	
	// check nav services availablilty
	g.navAvailable = (Boolean) NavServicesAvailable();
	g.useNavServices = g.navAvailable;		// assume if user has NavServices, s/he wants to use them
	if(g.navAvailable) NavLoad();			// preload for efficiency
	
	// check for MacOS 8.5's window manager (also in CarbonLib 1.0 - backported to 8.1)
	result = null;
	error = Gestalt(gestaltWindowMgrAttr, &result);
	if(!error) {
		g.windowMgrAvailable = (Boolean) (result & (1 << gestaltWindowMgrPresentBit));
		g.extendedWindowAttr = (Boolean) (result & (1 << gestaltExtendedWindowAttributes));
	} else {
		g.windowMgrAvailable = false;
		g.extendedWindowAttr = false;
	}
	
	UpdateMenus(null);
#endif
	return error;
}

#if !TARGET_API_MAC_CARBON

/*** PARSE EVENTS ***/
OSStatus ParseEvents(EventRecord *event)
{
	OSStatus error = eventNotHandledErr;
	switch(event->what)
	{
		case nullEvent:
			IdleEvent();
			break;
		case mouseDown:
			error = MouseDownEventOccoured(event);
			break;
		case mouseUp:
			error = MouseUpEventOccoured(event);
			break;
		case keyDown:
			error = KeyDownEventOccoured(event);
			break;
		case autoKey:
			error = KeyRepeatEventOccoured(event);
			break;
		case keyUp:
			error = KeyUpEventOccoured(event);
			break;
		case updateEvt:
			error = UpdateEventOccoured(event);
			break;
		case activateEvt:
			error = ActivateEventOccoured(event);
			break;
		case osEvt:
			error = ParseOSEvents(event);
			break;
		case kHighLevelEvent:
			error = AEProcessAppleEvent(event);
			break;
	}
	return error;
}

/*** PARSE DIALOG EVENTS ***/
pascal Boolean ParseDialogEvents(DialogPtr dialog, EventRecord *event, DialogItemIndex *itemHit)
{
	#pragma unused(dialog, event, itemHit)
/*	OSStatus error = eventNotHandledErr;
	if(dialog == null && itemHit == null);
*/	return false;
}

/*** PARSE OS EVENTS ***/
OSStatus ParseOSEvents(EventRecord *event)
{
	#pragma unused(event)
	OSStatus error = eventNotHandledErr;
	SInt8 eventType = event->message >> 24;	// high byte of message field
	if(eventType & mouseMovedMessage)
	{
		// mouse moved event
	}
	else if(eventType & suspendResumeMessage)			// suspend/resume event
	{
		g.frontApp = (event->message & resumeFlag);		// true on resume
		if(FrontWindow())								// only de/activate front window (if present)
		{
			WindowObjectPtr winObj = (WindowObjectPtr) GetWindowRefCon(FrontWindow());
			error = winObj->Activate(g.frontApp);
		}
		if(event->message & convertClipboardFlag)
		{
			// convert clipboard to private scrap
		}					
	}
	else error = paramErr;
	return error;
}

#endif

/*** PARSE APPLE EVENTS ***/
pascal OSErr ParseAppleEvents(const AppleEvent *event, AppleEvent *reply, SInt32 refCon)
{
	#pragma unused(reply, refCon)
	
	OSErr		error;
	Size		actualSize;
	DescType	actualType;
	DescType	eventClass, eventID;
	
	error = AEGetAttributePtr((AppleEvent *) event, keyEventClassAttr, typeType, &actualType, (Ptr) &eventClass, sizeof(eventClass), &actualSize);
	if(error) return errAEEventNotHandled;
				
	error = AEGetAttributePtr((AppleEvent *) event, keyEventIDAttr, typeType, &actualType, (Ptr) &eventID, sizeof(eventID), &actualSize);
	if(error) return errAEEventNotHandled;
	
	switch(eventClass)
	{
		case kCoreEventClass:
			switch(eventID)
			{
				case kAEOpenApplication:		// sent when app opened directly (ie not file opened)
#if TARGET_API_MAC_CARBON
					DisplayOpenDialog();
#else
					if(g.useNavServices)
						DisplayOpenDialog();
					else DisplayStandardFileOpenDialog();
#endif
					break;
					
				case kAEReopenApplication:		// sent when app is double-clicked on, but is already open
					if(FrontWindow() == null)
					{
						AEDescList list = {};
#if TARGET_API_MAC_CARBON
						AppleEventSendSelf(kCoreEventClass, kAEOpenApplication, list);
#else
						if(g.useAppleEvents)
							AppleEventSendSelf(kCoreEventClass, kAEOpenApplication, list);
						else if(g.useNavServices)
							DisplayOpenDialog();
						else DisplayStandardFileOpenDialog();
#endif
					}
					break;
				
				case kAEOpenDocuments:			// sent when file is double-clicked on in finder,
					AppleEventOpen(event);	//	or open is chosen in the file menu and g.useAppleEvents is true
					break;
					
				case kAEPrintDocuments:			// sent when document is dragged onto printer
					AppleEventPrint(event);
					break;
					
				case kAEQuitApplication:		// sent from many locations (eg after restart command)
					QuitResKnife();
					break;
			}
			break;
		
/*		case kAECoreSuite:	// i'm not even registering for these yet
			switch(eventID)
			{
				case kAECut:
				case kAECopy:
				case kAEPaste:
				case kAEDelete:
					DisplayErrorDialog("\pSorry, but cut, copy, paste and clear via Apple Events arn't yet supported.");
					error =  errAEEventNotHandled;
					break;
			}
			break;
*/	}
	return error;
}

  /******************/
 /* EVENT HANDLING */
/******************/

#if !TARGET_API_MAC_CARBON

/*** MOUSE DOWN EVENT OCCOURED ***/
OSStatus MouseDownEventOccoured(EventRecord *event)
{
	// get the window
	OSStatus	error = eventNotHandledErr;
	WindowRef	window;
	SInt16		windowPart = FindWindow(event->where, &window);
	WindowObjectPtr winObj = (WindowObjectPtr) GetWindowRefCon(window);
	
	// find out where the click occoured
	if(!windowPart) return error;
	else switch(windowPart)
	{
		case inMenuBar:
			error = UpdateMenus(FrontWindow());		// error ignored at the moment
			UInt32 menuChoice = MenuSelect(event->where);
			UInt16 menu = HiWord(menuChoice);
			UInt16 item = LoWord(menuChoice);
			error = ParseMenuSelection(menu, item);	// error ignored at the moment
			HiliteMenu(0);
			break;
			
		case inSysWindow:
			SystemClick(event, window);
			break;
			
		case inContent:
			SelectWindow(window);
			winObj->Click(event->where, event->modifiers);
			break;
			
		case inDrag:
			DragWindow(window, event->where, &qdb);
			winObj->BoundsChanged(null);
			break;
			
		case inGrow:
			Rect bounds;	// minimum and maximum bounds of window
			SetRect(&bounds, 128, 128, 1024, 1024);
			SInt32 result = GrowWindow(window, event->where, &bounds);
			if(result)
			{
				SInt16 newWidth = LoWord(result);
				SInt16 newHeight = HiWord(result);
				SizeWindow(window, newWidth, newHeight, false);
				winObj->BoundsChanged(null);
			}
			break;
			
		case inGoAway:
			if(TrackGoAway(window, event->where))
				winObj->Close();
			break;
			
		case inZoomIn:
		case inZoomOut:
			if(TrackBox(window, event->where, windowPart))
			{
				ZoomWindow(window, windowPart, window == FrontWindow());		// I think the last param *might* need to be "g.frontApp"
				winObj->BoundsChanged(null);
			}
			break;
		
		case inCollapseBox:
		case inProxyIcon:
			break;
	}
	return error;
}

/*** MOUSE UP EVENT OCCOURED ***/
OSStatus MouseUpEventOccoured(EventRecord *event)
{
	#pragma unused(event)
	OSStatus error = eventNotHandledErr;
	return error;
}

/*** KEY DOWN EVENT OCCOURED ***/
OSStatus KeyDownEventOccoured(EventRecord *event)
{
	OSStatus error = eventNotHandledErr;
	char key = (char)(event->message & charCodeMask);	// get the key pressed
	if(event->modifiers & cmdKey)						// was it a menu shortcut?
	{
		UpdateMenus(FrontWindow());
		UInt32 menuChoice = MenuKey(key);
		UInt16 menu = HiWord(menuChoice);
		UInt16 item = LoWord(menuChoice);
		if(menu && item)
			error = ParseMenuSelection(menu, item);
	}
	return error;
}

/*** KEY REPEAT EVENT OCCOURED ***/
OSStatus KeyRepeatEventOccoured(EventRecord *event)
{
	OSStatus error = KeyDownEventOccoured(event);
	return error;
}

/*** KEY UP EVENT OCCOURED ***/
OSStatus KeyUpEventOccoured(EventRecord *event)
{
	#pragma unused(event)
	OSStatus error = eventNotHandledErr;
	return error;
}

/*** UPDATE EVENT OCCOURED ***/
OSStatus UpdateEventOccoured(EventRecord *event)
{
	OSStatus	error = eventNotHandledErr;
	GrafPtr		oldPort;
	WindowRef	window = (WindowRef) event->message;
	
	// send update events to window
	GetPort(&oldPort);
	SetPortWindowPort(window);
	BeginUpdate(window);	// this sets up the visRgn
	{
		RgnHandle updateRgn = NewRgn();
		WindowObjectPtr winObj = (WindowObjectPtr) GetWindowRefCon(window);
		GetPortVisibleRegion(GetWindowPort(window), updateRgn);
		if(winObj) error = winObj->Update(updateRgn);
		DisposeRgn(updateRgn);
	}
	EndUpdate(window);
	SetPort(oldPort);
	return error;
}

/*** ACTIVATE EVENT OCCOURED ***/
OSStatus ActivateEventOccoured(EventRecord *event)
{
	OSStatus error = eventNotHandledErr;
	WindowObjectPtr winObj = (WindowObjectPtr) GetWindowRefCon((WindowRef) event->message);
	if(winObj) error = winObj->Activate((Boolean) (event->modifiers & activeFlag));
	return error;
}

/*** IDLE EVENT ***/
OSStatus IdleEvent(void)
{
	// call sound idle routine
	if(g.asyncSound) SHIdle();
	
	// compact all memory
/*	SInt32 total, contig;
	PurgeMem(kEmergencyMemory);
	CompactMem(kEmergencyMemory);
	PurgeSpace(&total, &contig);
	
	// deal with emergency memory
	if(total < kMinimumFreeMemory && g.emergencyMemory) 
	{
		DisposeHandle(g.emergencyMemory);		// release emergence memory
		DisplayError("\pMemory is running low, please close some windows.");
	}
	else if(!g.emergencyMemory && contig > kEmergencyMemory)	// try to recover handle if possible
		g.emergencyMemory = NewHandleClear(kEmergencyMemory);
*/	return noErr;
}

#endif

/*** QUIT RES KNIFE ***/
void QuitResKnife(void)
{
	// save all open files
	WindowRef window = FrontNonFloatingWindow(), nextWindow;
	while(window)
	{
		nextWindow = GetNextWindow(window);
		SInt32 kind = GetWindowKind(window);
		if(kind == kFileWindowKind)
		{
#if TARGET_API_MAC_CARBON
			EventRef event;
			CreateEvent(null, kEventClassWindow, kEventWindowClose, kEventDurationNoWait, kEventAttributeNone, &event);
			SendEventToWindow(event, window);
			ReleaseEvent(event);
#else
			// bug: this is totally the wrong thing to do here, but will have to do for now
			DisposeWindow(window);	// bug: windows don't close when sent a WindowClose event!
#endif
		}
		window = nextWindow;
	}
	
	if(!g.cancelQuit)
	{
		if(g.asyncSound) SHKillSoundHelper();
		if(g.navAvailable) NavUnload();
#if TARGET_API_MAC_CARBON
		QuitApplicationEventLoop();
#else
		g.quitting = true;
#endif
	}
}

  /*******************/
 /* MENU SELECTIONS */
/*******************/

#if TARGET_API_MAC_CARBON

/*** CARBON EVENT UPDATE MENUS ***/
pascal OSStatus CarbonEventUpdateMenus(EventHandlerCallRef callRef, EventRef event, void *userData)
{
	#pragma unused(callRef, event, userData)
	OSStatus error = eventNotHandledErr;
	Boolean fileOpen = (Boolean) (FrontNonFloatingWindow() != NULL);
	
	// application menu (passing null causes all menus to be searched)
	EnableCommand(null, kMenuCommandAbout, true);
	EnableCommand(null, kHICommandPreferences, true);
	
	// file menu
	EnableCommand(null, kMenuCommandNewFile, true);
	EnableCommand(null, kMenuCommandOpenFile, true);
	EnableCommand(null, kMenuCommandCloseWindow, fileOpen);
	EnableCommand(null, kMenuCommandCloseFile, fileOpen);
	EnableCommand(null, kMenuCommandSaveFile, fileOpen);	// bug: shoud be disabled if file is unmodified
	EnableCommand(null, kMenuCommandSaveFileAs, fileOpen);
	EnableCommand(null, kMenuCommandRevertFile, fileOpen);
	EnableCommand(null, kMenuCommandPageSetup, fileOpen);
	EnableCommand(null, kMenuCommandPrint, fileOpen);

/*	if(fileOpen)
	{
		// edit window
		EnableCommand(null, kHICommandUndo, false);
		EnableCommand(null, kHICommandRedo, false);
		EnableCommand(null, kHICommandCut, false);
		EnableCommand(null, kHICommandCopy, false);
		EnableCommand(null, kHICommandPaste, false);
		EnableCommand(null, kHICommandClear, false);
		EnableCommand(null, kHICommandSelectAll, false);
		EnableCommand(null, kMenuCommandFind, false);
		EnableCommand(null, kMenuCommandFindAgain, false);
		
		// resource menu
		EnableCommand(null, kMenuCommandNewResource, false);
		EnableCommand(null, kMenuCommandOpenHex, false);
		EnableCommand(null, kMenuCommandOpenDefault, false);
		EnableCommand(null, kMenuCommandOpenTemplate, false);
		EnableCommand(null, kMenuCommandOpenSpecific, false);
		EnableCommand(null, kMenuCommandRevertResource, false);
		EnableCommand(null, kMenuCommandPlaySound, false);
	}
*/	
	// debug menu
	EnableCommand(null, kMenuCommandDebug, true);
	EnableCommand(null, kMenuCommandAppleEvents, false);
	EnableCommand(null, kMenuCommandAppearance, false);
	EnableCommand(null, kMenuCommandNavServices, false);
	EnableCommand(null, kMenuCommandSheets, g.carbonVersion >= kCarbonLib11);
	SetMenuCommandMark(null, kMenuCommandDebug,          g.debug?          kMenuCheckmarkGlyph : kMenuNullGlyph);
	SetMenuCommandMark(null, kMenuCommandSurpressErrors, g.surpressErrors? kMenuCheckmarkGlyph : kMenuNullGlyph);
	SetMenuCommandMark(null, kMenuCommandAppleEvents,    g.useAppleEvents? kMenuCheckmarkGlyph : kMenuNullGlyph);	// these three should always be true in Carbon
	SetMenuCommandMark(null, kMenuCommandAppearance,     g.useAppearance?  kMenuCheckmarkGlyph : kMenuNullGlyph);
	SetMenuCommandMark(null, kMenuCommandNavServices,    g.useNavServices? kMenuCheckmarkGlyph : kMenuNullGlyph);
	SetMenuCommandMark(null, kMenuCommandSheets,         g.useSheets?      kMenuCheckmarkGlyph : kMenuNullGlyph);
	
	return error;
}

/*** CARBON EVENT PARSE MENU SELECTION ***/
pascal OSStatus CarbonEventParseMenuSelection(EventHandlerCallRef callRef, EventRef event, void *userData)
{
	#pragma unused(callRef, userData)
	
	// get menu command
	HICommand menuCommand;
	OSStatus error = GetEventParameter(event, kEventParamDirectObject, typeHICommand, null, sizeof(HICommand), null, &menuCommand);
	if(error) return eventNotHandledErr;
		
	switch(menuCommand.commandID)
	{
		// application menu
		case kMenuCommandAbout:
			ShowAboutBox();
			break;
		
		case kHICommandPreferences:
			ShowPrefsWindow();
			break;
		
		// file menu
		case kMenuCommandNewFile:
			new FileWindow;
			break;
		
		case kMenuCommandOpenFile:
			if(g.useSheets)
				error = DisplayModelessGetFileDialog();
			else error = DisplayOpenDialog();
			break;
				
		// debug menu
		case kMenuCommandDebug:
			g.debug = !g.debug;
			break;
		case kMenuCommandSurpressErrors:
			g.surpressErrors = !g.surpressErrors;
			break;
		case kMenuCommandAppleEvents:
			g.useAppleEvents = !g.useAppleEvents;
			break;
		case kMenuCommandAppearance:
			g.useAppearance = !g.useAppearance;
			break;
		case kMenuCommandNavServices:
			g.useNavServices = !g.useNavServices;
			break;
		case kMenuCommandSheets:
			g.useSheets = !g.useSheets;
			break;
		
		default:
			return eventNotHandledErr;	// pass all other events
	}
	
	return error;	// event handled here, so terminate.
}

/*** DEFAULT IDLE TIMER ***/
pascal void DefaultIdleTimer(EventLoopTimerRef timer, void *data)
{
	#pragma unused(timer, data)
	
	// idle controls (allow cursor blinking)
	IdleControls(GetUserFocusWindow());	// bug: apple should have the control install it's own timer
	
	// call sound idle routine
	if(g.asyncSound && g.callSH) SHIdle();
}

#else

/*** UPDATE MENUS ***/
OSStatus UpdateMenus(WindowRef window)
{
	#pragma unused(window)
	OSStatus error = noErr;
	
	// disable/checkmark items in the debug menu
	MenuRef debugMenu = GetMenuRef(kDebugMenu);
	MenuItemEnable(debugMenu, kDebugMenuAppearanceItem, g.appearanceAvailable);
	MenuItemEnable(debugMenu, kDebugMenuNavServicesItem, g.navAvailable);
	MenuItemEnable(debugMenu, kDebugMenuSheetsItem, false);
	CheckMenuItem(debugMenu, kDebugMenuDebugItem, g.debug);
	CheckMenuItem(debugMenu, kDebugMenuSurpressErrorsItem, g.surpressErrors);
	CheckMenuItem(debugMenu, kDebugMenuAppleEventsItem, g.useAppleEvents);
	CheckMenuItem(debugMenu, kDebugMenuAppearanceItem, g.useAppearance);
	CheckMenuItem(debugMenu, kDebugMenuNavServicesItem, g.useNavServices);
	
	return error;
}

/*** PARSE MENU SELECTION ***/
OSStatus ParseMenuSelection(UInt16 menu, UInt16 item)
{
	// get the frontmost window, in all it's various forms
	OSStatus error = eventNotHandledErr;
	WindowRef window = FrontWindow();
	WindowObjectPtr winObj = null;
	FileWindowPtr file = null;
	if(window)
	{
		winObj = (WindowObjectPtr) GetWindowRefCon(window);
		if(GetWindowKind(window) == kFileWindowKind)
			file = (FileWindowPtr) winObj;
	}
	
	// do the menu function
	if(menu && item)
	{
		switch(menu)
		{
			case kAppleMenu:
				switch(item)
				{
					case kAppleMenuAboutItem:
						ShowAboutBox();
						break;
					
					default:	// something from "apple menu items" folder
						Str255 itemName;
						MenuHandle appleMenu = GetMenuHandle(kAppleMenu);
						GetMenuItemText(appleMenu, item, itemName);
						OpenDeskAcc(itemName);
						break;
				}
				break;
			
			case kFileMenu:
				switch(item)
				{
					case kFileMenuNewFileItem:
						new FileWindow;
						break;
					
					case kFileMenuOpenFileItem:
						if(g.useNavServices)
							DisplayOpenDialog();
						else DisplayStandardFileOpenDialog();
						break;
					
					case kFileMenuCloseWindowItem:
						if(winObj) winObj->Close();
						break;
					
					case kFileMenuQuitItem:
						AEDescList list = {};
						error = AppleEventSendSelf(kCoreEventClass, kAEQuitApplication, list);
						if(error) QuitResKnife();
						break;
				}
				break;
			
			case kEditMenu:
/*				switch(item)
				{
					case :
						break;
				}
*/				break;
			
			case kResourceMenu:
				switch(item)
				{
					case kResourceMenuNewResource:
						if(file) file->DisplayNewResourceDialog();
						break;
				}
				break;
			
			case kDebugMenu:
				switch(item)
				{
					case kDebugMenuDebugItem:
						g.debug = !g.debug;
						break;
					
					case kDebugMenuSurpressErrorsItem:
						g.surpressErrors = !g.surpressErrors;
						break;
					
					case kDebugMenuAppleEventsItem:
						g.useAppleEvents = !g.useAppleEvents;
						break;
					
					case kDebugMenuAppearanceItem:
						g.useAppearance = !g.useAppearance;
						break;
					
					case kDebugMenuNavServicesItem:
						g.useNavServices = !g.useNavServices;
						break;
				}
				break;
		}
		error = UpdateMenus(FrontWindow());
	}
	return error;
}

#endif

  /****************/
 /* APPLE EVENTS */
/****************/

/*** SEND MYSELF AN APPLE EVENT ***/
OSStatus AppleEventSendSelf(DescType eventClass, DescType eventID, AEDescList list)
{
	OSStatus error;
	AEAddressDesc myAddress;			// all of these are really of type AEDesc
	AppleEvent noReply;
	AppleEvent event;

	myAddress.descriptorType = typeNull;
	myAddress.dataHandle = null;
	noReply.descriptorType = typeNull;
	noReply.dataHandle = null;

	ProcessSerialNumber psn;
	error = GetCurrentProcess(&psn);
	if(error) return error;
	
	error = AECreateDesc(typeProcessSerialNumber, &psn, sizeof(ProcessSerialNumber), &myAddress);
	if(error) return error;
	
	error = AECreateAppleEvent(eventClass, eventID, &myAddress, kAutoGenerateReturnID, kAnyTransactionID, &event);
	if(error) return error;
	
	error = AEPutParamDesc(&event, keyDirectObject, &list);
	if(error) return error;
	
	error = AESend(&event, &noReply, kAENoReply, kAENormalPriority, kAEDefaultTimeout, null, null);
	return error;
}

/*** GOT REQUIRED PARAMS ***/
Boolean GotRequiredParams(const AppleEvent *event)
{
	OSStatus error = noErr;
	DescType actualType;
	Size actualSize;
	
	// check if we have retrieved the required parameters
	error = AEGetAttributePtr(event, keyMissedKeywordAttr, typeWildCard, &actualType, null, 0, &actualSize);
	return error == errAEDescNotFound;
}

/*** OPEN ***/
OSStatus AppleEventOpen(const AppleEvent *event)
{
	OSStatus error = noErr;
	
	// get the list of objects to open
	AEDescList list;
	AEKeyword aeKeyword;
	aeKeyword = keyDirectObject;
	error = AEGetParamDesc(event, aeKeyword, typeAEList, &list);
	if(!GotRequiredParams(event) || error) return errAEEventNotHandled;
	
	// count how many we have
	SInt32 itemCount;
	error = AECountItems(&list, &itemCount);
	if(error) return errAEEventNotHandled;
	
	// open each one
	FSSpec fileSpec;
	DescType actualType;
	Size actualSize;
	for(SInt32 n = 1; n <= itemCount; n++)
	{
		error = AEGetNthPtr(&list, n, typeFSS, &aeKeyword, &actualType, (Ptr) &fileSpec, sizeof(FSSpec), &actualSize);
		if(actualType == typeFSS && !error) new FileWindow(&fileSpec);
	}
	
	AEDisposeDesc(&list);
	return error;
}

/*** PRINT ***/
OSStatus AppleEventPrint(const AppleEvent *event)
{
	#pragma unused(event)
	return errAEEventNotHandled;
}

  /************************/
 /* NIB WINDOW MANAGMENT */
/************************/

/*** SHOW ABOUT BOX ***/
OSStatus ShowAboutBox(void)
{
#if TARGET_API_MAC_CARBON
#if USE_NIBS
	// create a nib reference (only searches the application bundle)
	IBNibRef nibRef = null;
	OSStatus error = CreateNibReference(CFSTR("ResKnife"), &nibRef);
	if(error != noErr || nibRef == null)
	{
		DisplayError("\pThe nib file reference could not be obtained.");
		return error;
	}
	
	// create window
	WindowRef window;
	error = CreateWindowFromNib(nibRef, CFSTR("About Box"), &window);
	if(error != noErr || window == null)
	{
		DisplayError("\pThe about box could not be obtained from the nib file.");
		return error;
	}
	
	// dispose of nib ref
	DisposeNibReference(nibRef);
	
	// show window
	ShowWindow(window);
#else
	Rect creationBounds;
	WindowRef window;
	SetRect(&creationBounds, 0, 0, 300, 300);
	OffsetRect(&creationBounds, 50, 50);
	OSStatus error = CreateNewWindow(kDocumentWindowClass, kWindowStandardDocumentAttributes | kWindowStandardHandlerAttribute | kWindowInWindowMenuAttribute, &creationBounds, &window);
	if(error) return error;
	
	ControlRef picControl;
	ControlButtonContentInfo content;
/*	content.contentType = kControlContentPictHandle;
	content.u.picture = GetPicture(128);
	if(content.u.picture == null) DebugStr("\ppicture == null");
*/	content.contentType = kControlContentPictRes;
	content.u.resID = 128;
	CreatePictureControl(window, &creationBounds, &content, true, &picControl);
//	SetControlData(picControl, kControlPicturePart, kControlPictureHandleTag, sizeof(content.u.picture), content.u.picture);
#endif
#else
	WindowRef window = null;
	if(g.useAppearance && g.systemVersion >= kMacOS8)
		window = GetNewCWindow(kFileWindow8, null, kFirstWindowOfClass);
	else window = GetNewCWindow(kFileWindow7, null, kFirstWindowOfClass);
	if(window == null) return paramErr;
	PicHandle picture = (PicHandle) GetPicture(128);
	SetWindowPic(window, picture);
#endif
	
	ShowWindow(window);
	return noErr;
}

/*** SHOW PREFERENCES WINDOW ***/
OSStatus ShowPrefsWindow(void)
{
#if USE_NIBS
	// create a nib reference (only searches the application bundle)
	IBNibRef nibRef = null;
	OSStatus error = CreateNibReference(CFSTR("ResKnife"), &nibRef);
	if(error != noErr || nibRef == null)
	{
		DisplayError("\pThe nib file reference could not be obtained.");
		return error;
	}
	
	// create window
	WindowRef window;
	error = CreateWindowFromNib(nibRef, CFSTR("Preferences"), &window);
	if(error != noErr || window == null)
	{
		DisplayError("\pThe preferences window could not be obtained from the nib file.");
		return error;
	}
	
	// dispose of nib ref
	DisposeNibReference(nibRef);
	
	// install tabs handler
	ControlRef control;
	ControlID id = { 'tabs', 1 };
	GetControlByID(window, &id, &control);
	EventTypeSpec event = { kEventClassControl, kEventControlHit };
	InstallEventHandler(GetControlEventTarget(control), NewEventHandlerUPP(PrefsTabEventHandler), 1, &event, &control, null);
	
	// show window
	ShowWindow(window);
#endif
	return noErr;
}

/*** PREFS TAB EVENT HANDLER ***/
pascal OSStatus PrefsTabEventHandler(EventHandlerCallRef handlerRef, EventRef event, void* userData)
{
	#pragma unused(handlerRef, event)
	
	// get tabs control
	OSStatus error = noErr;
	ControlRef control = (ControlRef) userData;
	SInt16 selectedTab = GetControlValue(control);
	WindowRef window = GetControlOwner(control);
	
	// select correct tab
	ControlRef currentTab;
	ControlID id = { 'pane', 1 };
	GetControlByID(window, &id, &currentTab);
	SetControlVisibility(currentTab, selectedTab == id.id, true);
	id.id = 2;
	GetControlByID(window, &id, &currentTab);
	SetControlVisibility(currentTab, selectedTab == id.id, true);
	
	return error;
}