mac.c

早期freebsd实现

	if (M->menu_id == 0)
		return;
	M->Mn = NewMenu(M->menu_id,CtoPstr(M->Name));
	PtoCstr(M->Name);

	for (i = 0; i < NMENUITEMS; i++) {
		d = (M->m[i]);
		if (d == NULL)
			break;	/* last item... */
		switch (d->Type & TYPEMASK) {
		case (STRING):
			AppendMenu(M->Mn,CtoPstr(d->Name));
			PtoCstr(d->Name);
			break;
		case (VARIABLE):
			SetItemMark(M->Mn,i + 1, 0x12);
			/* ??? fall through? */
		case (FUNCTION):
			CtoPstr(name = ((data_obj *) d)->Name);
			AppendMenu(M->Mn,name);
			PtoCstr(name);
			break;
		}
	}
	InsertMenu(M->Mn,0);
}

private void
ProcMenu(menuno,itemno)
int menuno,itemno;
{
	void MacSetVar();

	int i;
	data_obj *d;

	for (i = 0; i < NMENUS && Menus[i].menu_id != menuno; i++)
		;
	if (i < NMENUS) {	/* found the menu */
		itemno--;
		d = Menus[i].m[itemno];
		switch(d->Type & TYPEMASK) {
		case FUNCTION:
			ExecCmd((data_obj *) d);
			break;
		case BUFFER:
			SetABuf(curbuf);
			tiewind(curwind,(Buffer *) d);
			SetBuf((Buffer *) d);
			break;
		case VARIABLE:
			MacSetVar((struct variable *) d,i,itemno);
			break;
		default:
			break;
		}
	}
}


private void
make_edits(menu)	/* add dummy edit menu */
int menu;
{
	MenuHandle M;
	int item;
	char *fname;

	M = NewMenu((menu),"\pEdit");
	AppendMenu(M,"\pUndo/Z;(-;Cut/X;Copy/C;Paste/V;Clear;Select All;(-;Show Clipboard");
	InsertMenu(M,0);
	DisableItem(M,0);
}

void
menus_off()
{
	int i;
	if (Keyonly || EventCmd)
		return;

#ifdef	MENU_DISABLE		/* NOBODY likes this, but it's here if you want it... */
	DisableItem(SysMenu,0);
	for (i = 0; i < NMENUS; i++)
		if (Menus[i].Mn)
			DisableItem(Menus[i].Mn,0);
	DrawMenuBar();
#endif
	Keyonly = YES;
}

void
menus_on()
{
	int i;

	if (!Keyonly)
		return;
#ifdef	MENU_DISABLE
	EnableItem(SysMenu,0);
	for (i = 0; i < NMENUS; i++)
		if (Menus[i].Mn)
			EnableItem(Menus[i].Mn,0);
	DrawMenuBar();
#endif
	Keyonly = NO;
}

private char *
BufMPrint(b,i)
Buffer	*b;
int	i;
{
	char *p;
	char *nm = filename(b);
	char t[35];

	if (strlen(nm) > 30) {
		strcpy(t,"...");
		strcat(t,nm + strlen(nm) - 30);
	} else
		strcpy(t,nm);
	nm = t;
	while (*nm) {
		switch(*nm) {	/* ugh... these are metacharacter for Menus */
		case '/':
			*nm = ':';
			break;
		case '^':
		case '!':
		case '<':
		case '(':
		case ';':
			*nm = '.';
			break;	/* that will confuse everybody */
		}
		nm++;
	}
	p = sprint("%-2d %-11s \"%-s\"",i,b->b_name,t);
	return p;
}

private void
SetBufMenu()
{
	register Buffer *b;
	data_obj *d;
	int i,j,stop;
	struct menu *M;

	Bufchange = NO;
	for (i = 0; i < NMENUS && strcmp(Menus[i].Name,"Buffer"); i++)
		;
	if (i < NMENUS) {
		M = &Menus[i];
		for (j = 0; j < NMENUITEMS && (d = Menus[i].m[j]) && (d->Type & TYPEMASK) != BUFFER; j++)
			;
		if (j < NMENUITEMS) {
			for (i = j, b = world; i < NMENUITEMS && b != NULL; i++, b = b->b_next) {

				if (M->m[i] == NULL)
					AppendMenu(M->Mn,CtoPstr(BufMPrint(b,i-j+1)));	/* add the item */
				else
					SetItem(M->Mn,i + 1,CtoPstr(BufMPrint(b,i-j+1)));	/* or change it */
				M->m[i] = (data_obj *) b;
			}
			stop = i;
			/* out of buffers? */
			for (;i < NMENUITEMS && M->m[i];i++) {
				DelMenuItem(M->Mn,stop + 1);	/* take off last item */
				M->m[i] = NULL;
			}
		}
	}
}

private void
MacSetVar(vp,mnu,itm)	/* Set a variable from the menu */
struct variable *vp;	/* Liberally taken from SetVar() in extend.c */
int mnu,itm;
{
	void MarkVar();

	char *prompt;

	prompt = sprint("Set %s: ", vp->Name);
	switch (vp->v_flags & V_TYPEMASK) {
	case V_BASE10:
	case V_BASE8:
	    {
		int	value;

		value = ask_int(prompt, ((vp->v_flags & V_TYPEMASK) == V_BASE10)
					  ? 10 : 8);
		*(vp->v_value) = value;
		break;
	    }
	case V_BOOL:	/* toggle the value */
		*(vp->v_value) = (*vp->v_value == ON ? OFF : ON);
		MarkVar(vp,mnu,itm);
		break;
	case V_FILENAME:
	case V_STRING:
	    {
		char	*str;

		/* Do_ask() so you can set string to "" if you so desire. */
		str = do_ask("\r\n", (bool (*) ptrproto((int))) NULL, (char *) vp->v_value,
			prompt);
		if (str == NULL)
			str = NullStr;
		strcpy((char *) vp->v_value, str);
		/* ... and hope there is enough room. */
		break;
	    }
	case V_CHAR:
		f_mess(prompt);
		*(vp->v_value) = addgetc();
		break;
	}

	if (vp->v_flags & V_MODELINE)
		UpdModLine = YES;
	if (vp->v_flags & V_CLRSCREEN)
		ClAndRedraw();
	if (vp->v_flags & V_TTY_RESET)
		tty_reset();	/* probably none on a Mac */
}

private void
MarkModes()
{
	int mnu,itm;
	data_obj *d;

	Modechange = NO;
	for (mnu = 0; mnu < NMENUS; mnu++)
		for (itm = 0; itm < NMENUITEMS; itm++) {
			if ((d = Menus[mnu].m[itm]) == NULL)
				break;
			if ((d->Type & (MAJOR_MODE | MINOR_MODE))
			|| ((d->Type & TYPEMASK) == BUFFER))
			{
				bool	checked;

				if (d->Type & (MAJOR_MODE))
					checked = curbuf->b_major == (d->Type >> 8);
				else if (d->Type & (MINOR_MODE))
					checked = (curbuf->b_minor & (d->Type >> 8)) != 0;
				else
					checked = d == (data_obj *) curbuf;
				CheckItem(Menus[mnu].Mn, itm + 1, checked);
			}
		}
}

void
MarkVar(vp,mnu,itm)	/* mark a boolean menu item */
struct variable *vp;
int mnu,itm;
{
	if (mnu == -1) {		/* we don't know the item... slow */
		for (mnu = 0; mnu < NMENUS; mnu++) {
			for (itm = 0; (itm < NMENUITEMS); itm++) {
				if ((struct variable *) (Menus[mnu].m[itm]) == vp) {
					CheckItem(Menus[mnu].Mn, itm + 1,
						*(vp->v_value) == ON);
					return;
				}
			}
		}
	}
}

private void
MarkAllVar()	/* slow, but only do it once */
{
	int mnu,itm;
	data_obj *d;
	for (mnu = 0; mnu < NMENUS; mnu++)
		for (itm = 0; itm < NMENUITEMS; itm++) {
			if ((d = Menus[mnu].m[itm]) == NULL)
				break;
			if ((d->Type & TYPEMASK) == VARIABLE)
				MarkVar((struct variable *)Menus[mnu].m[itm],mnu,itm);
		}
}


/* Screen routines and driver. The Macinitosh Text Edit routines are not utilized,
   as they are slow and cumbersome for a terminal emulator. Instead, direct QuickDraw
   calls are used. The fastest output is obtained writing a line at a time, rather
   than on a character basis, so the major output routine is writechr(), which takes
   a pascal-style string as an argument. See do_sputc() in screen.c. */

void
Placur(line,col)
int line, col;
{
	CapCol = col;
	CapLine = line;
	putcurs(line,col,ON);
}

void
NPlacur(line,col)
int line, col;
{
	CapCol = col;
	CapLine = line;
	putcurs(line,col,OFF);
}

void
i_lines(top, bottom, num)
int top, bottom, num;
{
	Placur(bottom - num + 1, 0);
	dellines(num,bottom);
	Placur(top, 0);
	inslines(num,bottom);
}

void
d_lines(top, bottom, num)
int top, bottom, num;
{
	Placur(top, 0);
	dellines(num,bottom);
	Placur(bottom + 1 - num, 0);
	inslines(num,bottom);
}

/* (ORIGINALLY IN) tn.c   */
/* window driver for MacIntosh using windows. */
/* K. Mitchum 9/86 */


/*#define VARFONT*/
#ifdef	VARFONT
private height,width,theight,twidth,descent;
#else
#define height HEIGHT
#define width WIDTH
#define theight THEIGHT
#define twidth TWIDTH
#define descent DESCENT
#endif

private int trow, tcol, insert, cursor;
private bool tattr;	/* ??? never fetched */
private Rect cursor_rect;
private char *p_scr, *p_curs;	/* physical screen and cursor */
private int p_size;

private Rect  vRect;
private WindowRecord myWindowRec;

#define active() SetPort(theScreen)
#define maxadjust(r) OffsetRect((r),0,2);

char *
conv_p_curs(row,col)
int	row,
	col;
{
	return p_scr + (row * (CO)) + col;
}

private void
INSmode(new)
bool new;
{
	insert = new;
}

private void
HLmode(new)
bool new;
{
	tattr = new;
}

void
SO_on()
{
	HLmode(TRUE);
}

void
SO_off()
{
	HLmode(FALSE);
}


private void
tn_init()
{
	void INSmode proto((bool)),
	init_slate();

	HLmode(FALSE);
	INSmode(OFF);
	init_slate();
	ShowPen();
}

void
clr_page()	/* clear and home function */
{
	Rect r;

	setmem(p_scr,p_size,' ');
	active();
	SetRect(&r, 0,0,WINDWIDTH,WINDHEIGHT);
	EraseRect(&r);
	cursor = OFF;
	putcurs(0,0,OFF);	/* ??? "OFF" guess by DHR */
	drawfluff();
}

private void
putcurs(row,col,vis)
unsigned	row, col;
bool	vis;
{
	active();
	curset(OFF);
	trow = row;
	tcol = col;
	curset(vis);
}

private void
curset(desired)
bool	desired;
{
	p_curs = conv_p_curs(trow,tcol);
	if (trow == MAXROW)
		MoveTo(tcol * width, (trow  +1) * height + 2 -descent );
	else
		MoveTo(tcol * width, (trow  +1) * height - descent);

	DrawChar(*p_curs);

	if (desired) {
		SetRect(&cursor_rect, tcol * width, (trow) * height , (tcol + 1) * width - 1, (trow +1) * height -1);
		if (trow == MAXROW)
			maxadjust(&cursor_rect);
		InvertRect(&cursor_rect);
	}
	if (trow == MAXROW)
		MoveTo(tcol * width, (trow  +1) * height + 2 -descent );
	else
		MoveTo(tcol * width, (trow  +1) * height - descent);
}


void
putp(p)			/* put one character, advance cursor */
int p;
{
	static Rect r;
	static RgnHandle updateRgn;

	active();
	curset(OFF);
	if (insert) {
		updateRgn = NewRgn();
		SetRect(&r, tcol * width, trow * height, WINDWIDTH, (trow +1) * height -1);
		if (trow == MAXROW)
			maxadjust(&r);
		ScrollRect(&r, width, 0, updateRgn);
		DisposeRgn(updateRgn);
	}
	if (p == '0')
		p = 0xAF;	/* slashed zero */
	if (insert)
		BlockMove(p_curs, p_curs + 1, (long) (MAXCOL - tcol));
	*p_curs = (char) p;
	DrawChar(p);
	if (tcol >= MAXCOL)
		putcurs(trow,MAXCOL, ON);	/* ??? "ON" guess by DHR */
	else
		putcurs(trow,tcol+1, ON);	/* ??? "ON" guess by DHR */
}

void
clr_eoln()
{
		static Rect r;

		active();
		cursor = OFF;
		SetRect(&r, tcol * width, trow * height, WINDWIDTH, (trow +1) * height);
		if (trow == MAXROW)
			maxadjust(&r);
		EraseRect(&r);
		setmem(p_curs,CO - tcol, ' ');
		curset(ON);
}

private void
delchars()
{
	static Rect r;
	static RgnHandle updateRgn;

	active();
	curset(OFF);
	updateRgn = NewRgn();
	SetRect(&r, tcol * width, trow * height, twidth - width, (trow +1) * height);
	if (trow == MAXROW)
		maxadjust(&r);
	ScrollRect(&r, 0 - width, 0, updateRgn);
	DisposeRgn(updateRgn);
	BlockMove(p_curs + 1, p_curs, (long) (MAXCOL - tcol));
	*(conv_p_curs(trow,MAXCOL)) = ' ';
	curset(ON);
}

private void
dellines(n,bot)
int n,bot;
{
	Rect r;
	RgnHandle updateRgn;
	long len;

	updateRgn = NewRgn();
	active();
	curset(OFF);
	SetRect(&r, 0, ((trow) * height), WINDWIDTH, ((bot + 1) * height));
	ScrollRect(&r, 0, 0 - (n * height), updateRgn);
	DisposeRgn(updateRgn);
	len = ((bot - trow - n + 1) * CO);
	BlockMove(conv_p_curs((trow + n),0), conv_p_curs(trow,0), len);
	setmem(conv_p_curs((bot - n + 1),0),(n * CO),' ');
	putcurs(trow, 0, ON);	/* ??? "ON" guess by DHR */
}

private void
inslines(n,bot)
int n,bot;
{
	Rect r;
	RgnHandle updateRgn;
	long len;

	updateRgn = NewRgn();
	active();
	curset(OFF);
	SetRect(&r, 0, trow * height, WINDWIDTH, (bot +1) * height);
	ScrollRect(&r, 0, (n * height), updateRgn);
	DisposeRgn(updateRgn);
	len = ((bot - trow - n +1) * CO);
	BlockMove(conv_p_curs(trow,0), conv_p_curs((trow + n),0), len);
	setmem(conv_p_curs(trow,0),(n * CO),' ');
	putcurs(trow,0, ON);	/* ??? "ON" guess by DHR */
}

void
writechr(start)
char *start;	/* actually, a Str255 type string */
{
	static Rect r;
	static RgnHandle updateRgn;
	register len;
	register char save;

	len = (int) start[0] & 0xff;		/* adjusted 6/86 K. M. in td.c*/

	active();
	curset(OFF);
	if (insert) {
		updateRgn = NewRgn();
		SetRect(&r, tcol * width, trow * height, twidth - width * len, (trow +1) * height -1);
		if (trow == MAXROW)
			maxadjust(&r);
		ScrollRect(&r, width * len, 0, updateRgn);
		DisposeRgn(updateRgn);
	}
	DrawString(start);
	if (insert)
		BlockMove(p_curs,p_curs + len, (long) (CO - tcol - len));
	strncpy(p_curs,start + 1,len);
	if (tcol >= MAXCOL)
		putcurs(trow, MAXCOL, ON);	/* ??? "ON" guess by DHR */
	else
		putcurs(trow, tcol+len, ON);	/* ??? "ON" guess by DHR */
}

private Rect myBoundsRect;

private void
init_slate()
{
	FontInfo f;

	char *Name = "Jove ";
	char *Title;

	InitGraf(&thePort);
	InitWindows();
	InitCursor();
	InitFonts();
	InitMenus();
	InitDialogs((ProcPtr)NULL);		/* no restart proc */

	/* figure limiting rectangle for window moves */
	SetRect(&LimitRect,
		screenBits.bounds.left + 3,
		screenBits.bounds.top + 20,
		screenBits.bounds.right - 3,
		screenBits.bounds.bottom -3);

	Set_std();
	SetBounds();

	/* initialize char array for updates */
	p_scr = emalloc(p_size = wc_std.w_cols * wc_std.w_rows);	/* only once */
	p_curs = p_scr;

	Title = sprint("%s%s",Name,version);
	theScreen = NewWindow(&myWindowRec, &myBoundsRect,CtoPstr(Title),
		1,8,(WindowPtr) -1, 1, 0L);

	/* figure an initial window configuration and adjust it */
	wc = &wc_std;
	wc_user = wc_std;	/* initially, only one configuration to toggle */
	user_state(theScreen) = std_state(theScreen);
	SetPort(theScreen);

	(theScreen)->txFont = FONT;
	(theScreen)->txSize = TEXTSIZE;

#ifdef	VARFONT
	GetFontInfo(&f);
		height = f.ascent+f.descent+f.leading;
		width = f.widMax;
		twidth = width * wc->w_cols;
		theight = height * wc->w_rows;
		descent = f.descent;
#endif

	theScreen->txMode = patCopy;
	theScreen->pnMode = patCopy;
	PenNormal();
	cursor = OFF;
}

private void
p_refresh()
{
	int lineno;
	char *curs, *buf;

	buf = emalloc(CO + 1);
	for (lineno = 0; lineno < LI; lineno++) {
		curs = conv_p_curs(lineno,0);
		if (lineno == MAXROW)
			MoveTo(0, (lineno  +1) * height + 2 -descent );
		else
			MoveTo(0, (lineno  +1) * height - descent);
		strncpy(buf + 1, curs, CO);
		buf[0] = (char) CO;
		DrawString(buf);
	}
	putcurs(trow,tcol,OFF);
	free(buf);
}


private bool
wc_adjust(w,h,wcf,init)		/* adjust window config to look nice */
int w, h;
struct wind_config *wcf;
int init;
{
	static int LIMIT_R, LIMIT_C;
	int rows, cols;

	if (init) {
		LIMIT_R = (h - 4) / HEIGHT;
		LIMIT_C = (w - SCROLLWIDTH - 1) / WIDTH + 1;
	}
	if ((w < WIDTH * 40) ||(h < HEIGHT * 10)	/* too small */
	|| ((rows = (h - 4) / HEIGHT) > LIMIT_R)	/* too big */
	|| ((cols = (w - SCROLLWIDTH - 1) / WIDTH + 1) > LIMIT_C))
		return NO;

	wcf->w_rows = rows;
	wcf->w_cols = cols;
	wcf->w_width = wcf->w_cols * WIDTH + 1 + SCROLLWIDTH;
	wcf->w_height = wcf->w_rows * HEIGHT + 4;
	return YES;
}

int
getCO()	/* so that jove knows params */
{
	return wc->w_cols;
}

int
getLI()
{
	return wc->w_rows;
}

private void
SetBounds()
{
	SetRect(&myBoundsRect,
		screenBits.bounds.left + 3,
		screenBits.bounds.top + 40,
		screenBits.bounds.left + 3 + wc_std.w_width,
		screenBits.bounds.top + 40 + wc_std.w_height);
}

private void
Set_std()
{
	(void) wc_adjust(screenBits.bounds.right - screenBits.bounds.left - 6,
		screenBits.bounds.bottom - screenBits.bounds.top - 42,
		&wc_std,1);
}

private void
Reset_std()
{
	Set_std();
	std_state(theScreen) = myBoundsRect;
}
#endif	/* MAC */