[BACK]Return to np2.cpp CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / macosx

Diff for /np2/macosx/np2.cpp between versions 1.2 and 1.22

version 1.2, 2003/10/17 03:52:24 version 1.22, 2003/10/25 21:28:14
Line 3 Line 3
 #include        "strres.h"  #include        "strres.h"
 #include        "np2.h"  #include        "np2.h"
 #include        "dosio.h"  #include        "dosio.h"
   #include        "commng.h"
 #include        "scrnmng.h"  #include        "scrnmng.h"
 #include        "soundmng.h"  #include        "soundmng.h"
 #include        "sysmng.h"  #include        "sysmng.h"
Line 26 Line 27
 #include        "diskdrv.h"  #include        "diskdrv.h"
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "statsave.h"  #include        "statsave.h"
   #include        "mousemng.h"
   #include        "configure.h"
   #include        "screenopt.h"
   #include        "soundopt.h"
   
   
 #define USE_RESUME  #define USE_RESUME
   #define NP2OPENING
   
   #ifdef          NP2OPENING
   #include        <QuickTime/QuickTime.h>
   // #define      OPENING_WAIT    1500
   #endif
   
   
                 NP2OSCFG        np2oscfg = {0, 2, 0, 0, 0};  
                   NP2OSCFG        np2oscfg = {0, 2, 0, 0, 0, 0, 1, 0};
   
                 WindowPtr       hWndMain;                  WindowPtr       hWndMain;
                 BOOL            np2running;                  BOOL            np2running;
Line 62  static const char np2resume[] = "sav"; Line 74  static const char np2resume[] = "sav";
 #define AEProc(fn)      NewAEEventHandlerProc(fn)  #define AEProc(fn)      NewAEEventHandlerProc(fn)
 #endif  #endif
   
   static void setUpCarbonEvent(void);
   static bool setupMainWindow(void);
   static void toggleFullscreen(void);
   
 #ifdef TARGET_API_MAC_CARBON  #ifdef TARGET_API_MAC_CARBON
 static pascal OSErr handleQuitApp(const AppleEvent *event, AppleEvent *reply,  static pascal OSErr handleQuitApp(const AppleEvent *event, AppleEvent *reply,
                                                                                                                         long refcon) {                                                                                                                          long refcon) {
Line 94  static void InitToolBox(void) { Line 110  static void InitToolBox(void) {
 }  }
   
 static void MenuBarInit(void) {  static void MenuBarInit(void) {
   #if 0
         Handle          hMenu;          Handle          hMenu;
         MenuHandle      happlemenu;          MenuHandle      happlemenu;
   
Line 113  static void MenuBarInit(void) { Line 129  static void MenuBarInit(void) {
         InsertMenu(GetMenu(IDM_SOUND), -1);          InsertMenu(GetMenu(IDM_SOUND), -1);
         InsertMenu(GetMenu(IDM_MEMORY), -1);          InsertMenu(GetMenu(IDM_MEMORY), -1);
         DrawMenuBar();          DrawMenuBar();
   #endif
       OSStatus    err;
       IBNibRef    nibRef;    
       err = CreateNibReference(CFSTR("np2"), &nibRef);
       if (err!=noErr) return;
       err = SetMenuBarFromNib(nibRef, CFSTR("MainMenu"));
       DisposeNibReference(nibRef);
 }  }
   
   
 static void changescreen(BYTE mode) {  static void changescreen(BYTE mode) {
   #if 0
         (void)mode;          (void)mode;
 }  #endif
   
           BYTE    change;
           BYTE    renewal;
   
           change = scrnmode ^ mode;
           renewal = (change & SCRNMODE_FULLSCREEN);
           if (mode & SCRNMODE_FULLSCREEN) {
                   renewal |= (change & SCRNMODE_HIGHCOLOR);
           }
           else {
                   renewal |= (change & SCRNMODE_ROTATEMASK);
           }
           if (renewal) {
                   soundmng_stop();
                   mouse_running(MOUSE_STOP);
                   scrnmng_destroy();
                   if (scrnmng_create(mode) == SUCCESS) {
                           scrnmode = mode;
                   }
                   scrndraw_redraw();
                   mouse_running(MOUSE_CONT);
                   soundmng_play();
           }
           else {
                   scrnmode = mode;
           }
   }
   
 static void HandleMenuChoice(long wParam) {  static void HandleMenuChoice(long wParam) {
   
Line 137  static void HandleMenuChoice(long wParam Line 185  static void HandleMenuChoice(long wParam
                         pccore_cfgupdate();                          pccore_cfgupdate();
                         pccore_reset();                          pccore_reset();
                         break;                          break;
               
                   case IDM_CONFIGURE:
                           initConfig();
                           break;
   
 #if 0  #if 0
                 case IDM_NEWFDD:                  case IDM_NEWFDD:
Line 148  static void HandleMenuChoice(long wParam Line 200  static void HandleMenuChoice(long wParam
                         newhdddisk();                          newhdddisk();
                         break;                          break;
 #endif  #endif
   
           case IDM_FONT:
               dialog_font();
               break;
               
                 case IDM_EXIT:                  case IDM_EXIT:
                         np2running = FALSE;                          np2running = FALSE;
                         break;                          break;
Line 184  static void HandleMenuChoice(long wParam Line 241  static void HandleMenuChoice(long wParam
                         diskdrv_sethdd(1, NULL);                          diskdrv_sethdd(1, NULL);
                         break;                          break;
   
                   case IDM_FULLSCREEN:
               toggleFullscreen();
               break;
               
                 case IDM_ROLNORMAL:                  case IDM_ROLNORMAL:
                         menu_setrotate(0);                          menu_setrotate(0);
                         changescreen(scrnmode & (~SCRNMODE_ROTATEMASK));                          changescreen(scrnmode & (~SCRNMODE_ROTATEMASK));
Line 241  static void HandleMenuChoice(long wParam Line 302  static void HandleMenuChoice(long wParam
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                         break;                          break;
   
   #if defined(NP2GCC)
                   case IDM_SCREENOPT:
                           initScreenOpt();
                           break;
   
           case IDM_MOUSE:
               mouse_running(MOUSE_XOR);
               menu_setmouse(np2oscfg.MOUSE_SW ^ 1);
               sysmng_update(SYS_UPDATECFG);
               toggleMenubar();
                           break;
               
           case IDM_SOUNDOPT:
               initSoundOpt();
               break;
   #endif
   
                 case IDM_KEY:                  case IDM_KEY:
                         menu_setkey(0);                          menu_setkey(0);
                         keystat_resetjoykey();                          keystat_resetjoykey();
Line 426  static void HandleMenuChoice(long wParam Line 504  static void HandleMenuChoice(long wParam
         HiliteMenu(0);          HiliteMenu(0);
 }  }
   
   #if 0
 static void HandleUpdateEvent(EventRecord *pevent) {  static void HandleUpdateEvent(EventRecord *pevent) {
   
         WindowPtr       hWnd;          WindowPtr       hWnd;
Line 435  static void HandleUpdateEvent(EventRecor Line 514  static void HandleUpdateEvent(EventRecor
         scrndraw_redraw();          scrndraw_redraw();
         EndUpdate(hWnd);          EndUpdate(hWnd);
 }  }
   #endif
   
 static void HandleMouseDown(EventRecord *pevent) {  static void HandleMouseDown(EventRecord *pevent) {
   
         WindowPtr       hWnd;          WindowPtr       hWnd;
         Rect            rDrag;          Rect            rDrag;
   
       soundmng_stop();
         switch(FindWindow(pevent->where, &hWnd)) {          switch(FindWindow(pevent->where, &hWnd)) {
                 case inMenuBar:                  case inMenuBar:
                         HandleMenuChoice(MenuSelect(pevent->where));                          HandleMenuChoice(MenuSelect(pevent->where));
Line 463  static void HandleMouseDown(EventRecord  Line 544  static void HandleMouseDown(EventRecord 
                         break;                          break;
   
                 case inContent:                  case inContent:
   #if defined(NP2GCC)
               if (controlKey & GetCurrentKeyModifiers() ) {
                   mouse_btn(MOUSE_RIGHTDOWN);
               }
               else {
                   mouse_btn(MOUSE_LEFTDOWN);
               }
   #endif
                         break;                          break;
   
   #ifndef NP2GCC
                 case inGoAway:                  case inGoAway:
                         if (TrackGoAway(hWnd, pevent->where)) { }                          if (TrackGoAway(hWnd, pevent->where)) { }
                         np2running = FALSE;                          np2running = FALSE;
                         break;                          break;
   #endif
         }          }
       soundmng_play();
 }  }
   
   #if 0
 static void eventproc(EventRecord *event) {  static void eventproc(EventRecord *event) {
   
         switch(event->what) {          switch(event->what) {
Line 485  static void eventproc(EventRecord *event Line 578  static void eventproc(EventRecord *event
   
                 case keyDown:                  case keyDown:
                 case autoKey:                  case autoKey:
                           mackbd_f12down(((event->message) & keyCodeMask) >> 8);
                         if (event->modifiers & cmdKey) {                          if (event->modifiers & cmdKey) {
                                 if (!mackbd_down(1, ((event->message) & keyCodeMask) >> 8)) {                                  HandleMenuChoice(MenuKey(event->message & charCodeMask));
                                         HandleMenuChoice(MenuKey(event->message & charCodeMask));  
                                 }  
                         }  
                         else {  
                                 mackbd_down(0, ((event->message) & keyCodeMask) >> 8);  
                         }                          }
                         break;                          break;
   
                 case keyUp:                  case keyUp:
                         mackbd_up(((event->message) & keyCodeMask) >> 8);                          mackbd_f12up(((event->message) & keyCodeMask) >> 8);
                         break;                          break;
   
   #if defined(NP2GCC)
           case mouseUp:
               if (controlKey & GetCurrentKeyModifiers()) {
                   mouse_btn(MOUSE_RIGHTUP);
               }
               else {
                   mouse_btn(MOUSE_LEFTUP);
               }
                           break;
   #endif
         }          }
 }  }
   #endif
   
   // ----
   
 static void processwait(UINT waitcnt) {  static void processwait(UINT waitcnt) {
   
         if (timing_getcount() >= waitcnt) {          if (timing_getcount() >= waitcnt) {
                 timing_setcount(0);  
                 framecnt = 0;                  framecnt = 0;
                 if (np2oscfg.DISPCLK & 2) {                  timing_setcount(0);
                   if (np2oscfg.DISPCLK & 3) {
                         if (sysmng_workclockrenewal()) {                          if (sysmng_workclockrenewal()) {
                                 sysmng_updatecaption(2);                                  sysmng_updatecaption(3);
                         }                          }
                 }                  }
         }          }
Line 533  static void flagsave(const char *ext) { Line 635  static void flagsave(const char *ext) {
 static void flagload(const char *ext) {  static void flagload(const char *ext) {
   
         char    path[MAX_PATH];          char    path[MAX_PATH];
           char    buf[1024];
           int             ret;
   
         getstatfilename(path, ext, sizeof(path));          getstatfilename(path, ext, sizeof(path));
         statsave_load(path);          ret = statsave_check(path, buf, sizeof(buf));
           if (ret == NP2FLAG_SUCCESS) {
                   statsave_load(path);
           }
   }
   
   #ifdef          NP2OPENING
   static void openingNP2(void) {
       Rect                srt, bounds;
       GrafPtr             port;
       CFURLRef    openingURL;
       CFStringRef path;
       char                buffer[1024];
       FSRef               fsr;
       FSSpec              fsc;
       PicHandle   pict;
       GraphicsImportComponent     gi;
       
       GetPort(&port);
       SetPortWindowPort(hWndMain);
       const RGBColor col = {0, 0, 0};
       SetRect(&bounds, 0, 0, 640, 400);
       RGBBackColor(&col);
       EraseRect(&bounds);
       
       openingURL=CFURLCopyAbsoluteURL(CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle()));
       if (openingURL) {
           path = CFURLCopyFileSystemPath(openingURL, kCFURLPOSIXPathStyle);
           if (path) {
               if (CFStringGetCString(path, buffer, 1024, CFStringGetSystemEncoding())) {
                   strcat(buffer, "/nekop2.bmp");
                   FSPathMakeRef((const UInt8*)buffer, &fsr, NULL);
                   FSGetCatalogInfo(&fsr, kFSCatInfoNone, NULL, NULL, &fsc, NULL);
                   if (!GetGraphicsImporterForFile(&fsc, &gi)) {
                       if (!GraphicsImportGetNaturalBounds(gi, &srt)) {
                           OffsetRect( &srt, -srt.left, -srt.top);
                           GraphicsImportSetBoundsRect(gi, &srt);
                           GraphicsImportGetAsPicture(gi, &pict);
                           OffsetRect(&srt, (640-srt.right)/2, (400-srt.bottom)/2);
                           DrawPicture(pict,&srt);
                           QDFlushPortBuffer(GetWindowPort(hWndMain), NULL);
                           KillPicture(pict);
                       }
                       CloseComponent(gi);
                   }
               }
               if (path) CFRelease(path);
           }
           if (openingURL) CFRelease(openingURL);
       }
       SetPort(port);
 }  }
   #endif
   
   
 int main(int argc, char *argv[]) {  int main(int argc, char *argv[]) {
   
   #if 0
         Rect            wRect;          Rect            wRect;
         EventRecord     event;          EventRecord     event;
   #endif
       EventRef            theEvent;
       EventTargetRef      theTarget;
   #ifdef OPENING_WAIT
           UINT32          tick;
   #endif
   
         dosio_init();          dosio_init();
         file_setcd(target);          file_setcd(target);
Line 552  int main(int argc, char *argv[]) { Line 715  int main(int argc, char *argv[]) {
   
         initload();          initload();
   
           TRACEINIT();
   
   #if 0
         SetRect(&wRect, 100, 100, 100, 100);          SetRect(&wRect, 100, 100, 100, 100);
         hWndMain = NewWindow(0, &wRect, "\pNeko Project II", FALSE,          hWndMain = NewWindow(0, &wRect, "\pNeko Project II", FALSE,
                                                                 noGrowDocProc, (WindowPtr)-1, TRUE, 0);                                                                  noGrowDocProc, (WindowPtr)-1, TRUE, 0);
         if (!hWndMain) {          if (!hWndMain) {
                   TRACETERM();
                 macossub_term();                  macossub_term();
                 dosio_term();                  dosio_term();
                 return(0);                  return(0);
         }          }
         scrnmng_initialize();          scrnmng_initialize();
         SizeWindow(hWndMain, 640, 400, TRUE);          SizeWindow(hWndMain, 640, 400, TRUE);
       setUpCarbonEvent();
         ShowWindow(hWndMain);          ShowWindow(hWndMain);
   #endif
       if (!(setupMainWindow())) {
           return(0);
       }
   
   #ifdef    NP2OPENING
       openingNP2();
   #endif
   #ifdef OPENING_WAIT
           tick = GETTICK();
   #endif
   
         menu_setrotate(0);          menu_setrotate(0);
         menu_setdispmode(np2cfg.DISPSYNC);          menu_setdispmode(np2cfg.DISPSYNC);
Line 581  int main(int argc, char *argv[]) { Line 760  int main(int argc, char *argv[]) {
   
         scrnmode = 0;          scrnmode = 0;
         if (scrnmng_create(scrnmode) != SUCCESS) {          if (scrnmng_create(scrnmode) != SUCCESS) {
                   TRACETERM();
                 macossub_term();                  macossub_term();
                 dosio_term();                  dosio_term();
                 DisposeWindow(hWndMain);                  DisposeWindow(hWndMain);
                 return(0);                  return(0);
         }          }
   
           commng_initialize();
         sysmng_initialize();          sysmng_initialize();
           mackbd_initialize();
         pccore_init();          pccore_init();
         S98_init();          S98_init();
   
   #if defined(NP2GCC)
           if (np2oscfg.MOUSE_SW) {                                                                                // ver0.30
                   mouse_running(MOUSE_ON);
           }
   #endif
   #ifdef OPENING_WAIT
           while((GETTICK() - tick) < OPENING_WAIT);
   #endif
         scrndraw_redraw();          scrndraw_redraw();
         pccore_reset();          pccore_reset();
   
 #if defined(USE_RESUME)  #if defined(USE_RESUME)
         flagload(np2resume);      if (np2oscfg.resume) {
           flagload(np2resume);
       }
 #endif  #endif
   
   #if 0
         SetEventMask(everyEvent);          SetEventMask(everyEvent);
   #endif
       theTarget = GetEventDispatcherTarget();
       
         np2running = TRUE;          np2running = TRUE;
         while(np2running) {          while(np2running) {
           if (ReceiveNextEvent(0, NULL,kEventDurationNoWait,true, &theEvent)== noErr)
           {
               SendEventToEventTarget (theEvent, theTarget);
               ReleaseEvent(theEvent);
           }
   #if 0
                 if (WaitNextEvent(everyEvent, &event, 0, 0)) {                  if (WaitNextEvent(everyEvent, &event, 0, 0)) {
                         eventproc(&event);                          eventproc(&event);
                 }                  }
   #endif
                 else {                  else {
                         if (np2oscfg.NOWAIT) {                          if (np2oscfg.NOWAIT) {
   #if 0
                                 mackbd_callback();                                  mackbd_callback();
   #endif
                                 pccore_exec(framecnt == 0);                                  pccore_exec(framecnt == 0);
                                 if (np2oscfg.DRAW_SKIP) {                       // nowait frame skip                                  if (np2oscfg.DRAW_SKIP) {                       // nowait frame skip
                                         framecnt++;                                          framecnt++;
Line 624  int main(int argc, char *argv[]) { Line 828  int main(int argc, char *argv[]) {
                         }                          }
                         else if (np2oscfg.DRAW_SKIP) {                  // frame skip                          else if (np2oscfg.DRAW_SKIP) {                  // frame skip
                                 if (framecnt < np2oscfg.DRAW_SKIP) {                                  if (framecnt < np2oscfg.DRAW_SKIP) {
                                         mackbd_callback();  #if 0
                       mackbd_callback();
   #endif
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         framecnt++;                                          framecnt++;
                                 }                                  }
Line 634  int main(int argc, char *argv[]) { Line 840  int main(int argc, char *argv[]) {
                         }                          }
                         else {                                                          // auto skip                          else {                                                          // auto skip
                                 if (!waitcnt) {                                  if (!waitcnt) {
                                         mackbd_callback();                                          UINT cnt;
   #if 0
                       mackbd_callback();
   #endif
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         framecnt++;                                          framecnt++;
                                         if (timing_getcount() < framecnt) {                                          cnt = timing_getcount();
                                           if (framecnt > cnt) {
                                                 waitcnt = framecnt;                                                  waitcnt = framecnt;
                                                 if (framemax > 1) {                                                  if (framemax > 1) {
                                                         framemax--;                                                          framemax--;
                                                 }                                                  }
                                         }                                          }
                                         else if (framecnt >= framemax) {                                          else if (framecnt >= framemax) {
                                                 waitcnt = framecnt;  
                                                 if (framemax < 12) {                                                  if (framemax < 12) {
                                                         framemax++;                                                          framemax++;
                                                 }                                                  }
                                                   if (cnt >= 12) {
                                                           timing_reset();
                                                   }
                                                   else {
                                                           timing_setcount(cnt - framecnt);
                                                   }
                                                   processwait(0);
                                         }                                          }
                                 }                                  }
                                 else {                                  else {
Line 659  int main(int argc, char *argv[]) { Line 875  int main(int argc, char *argv[]) {
         }          }
         np2running = FALSE;          np2running = FALSE;
   
       if (scrnmode & SCRNMODE_FULLSCREEN) {
           toggleFullscreen();
       }
       
         pccore_cfgupdate();          pccore_cfgupdate();
   
 #if defined(USE_RESUME)  #if defined(USE_RESUME)
         flagsave(np2resume);      if (np2oscfg.resume) {
           flagsave(np2resume);
       }
 #endif  #endif
   
         pccore_term();          pccore_term();
         S98_trash();          S98_trash();
   
   #if defined(NP2GCC)
           mouse_running(MOUSE_OFF);
   #endif
   
         scrnmng_destroy();          scrnmng_destroy();
   
         if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {          if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {
                 initsave();                  initsave();
         }          }
         TRACETERM();          TRACETERM();
Line 684  int main(int argc, char *argv[]) { Line 910  int main(int argc, char *argv[]) {
         return(0);          return(0);
 }  }
   
   //以下、ごっそりIIxからマージ
   static pascal OSStatus np2appevent (EventHandlerCallRef myHandlerChain, EventRef event, void* userData)
   {
       UInt32          whatHappened;
       OSStatus        result = eventNotHandledErr;
       
       long                eventClass;
       
       eventClass = GetEventClass(event);
       whatHappened = GetEventKind(event);
   
       EventRecord         eve;
       ConvertEventRefToEventRecord( event,&eve );
   
       if (IsDialogEvent(&eve)) return result;
   
       UInt32 modif;
       GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modif);
   
   #if defined(NP2GCC)
       HIPoint delta;
       EventMouseButton buttonKind;
       GetEventParameter (event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &buttonKind);
   
           BYTE ret;
   #endif
           
       switch (eventClass)
           {
                   case kEventClassAppleEvent:  
                       if (whatHappened == kEventAppleEvent) {
                           AEProcessAppleEvent(&eve);
                       }
                       break;
   
                   case kEventClassMouse: 
   #if defined(NP2GCC)
                       switch (whatHappened)
                           {
                           case kEventMouseMoved:
                               GetEventParameter (event, kEventParamMouseDelta, typeHIPoint, NULL, sizeof(HIPoint), NULL, &delta);
                               mouse_callback(delta);
                               result = noErr;
                               break;
                          case kEventMouseDown:
                               if (buttonKind == kEventMouseButtonSecondary | modif & controlKey) {
                                   ret=mouse_btn(MOUSE_RIGHTDOWN);
                               }
                               else {
                                   HandleMouseDown(&eve);
                               }
                               result=noErr;
                               break;
                           case kEventMouseUp:
                               if (buttonKind == kEventMouseButtonSecondary | modif & controlKey) {
                                   ret=mouse_btn(MOUSE_RIGHTUP);
                               }
                               else if (buttonKind == kEventMouseButtonTertiary) {
                                   mouse_running(MOUSE_XOR);
                                   menu_setmouse(np2oscfg.MOUSE_SW ^ 1);
                                   sysmng_update(SYS_UPDATECFG);
                               }
                               else {
                                   ret=mouse_btn(MOUSE_LEFTUP);
                               }
                               result=noErr;
                               break;    
                           }
   #else
                                                   if (whatHappened == kEventMouseDown) {
                                                           HandleMouseDown(&eve);
                                                   }
   #endif
                           break;
               default:
                       break; 
           }
   
           (void)myHandlerChain;
           (void)userData;
       return result; 
   }
   
   static pascal OSStatus np2windowevent(EventHandlerCallRef myHandler,  EventRef event, void* userData)
   {
       WindowRef   window;
       UInt32              whatHappened;
       OSStatus    result = eventNotHandledErr;    
       long                eventClass;
       static UInt32 backup = 0;
       
       GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL,
                            sizeof(window), NULL, &window);
       eventClass = GetEventClass(event);
       whatHappened = GetEventKind(event);
           
       switch (eventClass)
           {        
               case kEventClassWindow:            
                   if (whatHappened == kEventWindowClose) {
                       np2running = FALSE;
                       result = noErr;
                   }
                   else if (whatHappened == kEventWindowShowing) {
                       scrndraw_redraw();
                   }
                   break;
               case kEventClassKeyboard:
                   UInt32 key;
                   GetEventParameter (event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &key);
                   UInt32 modif;
                   GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modif);
                   switch (whatHappened)
                   {
                       case kEventRawKeyUp:
                           mackbd_f12up(key);
                           result = noErr;
                           break;
                       case kEventRawKeyRepeat:
                           mackbd_f12down(key);
                           result = noErr;
                           break;
                       case kEventRawKeyDown:
                           if (modif & cmdKey) {
                               EventRecord eve;
                               ConvertEventRefToEventRecord( event,&eve );
                               HandleMenuChoice(MenuEvent(&eve));
                           }
                           else {
                               mackbd_f12down(key);
                           }
                           result = noErr;
                           break;
                       case kEventRawKeyModifiersChanged:
                           if (modif & shiftKey) keystat_senddata(0x70);
                           else keystat_senddata(0x70 | 0x80);
                           if (modif & optionKey) keystat_senddata(0x73);
                           else keystat_senddata(0x73 | 0x80);
                           if (modif & controlKey) keystat_senddata(0x74);
                           else keystat_senddata(0x74 | 0x80);
                           if ((modif & alphaLock) != (backup & alphaLock)) {
                               keystat_senddata(0x71);
                               backup = modif;
                           }
                           result = noErr;
                           break;
                       default: 
                           break;             
                   }
               default: 
                   break;                
           }
   
           (void)myHandler;
           (void)userData;
       return result;
   }
   
   static const EventTypeSpec appEventList[] = {
                                   {kEventClassAppleEvent, kEventAppleEvent},
                                   {kEventClassMouse,              kEventMouseDown},
   #if defined(NP2GCC)
                                   {kEventClassMouse,              kEventMouseMoved},
                                   {kEventClassMouse,              kEventMouseUp},
   #endif
                           };
   
   static const EventTypeSpec windEventList[] = {
                                   {kEventClassWindow,             kEventWindowClose},
                                   {kEventClassWindow,             kEventWindowShowing},
                                   {kEventClassKeyboard,   kEventRawKeyDown},
                                   {kEventClassKeyboard,   kEventRawKeyUp},
                                   {kEventClassKeyboard,   kEventRawKeyRepeat},
                                   {kEventClassKeyboard,   kEventRawKeyModifiersChanged},
                           };
   
   
   static void setUpCarbonEvent(void) {
   
           InstallStandardEventHandler(GetWindowEventTarget(hWndMain));
           InstallApplicationEventHandler(NewEventHandlerUPP(np2appevent),
                                                                   GetEventTypeCount(appEventList),
                                                                   appEventList, 0, NULL);
           InstallWindowEventHandler(hWndMain, NewEventHandlerUPP(np2windowevent),
                                                                   GetEventTypeCount(windEventList),
                                                                   windEventList, 0, NULL);
   }
   
   bool setupMainWindow(void) {
   #if defined(NP2GCC) && 0
   #else
       Rect wRect;
       
           SetRect(&wRect, 100, 100, 100, 100);
           hWndMain = NewWindow(0, &wRect, "\pNeko Project II", FALSE,
                                                                   noGrowDocProc, (WindowPtr)-1, TRUE, 0);
           if (!hWndMain) {
                   TRACETERM();
                   macossub_term();
                   dosio_term();
                   return(false);
           }
           SizeWindow(hWndMain, 640, 400, TRUE);
   #endif
           scrnmng_initialize();
       setUpCarbonEvent();
           ShowWindow(hWndMain);
       return(true);
   }
   
   static void toggleFullscreen(void) {
       static Ptr  bkfullscreen;
       static BYTE mouse = 0;
   
       soundmng_stop();
       if (!scrnmode & SCRNMODE_FULLSCREEN) {
           RGBColor col = {0, 0, 0};
           short   w=640, h=480;
           DisposeWindow(hWndMain);
           BeginFullScreen(&bkfullscreen,0,&w,&h,&hWndMain,&col,(fullScreenAllowEvents | fullScreenDontChangeMenuBar));    
           HideMenuBar();
           setUpCarbonEvent();
           if (!np2oscfg.MOUSE_SW) {
               mouse = np2oscfg.MOUSE_SW;
               mouse_running(MOUSE_ON);
               menu_setmouse(1);
           }
           changescreen(scrnmode | SCRNMODE_FULLSCREEN);
       }
       else {
           scrnmng_destroy();
           EndFullScreen(bkfullscreen, 0);
           setupMainWindow();
           changescreen(scrnmode & (~SCRNMODE_FULLSCREEN));
           if (!mouse) {
               mouse_running(MOUSE_OFF);
               menu_setmouse(0);
           }
           ShowMenuBar();
       }
       CheckMenuItem(GetMenuHandle(IDM_SCREEN), LoWord(IDM_FULLSCREEN), scrnmode & SCRNMODE_FULLSCREEN);
       soundmng_play();
   }
   
   void toggleMenubar(void) {
       if (scrnmode & SCRNMODE_FULLSCREEN) {
           if (!np2oscfg.MOUSE_SW) {
               ShowMenuBar();
           }
           else {
               HideMenuBar();
           }
       }
   }
   
Removed from v.1.2  
changed lines
  Added in v.1.22

RetroPC.NET-CVS <cvs@retropc.net>