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