[u/mdw/putty] / mac / mac.c

/* $Id: mac.c,v 1.5 2002/12/06 00:09:34 ben Exp $ */
/*
 * Copyright (c) 1999 Ben Harris
 * All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
/*
 * mac.c -- miscellaneous Mac-specific routines
 */

#include <MacTypes.h>
#include <Quickdraw.h>
#include <Fonts.h>
#include <MacWindows.h>
#include <Menus.h>
#include <TextEdit.h>
#include <Appearance.h>
#include <CodeFragments.h>
#include <Dialogs.h>
#include <Devices.h>
#include <DiskInit.h>
#include <Gestalt.h>
#include <Resources.h>
#include <Script.h>
#include <ToolUtils.h>

#include <assert.h>
#include <limits.h>
#include <stdarg.h>
#include <stdlib.h>		/* putty.h needs size_t */
#include <stdio.h>		/* for vsprintf */

#define PUTTY_DO_GLOBALS

#include "macresid.h"
#include "putty.h"
#include "mac.h"

QDGlobals qd;

static int cold = 1;
struct mac_gestalts mac_gestalts;

static void mac_startup(void);
static void mac_eventloop(void);
#pragma noreturn (mac_eventloop)
static void mac_event(EventRecord *);
static void mac_contentclick(WindowPtr, EventRecord *);
static void mac_growwindow(WindowPtr, EventRecord *);
static void mac_activatewindow(WindowPtr, EventRecord *);
static void mac_activateabout(WindowPtr, EventRecord *);
static void mac_updatewindow(WindowPtr);
static void mac_updatelicence(WindowPtr);
static void mac_keypress(EventRecord *);
static int mac_windowtype(WindowPtr);
static void mac_menucommand(long);
static void mac_openabout(void);
static void mac_openlicence(void);
static void mac_adjustcursor(RgnHandle);
static void mac_adjustmenus(void);
static void mac_closewindow(WindowPtr);
static void mac_zoomwindow(WindowPtr, short);
static void mac_shutdown(void);
#pragma noreturn (mac_shutdown)

struct mac_windows {
    WindowPtr about;
    WindowPtr licence;
};

struct mac_windows windows;

int main (int argc, char **argv) {

    mac_startup();
    mac_eventloop();
}

#pragma noreturn (main)

static void mac_startup(void) {
    Handle menuBar;

    /* Init Memory Manager */
    MaxApplZone();
    /* Init QuickDraw */
    InitGraf(&qd.thePort);
    /* Init Font Manager */
    InitFonts();
    /* Init Window Manager */
    InitWindows();
    /* Init Menu Manager */
    InitMenus();
    /* Init TextEdit */
    TEInit();
    /* Init Dialog Manager */
    InitDialogs(nil);
    cold = 0;
    
    /* Find out if we've got Color Quickdraw */
    if (Gestalt(gestaltQuickdrawVersion, &mac_gestalts.qdvers) != noErr)
    	mac_gestalts.qdvers = gestaltOriginalQD;
    /* ... and the Appearance Manager? */
    if (Gestalt(gestaltAppearanceVersion, &mac_gestalts.apprvers) != noErr)
	if (Gestalt(gestaltAppearanceAttr, NULL) == noErr)
	    mac_gestalts.apprvers = 0x0100;
	else
	    mac_gestalts.apprvers = 0;
#if TARGET_RT_MAC_CFM
    /* Paranoia: Did we manage to pull in AppearanceLib? */
    if (&RegisterAppearanceClient == kUnresolvedCFragSymbolAddress)
	mac_gestalts.apprvers = 0;
#endif
    /* Mac OS 8.5 Control Manager (proportional scrollbars)? */
    if (Gestalt(gestaltControlMgrAttr, &mac_gestalts.cntlattr) != noErr)
	mac_gestalts.cntlattr = 0;
    /* Mac OS 8.5 Window Manager? */
    if (Gestalt(gestaltWindowMgrAttr, &mac_gestalts.windattr) != noErr)
	mac_gestalts.windattr = 0;

    /* We've been tested with the Appearance Manager */
    if (mac_gestalts.apprvers != 0)
	RegisterAppearanceClient();

    menuBar = GetNewMBar(128);
    if (menuBar == NULL)
	fatalbox("Unable to create menu bar.");
    SetMenuBar(menuBar);
    AppendResMenu(GetMenuHandle(mApple), 'DRVR');
    mac_adjustmenus();
    DrawMenuBar();
    InitCursor();
    windows.about = NULL;
    windows.licence = NULL;

    init_ucs();
}

static void mac_eventloop(void) {
    Boolean gotevent;
    EventRecord event;
    RgnHandle cursrgn;

    cursrgn = NewRgn();
    for (;;) {
    	mac_adjustcursor(cursrgn);
	gotevent = WaitNextEvent(everyEvent, &event, LONG_MAX, cursrgn);
	mac_adjustcursor(cursrgn);
	if (gotevent)
	    mac_event(&event);
    }
    DisposeRgn(cursrgn);
}

static void mac_event(EventRecord *event) {
    short part;
    WindowPtr window;
    Point pt;

    switch (event->what) {
      case mouseDown:
	part = FindWindow(event->where, &window);
	switch (part) {
	  case inMenuBar:
	    mac_adjustmenus();
	    mac_menucommand(MenuSelect(event->where));
	    break;
	  case inSysWindow:
	    SystemClick(event, window);
	    break;
	  case inContent:
	    if (window != FrontWindow())
	    	/* XXX: check for movable modal dboxes? */
		SelectWindow(window);
	    else
		mac_contentclick(window, event);
	    break;
	  case inGoAway:
	    if (TrackGoAway(window, event->where))
		mac_closewindow(window);
	    break;
	  case inDrag:
	    /* XXX: moveable modal check? */
	    DragWindow(window, event->where, &qd.screenBits.bounds);
	    break;
	  case inGrow:
	    mac_growwindow(window, event);
	    break;
	  case inZoomIn:
	  case inZoomOut:
	    if (TrackBox(window, event->where, part))
		mac_zoomwindow(window, part);
	    break;
	}
	break;
      case keyDown:
      case autoKey:
        mac_keypress(event);
        break;
      case activateEvt:
	mac_activatewindow((WindowPtr)event->message, event);
        break;
      case updateEvt:
        mac_updatewindow((WindowPtr)event->message);
        break;
      case diskEvt:
	if (HiWord(event->message) != noErr) {
	    SetPt(&pt, 120, 120);
	    DIBadMount(pt, event->message);
        }
        break;
    }
}

static void mac_contentclick(WindowPtr window, EventRecord *event) {
    short item;

    switch (mac_windowtype(window)) {
      case wTerminal:
	mac_clickterm(window, event);
	break;
      case wAbout:
	if (DialogSelect(event, &(DialogPtr)window, &item))
	    switch (item) {
	      case wiAboutLicence:
		mac_openlicence();
		break;
	    }
	break;
    }
}

static void mac_growwindow(WindowPtr window, EventRecord *event) {

    switch (mac_windowtype(window)) {
      case wTerminal:
	mac_growterm(window, event);
    }
}

static void mac_activatewindow(WindowPtr window, EventRecord *event) {
    int active;

    active = (event->modifiers & activeFlag) != 0;
    mac_adjustmenus();
    switch (mac_windowtype(window)) {
      case wTerminal:
	mac_activateterm(window, active);
	break;
      case wAbout:
	mac_activateabout(window, event);
	break;
    }
}

static void mac_activateabout(WindowPtr window, EventRecord *event) {
    DialogItemType itemtype;
    Handle itemhandle;
    short item;
    Rect itemrect;
    int active;

    active = (event->modifiers & activeFlag) != 0;
    GetDialogItem(window, wiAboutLicence, &itemtype, &itemhandle, &itemrect);
    HiliteControl((ControlHandle)itemhandle, active ? 0 : 255);
    DialogSelect(event, &window, &item);
}

static void mac_updatewindow(WindowPtr window) {

    switch (mac_windowtype(window)) {
      case wTerminal:
	mac_updateterm(window);
	break;
      case wAbout:
	BeginUpdate(window);
	UpdateDialog(window, window->visRgn);
	EndUpdate(window);
	break;
      case wLicence:
	mac_updatelicence(window);
	break;
    }
}

static void mac_updatelicence(WindowPtr window)
{
    Handle h;
    int len;
    long fondsize;

    SetPort(window);
    BeginUpdate(window);
    fondsize = GetScriptVariable(smRoman, smScriptSmallFondSize);
    TextFont(HiWord(fondsize));
    TextSize(LoWord(fondsize));
    h = Get1Resource('TEXT', wLicence);
    len = GetResourceSizeOnDisk(h);
    if (h != NULL) {
	HLock(h);
	TETextBox(*h, len, &window->portRect, teFlushDefault);
	HUnlock(h);
    }
    EndUpdate(window);
}

/*
 * Work out what kind of window we're dealing with.
 * Concept shamelessly nicked from SurfWriter.
 */
static int mac_windowtype(WindowPtr window) {
    int kind;

    if (window == NULL)
	return wNone;
    kind = ((WindowPeek)window)->windowKind;
    if (kind < 0)
	return wDA;
    if (GetWVariant(window) == zoomDocProc)
	return wTerminal;
    return GetWRefCon(window);
}

/*
 * Handle a key press
 */
static void mac_keypress(EventRecord *event) {
    WindowPtr window;

    window = FrontWindow();
    /*
     * Check for a command-key combination, but ignore it if it counts
     * as a meta-key combination and we're in a terminal window.
     */
    if (event->what == keyDown && (event->modifiers & cmdKey) /*&&
	!((event->modifiers & cfg.meta_modifiers) == cfg.meta_modifiers &&
	    mac_windowtype(window) == wTerminal)*/) {
	mac_adjustmenus();
	mac_menucommand(MenuKey(event->message & charCodeMask));
    } else {
	switch (mac_windowtype(window)) {
	  case wTerminal:
	    mac_keyterm(window, event);
	    break;
	}
    }       
}

static void mac_menucommand(long result) {
    short menu, item;
    Str255 da;
    WindowPtr window;

    menu = HiWord(result);
    item = LoWord(result);
    window = FrontWindow();
    /* Things which do the same whatever window we're in. */
    switch (menu) {
      case mApple:
        switch (item) {
          case iAbout:
	    mac_openabout();
            goto done;
          default:
            GetMenuItemText(GetMenuHandle(mApple), item, da);
            OpenDeskAcc(da);
            goto done;
        }
        break;
      case mFile:
        switch (item) {
          case iNew:
            mac_newsession();
            goto done;
          case iClose:
            mac_closewindow(window);
            goto done;
          case iQuit:
            mac_shutdown();
            goto done;
        }
        break;
    }
    /* If we get here, handling is up to window-specific code. */
    switch (mac_windowtype(window)) {
      case wTerminal:
	mac_menuterm(window, menu, item);
	break;
    }
  done:
    HiliteMenu(0);
}

static void mac_openabout(void) {
    DialogItemType itemtype;
    Handle item;
    VersRecHndl vers;
    Rect box;
    StringPtr longvers;

    if (windows.about)
	SelectWindow(windows.about);
    else {
	windows.about = GetNewDialog(wAbout, NULL, (WindowPtr)-1);
	vers = (VersRecHndl)Get1Resource('vers', 1);
	if (vers != NULL && *vers != NULL) {
	    longvers = (*vers)->shortVersion + (*vers)->shortVersion[0] + 1;
	    GetDialogItem(windows.about, wiAboutVersion,
			  &itemtype, &item, &box);
	    assert(itemtype & kStaticTextDialogItem);
	    SetDialogItemText(item, longvers);
	}
	ShowWindow(windows.about);
    }
}

static void mac_openlicence(void) {
    DialogItemType itemtype;
    Handle item;
    VersRecHndl vers;
    Rect box;
    StringPtr longvers;

    if (windows.licence)
	SelectWindow(windows.licence);
    else {
	windows.licence = GetNewWindow(wLicence, NULL, (WindowPtr)-1);
	ShowWindow(windows.licence);
    }
}

static void mac_closewindow(WindowPtr window) {

    switch (mac_windowtype(window)) {
      case wDA:
	CloseDeskAcc(((WindowPeek)window)->windowKind);
	break;
      case wTerminal:
	/* FIXME: end session and stuff */
	break;
      case wAbout:
	windows.about = NULL;
	CloseWindow(window);
	break;
      case wLicence:
	windows.licence = NULL;
	CloseWindow(window);
	break;
      default:
	CloseWindow(window);
	break;
    }
}

static void mac_zoomwindow(WindowPtr window, short part) {

    /* FIXME: do something */
}

/*
 * Make the menus look right before the user gets to see them.
 */
static void mac_adjustmenus(void) {
    WindowPtr window;
    MenuHandle menu;

    window = FrontWindow();
    menu = GetMenuHandle(mApple);
    EnableItem(menu, 0);
    EnableItem(menu, iAbout);

    menu = GetMenuHandle(mFile);
    EnableItem(menu, 0);
    EnableItem(menu, iNew);
    if (window != NULL)
	EnableItem(menu, iClose);
    else
	DisableItem(menu, iClose);
    EnableItem(menu, iQuit);

    switch (mac_windowtype(window)) {
      case wTerminal:
	mac_adjusttermmenus(window);
	break;
      default:
	menu = GetMenuHandle(mEdit);
	DisableItem(menu, 0);
	break;
    }
    DrawMenuBar();
}

/*
 * Make sure the right cursor's being displayed.
 */
static void mac_adjustcursor(RgnHandle cursrgn) {
    Point mouse;
    WindowPtr window, front;
    short part;

    GetMouse(&mouse);
    LocalToGlobal(&mouse);
    part = FindWindow(mouse, &window);
    front = FrontWindow();
    if (part != inContent || window == NULL || window != front) {
	/* Cursor isn't in the front window, so switch to arrow */
	SetCursor(&qd.arrow);
	SetRectRgn(cursrgn, SHRT_MIN, SHRT_MIN, SHRT_MAX, SHRT_MAX);
	if (front != NULL)
	    DiffRgn(cursrgn, front->visRgn, cursrgn);
    } else {
	switch (mac_windowtype(window)) {
	  case wTerminal:
	    mac_adjusttermcursor(window, mouse, cursrgn);
	    break;
	  default:
	    SetCursor(&qd.arrow);
	    CopyRgn(window->visRgn, cursrgn);
	    break;
	}
    }
}

static void mac_shutdown(void) {

    exit(0);
}

void fatalbox(char *fmt, ...) {
    va_list ap;
    Str255 stuff;
    
    va_start(ap, fmt);
    /* We'd like stuff to be a Pascal string */
    stuff[0] = vsprintf((char *)(&stuff[1]), fmt, ap);
    va_end(ap);
    ParamText(stuff, NULL, NULL, NULL);
    StopAlert(128, nil);
    exit(1);
}

void modalfatalbox(char *fmt, ...) {
    va_list ap;
    Str255 stuff;
    
    va_start(ap, fmt);
    /* We'd like stuff to be a Pascal string */
    stuff[0] = vsprintf((char *)(&stuff[1]), fmt, ap);
    va_end(ap);
    ParamText(stuff, NULL, NULL, NULL);
    StopAlert(128, nil);
    exit(1);
}

/*
 * Local Variables:
 * c-file-style: "simon"
 * End:
 */
Commit	Line	Data
36577dc9	1	/* $Id: mac.c,v 1.5 2002/12/06 00:09:34 ben Exp $ */
d082ac49	2	/*
	3	* Copyright (c) 1999 Ben Harris
	4	* All rights reserved.
	5	*
	6	* Permission is hereby granted, free of charge, to any person
	7	* obtaining a copy of this software and associated documentation
	8	* files (the "Software"), to deal in the Software without
	9	* restriction, including without limitation the rights to use,
	10	* copy, modify, merge, publish, distribute, sublicense, and/or
	11	* sell copies of the Software, and to permit persons to whom the
	12	* Software is furnished to do so, subject to the following
	13	* conditions:
	14	*
	15	* The above copyright notice and this permission notice shall be
	16	* included in all copies or substantial portions of the Software.
	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	19	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	20	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	21	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
	22	* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
	23	* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	24	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	25	* SOFTWARE.
	26	*/
	27	/*
	28	* mac.c -- miscellaneous Mac-specific routines
	29	*/
	30
	31	#include <MacTypes.h>
	32	#include <Quickdraw.h>
	33	#include <Fonts.h>
	34	#include <MacWindows.h>
	35	#include <Menus.h>
	36	#include <TextEdit.h>
	37	#include <Appearance.h>
	38	#include <CodeFragments.h>
	39	#include <Dialogs.h>
	40	#include <Devices.h>
	41	#include <DiskInit.h>
	42	#include <Gestalt.h>
	43	#include <Resources.h>
36577dc9	44	#include <Script.h>
d082ac49	45	#include <ToolUtils.h>
	46
	47	#include <assert.h>
	48	#include <limits.h>
	49	#include <stdarg.h>
	50	#include <stdlib.h> /* putty.h needs size_t */
	51	#include <stdio.h> /* for vsprintf */
	52
	53	#define PUTTY_DO_GLOBALS
	54
	55	#include "macresid.h"
	56	#include "putty.h"
	57	#include "mac.h"
	58
	59	QDGlobals qd;
	60
	61	static int cold = 1;
	62	struct mac_gestalts mac_gestalts;
	63
	64	static void mac_startup(void);
	65	static void mac_eventloop(void);
	66	#pragma noreturn (mac_eventloop)
	67	static void mac_event(EventRecord *);
	68	static void mac_contentclick(WindowPtr, EventRecord *);
	69	static void mac_growwindow(WindowPtr, EventRecord *);
	70	static void mac_activatewindow(WindowPtr, EventRecord *);
	71	static void mac_activateabout(WindowPtr, EventRecord *);
	72	static void mac_updatewindow(WindowPtr);
ebd78b62	73	static void mac_updatelicence(WindowPtr);
d082ac49	74	static void mac_keypress(EventRecord *);
	75	static int mac_windowtype(WindowPtr);
	76	static void mac_menucommand(long);
	77	static void mac_openabout(void);
ebd78b62	78	static void mac_openlicence(void);
d082ac49	79	static void mac_adjustcursor(RgnHandle);
	80	static void mac_adjustmenus(void);
	81	static void mac_closewindow(WindowPtr);
	82	static void mac_zoomwindow(WindowPtr, short);
	83	static void mac_shutdown(void);
	84	#pragma noreturn (mac_shutdown)
	85
	86	struct mac_windows {
	87	WindowPtr about;
	88	WindowPtr licence;
	89	};
	90
	91	struct mac_windows windows;
	92
	93	int main (int argc, char **argv) {
	94
	95	mac_startup();
	96	mac_eventloop();
	97	}
	98
	99	#pragma noreturn (main)
	100
	101	static void mac_startup(void) {
	102	Handle menuBar;
	103
	104	/* Init Memory Manager */
	105	MaxApplZone();
	106	/* Init QuickDraw */
	107	InitGraf(&qd.thePort);
	108	/* Init Font Manager */
	109	InitFonts();
	110	/* Init Window Manager */
	111	InitWindows();
	112	/* Init Menu Manager */
	113	InitMenus();
	114	/* Init TextEdit */
	115	TEInit();
	116	/* Init Dialog Manager */
	117	InitDialogs(nil);
	118	cold = 0;
	119
d082ac49	120	/* Find out if we've got Color Quickdraw */
	121	if (Gestalt(gestaltQuickdrawVersion, &mac_gestalts.qdvers) != noErr)
	122	mac_gestalts.qdvers = gestaltOriginalQD;
	123	/* ... and the Appearance Manager? */
	124	if (Gestalt(gestaltAppearanceVersion, &mac_gestalts.apprvers) != noErr)
	125	if (Gestalt(gestaltAppearanceAttr, NULL) == noErr)
	126	mac_gestalts.apprvers = 0x0100;
	127	else
	128	mac_gestalts.apprvers = 0;
	129	#if TARGET_RT_MAC_CFM
	130	/* Paranoia: Did we manage to pull in AppearanceLib? */
	131	if (&RegisterAppearanceClient == kUnresolvedCFragSymbolAddress)
	132	mac_gestalts.apprvers = 0;
	133	#endif
	134	/* Mac OS 8.5 Control Manager (proportional scrollbars)? */
	135	if (Gestalt(gestaltControlMgrAttr, &mac_gestalts.cntlattr) != noErr)
	136	mac_gestalts.cntlattr = 0;
	137	/* Mac OS 8.5 Window Manager? */
	138	if (Gestalt(gestaltWindowMgrAttr, &mac_gestalts.windattr) != noErr)
	139	mac_gestalts.windattr = 0;
	140
	141	/* We've been tested with the Appearance Manager */
	142	if (mac_gestalts.apprvers != 0)
	143	RegisterAppearanceClient();
	144
	145	menuBar = GetNewMBar(128);
	146	if (menuBar == NULL)
	147	fatalbox("Unable to create menu bar.");
	148	SetMenuBar(menuBar);
	149	AppendResMenu(GetMenuHandle(mApple), 'DRVR');
	150	mac_adjustmenus();
	151	DrawMenuBar();
	152	InitCursor();
	153	windows.about = NULL;
	154	windows.licence = NULL;
	155
	156	init_ucs();
	157	}
	158
	159	static void mac_eventloop(void) {
	160	Boolean gotevent;
	161	EventRecord event;
	162	RgnHandle cursrgn;
	163
	164	cursrgn = NewRgn();
	165	for (;;) {
	166	mac_adjustcursor(cursrgn);
	167	gotevent = WaitNextEvent(everyEvent, &event, LONG_MAX, cursrgn);
	168	mac_adjustcursor(cursrgn);
	169	if (gotevent)
	170	mac_event(&event);
d082ac49	171	}
	172	DisposeRgn(cursrgn);
	173	}
	174
	175	static void mac_event(EventRecord *event) {
	176	short part;
	177	WindowPtr window;
	178	Point pt;
	179
	180	switch (event->what) {
	181	case mouseDown:
	182	part = FindWindow(event->where, &window);
	183	switch (part) {
	184	case inMenuBar:
	185	mac_adjustmenus();
	186	mac_menucommand(MenuSelect(event->where));
	187	break;
	188	case inSysWindow:
	189	SystemClick(event, window);
	190	break;
	191	case inContent:
	192	if (window != FrontWindow())
	193	/* XXX: check for movable modal dboxes? */
	194	SelectWindow(window);
	195	else
	196	mac_contentclick(window, event);
	197	break;
	198	case inGoAway:
	199	if (TrackGoAway(window, event->where))
	200	mac_closewindow(window);
	201	break;
	202	case inDrag:
	203	/* XXX: moveable modal check? */
	204	DragWindow(window, event->where, &qd.screenBits.bounds);
	205	break;
	206	case inGrow:
	207	mac_growwindow(window, event);
	208	break;
	209	case inZoomIn:
	210	case inZoomOut:
	211	if (TrackBox(window, event->where, part))
	212	mac_zoomwindow(window, part);
	213	break;
	214	}
	215	break;
	216	case keyDown:
	217	case autoKey:
	218	mac_keypress(event);
	219	break;
	220	case activateEvt:
	221	mac_activatewindow((WindowPtr)event->message, event);
	222	break;
	223	case updateEvt:
	224	mac_updatewindow((WindowPtr)event->message);
	225	break;
	226	case diskEvt:
	227	if (HiWord(event->message) != noErr) {
	228	SetPt(&pt, 120, 120);
	229	DIBadMount(pt, event->message);
	230	}
	231	break;
	232	}
	233	}
	234
235	static void mac_contentclick(WindowPtr window, EventRecord *event) {
236	short item;
237
238	switch (mac_windowtype(window)) {
239	case wTerminal:
240	mac_clickterm(window, event);
241	break;
242	case wAbout:
243	if (DialogSelect(event, &(DialogPtr)window, &item))
244	switch (item) {
245	case wiAboutLicence:
ebd78b62	246	mac_openlicence();
d082ac49	247	break;
	248	}
	249	break;
	250	}
	251	}
	252
	253	static void mac_growwindow(WindowPtr window, EventRecord *event) {
	254
	255	switch (mac_windowtype(window)) {
	256	case wTerminal:
	257	mac_growterm(window, event);
	258	}
	259	}
	260
	261	static void mac_activatewindow(WindowPtr window, EventRecord *event) {
	262	int active;
	263
	264	active = (event->modifiers & activeFlag) != 0;
	265	mac_adjustmenus();
	266	switch (mac_windowtype(window)) {
	267	case wTerminal:
	268	mac_activateterm(window, active);
	269	break;
	270	case wAbout:
	271	mac_activateabout(window, event);
	272	break;
	273	}
	274	}
	275
	276	static void mac_activateabout(WindowPtr window, EventRecord *event) {
	277	DialogItemType itemtype;
	278	Handle itemhandle;
	279	short item;
	280	Rect itemrect;
	281	int active;
	282
	283	active = (event->modifiers & activeFlag) != 0;
	284	GetDialogItem(window, wiAboutLicence, &itemtype, &itemhandle, &itemrect);
	285	HiliteControl((ControlHandle)itemhandle, active ? 0 : 255);
	286	DialogSelect(event, &window, &item);
	287	}
	288
	289	static void mac_updatewindow(WindowPtr window) {
	290
	291	switch (mac_windowtype(window)) {
	292	case wTerminal:
	293	mac_updateterm(window);
	294	break;
	295	case wAbout:
	296	BeginUpdate(window);
	297	UpdateDialog(window, window->visRgn);
	298	EndUpdate(window);
	299	break;
	300	case wLicence:
ebd78b62	301	mac_updatelicence(window);
	302	break;
	303	}
	304	}
	305
	306	static void mac_updatelicence(WindowPtr window)
	307	{
	308	Handle h;
	309	int len;
36577dc9	310	long fondsize;
ebd78b62	311
	312	SetPort(window);
	313	BeginUpdate(window);
36577dc9	314	fondsize = GetScriptVariable(smRoman, smScriptSmallFondSize);
	315	TextFont(HiWord(fondsize));
	316	TextSize(LoWord(fondsize));
ebd78b62	317	h = Get1Resource('TEXT', wLicence);
	318	len = GetResourceSizeOnDisk(h);
	319	if (h != NULL) {
	320	HLock(h);
	321	TETextBox(*h, len, &window->portRect, teFlushDefault);
	322	HUnlock(h);
d082ac49	323	}
ebd78b62	324	EndUpdate(window);
d082ac49	325	}
	326
	327	/*
	328	* Work out what kind of window we're dealing with.
	329	* Concept shamelessly nicked from SurfWriter.
	330	*/
	331	static int mac_windowtype(WindowPtr window) {
	332	int kind;
	333
	334	if (window == NULL)
	335	return wNone;
	336	kind = ((WindowPeek)window)->windowKind;
	337	if (kind < 0)
	338	return wDA;
	339	if (GetWVariant(window) == zoomDocProc)
	340	return wTerminal;
	341	return GetWRefCon(window);
	342	}
	343
	344	/*
	345	* Handle a key press
	346	*/
	347	static void mac_keypress(EventRecord *event) {
	348	WindowPtr window;
	349
	350	window = FrontWindow();
	351	/*
	352	* Check for a command-key combination, but ignore it if it counts
	353	* as a meta-key combination and we're in a terminal window.
	354	*/
	355	if (event->what == keyDown && (event->modifiers & cmdKey) /*&&
	356	!((event->modifiers & cfg.meta_modifiers) == cfg.meta_modifiers &&
	357	mac_windowtype(window) == wTerminal)*/) {
	358	mac_adjustmenus();
	359	mac_menucommand(MenuKey(event->message & charCodeMask));
	360	} else {
	361	switch (mac_windowtype(window)) {
	362	case wTerminal:
	363	mac_keyterm(window, event);
	364	break;
	365	}
	366	}
	367	}
	368
	369	static void mac_menucommand(long result) {
	370	short menu, item;
	371	Str255 da;
	372	WindowPtr window;
	373
	374	menu = HiWord(result);
	375	item = LoWord(result);
	376	window = FrontWindow();
	377	/* Things which do the same whatever window we're in. */
	378	switch (menu) {
	379	case mApple:
	380	switch (item) {
	381	case iAbout:
	382	mac_openabout();
	383	goto done;
	384	default:
	385	GetMenuItemText(GetMenuHandle(mApple), item, da);
	386	OpenDeskAcc(da);
	387	goto done;
	388	}
389	break;
390	case mFile:
391	switch (item) {
392	case iNew:
393	mac_newsession();
394	goto done;
395	case iClose:
396	mac_closewindow(window);
397	goto done;
398	case iQuit:
399	mac_shutdown();
400	goto done;
401	}
402	break;
403	}
404	/* If we get here, handling is up to window-specific code. */
405	switch (mac_windowtype(window)) {
406	case wTerminal:
407	mac_menuterm(window, menu, item);
408	break;
409	}
410	done:
411	HiliteMenu(0);
412	}
413
414	static void mac_openabout(void) {
415	DialogItemType itemtype;
416	Handle item;
417	VersRecHndl vers;
418	Rect box;
419	StringPtr longvers;
420
421	if (windows.about)
422	SelectWindow(windows.about);
423	else {
424	windows.about = GetNewDialog(wAbout, NULL, (WindowPtr)-1);
5dbc118e	425	vers = (VersRecHndl)Get1Resource('vers', 1);
	426	if (vers != NULL && *vers != NULL) {
	427	longvers = (vers)->shortVersion + (vers)->shortVersion[0] + 1;
	428	GetDialogItem(windows.about, wiAboutVersion,
	429	&itemtype, &item, &box);
	430	assert(itemtype & kStaticTextDialogItem);
	431	SetDialogItemText(item, longvers);
	432	}
d082ac49	433	ShowWindow(windows.about);
	434	}
	435	}
	436
ebd78b62	437	static void mac_openlicence(void) {
	438	DialogItemType itemtype;
	439	Handle item;
	440	VersRecHndl vers;
	441	Rect box;
	442	StringPtr longvers;
	443
	444	if (windows.licence)
	445	SelectWindow(windows.licence);
	446	else {
	447	windows.licence = GetNewWindow(wLicence, NULL, (WindowPtr)-1);
	448	ShowWindow(windows.licence);
	449	}
	450	}
	451
d082ac49	452	static void mac_closewindow(WindowPtr window) {
	453
	454	switch (mac_windowtype(window)) {
	455	case wDA:
	456	CloseDeskAcc(((WindowPeek)window)->windowKind);
	457	break;
	458	case wTerminal:
	459	/* FIXME: end session and stuff */
	460	break;
	461	case wAbout:
	462	windows.about = NULL;
	463	CloseWindow(window);
	464	break;
ebd78b62	465	case wLicence:
	466	windows.licence = NULL;
	467	CloseWindow(window);
	468	break;
d082ac49	469	default:
	470	CloseWindow(window);
	471	break;
	472	}
	473	}
	474
	475	static void mac_zoomwindow(WindowPtr window, short part) {
	476
	477	/* FIXME: do something */
	478	}
	479
	480	/*
	481	* Make the menus look right before the user gets to see them.
	482	*/
	483	static void mac_adjustmenus(void) {
	484	WindowPtr window;
	485	MenuHandle menu;
	486
	487	window = FrontWindow();
	488	menu = GetMenuHandle(mApple);
	489	EnableItem(menu, 0);
	490	EnableItem(menu, iAbout);
	491
	492	menu = GetMenuHandle(mFile);
	493	EnableItem(menu, 0);
	494	EnableItem(menu, iNew);
	495	if (window != NULL)
	496	EnableItem(menu, iClose);
	497	else
	498	DisableItem(menu, iClose);
	499	EnableItem(menu, iQuit);
	500
	501	switch (mac_windowtype(window)) {
	502	case wTerminal:
	503	mac_adjusttermmenus(window);
	504	break;
	505	default:
	506	menu = GetMenuHandle(mEdit);
	507	DisableItem(menu, 0);
	508	break;
	509	}
	510	DrawMenuBar();
	511	}
	512
	513	/*
	514	* Make sure the right cursor's being displayed.
	515	*/
	516	static void mac_adjustcursor(RgnHandle cursrgn) {
	517	Point mouse;
	518	WindowPtr window, front;
	519	short part;
	520
	521	GetMouse(&mouse);
	522	LocalToGlobal(&mouse);
	523	part = FindWindow(mouse, &window);
	524	front = FrontWindow();
	525	if (part != inContent \|\| window == NULL \|\| window != front) {
	526	/* Cursor isn't in the front window, so switch to arrow */
	527	SetCursor(&qd.arrow);
	528	SetRectRgn(cursrgn, SHRT_MIN, SHRT_MIN, SHRT_MAX, SHRT_MAX);
	529	if (front != NULL)
	530	DiffRgn(cursrgn, front->visRgn, cursrgn);
	531	} else {
	532	switch (mac_windowtype(window)) {
533	case wTerminal:
534	mac_adjusttermcursor(window, mouse, cursrgn);
535	break;
536	default:
537	SetCursor(&qd.arrow);
538	CopyRgn(window->visRgn, cursrgn);
539	break;
540	}
541	}
542	}
543
544	static void mac_shutdown(void) {
545
546	exit(0);
547	}
548
549	void fatalbox(char *fmt, ...) {
550	va_list ap;
551	Str255 stuff;
552
553	va_start(ap, fmt);
554	/* We'd like stuff to be a Pascal string */
555	stuff[0] = vsprintf((char *)(&stuff[1]), fmt, ap);
556	va_end(ap);
557	ParamText(stuff, NULL, NULL, NULL);
558	StopAlert(128, nil);
559	exit(1);
560	}
561
562	void modalfatalbox(char *fmt, ...) {
563	va_list ap;
564	Str255 stuff;
565
566	va_start(ap, fmt);
567	/* We'd like stuff to be a Pascal string */
568	stuff[0] = vsprintf((char *)(&stuff[1]), fmt, ap);
569	va_end(ap);
570	ParamText(stuff, NULL, NULL, NULL);
571	StopAlert(128, nil);
572	exit(1);
573	}
574
575	/*
576	* Local Variables:
577	* c-file-style: "simon"
578	* End:
579	*/