1 /*
2     TiMidity++ -- MIDI to WAVE converter and player
3     Copyright (C) 1999-2002 Masanao Izumo <mo@goice.co.jp>
4     Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>
5 
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10 
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15 
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 
20     wrdt_mac.c
21 
22     Written by by T.Nogami	<t-nogami@happy.email.ne.jp>
23 
24 */
25 
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif /* HAVE_CONFIG_H */
29 #include <stdio.h>
30 #include <stdlib.h>
31 #ifndef NO_STRING_H
32 #include <string.h>
33 #else
34 #include <strings.h>
35 #endif
36 #include "timidity.h"
37 #include "common.h"
38 #include "instrum.h"
39 #include "playmidi.h"
40 #include "readmidi.h"
41 #include "controls.h"
42 #include "wrd.h"
43 #include "VTparse.h"
44 
45 //#include <Palettes.h>
46 #include "mac_main.h"
47 #include "mac_c.h"
48 #include "mac_wrdwindow.h"
49 #include "mac_mag.h"
50 #include "mac_wrd.h"
51 #include "aq.h"
52 
53 static int wrd_argc;
54 //static int wrd_args[WRD_MAXPARAM];
55 static int inkey_flag;
56 //#define WRD_DEBUG(x)	ctl->cmsg x
57 #define WRD_DEBUG(x)	/*nothing*/
58 
59 static int wrdt_open(char *wrdt_opts);
60 static void wrdt_apply(int cmd, int wrd_argc, int wrd_args[]);
61 static void wrdt_update_events(void);
wrdt_start(int wrdflag)62 static int wrdt_start(int wrdflag)
63 {
64 	if( wrdflag ){
65 		#ifdef ENABLE_SHERRY
66 		sry_start();
67 		#endif
68 		ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
69 			  "WRD START");
70 	}
71 	return 0;
72 }
73 
wrdt_end(void)74 static void wrdt_end(void)
75 {
76 	wrd_argc = 0;
77 	inkey_flag = 0;
78 	#ifdef ENABLE_SHERRY
79 	sry_end();
80 	#endif
81 	ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
82 		  "WRD END");
83 }
84 
85 static void wrdt_end(void);
86 static void wrdt_close(void);
87 
88 #define wrdt mac_wrdt_mode
89 #define win mac_WrdWindow
90 
91 WRDTracer wrdt =
92 {
93     "mac WRD tracer", 'm',
94     0,
95     wrdt_open,
96     wrdt_apply,
97     #ifdef ENABLE_SHERRY
98     sry_wrdt_apply,
99     #else
100     NULL,
101     #endif
102     wrdt_update_events,
103     wrdt_start,
104     wrdt_end,
105     wrdt_close
106 };
107 
108 // ***********************************************
109 // Low level output
110 
dev_set_height(int height)111 void dev_set_height(int height)
112 {
113 	SizeWindow(win.ref, WRD_GSCR_WIDTH, height, false);
114 }
115 
mac_RedrawControl(int flag)116 static void mac_RedrawControl(int flag)
117 {
118 	dev_redrawflag=flag;
119 }
120 
dev_redisp(Rect rect)121 void dev_redisp(Rect rect)
122 {
123 	GDHandle	oldGD;
124 	GWorldPtr	oldGW;
125 
126 	if( !dev_redrawflag ) return;
127 
128 	//ActivatePalette(win.ref);
129 	LOCK_ALL_PIXMAP();
130 	GetGWorld(&oldGW, &oldGD);
131 
132 		SetPortWindowPort(win.ref);
133 		RGBBackColor(&white);
134 		RGBForeColor(&black);
135 		CopyBits((BitMap*)&DISP_PIX, &win.ref->portBits,
136 				&rect, &rect, srcCopy,0);
137 
138 	SetGWorld(oldGW, oldGD);
139 	UNLOCK_ALL_PIXMAP();
140 }
141 
reverse_helper(int x,int y,int byte)142 static void reverse_helper(int x, int y, int byte)
143 {
144 	Rect rect;
145 
146 	rect.left=WRD_LOCX(x); //erase upper
147 	rect.top=WRD_LOCY(y-1)+3;
148 	rect.right=rect.left+BASE_X*byte;
149 	rect.bottom=rect.top+1;
150 	PaintRect(&rect);
151 
152 	rect.left=WRD_LOCX(x)+7*byte; //erase right
153 	//rect.top=WRD_LOCY(y-1)+2;
154 	rect.right=rect.left+byte;
155 	rect.bottom=WRD_LOCY(y)+3;
156 	PaintRect(&rect);
157 }
158 
dev_text_redraw(int locx1,int locy1,int locx2,int locy2)159 static void dev_text_redraw(int locx1, int locy1, int locx2, int locy2)
160 {
161 	int x,y,startx, mode,color, len;
162 	GDHandle	oldGD;
163 	GWorldPtr	oldGW;
164 
165 	if( !wrd_ton ) return;
166 
167 	if( locx1<1 ) locx1=1;
168 	if( locx2>80 ) locx2=80;
169 	if( locy1<1 ) locy1=1;
170 	if( locy2>25 ) locy2=25;
171 	if( wrd_ton==2 ){
172 		//locx1-= (locx1-1)%4;
173 		locx1=1;
174 	}
175 
176 	LOCK_ALL_PIXMAP();
177 	GetGWorld(&oldGW, &oldGD);
178 
179 		SetGWorld(dispWorld,0);
180 		TextMode(srcOr);
181 		for( y=locy1; y<=locy2; y++){
182 			startx=locx1;
183 			if( startx-1>=1 && MULTI_BYTE_FLAG(startx-1,y) )
184 					startx--;
185 			for( x=startx; x<=locx2; ){
186 				if( CHAR_VRAM(x,y)==0 ){ x++; continue;}
187 				SET_T_RGBFORECOLOR_TMP(CHAR_COLOR_VRAM(x,y)&CATTR_TXTCOL_MASK);
188 				mode= (CHAR_COLOR_VRAM(x,y)&CATTR_BGCOLORED)? 2:1;
189 				color= TCODE2INDEX(CHAR_COLOR_VRAM(x,y));
190 				len= MULTI_BYTE_FLAG(x,y)? 2:1;
191 				if( wrd_ton==2 ){
192 					char *cp;
193 					if( MULTI_BYTE_FLAG(x-1,y) ){
194 						cp= &CHAR_VRAM(x-1,y); len=2;
195 						SET_T_RGBFORECOLOR_TMP(CHAR_COLOR_VRAM(x-1,y)&CATTR_TXTCOL_MASK);
196 						mode= (CHAR_COLOR_VRAM(x-1,y)&CATTR_BGCOLORED)? 2:1;
197 						color= TCODE2INDEX(CHAR_COLOR_VRAM(x-1,y));
198 					}else{
199 						cp= &CHAR_VRAM(x,y);
200 					}
201 					dev_draw_text_gmode( dispWorld->portPixMap, WRD_LOCX(x), WRD_LOCY(y-1)+3,
202 						cp, len, 0xFF, mode, color, color, wrd_ton );
203 					x+= len*2;
204 					continue;
205 				}
206 				(CHAR_COLOR_VRAM(x,y)&CATTR_BGCOLORED)?
207 					TextMode(notSrcOr) : TextMode(srcOr);
208 				WRD_MOVE_COURSOR_TMP(x,y);
209 				if( MULTI_BYTE_FLAG(x,y) ){
210 					DrawText(&CHAR_VRAM(x,y), 0, 2);
211 					if(CHAR_COLOR_VRAM(x,y)&CATTR_BGCOLORED) reverse_helper(x,y, 2);
212 					x+=2;
213 				}else{
214 					if( CHAR_VRAM(x,y)==' ' && (CHAR_COLOR_VRAM(x,y)&CATTR_BGCOLORED) ){
215 						Rect rect;              //speedy draw
216 						rect.top=WRD_LOCY(y-1)+3;
217 						rect.left=WRD_LOCX(x);
218 						rect.bottom=rect.top+BASE_Y;
219 						rect.right=rect.left+BASE_X;
220 						PaintRect(&rect); x++;
221 					}else{
222 						DrawText(&CHAR_VRAM(x,y), 0, 1);
223 						if(CHAR_COLOR_VRAM(x,y)&CATTR_BGCOLORED) reverse_helper(x,y, 1); x++;
224 					}
225 				}
226 			}
227 		}
228 
229 	SetGWorld(oldGW, oldGD);
230 	UNLOCK_ALL_PIXMAP();
231 }
232 
dev_text_redraw_rect(Rect rect)233 static void dev_text_redraw_rect(Rect rect)
234 {
235 	dev_text_redraw(rect.left/BASE_X+1, rect.top/BASE_Y+1,
236 						rect.right/BASE_X+1, rect.bottom/BASE_Y+1);
237 }
238 
dev_remake_disp(Rect rect)239 void dev_remake_disp(Rect rect)
240 {						//copy gdisp -> disp, draw text on gdisp
241 	LOCK_ALL_PIXMAP();
242 		if( dev_gon_flag) MyCopyBits(GDISP_PIX, DISP_PIX,
243 						rect, rect, 0, 0, 0xFF, 0,0,0);
244 			else dev_box(DISP_PIX, rect, 0, 0xFF); //all pal=0 color
245 	UNLOCK_ALL_PIXMAP();
246 
247 	dev_text_redraw_rect(rect);
248 }
249 
loc2rect(int locx1,int locy1,int locx2,int locy2)250 static Rect loc2rect(int locx1, int locy1, int locx2, int locy2)
251 {
252 	Rect	rect;
253 
254 	if( locx1 < 1 ) locx1=1;
255 	if( locx2 > COLS ) locx2=COLS;
256 	if( locy1 < 1 ) locy1=1;
257 	if( locy2 > LINES ) locy2=LINES;
258 
259 	rect.top=WRD_LOCY(locy1-1)+3;
260 	rect.left=WRD_LOCX(locx1);
261 	rect.bottom=WRD_LOCY(locy2)+3;
262 	rect.right=WRD_LOCX(locx2+1);
263 	return rect;
264 }
265 
dev_text_clear(int locx1,int locy1,int locx2,int locy2,int color,char ch,int need_update)266 static void dev_text_clear(int locx1, int locy1, int locx2, int locy2,
267 							int color, char ch, int need_update)
268 {									// clear (x1,y1) .... (x2,y1)
269 	int		y, startx,endx, width;
270 
271 	if( COLS<locx2 ) locx2=COLS;
272 	if( locx1<0 || COLS<locx1  || locx2<0 ||
273 		locy1<0 || LINES<locy1 || locy2<0 || LINES<locy2 ) return;
274 	if( locx2 < locx1 ) return;
275 
276 	if( ch==' ' && !(color & 0x08) ){ch=0;}
277 	width=locx2-locx1+1;
278 	for( y=locy1; y<=locy2; y++ ){
279 		startx= locx1-(MULTI_BYTE_FLAG(locx1-1,y)? 1:0);
280 		endx= locx2+(MULTI_BYTE_FLAG(locx2,y)? 1:0);
281 		width=endx-startx+1;
282 		memset(&CHAR_VRAM(startx,y), ch, width);
283 		memset(&MULTI_BYTE_FLAG(startx,y), 0, width);
284 		memset(&CHAR_COLOR_VRAM(startx,y), color, width);
285 	}
286 	if( need_update ){
287 		Rect rect=loc2rect(locx1-1, locy1, locx2+1, locy2); //take margin
288 		dev_remake_disp(rect);
289 		dev_redisp(rect);
290 	}
291 }
292 
dev_text_clear_all()293 static void dev_text_clear_all()
294 {
295 	memset(&CHAR_VRAM(0,0), 0, sizeof(char_vram));
296 	memset(&MULTI_BYTE_FLAG(0,0), 0, sizeof(multi_byte_flag));
297 }
298 
dev_text_output(const char * text,int n)299 static void dev_text_output(const char* text, int n)
300 {
301 	int i, startx=wrd_coursor_x, endx=wrd_coursor_x+n-1;
302 	GDHandle	oldGD;
303 	GWorldPtr	oldGW;
304 
305 	if( wrd_coursor_x<=0 || 81<=wrd_coursor_x ||
306 		wrd_coursor_y<=0 || 26 <=wrd_coursor_y ) return;
307 
308 	LOCK_ALL_PIXMAP();
309 	GetGWorld(&oldGW, &oldGD);
310 
311 	dev_text_clear(startx, wrd_coursor_y, endx, wrd_coursor_y, 0, 0, false);
312 
313 	SetGWorld(oldGW, oldGD);
314 	UNLOCK_ALL_PIXMAP();
315 
316 	for( i=0; i<n; i++ ){
317 		if( wrd_coursor_x+i<=0 || 81<=wrd_coursor_x+i ||
318 			wrd_coursor_y<=0 || 26 <=wrd_coursor_y ) continue;
319 		CHAR_VRAM(wrd_coursor_x+i,wrd_coursor_y)=text[i];
320 		CHAR_COLOR_VRAM(wrd_coursor_x+i,wrd_coursor_y)= wrd_text_color_attr;
321 		if( IS_MULTI_BYTE(text[i]) ){
322 			MULTI_BYTE_FLAG(wrd_coursor_x+i,wrd_coursor_y)=1;
323 			if( i<n ){
324 				i++; CHAR_VRAM(wrd_coursor_x+i,wrd_coursor_y)=text[i];
325 				MULTI_BYTE_FLAG(wrd_coursor_x+i,wrd_coursor_y)=0;
326 			}
327 		}
328 	}
329 	wrd_coursor_x+=n;
330 	if( wrd_ton==2) endx+=2;
331 
332 	dev_remake_disp(loc2rect(startx-1, wrd_coursor_y, endx+1, wrd_coursor_y));
333 	dev_redisp(loc2rect(startx-1, wrd_coursor_y, endx+1, wrd_coursor_y));
334 }
335 
dev_text_scroll(int x1,int y1,int x2,int y2,int mode,int color,char ch,int num)336 static void dev_text_scroll(int x1, int y1, int x2, int y2, int mode, int color, char ch, int num)
337 {
338 	int y,width;
339 
340 	if( num<=0 ) return;
341 	switch(mode)
342 	{
343 	case 0: //scroll upper
344 		for( y=y1; y<=y2 && y<=LINES; y++ ){
345 			if( y-num <y1 ) continue;
346 			memcpy(&CHAR_VRAM(1,y-num),&CHAR_VRAM(1,y),COLS);
347 			memcpy(&CHAR_COLOR_VRAM(1,y-num),&CHAR_COLOR_VRAM(1,y),COLS);
348 			memcpy(&MULTI_BYTE_FLAG(1,y-num),&MULTI_BYTE_FLAG(1,y),COLS);
349 		}
350 		dev_text_clear(x1, y2-num+1, x2, y2, color, ch, false);
351 		break;
352 	case 1: //scroll down
353 		for( y=y2; y>=y1 && y>=1; y-- ){
354 			if( y+num> y2 ) continue;
355 			memcpy(&CHAR_VRAM(1,y+num),&CHAR_VRAM(1,y),COLS);
356 			memcpy(&CHAR_COLOR_VRAM(1,y+num),&CHAR_COLOR_VRAM(1,y),COLS);
357 			memcpy(&MULTI_BYTE_FLAG(1,y+num),&MULTI_BYTE_FLAG(1,y),COLS);
358 		}
359 		dev_text_clear(x1, y1, x2, y1+num-1, color, ch, false);
360 		break;
361 	case 2: //scroll right
362 	case 3: //scroll left
363 		if( mode==3 ) num*=-1;
364 		if( x1+num<1 ) x1=1-num;
365 		if( x2+num>COLS ) x2=COLS-num;
366 		width=x2-x1+1; if( width<=0 ) break;
367 		for( y=y1; y<=y2 && y<=LINES; y++ ){
368 			memmove(&CHAR_VRAM(x1+num,y),&CHAR_VRAM(x1,y),width);
369 			memmove(&CHAR_COLOR_VRAM(x1+num,y),&CHAR_COLOR_VRAM(x1,y),width);
370 			memmove(&MULTI_BYTE_FLAG(x1+num,y),&MULTI_BYTE_FLAG(x1,y),width);
371 		}
372 		if( mode==2 ) //right
373 			dev_text_clear(x1, y1, x1+num-1, y2, color, ch, false);
374 		else if( mode==3 )
375 			dev_text_clear(x2+num+1, y1, x2, y2, color, ch, false);
376 		break;
377 	}
378 }
379 
dev_move_coursor(int x,int y)380 static void dev_move_coursor(int x, int y)
381 {
382 	wrd_coursor_x=x;
383 	wrd_coursor_y=y;
384 	if( wrd_coursor_x<1 ) wrd_coursor_x=1;
385 	else if( wrd_coursor_x>COLS ) wrd_coursor_x=COLS;
386 	if( wrd_coursor_y<1 ) wrd_coursor_y=1;
387 	else if( wrd_coursor_y>LINES ) wrd_coursor_y=LINES;
388 }
389 
dev_newline()390 static void dev_newline()
391 {
392 	if( wrd_coursor_y>=25 ){
393 		dev_text_scroll(1, 1, 80, 25, 0, 0, 0, 1);
394 		dev_remake_disp(portRect);
395 		dev_redisp(portRect);
396 		dev_move_coursor(1, 25);
397 	}else{
398 		dev_move_coursor(1, wrd_coursor_y+1);
399 	}
400 }
401 
dev_clear_graphics(int pmask)402 static void dev_clear_graphics(int pmask)
403 {				//clear active bank only
404 	GDHandle	oldGD;
405 	GWorldPtr	oldGW;
406 
407 	GetGWorld(&oldGW, &oldGD);
408 	LOCK_ALL_PIXMAP();
409 
410 	SetGWorld(graphicWorld[activeGraphics],0);
411 		dev_box(GACTIVE_PIX, portRect, 0, pmask);
412 	UNLOCK_ALL_PIXMAP();
413 	SetGWorld(oldGW, oldGD);
414 
415 	if( activeGraphics==dispGraphics ){
416 		dev_remake_disp(portRect);
417 		dev_redisp(portRect);
418 	}
419 }
420 
421 #define  CHECK_RECT(rect) {            \
422 	short	tmp;                       \
423 	if( rect.left>rect.right ){ tmp=rect.left; rect.left=rect.right; rect.right=tmp;} \
424 	if( rect.top>rect.bottom ){ tmp=rect.top; rect.top=rect.bottom; rect.bottom=tmp;} \
425 }
426 
427 
dev_gmove(int x1,int y1,int x2,int y2,int xd,int yd,GWorldPtr srcworld,GWorldPtr destworld,int sw,int trans,int pmask,int maskx,int masky,const uint8 maskdata[])428 void dev_gmove(int x1, int y1, int x2, int y2, int xd, int yd,
429 		GWorldPtr srcworld, GWorldPtr destworld, int sw, int trans, int pmask,
430 		int maskx, int masky, const uint8 maskdata[])
431 {
432 	static Rect	src,dest, rect;
433 	GDHandle	oldGD;
434 	GWorldPtr	oldGW;
435 
436 	if( srcworld==NULL || destworld==NULL ){
437 	    ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Can't use gvram bank" );
438 		return;
439 	}
440 
441 	LOCK_ALL_PIXMAP();
442 	GetGWorld(&oldGW, &oldGD);
443 	LockPixels(srcworld->portPixMap);
444 	LockPixels(destworld->portPixMap);
445 
446 	SetRect(&src,  x1,y1,x2+1,y2+1);		CHECK_RECT(src);
447 	SetRect(&dest, xd,yd, xd+x2-x1+1, yd+y2-y1+1);	CHECK_RECT(dest);
448 
449 	SetPortWindowPort(win.ref);
450 	RGBBackColor(&white);
451 	RGBForeColor(&black);
452 	if( sw==0 ){ //simple copy
453 		//CopyBits((BitMap*)&graphicWorld[vs]->portPixMap, (BitMap*)&graphicWorld[vd]->portPixMap,
454 		//		&src, &dest, srcCopy,0); //make offscreen Graphics
455 		MyCopyBits(srcworld->portPixMap, destworld->portPixMap,
456 				src, dest, 0, 0, gmode_mask,0,0,0); //make offscreen Graphics
457 	} else if(sw==1){ //exchange
458 		CopyBits((BitMap*)&srcworld->portPixMap, (BitMap*)&destworld->portPixMap,
459 				&src, &dest, srcXor,0);
460 		CopyBits((BitMap*)&destworld->portPixMap, (BitMap*)&srcworld->portPixMap,
461 				&dest, &src, srcXor,0);
462 		CopyBits((BitMap*)&srcworld->portPixMap, (BitMap*)&destworld->portPixMap,
463 				&src, &dest, srcXor,0);	//make offscreen Graphics
464 
465 	} else if(sw==2){	//xor copy
466 		CopyBits((BitMap*)&srcworld->portPixMap, (BitMap*)&destworld->portPixMap,
467 				&src, &dest, srcXor,0); //make offscreen Graphics
468 	}else if( sw & 0x10 ){ //xcopy mode
469 		MyCopyBits(srcworld->portPixMap, destworld->portPixMap,
470 			src, dest, sw, trans, pmask, maskx, masky, maskdata); //make offscreen Graphics
471 	}
472 
473 	SetGWorld(oldGW, oldGD);
474 	UNLOCK_ALL_PIXMAP();
475 	UnlockPixels(srcworld->portPixMap);
476 	UnlockPixels(destworld->portPixMap);
477 
478 	if( graphicWorld[dispGraphics]==destworld ){
479 		dev_remake_disp(dest);
480 		dev_redisp(dest);
481 	}
482 	if( graphicWorld[dispGraphics]==srcworld && sw==1 ){  //exchange? update src
483 		dev_remake_disp(src);
484 		dev_redisp(src);
485 	}
486 }
487 
dev_gscreen(int act,int dis)488 static void dev_gscreen(int act, int dis)
489 {
490 	if( act!=0 && act!=1 ) return;
491 	if( dis!=0 && dis!=1 ) return;
492 
493 	activeGraphics=act;
494 	if( dispGraphics!=dis ){
495 		dispGraphics=dis;
496 		dev_remake_disp(portRect);
497 		dev_redisp(portRect);
498 	}
499 }
500 
dev_get_pixel(int x,int y)501 static int dev_get_pixel(int x, int y)
502 {
503 	Ptr baseadr;
504 	int rowBytes;
505 
506 	baseadr=GetPixBaseAddr(graphicWorld[activeGraphics]->portPixMap);
507 	rowBytes= (**graphicWorld[activeGraphics]->portPixMap).rowBytes & 0x1FFF;
508 
509 	return baseadr[y*rowBytes+x];
510 }
511 
dev_gline(int x1,int y1,int x2,int y2,int p1,int sw,int p2,GWorldPtr world)512 void dev_gline(int x1, int y1, int x2, int y2, int p1, int sw, int p2, GWorldPtr world)
513 {
514 	Rect	rect;
515 	GDHandle	oldGD;
516 	GWorldPtr	oldGW;
517 
518 	GetGWorld(&oldGW, &oldGD);
519 	LockPixels(world->portPixMap);
520 	SetGWorld(world,0);
521 
522 	rect.left=x1; rect.right=x2;
523 	rect.top=y1; rect.bottom=y2;
524 	CHECK_RECT(rect);
525 
526 	switch(sw)
527 	{
528 	case 0: //line
529 		if( p2==0 || p2==WRD_NOARG ) p2= 0xFF;
530 		dev_line(x1, y1, x2, y2, p1,p2, gmode_mask_gline,
531 			world->portPixMap );
532 		break;
533 	case 1: //rect
534 		if( p2==0 || p2==WRD_NOARG ) p2= 0xFF;
535 		dev_line(x1, y1, x2, y1, p1,p2, gmode_mask_gline,world->portPixMap );
536 		dev_line(x1, y1, x1, y2, p1,p2, gmode_mask_gline,world->portPixMap );
537 		dev_line(x2, y1, x2, y2, p1,p2, gmode_mask_gline,world->portPixMap );
538 		dev_line(x1, y2, x2, y2, p1,p2, gmode_mask_gline,world->portPixMap );
539 		break;
540 	case 2:	//filled rect
541 	      	if( p2==WRD_NOARG ) p2= p1;
542 		rect.right++; rect.bottom++;
543 		dev_box(world->portPixMap, rect, p2, gmode_mask_gline);
544 		if( p1!=p2 ){
545 			dev_line(x1, y1, x2, y1, p1,0xFF, gmode_mask_gline,world->portPixMap );
546 			dev_line(x1, y1, x1, y2, p1,0xFF, gmode_mask_gline,world->portPixMap );
547 			dev_line(x2, y1, x2, y2, p1,0xFF, gmode_mask_gline,world->portPixMap );
548 			dev_line(x1, y2, x2, y2, p1,0xFF, gmode_mask_gline,world->portPixMap );
549 		}
550 		break;
551 	}
552 	SetGWorld(oldGW, oldGD);
553 	UnlockPixels(world->portPixMap);
554 
555 	if( graphicWorld[dispGraphics]==world ){
556 		rect.right++; rect.bottom++;
557 		dev_remake_disp(rect);
558 		if( pallette_exist) dev_redisp(rect);
559 	}
560 }
561 
dev_gcircle(int x,int y,int r,int p1,int sw,int p2)562 static void dev_gcircle(int x, int y, int r, int p1, int sw, int p2)
563 {
564 	//int		onbit;
565 	Rect	rect;
566 	GDHandle	oldGD;
567 	GWorldPtr	oldGW;
568 
569 	GetGWorld(&oldGW, &oldGD);
570 	LockPixels(GACTIVE_PIX);
571 	SetGWorld(graphicWorld[activeGraphics],0);
572 	rect.left=x-r; rect.right=x+r;
573 	rect.top=y-r; rect.bottom=y+r;
574 
575 	switch(sw)
576 	{
577 	case 0:
578 	case 1: //frame
579 		SET_G_COLOR(p1,graphicWorld[activeGraphics]);
580 		FrameOval(&rect);
581 		break;
582 	case 2:	//filled circle
583 		SET_G_COLOR(p2,graphicWorld[activeGraphics]);
584 		PaintOval(&rect);
585 		SET_G_COLOR(p1,graphicWorld[activeGraphics]);
586 		FrameOval(&rect);
587 		break;
588 	}
589 	SetGWorld(oldGW, oldGD);
590 	UnlockPixels(GACTIVE_PIX);
591 
592 	if( activeGraphics==dispGraphics ){
593 		rect.right++; rect.bottom++;
594 		dev_remake_disp(rect);
595 		dev_redisp(rect);
596 	}
597 }
598 
599 static void dev_set_text_attr(int esccode);
600 static int Parse(int c);
601 
dev_init(int version)602 void dev_init(int version)
603 {
604 	int i;
605 
606 	inkey_flag = 0;
607 	dev_gon_flag=1;
608 	dev_set_text_attr(37); //white
609 	dev_change_1_palette(0, black);
610 	dev_change_1_palette(16, black); //for gon(0)
611 
612     gmode_mask=0xF;
613    	if( version<=0 || (380<=version && version<=399))
614 			gmode_mask_gline=0x7;  //change gline behavier
615 	else    gmode_mask_gline=0xF;
616 
617 	for(i=0; i<gvram_bank_num; i++){
618 		dev_gscreen(i, dispGraphics); dev_clear_graphics(0xFF);
619 	}
620     dev_gscreen(0, 0);
621 
622 	dev_text_clear_all(); wrd_ton=1;
623    	dev_remake_disp(portRect);
624 	dev_redisp(portRect);
625 
626 	dev_move_coursor(1,1);
627 	startpal=endpal=0;
628 	pallette_exist=true;
629 	fading=false;
630 	Parse(-1); //initialize parser
631 
632 	wrd_init_path();
633 }
634 
get_vsscreen()635 static OSErr get_vsscreen()
636 {
637 	OSErr	err;
638 	Rect	rect=portRect;
639 
640 	rect.right++; rect.bottom++;  //keep safty zone
641 	err=NewGWorld(&graphicWorld[gvram_bank_num], 8, &rect,
642 						0, 0,0);
643 	if( ! err ){
644 		ctl->cmsg(CMSG_INFO, VERB_NORMAL, "get gvram bank %d",gvram_bank_num );
645 		gvram_bank_num++;
646 	}else{
647 		ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Can't get gvram bank %d",gvram_bank_num );
648 	}
649 	return err;
650 }
651 
dev_vsget(int num)652 static OSErr dev_vsget(int num)
653 {
654 	OSErr	err;
655 	int i;
656 	for( i=gvram_bank_num; i<2+num; i++ ){
657 		err=get_vsscreen();
658 		if( err ) return err;
659 	}
660 	return 0;
661 }
662 
dev_setup()663 static OSErr dev_setup()
664 {
665 	static OSErr	err=0;
666 	int		i;
667 	Rect		destRect;
668 
669 	if( err ) return err; // once errored, do not retry
670 
671 	destRect.top=destRect.left=0;
672 	destRect.right=640;
673 	destRect.bottom=480;
674 	gvram_bank_num=0;
675 
676 	err=NewGWorld(&dispWorld, 8, &destRect,0,0,0);
677 	if( err ) return err;
678 
679 	{
680 	Rect charbufRect={0,0,16,32};
681 	err=NewGWorld(&charbufWorld, 8, &charbufRect,0,0,0);
682 	if( err ) return err;
683 	mac_setfont(charbufWorld, WRD_FONTNAME);
684 	}
685 
686 	//wrd_palette= NewPalette( 33, 0, pmTolerant, 0x0000);
687 	//if( wrd_palette )  SetPalette(win.ref, wrd_palette, true);
688 
689 	for( i=0; i<=1; i++){
690 		err=get_vsscreen();
691 		if( err ) return err;
692 	}
693 
694 	dev_init_text_color();
695 
696 	mac_setfont(dispWorld, WRD_FONTNAME);
697 
698 	dev_init(-1);
699 	return 0; //noErr
700 }
701 
702 // ***********************************************
703 #pragma mark -
704 
705 /*VTParse Table externals*/
706 extern int groundtable[];
707 extern int csitable[];
708 extern int dectable[];
709 extern int eigtable[];
710 extern int esctable[];
711 extern int iestable[];
712 extern int igntable[];
713 extern int scrtable[];
714 extern int scstable[];
715 extern int mbcstable[];
716 extern int smbcstable[];
717 #define MAXPARAM 20
718 #define DEFAULT -1
719 #define TAB_SET 8
720 #define MBCS 1
721 #define CATTR_LPART (1)
722 #define CATTR_16FONT (1<<1)
723 #define CATTR_COLORED (1<<2)
724 #define CATTR_BGCOLORED (1<<3)
725 #define CATTR_TXTCOL_MASK_SHIFT 4
726 #define CATTR_TXTCOL_MASK (7<<CATTR_TXTCOL_MASK_SHIFT)
727 #define CATTR_INVAL (1<<31)
728 
DelChar(int,int)729 static void DelChar(int /*x*/, int /*y*/){}
730 #define ClearLine(y) dev_text_clear(1, (y), 80, (y), 0, 0, false)
731 #define ClearRight()	dev_text_clear(wrd_coursor_x, wrd_coursor_y, 80, wrd_coursor_y, 0, 0, false)
732 #define ClearLeft()		dev_text_clear(1, wrd_coursor_y, wrd_coursor_x, wrd_coursor_y, 0, 0, false)
733 
RedrawInject(int x1,int y1,int x2,int y2,Boolean)734 static void RedrawInject(int x1, int y1, int x2, int y2, Boolean)
735 {
736 	Rect rect;
737 	SetRect(&rect,x1,y1,x2,y2);
738 	dev_remake_disp(rect);
739 	dev_redisp(rect);
740 }
741 
dev_set_text_attr(int esccode)742 static void dev_set_text_attr(int esccode)
743 {
744 start:
745 	switch(esccode){
746 	default:
747 	  esccode=37; goto start;
748 
749 	case 17: esccode=31; goto start;
750 	case 18: esccode=34; goto start;
751 	case 19: esccode=35; goto start;
752 	case 20: esccode=32; goto start;
753 	case 21: esccode=33; goto start;
754 	case 22: esccode=36; goto start;
755 	case 23: esccode=37; goto start;
756 
757 	case 16:
758 	case 30:
759 	case 31:
760 	case 32:
761 	case 33:
762 	case 34:
763 	case 35:
764 	case 36:
765 	case 37:
766 	  wrd_text_color_attr&=~CATTR_TXTCOL_MASK;
767 	  wrd_text_color_attr|=(
768 			  ((esccode>=30)?(esccode-30):(esccode-16))<<
769 			  CATTR_TXTCOL_MASK_SHIFT);
770 	  wrd_text_color_attr|=CATTR_COLORED;
771 	  wrd_text_color_attr&=~CATTR_BGCOLORED;
772 	  break;
773 	case 40:
774 	case 41:
775 	case 42:
776 	case 43:
777 	case 44:
778 	case 45:
779 	case 46:
780 	case 47:
781 	  wrd_text_color_attr&=~CATTR_TXTCOL_MASK;
782 	  wrd_text_color_attr|=(esccode-40)<<CATTR_TXTCOL_MASK_SHIFT;
783 	  wrd_text_color_attr|=CATTR_BGCOLORED;
784 	  break;
785 	}
786 }
787 
Parse(int c)788 static int Parse(int c)
789 {
790   static int *prstbl=groundtable;
791   static char mbcs;
792   static int params[MAXPARAM],nparam=0;
793   static int hankaku=0;
794   static int savcol,savline;
795   static long savattr;
796 
797   if(c==-1) {
798     prstbl=groundtable;
799     mbcs=0;
800     nparam=0;
801     hankaku=0;
802     savcol=savline=0;
803     return 0;
804   }
805 
806   if(mbcs&&
807      prstbl !=mbcstable&&
808      prstbl !=scstable&&
809      prstbl !=scstable){
810     mbcs=0;
811   }
812   switch(prstbl[c]){
813   case CASE_IGNORE_STATE:
814     prstbl=igntable;
815     break;
816   case CASE_IGNORE_ESC:
817     prstbl=iestable;
818     break;
819   case CASE_ESC:
820     prstbl=esctable;
821     break;
822   case CASE_ESC_IGNORE:
823     prstbl=eigtable;
824     break;
825   case CASE_ESC_DIGIT:
826     if(nparam<MAXPARAM){
827       if(params[nparam]==DEFAULT){
828 	params[nparam]=0;
829       }
830       if( c==' ' ){
831       	c='0';
832       }
833       params[nparam]*=10;
834       params[nparam]+=c-'0';
835     }
836     break;
837   case CASE_ESC_SEMI:
838     nparam++;
839     params[nparam]=DEFAULT;
840     break;
841   case CASE_TAB:
842     wrd_coursor_x+=TAB_SET;
843     wrd_coursor_x&=~(TAB_SET-1);
844     break;
845   case CASE_BS:
846     if(wrd_coursor_x > 0)
847       wrd_coursor_x--;
848 #if 0 /* ^H maybe work backward character in MIMPI's screen */
849     DelChar(wrd_coursor_y,wrd_coursor_x);
850     mywin.scrnbuf[wrd_coursor_y][wrd_coursor_x].c=0;
851     mywin.scrnbuf[wrd_coursor_y][wrd_coursor_x].attr=0;
852 #endif
853     break;
854   case CASE_CSI_STATE:
855     nparam=0;
856     params[0]=DEFAULT;
857     prstbl=csitable;
858     break;
859   case CASE_SCR_STATE:
860     prstbl=scrtable;
861     mbcs=0;
862     break;
863   case CASE_MBCS:
864     hankaku=0;
865     prstbl=mbcstable;
866     mbcs=MBCS;
867     break;
868   case CASE_SCS_STATE:
869     if(mbcs)
870       prstbl=smbcstable;
871     else
872       prstbl=scstable;
873     break;
874   case CASE_GSETS:
875     wrd_text_color_attr=(mbcs)?(wrd_text_color_attr|CATTR_16FONT):
876       (wrd_text_color_attr&~(CATTR_16FONT));
877     if(!mbcs){
878       hankaku=(c=='I')?1:0;
879     }
880     prstbl=groundtable;
881     break;
882   case CASE_DEC_STATE:
883     prstbl =dectable;
884     break;
885   case CASE_SS2:
886   case CASE_SS3:
887     /*These are ignored because this will not accept SS2 SS3 charset*/
888   case CASE_GROUND_STATE:
889     prstbl=groundtable;
890     break;
891   case CASE_CR:
892     wrd_coursor_x=1;
893     prstbl=groundtable;
894     break;
895   case CASE_IND:
896   case CASE_VMOT:
897     wrd_coursor_y++;
898     wrd_coursor_x=1;
899     prstbl=groundtable;
900     break;
901   case CASE_CUP:
902     wrd_coursor_y=(params[0]<1)?0:params[0];
903     if(nparam>=1)
904       wrd_coursor_x=(params[1]<1)?0:params[1];
905     else
906       wrd_coursor_x=0;
907     prstbl=groundtable;
908     break;
909   case CASE_PRINT:
910     if(wrd_text_color_attr&CATTR_16FONT){
911       if(!(wrd_text_color_attr&CATTR_LPART)&&(wrd_coursor_x==COLS)){
912 	wrd_coursor_x++;
913 	return 1;
914       }
915       wrd_text_color_attr^=CATTR_LPART;
916     }
917     else
918       wrd_text_color_attr&=~CATTR_LPART;
919     DelChar(wrd_coursor_y,wrd_coursor_x);
920     if(hankaku==1)
921       c|=0x80;
922     //mywin.scrnbuf[wrd_coursor_y][wrd_coursor_x].attr=wrd_text_color_attr;
923     //mywin.scrnbuf[wrd_coursor_y][wrd_coursor_x].c=c;
924     wrd_coursor_x++;
925     break;
926   case CASE_CUU:
927     wrd_coursor_y-=((params[0]<1)?1:params[0]);
928     prstbl=groundtable;
929     break;
930   case CASE_CUD:
931     wrd_coursor_y+=((params[0]<1)?1:params[0]);
932     prstbl=groundtable;
933     break;
934   case CASE_CUF:
935     wrd_coursor_x+=((params[0]<1)?1:params[0]);
936     prstbl=groundtable;
937     break;
938   case CASE_CUB:
939     wrd_coursor_x-=((params[0]<1)?1:params[0]);
940   	if( wrd_coursor_x<1 ) wrd_coursor_x=1;
941     prstbl=groundtable;
942     break;
943   case CASE_ED:
944     switch(params[0]){
945     case DEFAULT:
946     case 0:
947       {
948 	int j;
949 	  ClearRight();
950 	for(j=wrd_coursor_y+1;j<=LINES;j++)
951 	  ClearLine(j);
952       }
953       break;
954     case 1:
955       {
956 	int j;
957 	  ClearLeft();
958 	for(j=1;j<wrd_coursor_y;j++)
959 	  ClearLine(j);
960       }
961       break;
962     case 2:
963       {
964 	//int j;
965 	//for(j=0;j<LINES;j++){
966 	//  free(mywin.scrnbuf[j]);
967 	//  mywin.scrnbuf[j]=NULL;
968 	//}
969 	dev_text_clear_all();
970 	wrd_coursor_y=1;
971 	wrd_coursor_x=1;
972 	break;
973       }
974     }
975     RedrawInject(0,0,SIZEX,SIZEY,false);
976     prstbl=groundtable;
977     break;
978   case CASE_DECSC:
979     savcol=wrd_coursor_x;
980     savline=wrd_coursor_y;
981     savattr=wrd_text_color_attr;
982     prstbl=groundtable;
983   case CASE_DECRC:
984     wrd_coursor_x=savcol;
985     wrd_coursor_y=savline;
986     wrd_text_color_attr=savattr;
987     prstbl=groundtable;
988     break;
989   case CASE_SGR:
990     {
991       int i;
992       for(i=0;i<nparam+1;i++)
993 		dev_set_text_attr(params[i]);
994     }
995     prstbl=groundtable;
996     break;
997   case CASE_EL:
998     switch(params[0]){
999     case DEFAULT:
1000     case 0:
1001       ClearRight();
1002       break;
1003     case 1:
1004       ClearLeft();
1005       break;
1006     case 2:
1007       ClearLine(wrd_coursor_y);
1008       break;
1009     }
1010     RedrawInject(0,0,SIZEX,SIZEY,false);
1011     prstbl=groundtable;
1012     break;
1013   case CASE_NEL:
1014     wrd_coursor_y++;
1015     wrd_coursor_x=1;
1016     wrd_coursor_y=(wrd_coursor_y<LINES)?wrd_coursor_y:LINES;
1017     break;
1018 /*Graphic Commands*/
1019   case CASE_MY_GRAPHIC_CMD:
1020     //GrphCMD(params,nparam);
1021     prstbl=groundtable;
1022     break;
1023   case CASE_DL:
1024 	dev_text_scroll(1, wrd_coursor_y+params[0], COLS, LINES, 0, 0, 0, params[0]);
1025     RedrawInject(0,0,SIZEX,SIZEY,false);
1026 	prstbl=groundtable;
1027 	break;
1028 /*Unimpremented Command*/
1029   case CASE_ICH:
1030   case CASE_IL:
1031   case CASE_DCH:
1032   case CASE_DECID:
1033   case CASE_DECKPAM:
1034   case CASE_DECKPNM:
1035   //case CASE_IND:
1036   case CASE_HP_BUGGY_LL:
1037   case CASE_HTS:
1038   case CASE_RI:
1039   case CASE_DA1:
1040   case CASE_CPR:
1041   case CASE_DECSET:
1042   case CASE_RST:
1043   case CASE_DECSTBM:
1044   case CASE_DECREQTPARM:
1045   case CASE_OSC:
1046   case CASE_RIS:
1047   case CASE_HP_MEM_LOCK:
1048   case CASE_HP_MEM_UNLOCK:
1049   case CASE_LS2:
1050   case CASE_LS3:
1051   case CASE_LS3R:
1052   case CASE_LS2R:
1053   case CASE_LS1R:
1054     ctl->cmsg(CMSG_INFO,VERB_VERBOSE,"NOT IMPREMENTED:%d\n",prstbl[c]);
1055     prstbl=groundtable;
1056     break;
1057   case CASE_BELL:
1058   case CASE_IGNORE:
1059   default:
1060     break;
1061   }
1062   if( prstbl==groundtable ) return 1;
1063   return 0;
1064 }
1065 
1066 // ***********************************************
1067 #pragma mark -
1068 #pragma mark ================== Wrd Window
1069 
1070 static int open_WrdWin();
1071 static void click_WrdWin(Point local, short modifiers);
1072 static void update_WrdWin();
1073 static int	message_WrdWin(int message, long param);
1074 
1075 //#define win mac_WrdWindow  //already defined
1076 MacWindow win={
1077 	0,	//WindowRef
1078 	open_WrdWin,
1079 	click_WrdWin,
1080 	update_WrdWin,
1081 	goaway_default,
1082 	close_default,
1083 	message_WrdWin,
1084 	0, 50,70
1085 };
1086 
open_WrdWin()1087 static int open_WrdWin()
1088 		/*success-> return 0;*/
1089 {
1090 	open_window(&win, kWrdWinID);
1091 	position_window(&win);
1092 
1093 	return 0;
1094 }
1095 
click_WrdWin(Point,short)1096 static void click_WrdWin(Point /*local*/, short /*modifiers*/)
1097 {
1098 }
1099 
update_WrdWin()1100 static void update_WrdWin()
1101 {
1102 	dev_redisp(portRect);
1103 }
1104 
message_WrdWin(int message,long)1105 static int	message_WrdWin(int message, long /*param*/)
1106 {
1107 	Rect rect;
1108 
1109 	switch(message){
1110 	case MW_GROW:
1111 		rect=win.ref->portRect;
1112 		//rect.right-=15; rect.bottom-=15;
1113 		rect = win.ref->portRect;
1114 		rect.right  -= 15;
1115 		//rect.bottom -= 15;
1116 		return 0;
1117 
1118 	}
1119 
1120 	return -1;  //not supported
1121 }
1122 
1123 // ***********************************************
1124 #pragma mark -
1125 
1126 /*ARGSUSED*/
wrdt_open(char *)1127 static int wrdt_open(char * /*wrdt_opts*/)
1128 {	//  success -> return 0
1129 	OSErr	err;
1130 
1131 	err=dev_setup();
1132 	if( err ) return err;
1133     wrdt.opened = 1;
1134     wrd_argc = 0;
1135     inkey_flag = 0;
1136 	ctl->cmsg(CMSG_INFO,VERB_VERBOSE,"open macintosh wrd player\n");
1137     return 0;
1138 }
1139 
wrdt_update_events(void)1140 static void wrdt_update_events(void)
1141 {
1142 }
1143 
wrdt_close(void)1144 static void wrdt_close(void)
1145 {
1146     wrdt.opened = 0;
1147     inkey_flag = 0;
1148 }
1149 
wrd_event2string(int id)1150 static char *wrd_event2string(int id)
1151 {
1152     char *name;
1153 
1154     name = event2string(id);
1155     if(name != NULL)
1156 	return name + 1;
1157     return "";
1158 }
1159 
1160 // **************************************************
1161 #pragma mark -
mac_wrd_pal(int pnum,int wrd_args[])1162 static void mac_wrd_pal(int pnum, int wrd_args[])
1163 {
1164 	int code;
1165 	RGBColor color;
1166 
1167 	for( code=0; code<16; code++ ){
1168 		color.red=((wrd_args[code] >> 8) & 0x000F) * 0x1111;
1169 		color.green=((wrd_args[code] >> 4) & 0x000F) * 0x1111;
1170 		color.blue=(wrd_args[code] & 0x000F) * 0x1111;
1171 		dev_palette[pnum][code]=color;
1172 		if( pnum==0 ){
1173 			dev_change_1_palette(code, color);
1174 		}
1175 	}
1176 
1177 	if( pnum==0 ){
1178 		//dev_remake_disp(portRect);
1179 		dev_redisp(portRect);
1180 	}
1181 }
1182 
wrd_fadestep(int nowstep,int maxstep)1183 static void wrd_fadestep(int nowstep, int maxstep)
1184 {
1185 	RGBColor	pal[16];
1186 	int code;
1187 	//static unsigned long	lasttick=0;
1188 	static int	skip_num;
1189 
1190 	//if( nowstep!=1 && nowstep!=maxstep /*&& (nowstep%4)==0*/ && lasttick==TickCount() ){
1191 	//	return;  //too fast fade. skip fading.
1192 	//}
1193 
1194 	if( nowstep==1 ){
1195 		skip_num=0;
1196 	}
1197 
1198 	if( nowstep!=maxstep && !mac_flushing_flag){	//consider skipping
1199 		const int	skip_threshold[11]={99,99,6,5,4, 2,1,0,0,0,0};
1200 		int	threshold= skip_threshold[ (int)(aq_filled_ratio()*10) ];
1201 		if( skip_num<threshold ){
1202 			skip_num++;
1203 			return;     // system is busy
1204 		}
1205 	}
1206 
1207 	skip_num=0;
1208 	for( code=0; code<16; code++ ){
1209 		pal[code].red=
1210 			(dev_palette[startpal][code].red*(maxstep-nowstep) +
1211 				dev_palette[endpal][code].red*nowstep)/maxstep;
1212 		pal[code].green=
1213 			(dev_palette[startpal][code].green*(maxstep-nowstep) +
1214 				dev_palette[endpal][code].green*nowstep)/maxstep;
1215 		pal[code].blue=
1216 			(dev_palette[startpal][code].blue*(maxstep-nowstep) +
1217 				dev_palette[endpal][code].blue*nowstep)/maxstep;
1218 	}
1219 	dev_change_palette(pal);
1220 	dev_redisp(portRect);
1221 	if( nowstep==maxstep ) fading=false;
1222 	//lasttick=TickCount();
1223 }
1224 
mac_wrd_fade(int p1,int p2,int speed)1225 static void mac_wrd_fade(int p1, int p2, int speed)
1226 {
1227 	startpal=p1; endpal=p2;
1228 	if( fading ){	//double fade command
1229 		wrd_fadestep(1, 1);
1230 	}
1231 	if(speed==0){
1232 		dev_change_palette( dev_palette[p2]);
1233 		//dev_remake_disp(portRect);
1234 		dev_redisp(portRect);
1235 	}else{
1236 		fading=true;
1237 	}
1238 }
1239 
dev_gon(int gon)1240 static void dev_gon(int gon)
1241 {
1242 	dev_gon_flag=gon;
1243 	dev_remake_disp(portRect);
1244 	dev_redisp(portRect);
1245 }
1246 
dev_palrev(int paln)1247 static void dev_palrev(int paln )
1248 {
1249 	int code;
1250 	for( code=0; code<16; code++ ){
1251 		dev_palette[paln][code].red   ^= 0xFFFF;
1252 		dev_palette[paln][code].green ^= 0xFFFF;
1253 		dev_palette[paln][code].blue  ^= 0xFFFF;
1254 	}
1255 	if( paln==0 ){
1256 		dev_change_palette(dev_palette[0]);
1257 		dev_redisp(portRect);
1258 	}
1259 }
1260 
wrd_mag(char * filename,int x,int y,int,int p)1261 static int wrd_mag(char* filename, int x, int y, int /*s*/, int p)
1262 {
1263 	int		err;
1264 	Rect	rect;
1265 	//char	fullpath[255];
1266 	GDHandle	oldGD;
1267 	GWorldPtr	oldGW;
1268 
1269 	GetGWorld(&oldGW, &oldGD);
1270 	LockPixels(GACTIVE_PIX);
1271 		SetGWorld(graphicWorld[activeGraphics],0);
1272 		err= mac_mag_load(filename,  x,y, GACTIVE_PIX, p ,&rect);
1273 		SetGWorld(oldGW, oldGD);
1274 	UnlockPixels(GACTIVE_PIX);
1275 
1276 	if( err ) return err;
1277 
1278 	if( p==0 || p==2 ){
1279 		dev_change_palette(dev_palette[17]);
1280 		rect=portRect;	//update all
1281 	}
1282 	if( activeGraphics==dispGraphics || p==0 || p==2 ){
1283 		dev_remake_disp(rect);
1284 		dev_redisp(rect);
1285 	}
1286 	memcpy(&dev_palette[18+ (activeGraphics==0? 0:1)]
1287 					, &dev_palette[17], 16*sizeof(RGBColor));
1288 	return 0; //no error
1289 }
1290 
wrd_pho(char * filename)1291 static int wrd_pho(char* filename)
1292 {
1293 	//char	fullpath[255];
1294 	GDHandle	oldGD;
1295 	GWorldPtr	oldGW;
1296 
1297 	GetGWorld(&oldGW, &oldGD);
1298 	LockPixels(GACTIVE_PIX);
1299 	SetGWorld(graphicWorld[activeGraphics],0);
1300 	mac_pho_load(filename, GACTIVE_PIX);
1301 
1302 	SetGWorld(oldGW, oldGD);
1303 	UnlockPixels(GACTIVE_PIX);
1304 
1305 	if( activeGraphics==dispGraphics ){
1306 		dev_remake_disp(portRect);
1307 		dev_redisp(portRect);
1308 	}
1309 	return 0; //no error
1310 }
1311 
wrd_load_default_image()1312 static void wrd_load_default_image()
1313 {
1314 	char	filename[256], *p;
1315 
1316 	strncpy(filename, current_file_info->filename, sizeof filename - 1);
1317 	filename[sizeof filename - 1] = '\0';
1318 	p= strrchr( filename, '.' );
1319 	if( p==0 ) return;
1320 	strncpy( p, ".mag", sizeof(filename) - (p - filename) - 1 );
1321 	filename[sizeof(filename) - 1] = '\0';
1322 	ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
1323 		  "@DEFAULT_LOAD_MAG(%s)", filename);
1324 
1325 	if( wrd_mag(filename, WRD_NOARG, WRD_NOARG, 1,0)==0 ) //no err
1326 		return;
1327 
1328 		//retry pho file
1329 	strncpy(filename, current_file_info->filename, sizeof filename - 1);
1330 	filename[sizeof filename - 1] = '\0';
1331 	p= strrchr( filename, '.' );
1332 	if( p==0 ) return;
1333 	strncpy( p, ".pho", sizeof(filename) - (p - filename) - 1 );
1334 	filename[sizeof(filename) - 1] = '\0';
1335 	wrd_pho(filename);
1336 }
1337 
1338 // **************************************************
1339 #pragma mark -
mac_wrd_color(int c)1340 static void mac_wrd_color(int c)
1341 {
1342 	dev_set_text_attr(c);
1343 }
1344 
1345 
mac_wrd_DrawText(const char * str,int len)1346 static void mac_wrd_DrawText(const char* str, int len)
1347 {
1348 	int i;
1349 
1350 	for( i=0; i<=len; ){
1351 		if( str[i]==0 || i==len ){
1352 			dev_text_output(str, i);
1353 			break;
1354 		}else if( wrd_coursor_x+i>80 ){
1355 			dev_text_output(str, i);
1356 			dev_newline();
1357 			//i++;
1358 			str+=i; len-=i; i=0;
1359 		}else if( str[i]=='\x1b' ){ //esc sequence
1360 			if( i ){
1361 				dev_text_output(str, i);
1362 				str+=i; len-=i; i=0;
1363 			}
1364 			for(;;i++){
1365 				if( Parse(str[i]) ){
1366 					break; //esc sequence ended
1367 				}
1368 			}
1369 			i++;
1370 			str+=i; len-=i; i=0;
1371 		}else if (str[i]=='\t' ){ //tab space
1372 			int newx;
1373 			dev_text_output(str, i);
1374 			newx=((wrd_coursor_x-1)|7)+2;
1375 			dev_text_clear(wrd_coursor_x, wrd_coursor_y, newx-1, wrd_coursor_y, 0, 0, true);
1376 			dev_move_coursor(newx,wrd_coursor_y);
1377 			i++;
1378 			str+=i; len-=i; i=0;
1379 		}else{
1380 			i++;
1381 		}
1382 	}
1383 }
1384 
mac_wrd_doESC(const char * code)1385 static void mac_wrd_doESC(const char* code )
1386 {
1387 	char	str[20]="\33[";
1388 	strncat(str, code, sizeof(str) - strlen(code) - 1);
1389 	str[sizeof(str)-1] = '\0';
1390 	mac_wrd_DrawText(str, strlen(str));
1391 }
1392 
mac_wrd_event_esc(int esc)1393 static void mac_wrd_event_esc(int esc)
1394 {
1395 	mac_wrd_doESC(event2string(esc)+1);
1396 }
1397 
wrdt_apply(int cmd,int wrd_argc,int wrd_args[])1398 static void wrdt_apply(int cmd, int wrd_argc, int wrd_args[])
1399 {
1400     char *p;
1401     char *text;
1402     int i, len;
1403 
1404 	if( ! win.show ) return;
1405 
1406     //wrd_args[wrd_argc++] = arg;
1407     if(cmd == WRD_ARG)
1408 	return;
1409     if(cmd == WRD_MAGPRELOAD){
1410 	//char *p = wrd_event2string(arg);
1411 	 /* Load MAG file */
1412 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1413 		  "@WRD_MAGPRELOAD"));
1414     wrd_argc = 0;
1415 	return;
1416 	}
1417     if(inkey_flag)
1418 	printf("* ");
1419     switch(cmd)
1420     {
1421     case WRD_LYRIC:
1422     case WRD_NL:
1423 		if(cmd == WRD_NL)
1424 			text = "\n";
1425 		else{
1426 			p = wrd_event2string(wrd_args[0]);
1427 			len = strlen(p);
1428 			text = (char *)new_segment(&tmpbuffer, SAFE_CONVERT_LENGTH(len));
1429 			code_convert(p, text, SAFE_CONVERT_LENGTH(len), NULL, NULL);
1430 		}
1431 		len = strlen(text);
1432 		if( len ){
1433 		mac_wrd_DrawText(text, text[len-1]=='\n'? len-1:len);
1434 		if( text[len-1]=='\n' ){
1435 			dev_newline();
1436 		}
1437 		ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "%s", text);
1438 		}
1439 		reuse_mblock(&tmpbuffer);
1440 		break;
1441       case WRD_COLOR:
1442 		mac_wrd_color(wrd_args[0]);
1443 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE, "@COLOR(%d)", wrd_args[0]));
1444 	break;
1445       case WRD_END: /* Never call */
1446 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,"@END"));
1447 	break;
1448       case WRD_ESC:
1449       	mac_wrd_event_esc(wrd_args[0]);
1450 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1451 		  "@ESC(%s)", wrd_event2string(wrd_args[0])));
1452 	break;
1453       case WRD_EXEC:
1454 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1455 		  "@EXEC(%s)", wrd_event2string(wrd_args[0])));
1456 	break;
1457       case WRD_FADE:
1458 	mac_wrd_fade(wrd_args[0], wrd_args[1], wrd_args[2]);
1459 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1460 		  "@FADE(%d,%d,%d)", wrd_args[0], wrd_args[1], wrd_args[2]));
1461 	break;
1462       case WRD_FADESTEP:
1463 	wrd_fadestep(wrd_args[0], WRD_MAXFADESTEP);
1464 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1465 		  "@FADESTEP(%d/%d)", wrd_args[0], WRD_MAXFADESTEP));
1466 	break;
1467       case WRD_GCIRCLE:
1468 	dev_gcircle(wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
1469 		  wrd_args[4], wrd_args[5]);
1470 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1471 		  "@GCIRCLE(%d,%d,%d,%d,%d,%d)",
1472 		  wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
1473 		  wrd_args[4], wrd_args[5]));
1474 	break;
1475       case WRD_GCLS:
1476 	dev_clear_graphics(wrd_args[0]? wrd_args[0]:0xFF);
1477 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1478 		  "@GCLS(%d)", wrd_args[0]));
1479 	break;
1480       case WRD_GINIT:
1481 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE, "@GINIT()"));
1482 	break;
1483       case WRD_GLINE:
1484 	dev_gline(wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
1485 	       wrd_args[5], wrd_args[6],graphicWorld[activeGraphics]);
1486 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1487 		  "@GLINE(%d,%d,%d,%d,%d,%d,%d)",
1488 	       wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
1489 	       wrd_args[5], wrd_args[6]));
1490 	break;
1491       case WRD_GMODE:
1492 	DEV_SET_GMODE(wrd_args[0]);
1493 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1494 		  "@GMODE(%d)", wrd_args[0]));
1495 	break;
1496       case WRD_GMOVE:
1497 	wrd_args[0] &= ~0x7;  wrd_args[4] &= ~0x7;
1498 	wrd_args[2] |= 0x7;
1499 	dev_gmove(wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
1500 	       wrd_args[5], graphicWorld[wrd_args[6]], graphicWorld[wrd_args[7]],
1501 	       wrd_args[8], 0, gmode_mask, 0,0,0);
1502 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1503 		  "@GMOVE(%d,%d, %d,%d, %d,%d, %d,%d,%d)",
1504 	       wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
1505 	       wrd_args[5], wrd_args[6], wrd_args[7], wrd_args[8]));
1506 	break;
1507       case WRD_GON:
1508 	dev_gon(wrd_args[0]);
1509 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1510 		  "@GON(%d)", wrd_args[0]));
1511 	break;
1512       case WRD_GSCREEN:
1513 	dev_gscreen(wrd_args[0], wrd_args[1]);
1514 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1515 		  "@GSCREEN(%d,%d)", wrd_args[0], wrd_args[1]));
1516 	break;
1517       case WRD_INKEY:
1518 	inkey_flag = 1;
1519 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE, "@INKEY - begin"));
1520 	break;
1521       case WRD_OUTKEY:
1522 	inkey_flag = 0;
1523 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE, "@INKEY - end"));
1524 	break;
1525       case WRD_LOCATE:
1526 		dev_move_coursor(wrd_args[0], wrd_args[1]);
1527 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1528 		  "@LOCATE(%d,%d)", wrd_args[0], wrd_args[1]));
1529 	break;
1530       case WRD_LOOP: /* Never call */
1531 	break;
1532     case WRD_MAG:
1533    	wrd_mag(wrd_event2string(wrd_args[0]), wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4]);
1534 /* 	p = (char *)new_segment(&tmpbuffer, MIN_MBLOCK_SIZE); */
1535 /* 	strcpy(p, "@MAG("); */
1536 /* 	strcat(p, wrd_event2string(wrd_args[0])); */
1537 /* 	strcat(p, ","); */
1538 /* 	for(i = 1; i < 3; i++) */
1539 /* 	{ */
1540 /* 	    if(wrd_args[i] == WRD_NOARG) */
1541 /* 		strcat(p, "*,"); */
1542 /* 	    else */
1543 /* 		sprintf(p + strlen(p), "%d,", wrd_args[i]); */
1544 /* 	} */
1545 /* 	sprintf(p + strlen(p), "%d,%d)", wrd_args[3], wrd_args[4]); */
1546 /* 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE, "%s", p)); */
1547 /* 	reuse_mblock(&tmpbuffer); */
1548 	break;
1549       case WRD_MIDI: /* Never call */
1550 	break;
1551       case WRD_OFFSET: /* Never call */
1552 	break;
1553       case WRD_PAL:
1554       	mac_wrd_pal( wrd_args[0], &wrd_args[1]);
1555 /* 	p = (char *)new_segment(&tmpbuffer, MIN_MBLOCK_SIZE); */
1556 /* 	sprintf(p, "@PAL(%03x", wrd_args[0]); */
1557 /* 	for(i = 1; i < 17; i++) */
1558 /* 	    sprintf(p + strlen(p), ",%03x", wrd_args[i]); */
1559 /* 	strcat(p, ")"); */
1560 /* 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE, "%s", p)); */
1561 /* 	reuse_mblock(&tmpbuffer); */
1562 	break;
1563       case WRD_PALCHG:
1564 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1565 		  "@PALCHG(%s)", wrd_event2string(wrd_args[0])));
1566 	break;
1567       case WRD_PALREV:
1568 	dev_palrev(wrd_args[0]);
1569 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1570 		  "@PALREV(%d)", wrd_args[0]));
1571 	break;
1572       case WRD_PATH:
1573 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1574 		  "@PATH(%s)", wrd_event2string(wrd_args[0])));
1575 	break;
1576       case WRD_PLOAD:
1577    	wrd_pho(wrd_event2string(wrd_args[0]));
1578 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1579 		  "@PLOAD(%s)", wrd_event2string(wrd_args[0])));
1580 	break;
1581       case WRD_REM:
1582 	p = wrd_event2string(wrd_args[0]);
1583 	len = strlen(p);
1584 	text = (char *)new_segment(&tmpbuffer, SAFE_CONVERT_LENGTH(len));
1585 	code_convert(p, text, SAFE_CONVERT_LENGTH(len), NULL, NULL);
1586 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE, "@REM %s", text));
1587 	reuse_mblock(&tmpbuffer);
1588 	break;
1589       case WRD_REMARK:
1590 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1591 		  "@REMARK(%s)", wrd_event2string(wrd_args[0])));
1592 	break;
1593       case WRD_REST: /* Never call */
1594 	break;
1595       case WRD_SCREEN: /* Not supported */
1596 	break;
1597       case WRD_SCROLL:
1598 	dev_text_scroll(wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
1599 					wrd_args[4], wrd_args[5], wrd_args[6], 1);
1600 	dev_remake_disp(portRect);
1601 	dev_redisp(portRect);
1602 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1603 		  "@SCROLL(%d,%d,%d,%d,%d,%d,%d)",
1604 		  wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
1605 		  wrd_args[4], wrd_args[5], wrd_args[6]));
1606 	break;
1607       case WRD_STARTUP:
1608 	dev_init(wrd_args[0]);
1609 	dev_init_text_color();
1610 	wrd_load_default_image();
1611 	inkey_flag = 0;
1612 	dev_set_height(400);
1613 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1614 		  "@STARTUP(%d)", wrd_args[0]));
1615 	break;
1616       case WRD_STOP: /* Never call */
1617 	break;
1618       case WRD_TCLS:
1619 	dev_text_clear(wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],wrd_args[4],wrd_args[5], true);
1620 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1621 		  "@TCLS(%d,%d,%d,%d,%d,%d)",
1622 		  wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
1623 		  wrd_args[4], wrd_args[5]));
1624 	break;
1625       case WRD_TON:
1626 	wrd_ton=wrd_args[0];
1627 	dev_remake_disp(portRect);
1628 	dev_redisp(portRect);
1629 	WRD_DEBUG((CMSG_INFO, VERB_VERBOSE,
1630 		  "@TON(%d)", wrd_args[0]));
1631 	break;
1632       case WRD_WAIT: /* Never call */
1633 	break;
1634       case WRD_WMODE: /* Never call */
1635 	break;
1636 
1637 	/* Ensyutsukun */
1638       case WRD_eFONTM:
1639 	print_ecmd("FONTM", wrd_args, 1);
1640 	break;
1641       case WRD_eFONTP:
1642 	print_ecmd("FONTP", wrd_args, 4);
1643 	break;
1644       case WRD_eFONTR:
1645 	print_ecmd("FONTR", wrd_args, 17);
1646 	break;
1647       case WRD_eGSC:
1648 	print_ecmd("GSC", wrd_args, 1);
1649 	break;
1650       case WRD_eLINE:
1651 	print_ecmd("LINE", wrd_args, 1);
1652 	break;
1653       case WRD_ePAL:
1654 	print_ecmd("PAL", wrd_args, 2);
1655 	break;
1656       case WRD_eREGSAVE:
1657 	print_ecmd("REGSAVE", wrd_args, 17);
1658 	break;
1659       case WRD_eSCROLL:
1660 	print_ecmd("SCROLL",wrd_args, 2);
1661 	break;
1662       case WRD_eTEXTDOT:
1663 	print_ecmd("TEXTDOT", wrd_args, 1);
1664 	break;
1665       case WRD_eTMODE:
1666 	print_ecmd("TMODE", wrd_args, 1);
1667 	break;
1668       case WRD_eTSCRL:
1669 	print_ecmd("TSCRL", wrd_args, 0);
1670 	break;
1671       case WRD_eVCOPY:
1672 	wrd_args[0] &= ~0x7;  wrd_args[4] &= ~0x7;
1673 	wrd_args[2] |= 0x7;
1674 	dev_gmove(wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
1675 		wrd_args[4],wrd_args[5],
1676 	       graphicWorld[wrd_args[6]+(wrd_args[8]? 2:0)],
1677 	       graphicWorld[wrd_args[7]+ (wrd_args[8]? 0:2)], 0/*normal copy*/,0,gmode_mask,
1678 	       0,0,0 );
1679 			//ignore mode in this version, always EMS->GVRAM
1680 	print_ecmd("VCOPY", wrd_args, 9);
1681 	break;
1682       case WRD_eVSGET:
1683 	dev_vsget(wrd_args[0]);
1684 	print_ecmd("VSGE", wrd_args, 4);
1685 	break;
1686       case WRD_eVSRES:
1687 	print_ecmd("VSRES", wrd_args, 0);
1688 	break;
1689       case WRD_eXCOPY:
1690 	dev_gmove(wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
1691 	     		wrd_args[5], graphicWorld[wrd_args[6]], graphicWorld[wrd_args[7]],
1692 	       		wrd_args[8]+0x10, 0/*trans*/, gmode_mask, 0,0,0 );
1693 	print_ecmd("XCOPY", wrd_args, 14);
1694 	break;
1695 
1696 	/* Extensionals */
1697       case WRD_START_SKIP:
1698 	    mac_RedrawControl(0);
1699 	ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
1700 		  "WRD START SKIP");
1701 	break;
1702       case WRD_END_SKIP:
1703 	    mac_RedrawControl(1);
1704 	ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
1705 		  "WRD END SKIP");
1706 	break;
1707 #ifdef ENABLE_SHERRY
1708       case WRD_SHERRY_UPDATE:
1709 	sry_update();
1710 	break;
1711 #endif
1712     }
1713     wrd_argc = 0;
1714 }
1715