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

Diff for /np2/macosx/np2.cpp between versions 1.11 and 1.18

version 1.11, 2003/10/22 19:57:39 version 1.18, 2003/10/25 09:08:24
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"
   
 #if defined(NP2GCC)  
 #include        "mousemng.h"  #include        "mousemng.h"
 #endif  
 #include        "configure.h"  #include        "configure.h"
   #include        "screenopt.h"
   
 #define USE_RESUME  
   
   #define USE_RESUME
   #define NP2OPENING
   
 #if defined(NP2GCC)  #ifdef          NP2OPENING
                 NP2OSCFG        np2oscfg = {0, 2, 0, 0, 0, 0};  #include        <QuickTime/QuickTime.h>
 #else  #define         OPENING_WAIT            1500
                 NP2OSCFG        np2oscfg = {0, 2, 0, 0, 0};  
 #endif  #endif
   
   
   
                   NP2OSCFG        np2oscfg = {0, 2, 0, 0, 0, 0, 1, 0};
   
                 WindowPtr       hWndMain;                  WindowPtr       hWndMain;
                 BOOL            np2running;                  BOOL            np2running;
 static  UINT            framecnt = 0;  static  UINT            framecnt = 0;
Line 167  static void HandleMenuChoice(long wParam Line 170  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 261  static void HandleMenuChoice(long wParam Line 269  static void HandleMenuChoice(long wParam
                         break;                          break;
   
 #if defined(NP2GCC)  #if defined(NP2GCC)
                   case IDM_SCREENOPT:
                           initScreenOpt();
                           break;
   
         case IDM_MOUSE:          case IDM_MOUSE:
             mouse_running(MOUSE_XOR);              mouse_running(MOUSE_XOR);
             menu_setmouse(np2oscfg.MOUSE_SW ^ 1);              menu_setmouse(np2oscfg.MOUSE_SW ^ 1);
Line 453  static void HandleMenuChoice(long wParam Line 465  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 462  static void HandleUpdateEvent(EventRecor Line 475  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 500  static void HandleMouseDown(EventRecord  Line 515  static void HandleMouseDown(EventRecord 
 #endif  #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  #if 0
Line 588  static void flagload(const char *ext) { Line 606  static void flagload(const char *ext) {
         }          }
 }  }
   
   #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[]) {
   
         Rect            wRect;          Rect            wRect;
Line 596  int main(int argc, char *argv[]) { Line 663  int main(int argc, char *argv[]) {
 #endif  #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 621  int main(int argc, char *argv[]) { Line 691  int main(int argc, char *argv[]) {
         SizeWindow(hWndMain, 640, 400, TRUE);          SizeWindow(hWndMain, 640, 400, TRUE);
     setUpCarbonEvent();      setUpCarbonEvent();
         ShowWindow(hWndMain);          ShowWindow(hWndMain);
   #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 646  int main(int argc, char *argv[]) { Line 722  int main(int argc, char *argv[]) {
                 return(0);                  return(0);
         }          }
   
           commng_initialize();
         sysmng_initialize();          sysmng_initialize();
         mackbd_initialize();          mackbd_initialize();
         pccore_init();          pccore_init();
Line 656  int main(int argc, char *argv[]) { Line 733  int main(int argc, char *argv[]) {
                 mouse_running(MOUSE_ON);                  mouse_running(MOUSE_ON);
         }          }
 #endif  #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  #if 0
Line 682  int main(int argc, char *argv[]) { Line 764  int main(int argc, char *argv[]) {
 #endif  #endif
                 else {                  else {
                         if (np2oscfg.NOWAIT) {                          if (np2oscfg.NOWAIT) {
 #if defined(NP2GCC) && 0  #if 0
                                 mouse_callback();  
 #endif  
 #if 1  
                                 mackbd_callback();                                  mackbd_callback();
 #endif  #endif
                                 pccore_exec(framecnt == 0);                                  pccore_exec(framecnt == 0);
Line 704  int main(int argc, char *argv[]) { Line 783  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  #if 0
                     mouse_callback();  
 #endif  
 #if 1  
                     mackbd_callback();                      mackbd_callback();
 #endif  #endif
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
Line 720  int main(int argc, char *argv[]) { Line 796  int main(int argc, char *argv[]) {
                         else {                                                          // auto skip                          else {                                                          // auto skip
                                 if (!waitcnt) {                                  if (!waitcnt) {
                                         UINT cnt;                                          UINT cnt;
 #if defined(NP2GCC) && 0  #if 0
                     mouse_callback();  
 #endif  
 #if 1  
                     mackbd_callback();                      mackbd_callback();
 #endif  #endif
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         framecnt++;                                          framecnt++;
                                         // テスト  
                                         cnt = timing_getcount();                                          cnt = timing_getcount();
                                         if (framecnt > cnt) {                                          if (framecnt > cnt) {
                                                 waitcnt = framecnt;                                                  waitcnt = framecnt;
Line 741  int main(int argc, char *argv[]) { Line 813  int main(int argc, char *argv[]) {
                                                         framemax++;                                                          framemax++;
                                                 }                                                  }
                                                 if (cnt >= 12) {                                                  if (cnt >= 12) {
                                                         timing_init();                                                          timing_reset();
                                                 }                                                  }
                                                 else {                                                  else {
                                                         timing_setcount(cnt - framecnt);                                                          timing_setcount(cnt - framecnt);
Line 761  int main(int argc, char *argv[]) { Line 833  int main(int argc, char *argv[]) {
         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();
Line 773  int main(int argc, char *argv[]) { Line 847  int main(int argc, char *argv[]) {
   
         scrnmng_destroy();          scrnmng_destroy();
   
         if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {          if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {
                 initsave();                  initsave();
         }          }
         TRACETERM();          TRACETERM();
Line 788  int main(int argc, char *argv[]) { Line 862  int main(int argc, char *argv[]) {
 }  }
   
 //以下、ごっそりIIxからマージ  //以下、ごっそりIIxからマージ
 static pascal OSStatus MyAppEventHandler (EventHandlerCallRef myHandlerChain, EventRef event, void* userData)  static pascal OSStatus np2appevent (EventHandlerCallRef myHandlerChain, EventRef event, void* userData)
 {  {
     UInt32          whatHappened;      UInt32          whatHappened;
     OSStatus        result = eventNotHandledErr;      OSStatus        result = eventNotHandledErr;
Line 804  static pascal OSStatus MyAppEventHandler Line 878  static pascal OSStatus MyAppEventHandler
     if (IsDialogEvent(&eve)) return result;      if (IsDialogEvent(&eve)) return result;
   
     UInt32 modif;      UInt32 modif;
     EventMouseButton    buttonKind;  
     GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &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);      GetEventParameter (event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &buttonKind);
     BYTE ret;  
           BYTE ret;
   #endif
                   
     switch (eventClass)      switch (eventClass)
         {          {
Line 816  static pascal OSStatus MyAppEventHandler Line 895  static pascal OSStatus MyAppEventHandler
                         AEProcessAppleEvent(&eve);                          AEProcessAppleEvent(&eve);
                     }                      }
                     break;                      break;
   
                 case kEventClassMouse:                   case kEventClassMouse: 
   #if defined(NP2GCC)
                     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 847  static pascal OSStatus MyAppEventHandler Line 915  static pascal OSStatus MyAppEventHandler
                             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
                                                   if (whatHappened == kEventMouseDown) {
                                                           HandleMouseDown(&eve);
                                                   }
   #endif
                         break;                          break;
             default:              default:
                     break;                       break; 
         }          }
   
           (void)myHandlerChain;
           (void)userData;
     return result;       return result; 
 }  }
   
 static pascal OSStatus MyWindowEventHandler(EventHandlerCallRef myHandler,  EventRef event, void* userData)  static pascal OSStatus np2windowevent(EventHandlerCallRef myHandler,  EventRef event, void* userData)
 {  {
     WindowRef   window;      WindowRef   window;
     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 893  static pascal OSStatus MyWindowEventHand Line 973  static pascal OSStatus MyWindowEventHand
                 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 923  static pascal OSStatus MyWindowEventHand Line 998  static pascal OSStatus MyWindowEventHand
                         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 934  static pascal OSStatus MyWindowEventHand Line 1011  static pascal OSStatus MyWindowEventHand
                 break;                                  break;                
         }          }
   
           (void)myHandler;
           (void)userData;
     return result;      return result;
 }  }
   
 static void setUpCarbonEvent(void)  static const EventTypeSpec appEventList[] = {
 {                                  {kEventClassAppleEvent, kEventAppleEvent},
     InstallStandardEventHandler(GetWindowEventTarget(hWndMain));                                  {kEventClassMouse,              kEventMouseDown},
         EventTypeSpec   appEventList[] ={       { kEventClassAppleEvent, kEventAppleEvent },  #if defined(NP2GCC)
                                         { kEventClassMouse, kEventMouseDown},                                  {kEventClassMouse,              kEventMouseMoved},
                                         { kEventClassMouse, kEventMouseMoved},                                  {kEventClassMouse,              kEventMouseUp},
                                         { kEventClassMouse, kEventMouseUp}  #endif
                                     };                          };
     EventTypeSpec   windEventList[] ={  { kEventClassWindow, kEventWindowClose},  
                                                         { kEventClassKeyboard, kEventRawKeyDown},  
                                         { kEventClassKeyboard, kEventRawKeyUp},  
                                         { kEventClassKeyboard, kEventRawKeyRepeat},  
                                                         { kEventClassKeyboard, kEventRawKeyModifiersChanged}  
                                      };  
         InstallApplicationEventHandler(NewEventHandlerUPP(MyAppEventHandler), 4, appEventList, 0, NULL);   
         InstallWindowEventHandler(hWndMain, NewEventHandlerUPP(MyWindowEventHandler), 5, windEventList, 0, NULL);  
   
   static const EventTypeSpec windEventList[] = {
                                   {kEventClassWindow,             kEventWindowClose},
                                   {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);
 }  }
   
Removed from v.1.11  
changed lines
  Added in v.1.18

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