![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mac.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae|
Return to mac.c CVS log | Up to [UNIX Amiga Emulator] / uae |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * Mac port specific stuff
5: *
6: * (c) 1996 Ernesto Corvi
7: */
8:
9: #include <stdio.h>
10: #include <stdlib.h>
11: #include <string.h>
12: #include <QDOffscreen.h>
13: #include <Palettes.h>
14: #include <Profiler.h>
15:
16: #include "mackbd.h"
17: #include "config.h"
18: #include "amiga.h"
19: #include "options.h"
20: #include "memory.h"
21: #include "custom.h"
22: #include "newcpu.h"
23: #include "xwin.h"
24: #include "keyboard.h"
25: #include "keybuf.h"
26:
27: #define kQuitError 128
28:
29: extern bool left, right, top, bot, but;
30:
31: KeyMap keys,keysold;
32: GDHandle curDevice;
33: int oldDepth=0;
34: static int screen;
35: Boolean RM=false,Joy=false;
36: WindowPtr mywin;
37: short gOldMBarHeight;
38: RgnHandle gMBarRgn;
39: static int bitdepth;
40: KeyMap theKeys;
41:
42: unsigned long refresh;
43: char *xlinebuffer;
44: unsigned int *obuff;
45: long int xcolors[4096];
46:
47: /* Keyboard and mouse */
48:
49: static bool keystate[256];
50:
51: bool buttonstate[3];
52: int lastmx, lastmy;
53: bool newmousecounters;
54: static bool inwindow;
55:
56: int GetRawCode (long set0, long set1, long set2, long set3);
57:
58: static inline unsigned long doMask(int p, int bits, int shift)
59: {
60: /* p is a value from 0 to 15 (Amiga color value)
61: * scale to 0..255, shift to align msb with mask, and apply mask */
62:
63: unsigned long val = p * 0x11111111UL;
64: val >>= (32 - bits);
65: val <<= shift;
66:
67: return val;
68: }
69:
70: static void InitXColors(void)
71: {
72: int n=16;
73: int red_bits = 5;
74: int green_bits = 5;
75: int blue_bits = 5;
76: int red_shift = 10;
77: int green_shift = 5;
78: int blue_shift = 0;
79: int i=0;
80: int r,g,b;
81:
82: for(i = 0; i < 4096; i++) {
83: r = i >> 8;
84: g = (i >> 4) & 0xF;
85: b = i & 0xF;
86: xcolors[i] = (doMask(r, red_bits, red_shift)
87: | doMask(g, green_bits, green_shift)
88: | doMask(b, blue_bits, blue_shift));
89: }
90: }
91:
92: static void InitToolbox(void)
93: {
94: InitGraf (&qd.thePort);
95: InitFonts ();
96: FlushEvents (everyEvent,0);
97: InitWindows ();
98: InitMenus ();
99: TEInit ();
100: InitDialogs (nil);
101: InitCursor ();
102: }
103:
104: static void HideMenuBar(void)
105: {
106: Rect mBarRect;
107:
108: /* GET RID OF THE MENU BAR */
109:
110: gOldMBarHeight = GetMBarHeight();
111: /* make the Menu Bar's height zero */
112: LMSetMBarHeight(0);
113: SetRect(&mBarRect, qd.screenBits.bounds.left, qd.screenBits.bounds.top,
114: qd.screenBits.bounds.right, qd.screenBits.bounds.top + gOldMBarHeight);
115: gMBarRgn = NewRgn();
116: RectRgn(gMBarRgn, &mBarRect);
117: UnionRgn(LMGetGrayRgn(), gMBarRgn, LMGetGrayRgn()); /* tell the desktop it covers the menu bar */
118:
119: PaintOne(nil, gMBarRgn); /* redraw desktop */
120: }
121:
122: static void ShowMenuBar(void)
123: {
124: LMSetMBarHeight(gOldMBarHeight); /* make the menu bar's height normal */
125: DiffRgn(LMGetGrayRgn(), gMBarRgn, LMGetGrayRgn()); /* remove the menu bar from the desktop */
126: DisposeRgn(gMBarRgn);
127: }
128:
129: void graphics_init()
130: { int i;
131: long p1;
132: long tmp;
133:
134: Rect windowRectangle={0,0,480,640};
135: InitToolbox();
136:
137: if (CheckForSetup()) ExitToShell();
138:
139: HideMenuBar();
140: mywin = NewCWindow(nil, &windowRectangle, "\pUAE", true, 2, (WindowPtr)-1L, false, 0);
141: SetPort(mywin);
142:
143: PaintRect(&qd.screenBits.bounds);
144:
145: xlinebuffer = (char *)malloc (3200);
146: InitXColors();
147: buttonstate[0] = buttonstate[1] = buttonstate[2] = false;
148: for(i=0; i<256; i++) keystate[i] = false;
149:
150: lastmx = lastmy = 0; newmousecounters = false; inwindow = false;
151:
152: obuff=(unsigned int *)NewPtrClear(481*1280);
153: {
154: for(p1=0;p1 < (480*1280);p1++)
155: *obuff=-1;
156: }
157:
158: HideCursor();
159: refresh=TickCount();
160:
161: /* tmp=ProfilerInit(collectDetailed,bestTimeBase,200,10); */
162: }
163:
164: void graphics_leave()
165: {
166: /* ProfilerDump((unsigned char *)"\pmyProf");
167: ProfilerTerm();
168: */
169: DisposeWindow(mywin);
170: ShowCursor();
171: if (oldDepth != 0) SetDepth(curDevice,oldDepth,0,0);
172: ShowMenuBar();
173: FlushEvents (everyEvent,0);
174: ExitToShell();
175: }
176:
177: static bool next_line_double;
178: static int next_line_pos = 0;
179:
180: void flush_screen ()
181: {
182: GrafPtr oldPort;
183: short y,x,daColor=0;
184: RGBColor daColorRGB;
185: unsigned char *winbaseaddr;
186: double *src,*dest;
187: unsigned long winrowbytes;
188: PixMapHandle ph;
189:
190: if (TickCount() < refresh + 4) return;
191: GetPort(&oldPort);
192: SetPort(mywin);
193:
194: ph=GetGWorldPixMap((CGrafPort *) mywin);
195: LockPixels(ph);
196: winbaseaddr=( unsigned char *) GetPixBaseAddr(ph);
197: winrowbytes=(*ph)->rowBytes & 0x3FFF;
198: winbaseaddr-=((**ph).bounds.left);
199: winbaseaddr-=((**ph).bounds.top*winrowbytes);
200: dest=(double *)winbaseaddr;
201: src=(double *)obuff;
202:
203: for (y=1; y< 480; y++)
204: {
205: for (x=0;x < 160;x++)
206: {
207: *dest++ = *src++;
208: }
209: dest=(double *)(winbaseaddr+(y*winrowbytes));
210: }
211: UnlockPixels(ph);
212: SetPort(oldPort);
213:
214: }
215:
216: void prepare_line (int y, bool need_double)
217: {
218: next_line_double = need_double;
219: next_line_pos = y;
220: }
221:
222: void flush_line()
223: {
224: short i;
225: char *dst,*src;
226: double *dst1,*src1;
227:
228: if ((next_line_pos < 508) && (next_line_pos > 28))
229: {
230: dst=(char *)obuff+((next_line_pos-28)*1280);
231: src=(char *)xlinebuffer+292;
232: BlockMove(src,dst,1280);
233: }
234: if (next_line_double)
235: {
236: if ((next_line_pos+1 < 508) && (next_line_pos+1 > 28))
237: {
238: dst1=(double *)obuff+((next_line_pos+1-28)*160);
239: src1=(double *)obuff+((next_line_pos-28)*160);
240: for (i=0;i < 160;i++)
241: {
242: *dst1++=*src1++;
243: }
244: }
245: }
246: }
247:
248: /* Decode KeySyms. This function knows about all keys that are common
249: * between different keyboard languages.
250: */
251: static int kc_decode (long ks)
252: {
253: switch (ks)
254: {
255: case kAKeyMap: return AK_A;
256: case kBKeyMap: return AK_B;
257: case kCKeyMap: return AK_C;
258: case kDKeyMap: return AK_D;
259: case kEKeyMap: return AK_E;
260: case kFKeyMap: return AK_F;
261: case kGKeyMap: return AK_G;
262: case kHKeyMap: return AK_H;
263: case kIKeyMap: return AK_I;
264: case kJKeyMap: return AK_J;
265: case kKKeyMap: return AK_K;
266: case kLKeyMap: return AK_L;
267: case kMKeyMap: return AK_M;
268: case kNKeyMap: return AK_N;
269: case kOKeyMap: return AK_O;
270: case kPKeyMap: return AK_P;
271: case kQKeyMap: return AK_Q;
272: case kRKeyMap: return AK_R;
273: case kSKeyMap: return AK_S;
274: case kTKeyMap: return AK_T;
275: case kUKeyMap: return AK_U;
276: case kVKeyMap: return AK_V;
277: case kWKeyMap: return AK_W;
278: case kXKeyMap: return AK_X;
279:
280: case k0KeyMap: return AK_0;
281: case k1KeyMap: return AK_1;
282: case k2KeyMap: return AK_2;
283: case k3KeyMap: return AK_3;
284: case k4KeyMap: return AK_4;
285: case k5KeyMap: return AK_5;
286: case k6KeyMap: return AK_6;
287: case k7KeyMap: return AK_7;
288: case k8KeyMap: return AK_8;
289: case k9KeyMap: return AK_9;
290:
291: case kKP0KeyMap: return AK_NP0;
292: case kKP1KeyMap: return AK_NP1;
293: case kKP2KeyMap: return AK_NP2;
294: case kKP3KeyMap: return AK_NP3;
295: case kKP4KeyMap: return AK_NP4;
296: case kKP5KeyMap: return AK_NP5;
297: case kKP6KeyMap: return AK_NP6;
298: case kKP7KeyMap: return AK_NP7;
299: case kKP8KeyMap: return AK_NP8;
300: case kKP9KeyMap: return AK_NP9;
301:
302: case kF1KeyMap: return AK_F1;
303: case kF2KeyMap: return AK_F2;
304: case kF3KeyMap: return AK_F3;
305: case kF4KeyMap: return AK_F4;
306: case kF5KeyMap: return AK_F5;
307: case kF6KeyMap: return AK_F6;
308: case kF7KeyMap: return AK_F7;
309: case kF8KeyMap: return AK_F8;
310: case kF9KeyMap: return AK_F9;
311: case kF10KeyMap: return AK_F10;
312:
313: case kBackSpaceKeyMap: return AK_BS;
314: case kTabKeyMap: return AK_TAB;
315: case kReturnKeyMap: return AK_RET;
316: case kEscapeKeyMap: return AK_ESC;
317:
318: case kSpaceBarMap: if (Joy) return -1; else return AK_SPC;
319:
320: case kUpArrowKeyMap: if (Joy) return -1; else return AK_UP;
321: case kDownArrowKeyMap: if (Joy) return -1; else return AK_DN;
322: case kLeftArrowKeyMap: if (Joy) return -1; else return AK_LF;
323: case kRightArrowKeyMap: if (Joy) return -1; else return AK_RT;
324:
325: case kF11KeyMap: graphics_leave();
326: case kF12KeyMap: { Joy=!Joy; SysBeep(0); return -1; }
327:
328: case kPgUpKeyMap: return AK_RAMI;
329: case kPgDnKeyMap: return AK_LAMI;
330: case kBackSlash: return AK_BACKSLASH;
331: }
332: return -1;
333: }
334:
335: static int decode_us(long ks)
336: {
337: switch(ks) {
338: /* US specific */
339:
340: case kYKeyMap: return AK_Y;
341: case kZKeyMap: return AK_Z;
342: case kLBracketKeyMap: return AK_LBRACKET;
343: case kRBracketKeyMap: return AK_RBRACKET;
344: case kCommaKeyMap: return AK_COMMA;
345: case kPeriodKeyMap: return AK_PERIOD;
346: case kSlashKeyMap: return AK_SLASH;
347: case kSemiColonKeyMap: return AK_SEMICOLON;
348: case kMinusKeyMap: return AK_MINUS;
349: case kEqualKeyMap: return AK_EQUAL;
350: case kQuoteKeyMap: return AK_QUOTE;
351: }
352:
353: return -1;
354: }
355:
356: static int decode_de(long ks)
357: {
358: switch(ks) {
359: /* DE specific
360: case XK_Y: case XK_y: return AK_Z;
361: case XK_Z: case XK_z: return AK_Y;
362: case XK_Odiaeresis: case XK_odiaeresis: return AK_SEMICOLON;
363: case XK_Adiaeresis: case XK_adiaeresis: return AK_QUOTE;
364: case XK_Udiaeresis: case XK_udiaeresis: return AK_LBRACKET;
365: case XK_plus: case XK_asterisk: return AK_RBRACKET;
366: case XK_comma: return AK_COMMA;
367: case XK_period: return AK_PERIOD;
368: case XK_less: case XK_greater: return AK_LTGT;
369: case XK_numbersign: return AK_NUMBERSIGN;
370: case XK_ssharp: return AK_MINUS;
371: case XK_apostrophe: return AK_EQUAL;
372: case XK_asciicircum: return AK_00;
373: case XK_minus: return AK_SLASH;
374: */
375: }
376:
377: return -1;
378: }
379:
380: static int keycode2amiga(long code)
381: {
382: long ks;
383: int as;
384:
385: ks = (code & keyCodeMask) >> 8;
386: as = kc_decode (ks);
387:
388: if (as == -1) {
389: switch(keyboard_lang) {
390: case KBD_LANG_US:
391: as = decode_us(ks);
392: break;
393:
394: case KBD_LANG_DE:
395: as = decode_de(ks);
396: break;
397:
398: default:
399: as = -1;
400: break;
401: }
402: }
403: if(-1 != as)
404: return as;
405: return -1;
406: }
407:
408: void handle_events()
409: {
410: Boolean repeat;
411: Boolean itHappened;
412: Point mpos;
413: EventRecord event;
414: int kc,i,count;
415:
416: SetEventMask(-1);
417: SelectWindow(mywin);
418: HideCursor();
419:
420: GetKeys(keys);
421: if (BitTst(&keys, kCommandRawKey))
422: RM=true;
423: else
424: RM=false;
425:
426: if (BitTst(&keys, kShiftRawKey))
427: {
428: if (!keystate[AK_LSH]) {
429: keystate[AK_LSH] = true;
430: record_key (AK_LSH << 1);
431: goto label1;
432: }
433: } else {
434: if (keystate[AK_LSH]) {
435: keystate[AK_LSH] = false;
436: record_key ((AK_LSH << 1) | 1);
437: goto label1;
438: }
439: }
440: if (BitTst(&keys, kControlRawKey))
441: {
442: if (!keystate[AK_CTRL]) {
443: keystate[AK_CTRL] = true;
444: record_key (AK_CTRL << 1);
445: goto label1;
446: }
447: } else {
448: if (keystate[AK_CTRL]) {
449: keystate[AK_CTRL] = false;
450: record_key ((AK_CTRL << 1) | 1);
451: goto label1;
452: }
453: }
454: if (BitTst(&keys, kOptionRawKey))
455: {
456: if (!keystate[AK_LALT]) {
457: keystate[AK_LALT] = true;
458: record_key (AK_LALT << 1);
459: goto label1;
460: }
461: } else {
462: if (keystate[AK_LALT]) {
463: keystate[AK_LALT] = false;
464: record_key ((AK_LALT << 1) | 1);
465: goto label1;
466: }
467: }
468: do {
469: repeat = false;
470: newmousecounters = false;
471: itHappened=WaitNextEvent(-1,&event,0L,0L);
472:
473: switch(event.what) {
474: case keyDown:
475: case autoKey: {
476: int kc = keycode2amiga(event.message);
477: if (kc == -1) break;
478: if (RM == true && kc == AK_Q) graphics_leave();
479: switch (kc) {
480: case AK_mousestuff:
481: #if 0
482: if (keystate[AK_CTRL])
483: mousesetup();
484: else
485: #endif
486: togglemouse();
487: break;
488:
489: case AK_inhibit:
490: inhibit_frame ^= 1;
491: break;
492:
493: default:
494: if (!keystate[kc]) {
495: keystate[kc] = true;
496: record_key (kc << 1);
497: }
498: break;
499: }
500: break;
501: }
502: case keyUp: {
503: if (Joy) break;
504: kc = keycode2amiga(event.message);
505: if (kc == -1) break;
506: keystate[kc] = false;
507: record_key ((kc << 1) | 1);
508: break;
509: }
510: case mouseDown:
511: if (RM == true) buttonstate[2] = true;
512: else buttonstate[0] = true;
513: break;
514: case mouseUp:
515: buttonstate[0] = false;
516: buttonstate[2] = false;
517: break;
518: }
519: GetMouse(&mpos);
520: if (mpos.h != lastmx) { lastmx=mpos.h; repeat = true; }
521: if (mpos.v != lastmy) { lastmy=mpos.v; repeat = true; }
522: } while (repeat);
523:
524: label1:
525: /* "Affengriff" */
526: if(keystate[AK_CTRL] && keystate[AK_LAMI] && keystate[AK_RAMI])
527: MC68000_reset();
528: }
529:
530: bool debuggable()
531: {
532: return true;
533: }
534:
535: bool needmousehack()
536: {
537: return true;
538: }
539:
540: void LED(int on)
541: {
542: }
543:
544: void parse_cmdline ()
545: {
546: /* No commandline on the Mac. Implemented on Menus soon!*/
547: }
548:
549: // Check Minimal System Configuration and Setup
550: static Boolean CheckForSetup (void)
551: { Boolean retvalue=FALSE;
552: SysEnvRec env;
553:
554: SysEnvirons( 2, &env );
555:
556: if ( env.systemVersion < 0x0700 )
557: { ParamAString("\pUAE requires System 7 or later!");
558: DisplayError(kQuitError);
559: retvalue=TRUE;
560: }
561: if ( !env.hasColorQD)
562: { ParamAString("\pUAE requires Color QuickDraw!");
563: DisplayError(kQuitError);
564: retvalue=TRUE;
565: }
566: if ( env.processor < 3)
567: { ParamAString("\pUAE requires a 68020 or better processor to run!");
568: DisplayError(kQuitError);
569: retvalue=TRUE;
570: }
571: curDevice = GetMainDevice();
572: if ((*curDevice)->gdPMap == NULL || (*(*curDevice)->gdPMap)->pixelSize != 16)
573: { if (HasDepth(curDevice,16,0,0) == 0)
574: { ParamAString("\pUAE requires 16 bit color and your display doesn't support it!");
575: DisplayError(kQuitError);
576: retvalue=TRUE;
577: }
578: else
579: {
580: oldDepth=(*(*curDevice)->gdPMap)->pixelSize;
581: SetDepth(curDevice,16,0,0);
582: }
583: }
584: return(retvalue);
585: }
586:
587: // Shows up the standard error alert;
588: int DisplayError(int ID)
589: { int ret=0;
590:
591: InitCursor();
592: ret=Alert(ID,0);
593:
594: return (ret);
595: }
596:
597: // Parses a Pascal string for error display
598: void ParamAString( ConstStr255Param theStr )
599: {
600: ParamText(theStr, "\p", "\p", "\p");
601: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.