/* ScummVM - Scumm Interpreter * Copyright (C) 2001 Ludvig Strigeus * Copyright (C) 2001/2002 Mutwin Kraus (Mac Port) and The ScummVM Project * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * $Header$ * */ #include #include #include "stdafx.h" #include "scumm.h" #include "mididrv.h" #include "gameDetector.h" //#include "mp3_cd.h" #include "gui.h" //#include "gameDetector.h" #include "scaler.h" #define MAX(a,b) (((a)<(b)) ? (b) : (a)) #define MIN(a,b) (((a)>(b)) ? (b) : (a)) class OSystem_MAC : public OSystem { public: // Set colors of the palette void set_palette(const byte *colors, uint start, uint num); // Set the size of the video bitmap. // Typically, 320x200 void init_size(uint w, uint h); // Draw a bitmap to screen. // The screen will not be updated to reflect the new bitmap void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h); // Update the dirty areas of the screen void update_screen(); // Either show or hide the mouse cursor bool show_mouse(bool visible); // Set the position of the mouse cursor void set_mouse_pos(int x, int y); // Set the bitmap that's used when drawing the cursor. void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y); // Shaking is used in SCUMM. Set current shake position. void set_shake_pos(int shake_pos); // Get the number of milliseconds since the program was started. uint32 get_msecs(); // Delay for a specified amount of milliseconds void delay_msecs(uint msecs); // Create a thread void *create_thread(ThreadProc *proc, void *param); // Get the next event. // Returns true if an event was retrieved. bool poll_event(Event *event); // Set function that generates samples bool set_sound_proc(void *param, SoundProc *proc, byte sound); // Poll cdrom status // Returns true if cd audio is playing bool poll_cdrom(); // Play cdrom audio track void play_cdrom(int track, int num_loops, int start_frame, int end_frame); // Stop cdrom audio track void stop_cdrom(); // Update cdrom audio status void update_cdrom(); // Add a new callback timer void set_timer(int timer, int (*callback)(int)) { /* FIXME - TODO */ } // Mutex handling void *create_mutex(void) { return NULL; /* FIXME - TODO */ } void lock_mutex(void *mutex) { /* FIXME - TODO */ } void unlock_mutex(void *mutex) { /* FIXME - TODO */ } void delete_mutex(void *mutex) { /* FIXME - TODO */ } // Quit void quit(); // Set a parameter uint32 property(int param, Property *value); static OSystem *create(int gfx_mode, bool full_screen); void sound_callback(SndChannel *chan, SndCommand *cmd_passed); private: typedef void TwoXSaiProc(uint8 *srcPtr, uint32 srcPitch, uint8 *deltaPtr, uint8 *dstPtr, uint32 dstPitch, int width, int height); GWorldPtr screenBuf; WindowRef wref; CTabHandle pal; Rect blit_rect; enum { DF_WANT_RECT_OPTIM = 1 << 0, DF_REAL_8BIT = 1 << 1, DF_SEPARATE_TEMPSCREEN = 1 << 2, DF_UPDATE_EXPAND_1_PIXEL = 1 << 3 }; int _mode; bool _full_screen; bool _mouse_visible; bool _mouse_drawn; uint32 _mode_flags; byte _internal_scaling; bool force_full; //Force full redraw on next update_screen bool cksum_valid; enum { NUM_DIRTY_RECT = 100, MAX_MOUSE_W = 40, MAX_MOUSE_H = 40, MAX_SCALING = 3 }; int SCREEN_WIDTH, SCREEN_HEIGHT, CKSUM_NUM; Rect *dirty_rect_list; int num_dirty_rects; uint32 *dirty_checksums; int scaling; /* CD Audio */ int cd_track, cd_num_loops, cd_start_frame, cd_end_frame; uint32 cd_end_time, cd_stop_time, cd_next_second; struct MousePos { int16 x,y,w,h; }; byte *_ms_buf; byte *_ms_backup; MousePos _ms_cur; MousePos _ms_old; int16 _ms_hotspot_x; int16 _ms_hotspot_y; int _current_shake_pos; byte* _gfx_buf; /* Graphics memory */ int16 *_sai_buf, *_tmp_buf; uint _palette_changed_first, _palette_changed_last; TwoXSaiProc *_sai_func; void add_dirty_rgn_auto(const byte *buf); void mk_checksums(const byte *buf); static void fill_sound(void *userdata, uint8 * stream, int len); void add_dirty_rect(int x, int y, int w, int h); void draw_mouse(); void undraw_mouse(); void load_gfx_mode(); void unload_gfx_mode(); void hotswap_gfx_mode(); void get_320x200_image(byte *buf); void init_mac_stuff(); void set_scaling(); void blit_to_screen(); void update_rects(); static uint32 autosave(uint32); UInt8 *buffer[2]; CmpSoundHeader header; SndChannelPtr channel; int size; SoundProc *sndProc; void * parameter; }; KeyMap fKeyMap; Boolean CommandKeyDown() { GetKeys(fKeyMap); // get info if (fKeyMap[1] & 0x8000) return true; else return false; } static unsigned char *CToPascal(char *str) { register char *p,*q; register long len; len = strlen(str); if (len > 255) len = 255; p = str + len; q = p-1; while (p != str) *p-- = *q--; *str = len; return((unsigned char *)str); } static char *PascalToC(unsigned char *str) { register unsigned char *p,*q,*end; end = str + *str; q = (p=str) + 1; while (p < end) *p++ = *q++; *p = '\0'; return((char *)str); } const EventTypeSpec kCmdEvents[] = { { kEventClassMouse, kEventMouseDown }, { kEventClassMouse, kEventMouseUp }, { kEventClassMouse, kEventMouseMoved }, { kEventClassKeyboard, kEventRawKeyDown }, { kEventClassCommand, kEventProcessCommand } }; const EventTypeSpec kWindowEvents[] = { { kEventClassWindow, kEventWindowDrawContent }, { kEventClassWindow, kEventWindowHandleContentClick }, { kEventClassWindow, kEventWindowClose } }; pascal OSErr QuitEventHandler(const AppleEvent *theEvent, AppleEvent *theReply, SInt32 refCon) { //OSystem_MAC::quit(); return(noErr); } enum { kNewGameCmd = 'newG', kQuitCmd = kHICommandQuit, kOpenGameCmd = 'opnG', kSaveGameCmd = 'savG', kPrefsCmd = kHICommandPreferences, kAboutCmd = 'abtG' }; ControlRef radioGroupRef, musicVolumeSlider, masterVolumeSlider; char *gameTitle; ControlRef popUpControlRef, checkBoxControlRef; OSStatus prefsEventHandler(EventHandlerCallRef eventHandlerCallRef,EventRef eventRef, void *userData) { OSStatus result = eventNotHandledErr; UInt32 eventClass; UInt32 eventKind; ControlRef controlRef; ControlID controlID; eventClass = GetEventClass(eventRef); eventKind = GetEventKind(eventRef); if(eventClass == kEventClassControl) { if(eventKind == kEventControlHit) { GetEventParameter(eventRef,kEventParamDirectObject,typeControlRef,NULL, sizeof(ControlRef),NULL,&controlRef); GetControlID(controlRef,&controlID); if(controlID.id == 'okay') { /*scumm->_noSubtitles = (Boolean)!GetControlValue(checkBoxControlRef); short scale = GetControlValue(radioGroupRef); if(scale != scumm->_scale) wm->ChangeScaling(scale); short music_vol = GetControlValue(musicVolumeSlider); if(music_vol != sound.get_music_volume()) sound.set_music_volume(music_vol); short master_vol = GetControlValue(masterVolumeSlider); if(master_vol != sound.get_master_volume()) sound.set_master_volume(master_vol);*/ QuitAppModalLoopForWindow((WindowRef)userData); DisposeWindow((WindowRef)userData); result = noErr; } } } } void Preferences() { WindowRef prefsWin; OSStatus osError = noErr; Rect rect = { 0,0,210,300 }; Rect okButtonRect; ControlID controlID; ControlRef controlRef; EventTypeSpec dialogEvents[] = { kEventClassControl, kEventControlHit }; osError = CreateNewWindow(kMovableModalWindowClass,kWindowStandardHandlerAttribute,&rect, &prefsWin); SetWTitle(prefsWin, "\pPreferences"); RepositionWindow(prefsWin,FrontWindow(),kWindowAlertPositionOnMainScreen); SetThemeWindowBackground(prefsWin,kThemeBrushDialogBackgroundActive,false); CreateRootControl(prefsWin,&controlRef); SetRect(&rect, 5, 5, 150, 21); CreateStaticTextControl(prefsWin, &rect, CFSTR("ScummVM Preferences"), NULL, &controlRef); AutoEmbedControl(controlRef, prefsWin); SetRect(&okButtonRect, 225, 180, 295, 200); CreatePushButtonControl(prefsWin,&okButtonRect,CFSTR("OK"),&controlRef); SetWindowDefaultButton(prefsWin,controlRef); controlID.id = 'okay'; SetControlID(controlRef,&controlID); AutoEmbedControl(controlRef,prefsWin); SetRect(&rect, 150, 35, 260, 51); CreateCheckBoxControl(prefsWin,&rect, CFSTR("Subtitles"), 1, true, &checkBoxControlRef); AutoEmbedControl(checkBoxControlRef, prefsWin); //if(scumm->_noSubtitles) SetControlValue(checkBoxControlRef, false); OffsetRect(&rect, 0, 20); CreateCheckBoxControl(prefsWin,&rect, CFSTR("Fullscreen"), 0, true, &controlRef); AutoEmbedControl(controlRef, prefsWin); DeactivateControl(controlRef); Rect RadioGroupRect; SetRect(&RadioGroupRect, 5, 35, 120, 100); CreateRadioGroupControl(prefsWin, &RadioGroupRect, &radioGroupRef); AutoEmbedControl(radioGroupRef, prefsWin); ControlRef radioButton; Rect RadioButtonRect; SetRect(&RadioButtonRect, 5, 35, 120, 51); CreateRadioButtonControl(prefsWin, &RadioButtonRect, CFSTR("Scaling 1x"), 0, true, &radioButton); AutoEmbedControl(radioButton, prefsWin); OffsetRect(&RadioButtonRect, 0, 20); CreateRadioButtonControl(prefsWin, &RadioButtonRect, CFSTR("Scaling 2x"), 0, true, &radioButton); AutoEmbedControl(radioButton, prefsWin); OffsetRect(&RadioButtonRect, 0, 20); CreateRadioButtonControl(prefsWin, &RadioButtonRect, CFSTR("Scaling 3x"), 0, true, &radioButton); AutoEmbedControl(radioButton, prefsWin); //SetControlValue(radioGroupRef, scumm->_scale); SetRect(&rect, 5, 110, 175, 146); CreateSliderControl(prefsWin, &rect, 100, 1, 100, kControlSliderPointsDownOrRight, 10, false, NULL, &musicVolumeSlider); AutoEmbedControl(musicVolumeSlider, prefsWin); OffsetRect(&rect, 0, 36); CreateSliderControl(prefsWin, &rect, 100, 1, 100, kControlSliderPointsDownOrRight, 10, false, NULL, &masterVolumeSlider); AutoEmbedControl(masterVolumeSlider, prefsWin); OffsetRect(&rect, 180, -36); CreateStaticTextControl(prefsWin, &rect, CFSTR("Music Volume"), NULL, &controlRef); AutoEmbedControl(controlRef, prefsWin); OffsetRect(&rect, 0, 36); CreateStaticTextControl(prefsWin, &rect, CFSTR("Master Volume"), NULL, &controlRef); AutoEmbedControl(controlRef, prefsWin); InstallWindowEventHandler(prefsWin, NewEventHandlerUPP((EventHandlerProcPtr) prefsEventHandler), GetEventTypeCount(dialogEvents),dialogEvents,prefsWin,NULL); ShowWindow(prefsWin); osError = RunAppModalLoopForWindow(prefsWin); } void LaunchGame(int id) { switch(id) { case 6: gameTitle = "indy3"; break; case 7: gameTitle = "zak256"; break; case 8: gameTitle = "loom"; break; case 9: gameTitle = "monkeyEGA"; break; case 10: gameTitle = "monkeyVGA"; break; case 11: gameTitle = "loomcd"; break; case 12: gameTitle = "monkey"; break; case 13: gameTitle = "monkey1"; break; case 14: gameTitle = "monkey2"; break; case 15: gameTitle = "atlantis"; break; case 16: gameTitle = "playfate"; break; case 17: gameTitle = "tentacle"; break; case 18: gameTitle = "dottdemo"; break; case 19: gameTitle = "samnmax"; break; case 20: gameTitle = "snmdemo"; break; case 21: gameTitle = "ft"; break; case 22: gameTitle = "dig"; break; case 25: gameTitle = "simon1dos"; break; case 26: gameTitle = "simon1win"; break; case 27: gameTitle = "simon2win"; break; } } OSStatus dialogEventHandler(EventHandlerCallRef eventHandlerCallRef,EventRef eventRef, void *userData) { OSStatus result = eventNotHandledErr; UInt32 eventClass; UInt32 eventKind; ControlRef controlRef; ControlID controlID; eventClass = GetEventClass(eventRef); eventKind = GetEventKind(eventRef); if(eventClass == kEventClassControl) { if(eventKind == kEventControlHit) { GetEventParameter(eventRef,kEventParamDirectObject,typeControlRef,NULL, sizeof(ControlRef),NULL,&controlRef); GetControlID(controlRef,&controlID); if(controlID.id == 'okay') { QuitAppModalLoopForWindow((WindowRef)userData); LaunchGame(GetControlValue(popUpControlRef)); DisposeWindow((WindowRef)userData); result = noErr; } else if(controlID.id == 'cncl') { QuitAppModalLoopForWindow((WindowRef)userData); DisposeWindow((WindowRef)userData); ExitToShell(); } } } return result; } char* SelectGame() { WindowRef aboutWin; OSStatus osError = noErr; Rect rect = { 0,0,120,350 }; Rect pushButtonRect = { 75,250,96,330 }; Rect popupRect = { 10, 10, 26, 330 }; ControlID controlID; ControlRef controlRef; Rect checkboxRect = { 36, 10, 50, 80 }; EventTypeSpec dialogEvents[] = { kEventClassControl, kEventControlHit }; InitCursor(); SIOUXSettings.autocloseonquit = true; SIOUXSettings.asktosaveonclose = false; SIOUXSettings.showstatusline = false; SIOUXSettings.fontsize = 9; GetFNum("\pMonaco",&SIOUXSettings.fontid); SIOUXSettings.standalone = false; SIOUXSettings.setupmenus = false; SIOUXSettings.toppixel = 40; SIOUXSettings.leftpixel = 5; osError = CreateNewWindow(kMovableModalWindowClass,kWindowStandardHandlerAttribute,&rect, &aboutWin); SetWTitle(aboutWin, "\pPlease Select a GameÉ"); RepositionWindow(aboutWin,FrontWindow(),kWindowAlertPositionOnMainScreen); SetThemeWindowBackground(aboutWin,kThemeBrushDialogBackgroundActive,false); CreateRootControl(aboutWin,&controlRef); CreatePushButtonControl(aboutWin,&pushButtonRect,CFSTR("OK"),&controlRef); SetWindowDefaultButton(aboutWin,controlRef); controlID.id = 'okay'; SetControlID(controlRef,&controlID); AutoEmbedControl(controlRef,aboutWin); OffsetRect(&pushButtonRect, -100, 0); CreatePushButtonControl(aboutWin,&pushButtonRect,CFSTR("Cancel"),&controlRef); SetWindowCancelButton(aboutWin,controlRef); controlID.id = 'cncl'; SetControlID(controlRef,&controlID); AutoEmbedControl(controlRef,aboutWin); CreatePopupButtonControl(aboutWin, &popupRect, CFSTR("Game: "), 999, false, -1, 0, NULL, &popUpControlRef); SetWindowDefaultButton(aboutWin,popUpControlRef); controlID.id = 'game'; SetControlID(popUpControlRef,&controlID); AutoEmbedControl(controlRef,aboutWin); InstallWindowEventHandler(aboutWin, NewEventHandlerUPP((EventHandlerProcPtr) dialogEventHandler), GetEventTypeCount(dialogEvents),dialogEvents,aboutWin,NULL); ShowWindow(aboutWin); osError = RunAppModalLoopForWindow(aboutWin); return gameTitle; } OSystem *OSystem_MAC::create(int gfx_mode, bool full_screen) { Rect rectWin; OSystem_MAC *syst = new OSystem_MAC(); syst->_mode = gfx_mode; syst->_full_screen = full_screen; /* Macintosh init */ syst->init_mac_stuff(); return syst; } uint32 OSystem_MAC::autosave(uint32 interval) { g_scumm->_doAutosave = true; return interval; } OSystem *OSystem_MAC_create(int gfx_mode, bool full_screen) { return OSystem_MAC::create(gfx_mode, full_screen); } void OSystem_MAC::set_palette(const byte *colors, uint start, uint num) { const byte *b = colors; (*pal)->ctSeed = TickCount(); for(int i = start; i < num; i++, b += 4) { (*pal)->ctTable[i].value = i; (*pal)->ctTable[i].rgb.red = b[0]<<8; (*pal)->ctTable[i].rgb.green = b[1]<<8; (*pal)->ctTable[i].rgb.blue = b[2]<<8; } CTabChanged(pal); if(_sai_func) UpdateGWorld(&screenBuf, 16, &blit_rect, NULL, NULL, 0); else UpdateGWorld(&screenBuf, 8, &blit_rect, pal, NULL, 0); if(start < _palette_changed_first) _palette_changed_first = start; if(start + num > _palette_changed_last) _palette_changed_last = start + num; } void OSystem_MAC::load_gfx_mode() { force_full = true; scaling = 1; _internal_scaling = 1; _mode_flags = 0; _sai_func = NULL; switch(_mode) { case GFX_2XSAI: _sai_func = _2xSaI; break; case GFX_SUPER2XSAI: _sai_func = Super2xSaI; break; case GFX_SUPEREAGLE: _sai_func = SuperEagle; break; case GFX_ADVMAME2X: _sai_func = AdvMame2x; break; case GFX_DOUBLESIZE: scaling = 2; _internal_scaling = 2; _mode_flags = DF_WANT_RECT_OPTIM; break; case GFX_TRIPLESIZE: if (_full_screen) { warning("full screen in useless in triplesize mode, reverting to normal mode"); goto normal_mode; } scaling = 3; _internal_scaling = 3; _mode_flags = DF_WANT_RECT_OPTIM; break; case GFX_NORMAL: normal_mode:; _mode_flags = DF_WANT_RECT_OPTIM; break; } if(_sai_func) { _mode_flags = DF_WANT_RECT_OPTIM | DF_SEPARATE_TEMPSCREEN | DF_UPDATE_EXPAND_1_PIXEL; Init_2xSaI(565); _tmp_buf = (int16*)calloc((SCREEN_WIDTH+3)*(SCREEN_HEIGHT+3), sizeof(int16)); scaling = 2; } else { switch(scaling) { case 3: _sai_func = Normal3x; break; case 2: _sai_func = Normal2x; break; case 1: _sai_func = Normal1x; break; } _mode_flags = DF_WANT_RECT_OPTIM | DF_REAL_8BIT; } set_scaling(); } void OSystem_MAC::unload_gfx_mode() { //warning("STUB: unload_gfx_mode()"); /* FIXME: Must free data here */ } void OSystem_MAC::init_size(uint w, uint h) { //if (w != SCREEN_WIDTH && h != SCREEN_HEIGHT) // error("320x200 is the only game resolution supported"); SCREEN_WIDTH = w; SCREEN_HEIGHT = h; CKSUM_NUM = (SCREEN_WIDTH * SCREEN_HEIGHT / (8*8)); dirty_rect_list = (Rect*)calloc(NUM_DIRTY_RECT, sizeof(Rect)); _ms_backup = (byte*)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING); dirty_checksums = (uint32*)calloc(CKSUM_NUM*2, sizeof(uint32)); load_gfx_mode(); } void OSystem_MAC::copy_rect(const byte *buf, int pitch, int x, int y, int w, int h) { if (pitch == SCREEN_WIDTH && x==0 && y==0 && w==SCREEN_WIDTH && h==SCREEN_HEIGHT && _mode_flags&DF_WANT_RECT_OPTIM) { /* Special, optimized case for full screen updates. * It tries to determine what areas were actually changed, * and just updates those, on the actual display. */ add_dirty_rgn_auto(buf); } else { /* Clip the coordinates */ if (x < 0) { w+=x; buf-=x; x = 0; } if (y < 0) { h+=y; buf-=y*pitch; y = 0; } if (w >= SCREEN_WIDTH-x) { w = SCREEN_WIDTH - x; } if (h >= SCREEN_HEIGHT-y) { h = SCREEN_HEIGHT - y; } if (w<=0 || h<=0) return; cksum_valid = false; add_dirty_rect(x, y, w, h); } /* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */ if (_mouse_drawn) undraw_mouse(); byte *dst = (byte*)buf + y * SCREEN_WIDTH + x; do { memcpy(dst, buf, w); dst += SCREEN_WIDTH; buf += pitch; } while(--h); } void OSystem_MAC::add_dirty_rect(int x, int y, int w, int h) { if (force_full) return; if (num_dirty_rects == NUM_DIRTY_RECT) force_full = true; else { Rect *r = &dirty_rect_list[num_dirty_rects++]; /* Update the dirty region by 1 pixel for graphics drivers * that "smear" the screen */ if (_mode_flags & DF_UPDATE_EXPAND_1_PIXEL) { x--; y--; w+=2; h+=2; } /* clip */ if (x<0) { w+=x; x=0; } if (y<0) { h+=y; y=0; } if (w>=SCREEN_WIDTH-x) { w=SCREEN_WIDTH-x; } if (h>=SCREEN_HEIGHT-y) { h=SCREEN_HEIGHT-y; } if (_internal_scaling != 1) { x *= _internal_scaling; y *= _internal_scaling; w *= _internal_scaling; h *= _internal_scaling; } r->left = x; r->top = y; r->right = x + w; r->bottom = y + h; } } #define ROL(a,n) a = (a<<(n)) | (a>>(32-(n))) #define DOLINE(x) a ^= ((uint32*)buf)[0+(x)*(SCREEN_WIDTH/4)]; b ^= ((uint32*)buf)[1+(x)*(SCREEN_WIDTH/4)] void OSystem_MAC::mk_checksums(const byte *buf) { uint32 *sums = dirty_checksums; uint x,y; /* the 8x8 blocks in buf are enumerated starting in the top left corner and * reading each line at a time from left to right */ for(y=0; y!=SCREEN_HEIGHT/8; y++,buf+=SCREEN_WIDTH*(8-1)) for(x=0; x!=SCREEN_WIDTH/8; x++,buf+=8) { uint32 a = x; uint32 b = y; DOLINE(0); ROL(a,13); ROL(b,11); DOLINE(2); ROL(a,13); ROL(b,11); DOLINE(4); ROL(a,13); ROL(b,11); DOLINE(6); ROL(a,13); ROL(b,11); a*=0xDEADBEEF; b*=0xBAADF00D; DOLINE(1); ROL(a,13); ROL(b,11); DOLINE(3); ROL(a,13); ROL(b,11); DOLINE(5); ROL(a,13); ROL(b,11); DOLINE(7); ROL(a,13); ROL(b,11); /* output the checksum for this block */ *sums++=a+b; } } #undef DOLINE #undef ROL void OSystem_MAC::add_dirty_rgn_auto(const byte *buf) { assert( ((uint32)buf & 3) == 0); /* generate a table of the checksums */ mk_checksums(buf); if (!cksum_valid) { force_full = true; cksum_valid = true; } /* go through the checksum list, compare it with the previous checksums, and add all dirty rectangles to a list. try to combine small rectangles into bigger ones in a simple way */ if (!force_full) { uint x,y,w; uint32 *ck = dirty_checksums; for(y=0; y!=SCREEN_HEIGHT/8; y++) { for(x=0; x!=SCREEN_WIDTH/8; x++,ck++) { if (ck[0] != ck[CKSUM_NUM]) { /* found a dirty 8x8 block, now go as far to the right as possible, and at the same time, unmark the dirty status by setting old to new. */ w=0; do { ck[w+CKSUM_NUM] = ck[w]; w++; } while (x+w != SCREEN_WIDTH/8 && ck[w] != ck[w+CKSUM_NUM]); add_dirty_rect(x*8, y*8, w*8, 8); if (force_full) goto get_out; } } } } else { get_out:; /* Copy old checksums to new */ memcpy(dirty_checksums + CKSUM_NUM, dirty_checksums, CKSUM_NUM * sizeof(uint32)); } } void OSystem_MAC::update_screen() { #if 0 /* First make sure the mouse is drawn, if it should be drawn. */ draw_mouse(); if (_palette_changed_last != 0) { //warning("MAC: Palette should be uploaded!");/* FIXME: Add Palette changing code */ /*GDevice **odisplay; odisplay = GetGDevice(); SetGDevice(GetMainDevice()); SetEntries(0, (**pal).ctSize, (ColorSpec *)&(**pal).ctTable); SetGDevice(odisplay);*/ /*_palette_changed_last = 0; if (_mode_flags & DF_FORCE_FULL_ON_PALETTE) */force_full = true; } /* force a full redraw, accomplish that by adding one big rect to the dirty * rect list */ if (force_full) { num_dirty_rects = 1; dirty_rect_list[0].left = 0; dirty_rect_list[0].top = 0; dirty_rect_list[0].right = SCREEN_WIDTH; dirty_rect_list[0].bottom = SCREEN_HEIGHT; } if (num_dirty_rects > 0) { Rect *r; uint32 srcPitch, dstPitch; Rect *last_rect = dirty_rect_list + num_dirty_rects; /* Convert appropriate parts of the image into 16bpp */ if ((_mode_flags & DF_REAL_8BIT) == 0) { Rect dst; for(r=dirty_rect_list; r!=last_rect; ++r) { dst = *r; dst.left++; dst.top++; dst.right++; dst.bottom++; } } /*srcPitch = sdl_tmpscreen->pitch; dstPitch = sdl_hwscreen->pitch;*/ if ((_mode_flags & DF_REAL_8BIT) == 0) { for(r=dirty_rect_list; r!=last_rect; ++r) { register int dst_y = r->y + _current_shake_pos; register int dst_h = 0; if (dst_y < SCREEN_HEIGHT) { dst_h = r->h; if (dst_h > SCREEN_HEIGHT - dst_y) dst_h = SCREEN_HEIGHT - dst_y; r->x <<= 1; dst_y <<= 1; _sai_func((byte*)sdl_tmpscreen->pixels + (r->x+2) + (r->y+1)*srcPitch, srcPitch, NULL, (byte*)sdl_hwscreen->pixels + r->x*scaling + dst_y*dstPitch, dstPitch, r->w, dst_h); } r->y = dst_y; r->w <<= 1; r->h = dst_h << 1; } } else { for(r=dirty_rect_list; r!=last_rect; ++r) { register int dst_y = r->y + _current_shake_pos; register int dst_h = 0; if (dst_y < SCREEN_HEIGHT) { dst_h = r->h; if (dst_h > SCREEN_HEIGHT - dst_y) dst_h = SCREEN_HEIGHT - dst_y; dst_y *= scaling; _sai_func((byte*)sdl_tmpscreen->pixels + r->x + r->y*srcPitch, srcPitch, NULL, (byte*)sdl_hwscreen->pixels + r->x*scaling + dst_y*dstPitch, dstPitch, r->w, dst_h); } r->x *= scaling; r->y = dst_y; r->w *= scaling; r->h = dst_h * scaling; } } if (force_full) { dirty_rect_list[0].y = 0; dirty_rect_list[0].h = SCREEN_HEIGHT * scaling; } } /*if(_mode_flags & DF_2xSAI) { Rect *r; uint32 area = 0; Rect *dr = dirty_rect_list + num_dirty_rects; for(r = dirty_rect_list; r != dr; r++) { GWorldPtr gw; Rect rec; SetRect(&rec, 0, 0, 320, 200); NewGWorldFromPtr(&gw, 16, &rec, NULL, NULL, 0, (char*)_tmp_buf, rec.right); CopyBits(GetPortBitMapForCopyBits(gw), GetPortBitMapForCopyBits(screenBuf), r, r, srcCopy, 0L); } for(r = dirty_rect_list; r != dr; r++) { _sai_func((byte*)_tmp_buf + r->left * 2 + r->top * 640, 640, NULL, (byte*)_sai_buf + r->left * 4 + r->top * 640 * 4, 640 * 2, r->right - r->left, r->bottom - r->top); area += (r->right - r->left) * (r->bottom - r->top); r->left <<= 1; r->right <<= 1; r->top <<= 1; r->bottom <<= 1; } }*/ update_rects(); //blit_to_screen(); num_dirty_rects = 0; #endif } bool OSystem_MAC::show_mouse(bool visible) { if (_mouse_visible == visible) return visible; bool last = _mouse_visible; _mouse_visible = visible; if (visible) draw_mouse(); else undraw_mouse(); return last; } void OSystem_MAC::set_mouse_pos(int x, int y) { if (x != _ms_cur.x || y != _ms_cur.y) { _ms_cur.x = x; _ms_cur.y = y; undraw_mouse(); } } void OSystem_MAC::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) { _ms_cur.w = w; _ms_cur.h = h; _ms_hotspot_x = hotspot_x; _ms_hotspot_y = hotspot_y; _ms_buf = (byte*)buf; undraw_mouse(); } void OSystem_MAC::set_shake_pos(int shake_pos) { /*int old_shake_pos = _current_shake_pos; int dirty_height, dirty_blackheight; int dirty_top, dirty_blacktop; if (shake_pos != old_shake_pos) { _current_shake_pos = shake_pos; force_full = true; /* Old shake pos was current_shake_pos, new is shake_pos. * Move the screen up or down to account for the change. */ //SDL_Rect dstr = { 0, shake_pos*scaling, 320*scaling, 200*scaling }; //SDL_Rect srcr = { 0, old_shake_pos*scaling, 320*scaling, 200*scaling }; //SDL_BlitSurface(sdl_screen, &srcr, sdl_screen, &dstr); /* Rect srcr, dstr; SetRect(&srcr, 0, old_shake_pos * scaling, 320 * scaling, 200 * scaling); SetRect(&dstr, 0, shake_pos * scaling, 320 * scaling, 200 * scaling); CopyBits(GetPortBitMapForCopyBits(screenBuf), GetPortBitMapForCopyBits(GetWindowPort(wref)), &srcr, &dstr, srcCopy, 0L); /* Refresh either the upper part of the screen, * or the lower part */ /* if (shake_pos > old_shake_pos) { dirty_height = MIN(shake_pos, 0) - MIN(old_shake_pos, 0); dirty_top = -MIN(shake_pos, 0); dirty_blackheight = MAX(shake_pos, 0) - MAX(old_shake_pos, 0); dirty_blacktop = MAX(old_shake_pos, 0); } else { dirty_height = MAX(old_shake_pos, 0) - MAX(shake_pos, 0); dirty_top = 200 - MAX(old_shake_pos, 0); dirty_blackheight = MIN(old_shake_pos, 0) - MIN(shake_pos, 0); dirty_blacktop = 200 + MIN(shake_pos, 0); } /* Fill the dirty area with blackness or the scumm image */ //SDL_Rect blackrect = {0, dirty_blacktop*scaling, 320*scaling, dirty_blackheight*scaling}; //SDL_FillRect(sdl_screen, &blackrect, 0); /* FIXME: Um, screen seems to glitch since this 'not needed' function was removed */ //g_scumm->redrawLines(dirty_top, dirty_top + dirty_height); /* }*/ } uint32 OSystem_MAC::get_msecs() { UnsignedWide ms; Microseconds(&ms); return(ms.lo / 1000); } void OSystem_MAC::delay_msecs(uint msecs) { uint32 start = get_msecs(); Event dummy; do { poll_event(&dummy); /* Do something to avoid CPU lock */ if(get_msecs() >= start + msecs) break; } while (1); } void *OSystem_MAC::create_thread(ThreadProc *proc, void *param) { warning("MAC: Stub create_thread()"); //NewThread(kCooperativeThread, (void*)proc, param, 0L, kCreateIfNeeded, NULL, NULL); } int mapKey(int key, byte code, byte mod) { switch(code) { case 0x35: key = 27; break; case 0x31: key = 32; break; case 0x60: key = 601; break; } return key; } bool OSystem_MAC::poll_event(Event *event) { EventRef theEvent; EventTargetRef theTarget; OSStatus theErr; OSStatus result = eventNotHandledErr; HICommand command; Point mouse; theTarget = GetEventDispatcherTarget(); theErr = ReceiveNextEvent(GetEventTypeCount(kCmdEvents), kCmdEvents, kEventDurationNoWait,true, &theEvent); GetEventParameter( theEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof( HICommand ), NULL, &command ); switch(GetEventClass(theEvent)) { case kEventClassWindow: switch(GetEventKind(theEvent)) { case kEventWindowDrawContent: break; case kEventWindowHandleContentClick: EventMouseButton btn; GetEventParameter(theEvent, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &btn); if(btn == kEventMouseButtonPrimary) event->event_code = EVENT_RBUTTONDOWN; else if(btn == kEventMouseButtonSecondary) event->event_code = EVENT_LBUTTONDOWN; debug(1, "Mouse down!"); if(wref != FrontWindow()) { // FIXME - seems some versions of the CarbonLib stub are missing ActivateWindow // ActivateWindow(wref, true); BringToFront(wref); } return true; break; case kEventWindowClose: quit(); break; } break; case kEventClassCommand: switch(command.commandID) { case kNewGameCmd: break; case kOpenGameCmd: //scumm->_saveLoadSlot = 0; //scumm->_saveLoadFlag = 2; break; case kSaveGameCmd: //scumm->_saveLoadSlot = 0; //sprintf(scumm->_saveLoadName, "Quicksave %d", scumm->_saveLoadSlot); //scumm->_saveLoadFlag = 1; break; case kQuitCmd: quit(); break; case kPrefsCmd: //Preferences(); break; case kAboutCmd: //About(); break; } break; case kEventClassKeyboard: if(GetEventKind(theEvent) == kEventRawKeyDown) { char key; UInt32 mod, code; GetEventParameter(theEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &code); GetEventParameter(theEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &key); GetEventParameter(theEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &mod); event->event_code = EVENT_KEYDOWN; event->kbd.keycode = code; event->kbd.ascii = mapKey(key, code, mod); debug(1, "Key down: %c", event->kbd.ascii); return true; } break; case kEventClassMouse: EventMouseButton btn; Rect winRect; switch(GetEventKind(theEvent)) { case kEventMouseDown: WindowRef theWin; GetEventParameter(theEvent, kEventParamDirectObject, typeWindowRef, NULL, sizeof(WindowRef), NULL, &theWin); if(theWin != FrontWindow()) { // FIXME - seems some versions of the CarbonLib stub are missing ActivateWindow // ActivateWindow(theWin, true); BringToFront(theWin); } GetEventParameter(theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &mouse); GetWindowBounds(wref, kWindowContentRgn, &winRect); if(PtInRect(mouse, &winRect)) { GetEventParameter(theEvent, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &btn); if(btn == kEventMouseButtonPrimary) event->event_code = EVENT_RBUTTONDOWN; else if(btn == kEventMouseButtonSecondary) event->event_code = EVENT_LBUTTONDOWN; debug(1, "Mouse down!"); } break; case kEventMouseUp: GetEventParameter(theEvent, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &btn); if(btn == kEventMouseButtonPrimary) event->event_code = EVENT_RBUTTONUP; else if(btn == kEventMouseButtonSecondary) event->event_code = EVENT_LBUTTONUP; debug(1, "Mouse up!"); return true; break; case kEventMouseMoved: GetEventParameter(theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &mouse); GetWindowBounds(wref, kWindowContentRgn, &winRect); if(PtInRect(mouse, &winRect)) { CGrafPtr oldPort; GetPort(&oldPort); SetPortWindowPort(wref); GlobalToLocal(&mouse); event->event_code = EVENT_MOUSEMOVE; event->mouse.x = mouse.h / scaling; event->mouse.y = mouse.v / scaling; //scumm->mouse.x = mouse.h/wm->scale; //scumm->mouse.y = mouse.v/wm->scale; } Point offset = {0, 0}; ShieldCursor(&winRect, offset); return true; break; } break; } if(theErr == noErr && theEvent != NULL) { SendEventToEventTarget (theEvent, theTarget); ReleaseEvent(theEvent); } } pascal void sound_callback(SndChannel *chan, SndCommand *cmd_passed) { OSystem_MAC* syst = (OSystem_MAC*)chan->userInfo; syst->sound_callback(chan, cmd_passed); } void OSystem_MAC::sound_callback(SndChannel *chan, SndCommand *cmd_passed) { UInt32 fill_me, play_me; SndCommand cmd; fill_me = cmd_passed->param2; play_me = ! fill_me; header.samplePtr = (Ptr)buffer[play_me]; cmd.cmd = bufferCmd; cmd.param1 = 0; cmd.param2 = (long)&header; SndDoCommand(chan, &cmd, 0); memset(buffer[fill_me], 0, size); //sndProc(parameter, buffer[fill_me], size); //SoundMixer::on_generate_samples(parameter, buffer[fill_me], size); cmd.cmd = callBackCmd; cmd.param1 = 0; cmd.param2 = play_me; SndDoCommand(chan, &cmd, 0); } bool OSystem_MAC::set_sound_proc(void *param, SoundProc *proc, byte format) { SndCallBackUPP callback; int sample_size; memset(&header, 0, sizeof(header)); callback = NewSndCallBackUPP(::sound_callback); size = ((0x9010 & 0xFF) / 8) * 2048; sample_size = size / 2048 * 8; header.numChannels = 1; header.sampleSize = sample_size; header.sampleRate = SAMPLES_PER_SEC << 16; header.numFrames = 2048; header.encode = cmpSH; for(int i = 0; i < 2; i++) { buffer[i] = (UInt8*)malloc(sizeof(UInt8) * size); memset(buffer[i], 0, size); } channel = (SndChannelPtr)malloc(sizeof(*channel)); channel->qLength = 128; channel->userInfo = (long)this; SndNewChannel(&channel, sampledSynth, initMono, callback); SndCommand cmd; cmd.cmd = callBackCmd; cmd.param2 = 0; SndDoCommand(channel, &cmd, 0); sndProc = proc; parameter = param; return true; } /* retrieve the 320x200 bitmap currently being displayed */ void OSystem_MAC::get_320x200_image(byte *buf) { /* make sure the mouse is gone */ undraw_mouse(); byte *src; int x,y; switch(_internal_scaling) { case 1: memcpy(buf, _gfx_buf, 320*200); break; case 2: src = (byte*)_gfx_buf; for(y=0; y!=200; y++) { for(x=0; x!=320; x++) buf[x] = src[x*2]; buf += 320; src += 320 * 2 * 2; } break; case 3: src = (byte*)_gfx_buf; for(y=0; y!=200; y++) { for(x=0; x!=320; x++) buf[x] = src[x*3]; buf += 320; src += 320 * 3 * 3; } break; } } void OSystem_MAC::hotswap_gfx_mode() { /* hmm, need to allocate a 320x200 bitmap * which will contain the "backup" of the screen during the change. * then draw that to the new screen right after it's setup. */ byte *bak_mem = (byte*)malloc(320*200); get_320x200_image(bak_mem); unload_gfx_mode(); load_gfx_mode(); force_full = true; /* reset palette ? */ pal = (CTabHandle)NewHandleClear(sizeof(ColorTable) + 255 * sizeof(ColorSpec)); (*pal)->ctFlags = 0; (*pal)->ctSize = 255; /* blit image */ copy_rect(bak_mem, 320, 0, 0, 320, 200); free(bak_mem); update_screen(); } uint32 OSystem_MAC::property(int param, Property *value) { switch(param) { case PROP_TOGGLE_FULLSCREEN: _full_screen ^= true; return 1; case PROP_SET_WINDOW_CAPTION: StringPtr gameText = CToPascal((char*)value->caption); SetWTitle(wref, gameText); return 1; case PROP_OPEN_CD: break; case PROP_SET_GFX_MODE: if(value->gfx_mode >= 7) return 0; _mode = value->gfx_mode; hotswap_gfx_mode(); return 1; case PROP_SHOW_DEFAULT_CURSOR: break; case PROP_GET_SAMPLE_RATE: return SAMPLES_PER_SEC; break; } return 0; } void OSystem_MAC::quit() { unload_gfx_mode(); QuitApplicationEventLoop(); ExitToShell(); } void OSystem_MAC::draw_mouse() { if (_mouse_drawn || !_mouse_visible) return; _mouse_drawn = true; const int ydraw = _ms_cur.y + _current_shake_pos - _ms_hotspot_y; const int xdraw = _ms_cur.x - _ms_hotspot_x; const int w = _ms_cur.w; const int h = _ms_cur.h; int x,y; byte color; byte *dst, *bak = _ms_backup; byte *buf = _ms_buf; _ms_old.w = w; _ms_old.h = h; _ms_old.x = xdraw; _ms_old.y = ydraw; byte *src; if(_sai_func) src = (byte*)_tmp_buf; else src = _gfx_buf; switch(_internal_scaling) { case 1: dst = (byte *)src + ydraw * 320 + xdraw; for (y = 0; y < h; y++, dst += 320, bak += MAX_MOUSE_W, buf += w) { if ((uint) (ydraw + y) < 200) { for (x = 0; x < w; x++) { if ((uint) (xdraw + x) < 320) { bak[x] = dst[x]; if ((color = buf[x]) != 0xFF) { dst[x] = color; } } } } } break; case 2: dst = (byte *)src + ydraw * 640 * 2 + xdraw * 2; for (y = 0; y < h; y++, dst += 640 * 2, bak += MAX_MOUSE_W * 2, buf += w) { if ((uint) (ydraw + y) < 200) { for (x = 0; x < w; x++) { if ((uint) (xdraw + x) < 320) { bak[x * 2] = dst[x * 2]; bak[x * 2 + 1] = dst[x * 2 + 1]; if ((color = buf[x]) != 0xFF) { dst[x * 2] = color; dst[x * 2 + 1] = color; dst[x * 2 + 640] = color; dst[x * 2 + 1 + 640] = color; } } } } } break; case 3: dst = (byte *)src + ydraw * 960 * 3 + xdraw * 3; for (y = 0; y < h; y++, dst += 960 * 3, bak += MAX_MOUSE_W * 3, buf += w) { if ((uint) (ydraw + y) < 200) { for (x = 0; x < w; x++) { if ((uint) (xdraw + x) < 320) { bak[x * 3] = dst[x * 3]; bak[x * 3 + 1] = dst[x * 3 + 1]; bak[x * 3 + 2] = dst[x * 3 + 2]; if ((color = buf[x]) != 0xFF) { dst[x * 3] = color; dst[x * 3 + 1] = color; dst[x * 3 + 2] = color; dst[x * 3 + 960] = color; dst[x * 3 + 1 + 960] = color; dst[x * 3 + 2 + 960] = color; dst[x * 3 + 960 + 960] = color; dst[x * 3 + 1 + 960 + 960] = color; dst[x * 3 + 2 + 960 + 960] = color; } } } } } break; } add_dirty_rect(xdraw,ydraw,w,h); } void OSystem_MAC::undraw_mouse() { if (!_mouse_drawn) return; _mouse_drawn = false; byte *dst, *bak = _ms_backup; byte *src; const int old_mouse_x = _ms_old.x; const int old_mouse_y = _ms_old.y; const int old_mouse_w = _ms_old.w; const int old_mouse_h = _ms_old.h; int x,y; if(_sai_func) src = (byte*)_tmp_buf; else src = _gfx_buf; switch(_internal_scaling) { case 1: dst = (byte *)src + old_mouse_y * 320 + old_mouse_x; for (y = 0; y < old_mouse_h; y++, bak += MAX_MOUSE_W, dst += 320) { if ((uint) (old_mouse_y + y) < 200) { for (x = 0; x < old_mouse_w; x++) { if ((uint) (old_mouse_x + x) < 320) { dst[x] = bak[x]; } } } } break; case 2: dst = (byte *)src + old_mouse_y * 640 * 2 + old_mouse_x * 2; for (y = 0; y < old_mouse_h; y++, bak += MAX_MOUSE_W * 2, dst += 640 * 2) { if ((uint) (old_mouse_y + y) < 200) { for (x = 0; x < old_mouse_w; x++) { if ((uint) (old_mouse_x + x) < 320) { dst[x * 2 + 640] = dst[x * 2] = bak[x * 2]; dst[x * 2 + 640 + 1] = dst[x * 2 + 1] = bak[x * 2 + 1]; } } } } break; case 3: dst = (byte *)src + old_mouse_y * 960 * 3 + old_mouse_x * 3; for (y = 0; y < old_mouse_h; y++, bak += MAX_MOUSE_W * 3, dst += 960 * 3) { if ((uint) (old_mouse_y + y) < 200) { for (x = 0; x < old_mouse_w; x++) { if ((uint) (old_mouse_x + x) < 320) { dst[x * 3 + 960] = dst[x * 3 + 960 + 960] = dst[x * 3] = bak[x * 3]; dst[x * 3 + 960 + 1] = dst[x * 3 + 960 + 960 + 1] = dst[x * 3 + 1] = bak[x * 3 + 1]; dst[x * 3 + 960 + 2] = dst[x * 3 + 960 + 960 + 2] = dst[x * 3 + 2] = bak[x * 3 + 2]; } } } } break; } add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h); } void OSystem_MAC::stop_cdrom() { } void OSystem_MAC::play_cdrom(int track, int num_loops, int start_frame, int end_frame) { /* Reset sync count */ g_scumm->_vars[g_scumm->VAR_MI1_TIMER] = 0; } bool OSystem_MAC::poll_cdrom() { } void OSystem_MAC::update_cdrom() { } /*************************************************************/ /** Mac specific code ****************************************/ void OSystem_MAC::set_scaling() { Rect rectWin; SetRect(&rectWin, 0, 0, 320 * scaling, 200 * scaling); HideWindow(wref); SetWindowBounds(wref, kWindowContentRgn, &rectWin); RepositionWindow(wref, NULL, kWindowCenterOnMainScreen); ShowWindow(wref); blit_rect = rectWin; if(_sai_func) { Rect r; //SetRect(&r, 0, 0, 320, 240); _sai_buf = (int16*)malloc((320 * 200) * 2 * sizeof(int16)); NewGWorldFromPtr(&screenBuf, 16, &blit_rect, NULL, nil, 0, (char *)_sai_buf, blit_rect.right); } else { _gfx_buf = (byte*)malloc((320 * 200) * scaling * sizeof(byte)); NewGWorldFromPtr(&screenBuf, 8, &blit_rect, pal, nil, 0, (char *)_gfx_buf, blit_rect.right); } //NewGWorldFromPtr(&screenBuf, 8, &blit_rect, pal, nil, 0, (char *)_gfx_buf, blit_rect.right); //if(screenBuf != NULL) // UpdateGWorld(&screenBuf, 8, &blit_rect, pal, NULL, NULL); } void OSystem_MAC::blit_to_screen() { CopyBits(GetPortBitMapForCopyBits(screenBuf), GetPortBitMapForCopyBits(GetWindowPort(wref)), &blit_rect, &blit_rect, srcCopy, 0L); } void OSystem_MAC::init_mac_stuff() { Rect rectWin; MenuRef AppleMenu = GetMenu(1000); InsertMenu(AppleMenu, 0); SetMenuItemCommandID(AppleMenu, 1, kAboutCmd); MenuRef FileMenu = GetMenu(1001); SetMenuItemCommandID(FileMenu, 1, kNewGameCmd); SetMenuItemCommandID(FileMenu, 2, kOpenGameCmd); SetMenuItemCommandID(FileMenu, 3, kSaveGameCmd); SetMenuItemCommandID(FileMenu, 5, kQuitCmd); DeleteMenuItems(FileMenu, CountMenuItems(FileMenu)-1, 2); InsertMenu(FileMenu, 0); MenuRef windMenu; CreateStandardWindowMenu(0, &windMenu); InsertMenu(windMenu, 0); EnableMenuCommand(NULL, kPrefsCmd); DrawMenuBar(); SetRect(&rectWin, 0, 0, 320, 200); UInt32 WinAttrib = (kWindowCloseBoxAttribute | kWindowCollapseBoxAttribute | kWindowInWindowMenuAttribute | kWindowStandardHandlerAttribute); if(noErr != CreateNewWindow(kDocumentWindowClass, WinAttrib, &rectWin, &wref)) { //Error("Couldn't create Window!"); } RepositionWindow(wref, NULL, kWindowCenterOnMainScreen); Str255 WindowTitle = "\pScummVM"; SetWTitle(wref, WindowTitle); SetPortWindowPort(wref); //ShowWindow(wref); InstallStandardEventHandler(GetWindowEventTarget(wref)); //OSStatus err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, NewAEEventHandlerUPP(QuitEventHandler), 0L, false); blit_rect = rectWin; pal = (CTabHandle)NewHandleClear(sizeof(ColorTable) + 255 * sizeof(ColorSpec)); (*pal)->ctFlags = 0; (*pal)->ctSize = 255; //NewGWorld(&screenBuf, 8, &blit_rect, 0, 0, 0); } void OSystem_MAC::update_rects() { for(int i = 0; i < num_dirty_rects; i++) { Rect rec = dirty_rect_list[i]; CopyBits(GetPortBitMapForCopyBits(screenBuf), GetPortBitMapForCopyBits(GetWindowPort(wref)), &rec, &rec, srcCopy, 0L); } }