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

Diff for /np2/macosx/np2.cpp between versions 1.14 and 1.25

version 1.14, 2003/10/23 21:00:24 version 1.25, 2003/10/30 19:39:52
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 29 Line 30
 #include        "mousemng.h"  #include        "mousemng.h"
 #include        "configure.h"  #include        "configure.h"
 #include        "screenopt.h"  #include        "screenopt.h"
   #include        "soundopt.h"
   #include        "macnewdisk.h"
   #include        "fdefine.h"
   #include        "hid.h"
   #include        "midiopt.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, 0, 1, 0};                  NP2OSCFG        np2oscfg = {0, 2, 0, 0, 0, 0, 1, 0};
Line 59  static const char np2resume[] = "sav"; Line 71  static const char np2resume[] = "sav";
   
 // ---- おまじない  // ---- おまじない
   
 #if TARGET_CARBON  
 #define AEProc(fn)      NewAEEventHandlerUPP((AEEventHandlerProcPtr)(fn))  #define AEProc(fn)      NewAEEventHandlerUPP((AEEventHandlerProcPtr)(fn))
 #else  
 #define AEProc(fn)      NewAEEventHandlerProc(fn)  
 #endif  
   
 static void setUpCarbonEvent(void);  static void setUpCarbonEvent(void);
   static bool setupMainWindow(void);
   static void toggleFullscreen(void);
   
 #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 76  static pascal OSErr handleQuitApp(const  Line 85  static pascal OSErr handleQuitApp(const 
         (void)event, (void)reply, (void)refcon;          (void)event, (void)reply, (void)refcon;
         return(noErr);          return(noErr);
 }  }
 #endif  
   pascal OSErr OpenAppleEventHandler(const AppleEvent *event, AppleEvent *reply,long print)
   {
           long            i,ct,len;
           FSSpec          fsc,*pp;
           DescType        rtype;
           AEKeyword       key;
           AEDescList      dlist;
           
           if( ! AEGetParamDesc( event,keyDirectObject,typeAEList,&dlist ) )       {
                   AECountItems( &dlist,&ct );
                   for( i=1;i<=ct;i++ )    {
               pp=&fsc;
                           if( ! AEGetNthPtr( &dlist,i,typeFSS,&key,&rtype,(Ptr)pp,(long)sizeof(FSSpec),&len ) )   {
                   char            fname[MAX_PATH];
                   int                     ftype;
                   fsspec2path(&fsc, fname, MAX_PATH);
                   ftype = file_getftype(fname);
                   if ((ftype != FTYPE_D88) && (ftype != FTYPE_BETA)) {
                       diskdrv_sethdd(0, fname);
                   }
                   else {
                       diskdrv_setfdd(i-1, fname, 0);
                   }
                           }
                   }
                   AEDisposeDesc( &dlist );
           }
           return( 0 );
   }
   
   
 static void InitToolBox(void) {  static void InitToolBox(void) {
   
 #if !TARGET_CARBON  
         MaxApplZone();  
         InitGraf(&qd.thePort);  
         InitFonts();  
         InitWindows();  
         InitMenus();  
         TEInit();  
         InitDialogs(0);  
 #endif  
         FlushEvents(everyEvent, 0);          FlushEvents(everyEvent, 0);
         InitCursor();          InitCursor();
   
 #ifdef TARGET_API_MAC_CARBON  
         AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,          AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
                                                 AEProc(handleQuitApp), 0L, false);                                                  AEProc(handleQuitApp), 0L, false);
 #endif          AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
                                                   AEProc(OpenAppleEventHandler), 0L, false);
 }  }
   
 static void MenuBarInit(void) {  static void MenuBarInit(void) {
 #if 0  #if 1
         Handle          hMenu;          Handle          hMenu;
         MenuHandle      happlemenu;          MenuHandle      happlemenu;
   
Line 117  static void MenuBarInit(void) { Line 147  static void MenuBarInit(void) {
         InsertMenu(GetMenu(IDM_KEYBOARD), -1);          InsertMenu(GetMenu(IDM_KEYBOARD), -1);
         InsertMenu(GetMenu(IDM_SOUND), -1);          InsertMenu(GetMenu(IDM_SOUND), -1);
         InsertMenu(GetMenu(IDM_MEMORY), -1);          InsertMenu(GetMenu(IDM_MEMORY), -1);
       SetMenuItemModifiers(GetMenuRef(IDM_FDD2), IDM_FDD2OPEN, kMenuOptionModifier);
       SetMenuItemModifiers(GetMenuRef(IDM_FDD2), IDM_FDD2EJECT, kMenuOptionModifier);
       SetMenuItemModifiers(GetMenuRef(IDM_SASI2), IDM_SASI2OPEN, kMenuOptionModifier);
         DrawMenuBar();          DrawMenuBar();
 #endif  #else
     OSStatus    err;      OSStatus    err;
     IBNibRef    nibRef;          IBNibRef    nibRef;    
     err = CreateNibReference(CFSTR("np2"), &nibRef);      err = CreateNibReference(CFSTR("np2"), &nibRef);
     if (err!=noErr) return;      if (err!=noErr) return;
     err = SetMenuBarFromNib(nibRef, CFSTR("MainMenu"));      err = SetMenuBarFromNib(nibRef, CFSTR("MainMenu"));
     DisposeNibReference(nibRef);      DisposeNibReference(nibRef);
   #endif
 }  }
   
 static void changescreen(BYTE mode) {  static void changescreen(BYTE mode) {
   
         (void)mode;          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) {
   
         UINT    update;          UINT    update;
         Str255  applname;  
   
       soundmng_stop();
         update = 0;          update = 0;
         switch(wParam) {          switch(wParam) {
                 case IDM_ABOUT:                  case IDM_ABOUT:
Line 152  static void HandleMenuChoice(long wParam Line 210  static void HandleMenuChoice(long wParam
                         initConfig();                          initConfig();
                         break;                          break;
   
 #if 0                  case IDM_NEWDISK:
                 case IDM_NEWFDD:              newdisk();
                         newdisk();  
                         break;                          break;
 #endif  
 #if 0  #if 0
                 case IDM_NEWHDD:                  case IDM_NEWHDD:
                         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 198  static void HandleMenuChoice(long wParam Line 258  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 255  static void HandleMenuChoice(long wParam Line 319  static void HandleMenuChoice(long wParam
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                         break;                          break;
   
 #if defined(NP2GCC)  
                 case IDM_SCREENOPT:                  case IDM_SCREENOPT:
                         initScreenOpt();                          initScreenOpt();
                         break;                          break;
Line 264  static void HandleMenuChoice(long wParam Line 327  static void HandleMenuChoice(long wParam
             mouse_running(MOUSE_XOR);              mouse_running(MOUSE_XOR);
             menu_setmouse(np2oscfg.MOUSE_SW ^ 1);              menu_setmouse(np2oscfg.MOUSE_SW ^ 1);
             sysmng_update(SYS_UPDATECFG);              sysmng_update(SYS_UPDATECFG);
               toggleMenubar();
                         break;                          break;
 #endif              
           case IDM_MIDIOPT:
               initMidiOpt();
               break;
               
                   case IDM_MIDIPANIC:
                           rs232c_midipanic();
                           mpu98ii_midipanic();
                           pc9861k_midipanic();
                           break;
   
           case IDM_SNDOPT:
               initSoundOpt();
               break;
   
                 case IDM_KEY:                  case IDM_KEY:
                         menu_setkey(0);                          menu_setkey(0);
Line 414  static void HandleMenuChoice(long wParam Line 491  static void HandleMenuChoice(long wParam
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                         break;                          break;
   
                   case IDM_BMPSAVE:
                           dialog_writebmp();
                           break;
   
           case IDM_S98LOGGING:
               dialog_s98();
               break;
               
                 case IDM_DISPCLOCK:                  case IDM_DISPCLOCK:
                         menu_setdispclk(np2oscfg.DISPCLK ^ 1);                          menu_setdispclk(np2oscfg.DISPCLK ^ 1);
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
Line 434  static void HandleMenuChoice(long wParam Line 519  static void HandleMenuChoice(long wParam
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                         break;                          break;
   
           case IDM_MSRAPID:
               menu_setmsrapid(np2cfg.MOUSERAPID ^ 1);
               update |= SYS_UPDATECFG;
               break;
   
                 case IDM_I286SAVE:                  case IDM_I286SAVE:
                         debugsub_status();                          debugsub_status();
                         break;                          break;
   
           case IDM_RECORDING:
               menu_setrecording(false);
               break;
   
                 default:                  default:
                         if (HiWord(wParam) == IDM_APPLE) {  
                                 GetMenuItemText(GetMenuHandle(IDM_APPLE),   
                                                                                         LoWord(wParam), applname);  
 #if !TARGET_API_MAC_CARBON  
                                 (void)OpenDeskAcc(applname);  
 #endif  
                         }  
                         break;                          break;
         }          }
         sysmng_update(update);          sysmng_update(update);
         HiliteMenu(0);          HiliteMenu(0);
 }  }
   
 #if 0  
 static void HandleUpdateEvent(EventRecord *pevent) {  
   
         WindowPtr       hWnd;  
   
         hWnd = (WindowPtr)pevent->message;  
         BeginUpdate(hWnd);  
         scrndraw_redraw();  
         EndUpdate(hWnd);  
 }  
 #endif  
   
 static void HandleMouseDown(EventRecord *pevent) {  static void HandleMouseDown(EventRecord *pevent) {
   
         WindowPtr       hWnd;          WindowPtr       hWnd;
         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));
                         break;                          break;
   
                 case inDrag:  
 #if TARGET_API_MAC_CARBON  
                 {  
                         BitMap  gscreenBits;  
                         GetQDGlobalsScreenBits(&gscreenBits);  
                         rDrag = gscreenBits.bounds;  
                         InsetRect(&rDrag, DRAG_THRESHOLD, DRAG_THRESHOLD);  
                         DragWindow(hWnd, pevent->where, &rDrag);  
                 }  
 #else  
                         rDrag = qd.screenBits.bounds;  
                         InsetRect(&rDrag, DRAG_THRESHOLD, DRAG_THRESHOLD);  
                         DragWindow(hWnd, pevent->where, &rDrag);  
 #endif  
                         break;  
   
                 case inContent:  
 #if defined(NP2GCC)  
             if (controlKey & GetCurrentKeyModifiers() ) {  
                 mouse_btn(MOUSE_RIGHTDOWN);  
             }  
             else {  
                 mouse_btn(MOUSE_LEFTDOWN);  
             }  
 #endif  
                         break;  
   
                 case inGoAway:  
                         if (TrackGoAway(hWnd, pevent->where)) { }  
                         np2running = FALSE;  
                         break;  
         }          }
 }  }
   
 #if 0  
 static void eventproc(EventRecord *event) {  
   
         switch(event->what) {  
                 case mouseDown:  
                         HandleMouseDown(event);  
                         break;  
   
                 case updateEvt:  
                         HandleUpdateEvent(event);  
                         break;  
   
                 case keyDown:  
                 case autoKey:  
                         mackbd_f12down(((event->message) & keyCodeMask) >> 8);  
                         if (event->modifiers & cmdKey) {  
                                 HandleMenuChoice(MenuKey(event->message & charCodeMask));  
                         }  
                         break;  
   
                 case keyUp:  
                         mackbd_f12up(((event->message) & keyCodeMask) >> 8);  
                         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;
                   timing_setcount(0);
                 if (np2oscfg.DISPCLK & 3) {                  if (np2oscfg.DISPCLK & 3) {
                         if (sysmng_workclockrenewal()) {                          if (sysmng_workclockrenewal()) {
                                 sysmng_updatecaption(3);                                  sysmng_updatecaption(3);
Line 576  static void flagsave(const char *ext) { Line 582  static void flagsave(const char *ext) {
         statsave_save(path);          statsave_save(path);
 }  }
   
   static void flagdelete(const char *ext) {
   
           char    path[MAX_PATH];
   
           getstatfilename(path, ext, sizeof(path));
           file_delete(path);
   }
   
 static void flagload(const char *ext) {  static void flagload(const char *ext) {
   
         char    path[MAX_PATH];          char    path[MAX_PATH];
Line 589  static void flagload(const char *ext) { Line 603  static void flagload(const char *ext) {
         }          }
 }  }
   
   #ifdef          NP2OPENING
   static void openingNP2(void) {
       Rect                srt, bounds;
       GrafPtr             port;
       CFURLRef    openingURL;
       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=CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("nekop2"), CFSTR("bmp"), NULL);
       if (openingURL) {
           if (CFURLGetFSRef(openingURL, &fsr)) {
               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);
               }
           }
           CFRelease(openingURL);
       }
       SetPort(port);
   }
   #endif
   
   
 int main(int argc, char *argv[]) {  int main(int argc, char *argv[]) {
   
         Rect            wRect;  
 #if 0  
         EventRecord     event;  
 #endif  
     EventRef            theEvent;      EventRef            theEvent;
     EventTargetRef      theTarget;      EventTargetRef      theTarget;
   #ifdef OPENING_WAIT
           UINT32          tick;
   #endif
   
         dosio_init();          dosio_init();
         file_setcd(target);          file_setcd(target);
Line 609  int main(int argc, char *argv[]) { Line 665  int main(int argc, char *argv[]) {
   
         TRACEINIT();          TRACEINIT();
   
         SetRect(&wRect, 100, 100, 100, 100);      if (!(setupMainWindow())) {
         hWndMain = NewWindow(0, &wRect, "\pNeko Project II", FALSE,          return(0);
                                                                 noGrowDocProc, (WindowPtr)-1, TRUE, 0);      }
         if (!hWndMain) {  
                 TRACETERM();  #ifdef    NP2OPENING
                 macossub_term();      openingNP2();
                 dosio_term();  #endif
                 return(0);  #ifdef OPENING_WAIT
         }          tick = GETTICK();
         scrnmng_initialize();  #endif
         SizeWindow(hWndMain, 640, 400, TRUE);  
     setUpCarbonEvent();  
         ShowWindow(hWndMain);  
   
         menu_setrotate(0);          menu_setrotate(0);
         menu_setdispmode(np2cfg.DISPSYNC);          menu_setdispmode(np2cfg.DISPSYNC);
Line 647  int main(int argc, char *argv[]) { Line 700  int main(int argc, char *argv[]) {
                 return(0);                  return(0);
         }          }
   
           commng_initialize();
         sysmng_initialize();          sysmng_initialize();
         mackbd_initialize();          mackbd_initialize();
         pccore_init();          pccore_init();
         S98_init();          S98_init();
   
       hid_init();
           if (soundmng_initialize() == SUCCESS) {
                   soundmng_pcmvolume(SOUND_PCMSEEK, np2cfg.MOTORVOL);
                   soundmng_pcmvolume(SOUND_PCMSEEK1, np2cfg.MOTORVOL);
           }
   
 #if defined(NP2GCC)  #if defined(NP2GCC)
         if (np2oscfg.MOUSE_SW) {                                                                                // ver0.30          if (np2oscfg.MOUSE_SW) {                                                                                // ver0.30
                 mouse_running(MOUSE_ON);                  mouse_running(MOUSE_ON);
         }          }
 #endif  #endif
         scrndraw_redraw();  #ifdef OPENING_WAIT
           while((GETTICK() - tick) < OPENING_WAIT);
   #endif
         pccore_reset();          pccore_reset();
   
 #if defined(USE_RESUME)  #if defined(USE_RESUME)
Line 666  int main(int argc, char *argv[]) { Line 728  int main(int argc, char *argv[]) {
     }      }
 #endif  #endif
   
 #if 0  
         SetEventMask(everyEvent);  
 #endif  
     theTarget = GetEventDispatcherTarget();      theTarget = GetEventDispatcherTarget();
           
         np2running = TRUE;          np2running = TRUE;
Line 678  int main(int argc, char *argv[]) { Line 737  int main(int argc, char *argv[]) {
             SendEventToEventTarget (theEvent, theTarget);              SendEventToEventTarget (theEvent, theTarget);
             ReleaseEvent(theEvent);              ReleaseEvent(theEvent);
         }          }
 #if 0  
                 if (WaitNextEvent(everyEvent, &event, 0, 0)) {  
                         eventproc(&event);  
                 }  
 #endif  
                 else {                  else {
               soundmng_play();
                         if (np2oscfg.NOWAIT) {                          if (np2oscfg.NOWAIT) {
 #if defined(NP2GCC) && 0  
                                 mouse_callback();  
 #endif  
 #if 1  
                                 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 707  int main(int argc, char *argv[]) { Line 756  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) {
 #if defined(NP2GCC) && 0  
                     mouse_callback();  
 #endif  
 #if 1  
                     mackbd_callback();  
 #endif  
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         framecnt++;                                          framecnt++;
                                 }                                  }
Line 723  int main(int argc, char *argv[]) { Line 766  int main(int argc, char *argv[]) {
                         else {                                                          // auto skip                          else {                                                          // auto skip
                                 if (!waitcnt) {                                  if (!waitcnt) {
                                         UINT cnt;                                          UINT cnt;
 #if defined(NP2GCC) && 0  
                     mouse_callback();  
 #endif  
 #if 1  
                     mackbd_callback();  
 #endif  
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         framecnt++;                                          framecnt++;
                                         cnt = timing_getcount();                                          cnt = timing_getcount();
Line 748  int main(int argc, char *argv[]) { Line 785  int main(int argc, char *argv[]) {
                                                 else {                                                  else {
                                                         timing_setcount(cnt - framecnt);                                                          timing_setcount(cnt - framecnt);
                                                 }                                                  }
                                                 framecnt = 0;                                                  processwait(0);
                                         }                                          }
                                 }                                  }
                                 else {                                  else {
Line 759  int main(int argc, char *argv[]) { Line 796  int main(int argc, char *argv[]) {
                 }                  }
         }          }
         np2running = FALSE;          np2running = FALSE;
       menu_setrecording(true);
   
       if (scrnmode & SCRNMODE_FULLSCREEN) {
           toggleFullscreen();
       }
       
         pccore_cfgupdate();          pccore_cfgupdate();
   
 #if defined(USE_RESUME)  #if defined(USE_RESUME)
     if (np2oscfg.resume) {      if (np2oscfg.resume) {
         flagsave(np2resume);          flagsave(np2resume);
     }      }
           else {
                   flagdelete(np2resume);
           }
 #endif  #endif
   
         pccore_term();          pccore_term();
         S98_trash();          S98_trash();
   
       hid_clear();
 #if defined(NP2GCC)  #if defined(NP2GCC)
         mouse_running(MOUSE_OFF);          mouse_running(MOUSE_OFF);
 #endif  #endif
   
           soundmng_deinitialize();
         scrnmng_destroy();          scrnmng_destroy();
   
         if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {          if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {
Line 811  static pascal OSStatus np2appevent (Even Line 858  static pascal OSStatus np2appevent (Even
     GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modif);      GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modif);
   
 #if defined(NP2GCC)  #if defined(NP2GCC)
       HIPoint delta;
     EventMouseButton buttonKind;      EventMouseButton buttonKind;
     GetEventParameter (event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &buttonKind);      GetEventParameter (event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &buttonKind);
   
Line 830  static pascal OSStatus np2appevent (Even Line 878  static pascal OSStatus np2appevent (Even
                     switch (whatHappened)                      switch (whatHappened)
                         {                          {
                         case kEventMouseMoved:                          case kEventMouseMoved:
 #if 0                              GetEventParameter (event, kEventParamMouseDelta, typeHIPoint, NULL, sizeof(HIPoint), NULL, &delta);
                             if (isFullScreen)                              mouse_callback(delta);
                             {                              result = noErr;
                                 HIPoint delta;                              break;
                                 Point pt;  
                                 GetEventParameter (event, kEventParamMouseDelta, typeHIPoint, NULL, sizeof(HIPoint), NULL, &delta);  
                                 pt.h=(short)delta.x;  
                                 pt.v=(short)delta.y;  
                                 mouse_callback(pt);  
                             }  
                             else {  
                                 mouse_callback(eve.where);  
                             }  
 #endif  
                                 mouse_callback();  
                                 result = noErr;  
                                 break;  
                        case kEventMouseDown:                         case kEventMouseDown:
                             if (buttonKind == kEventMouseButtonSecondary | modif & controlKey) {                              if (buttonKind == kEventMouseButtonSecondary | modif & controlKey) {
                                 ret=mouse_btn(MOUSE_RIGHTDOWN);                                  ret=mouse_btn(MOUSE_RIGHTDOWN);
Line 857  static pascal OSStatus np2appevent (Even Line 892  static pascal OSStatus np2appevent (Even
                             result=noErr;                              result=noErr;
                             break;                              break;
                         case kEventMouseUp:                          case kEventMouseUp:
                                 {                              if (buttonKind == kEventMouseButtonSecondary | modif & controlKey) {
                                     if (buttonKind == kEventMouseButtonSecondary | modif & cmdKey) {                                  ret=mouse_btn(MOUSE_RIGHTUP);
                                         ret=mouse_btn(MOUSE_RIGHTUP);                              }
                                     }                              else if (buttonKind == kEventMouseButtonTertiary) {
                                     else {                                  mouse_running(MOUSE_XOR);
                                         ret=mouse_btn(MOUSE_LEFTUP);                                  menu_setmouse(np2oscfg.MOUSE_SW ^ 1);
                                     }                                  sysmng_update(SYS_UPDATECFG);
                                     result=noErr;                              }
                                     break;                                  else {
                                 }                                                      ret=mouse_btn(MOUSE_LEFTUP);
                               }
                               result=noErr;
                               break;    
                         }                          }
 #else  #else
                                                 if (whatHappened == kEventMouseDown) {                                                  if (whatHappened == kEventMouseDown) {
Line 889  static pascal OSStatus np2windowevent(Ev Line 927  static pascal OSStatus np2windowevent(Ev
     UInt32              whatHappened;      UInt32              whatHappened;
     OSStatus    result = eventNotHandledErr;          OSStatus    result = eventNotHandledErr;    
     long                eventClass;      long                eventClass;
       static UInt32 backup = 0;
           
     GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL,      GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL,
                          sizeof(window), NULL, &window);                           sizeof(window), NULL, &window);
Line 897  static pascal OSStatus np2windowevent(Ev Line 936  static pascal OSStatus np2windowevent(Ev
                   
     switch (eventClass)      switch (eventClass)
         {                  {        
             case kEventClassWindow:                          case kEventClassWindow:
                 if (whatHappened == kEventWindowClose) {                  switch (whatHappened)
                     np2running = FALSE;                  {
                     result = noErr;                      case kEventWindowClose:
                           np2running = FALSE;
                           result = noErr;
                           break;
                       case kEventWindowShowing:
                           scrndraw_redraw();
                          break;
                       case kEventWindowActivated:
                           DisableAllMenuItems(GetMenuHandle(IDM_EDIT));
                           break;
                 }                  }
                 break;                  break;
             case kEventClassKeyboard:              case kEventClassKeyboard:
Line 911  static pascal OSStatus np2windowevent(Ev Line 959  static pascal OSStatus np2windowevent(Ev
                 switch (whatHappened)                  switch (whatHappened)
                 {                  {
                     case kEventRawKeyUp:                      case kEventRawKeyUp:
                         //mackeyup((int)key);  
                         mackbd_f12up(key);                          mackbd_f12up(key);
                         result = noErr;                          result = noErr;
                         break;                          break;
                     case kEventRawKeyRepeat:                      case kEventRawKeyRepeat:
                         //mackeydown(0, (int)key);  
                         mackbd_f12down(key);                          mackbd_f12down(key);
                         result = noErr;                          result = noErr;
                         break;                          break;
                     case kEventRawKeyDown:                      case kEventRawKeyDown:
                         mackbd_f12down(key);  
                         if (modif & cmdKey) {                          if (modif & cmdKey) {
                             //if (!mackeydown(1, (int)key)) {                              EventRecord eve;
                                 char    para;                              ConvertEventRefToEventRecord( event,&eve );
                                 GetEventParameter (event, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &para);                              HandleMenuChoice(MenuEvent(&eve));
                                 HandleMenuChoice(MenuKey(para));  
                             //}  
                         }                          }
                         else {                          else {
                             //mackeydown(0, (int)key);                              mackbd_f12down(key);
                         }                          }
                         result = noErr;                          result = noErr;
                         break;                          break;
Line 941  static pascal OSStatus np2windowevent(Ev Line 984  static pascal OSStatus np2windowevent(Ev
                         else keystat_senddata(0x73 | 0x80);                          else keystat_senddata(0x73 | 0x80);
                         if (modif & controlKey) keystat_senddata(0x74);                          if (modif & controlKey) keystat_senddata(0x74);
                         else keystat_senddata(0x74 | 0x80);                          else keystat_senddata(0x74 | 0x80);
                         if (modif & alphaLock) keystat_senddata(0x79);                          if ((modif & alphaLock) != (backup & alphaLock)) {
                         else keystat_senddata(0x79 | 0x80);                              keystat_senddata(0x71);
                               backup = modif;
                           }
                         result = noErr;                          result = noErr;
                         break;                          break;
                     default:                       default: 
Line 968  static const EventTypeSpec appEventList[ Line 1013  static const EventTypeSpec appEventList[
   
 static const EventTypeSpec windEventList[] = {  static const EventTypeSpec windEventList[] = {
                                 {kEventClassWindow,             kEventWindowClose},                                  {kEventClassWindow,             kEventWindowClose},
                                   {kEventClassWindow,             kEventWindowShowing},
                                   {kEventClassWindow,             kEventWindowActivated},
                                 {kEventClassKeyboard,   kEventRawKeyDown},                                  {kEventClassKeyboard,   kEventRawKeyDown},
                                 {kEventClassKeyboard,   kEventRawKeyUp},                                  {kEventClassKeyboard,   kEventRawKeyUp},
                                 {kEventClassKeyboard,   kEventRawKeyRepeat},                                  {kEventClassKeyboard,   kEventRawKeyRepeat},
Line 979  static void setUpCarbonEvent(void) { Line 1026  static void setUpCarbonEvent(void) {
   
         InstallStandardEventHandler(GetWindowEventTarget(hWndMain));          InstallStandardEventHandler(GetWindowEventTarget(hWndMain));
         InstallApplicationEventHandler(NewEventHandlerUPP(np2appevent),          InstallApplicationEventHandler(NewEventHandlerUPP(np2appevent),
                                                                 sizeof(appEventList)/sizeof(EventTypeSpec),                                                                  GetEventTypeCount(appEventList),
                                                                 appEventList, 0, NULL);                                                                  appEventList, 0, NULL);
         InstallWindowEventHandler(hWndMain, NewEventHandlerUPP(np2windowevent),          InstallWindowEventHandler(hWndMain, NewEventHandlerUPP(np2windowevent),
                                                                 sizeof(windEventList)/sizeof(EventTypeSpec),                                                                  GetEventTypeCount(windEventList),
                                                                 windEventList, 0, NULL);                                                                  windEventList, 0, NULL);
       InstallStandardEventHandler(GetWindowEventTarget(hWndMain));
   }
   
   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.14  
changed lines
  Added in v.1.25

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