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

Diff for /np2/macosx/np2.cpp between versions 1.19 and 1.56

version 1.19, 2003/10/25 16:01:21 version 1.56, 2004/03/15 05:06:01
Line 26 Line 26
 #include        "s98.h"  #include        "s98.h"
 #include        "diskdrv.h"  #include        "diskdrv.h"
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "statsave.h"  
 #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"
   #include        "macalert.h"
   #include        "np2opening.h"
   #include        "toolwin.h"
   #include        "aboutdlg.h"
   #include        "keystat.h"
   #include        "kdispwin.h"
   
 #define USE_RESUME  #define USE_RESUME
 // #define      NP2OPENING  #define NP2OPENING
   // #define      OPENING_WAIT    1500
 #ifdef          NP2OPENING  
 #include        <QuickTime/QuickTime.h>  
 #define         OPENING_WAIT            1500  
 #endif  
   
   
                   NP2OSCFG        np2oscfg = {"Neko Project IIx",                                         //titles
                 NP2OSCFG        np2oscfg = {0, 2, 0, 0, 0, 0, 1, 0};                                                                  -1,                                                                             //winx
                                                                   -1,                                                                             //winy
                                                                   0,                                                                              //NOWAIT
                                                                   0,                                                                              //DRAW_SKIP
                                                                   0,                                                                              //DISPCLK
                                                                   0,                                                                              //F11KEY
                                                                   0,                                                                              //F12KEY
                                                                   0,                                                                              //MOUSE_SW
                                                                   0,                                                                              //JOYPAD1
                                                                   {5, 0, 0x3e, 19200, "", "", "GM", ""},  //mpu
                                                                   0,                                                                              //confirm
                                                                   0,                                                                              //resume
                                                                   1,                                                                              //toolwin
                                                                   0,                                                                              //jastsnd
                                                                   0,                                                                              //I286SAVE
   #ifdef SUPPORT_KEYDISP
                                                                   1,                                                                              //keydisp
   #endif
                                                                   };
   
                 WindowPtr       hWndMain;                  WindowPtr       hWndMain;
                 BOOL            np2running;                  BOOL            np2running;
 static  UINT            framecnt = 0;  static  UINT            framecnt = 0;
 static  UINT            waitcnt = 0;  static  UINT            waitcnt = 0;
 static  UINT            framemax = 1;  static  UINT            framemax = 1;
 static  BYTE            scrnmode;          BYTE            scrnmode = 0;
   
   
 #define DRAG_THRESHOLD          5  #define DRAG_THRESHOLD          5
Line 67  static const char np2resume[] = "sav"; Line 90  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 84  static pascal OSErr handleQuitApp(const  Line 104  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;
       OSErr               err = noErr;
           
           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))      {
                   err = setDropFile(fsc, i-1);
                           }
                   }
                   AEDisposeDesc( &dlist );
           }
           return(err);
   }
   
   
 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 122  static void MenuBarInit(void) { Line 155  static void MenuBarInit(void) {
         }          }
         InsertMenu(GetMenu(IDM_SASI1), -1);          InsertMenu(GetMenu(IDM_SASI1), -1);
         InsertMenu(GetMenu(IDM_SASI2), -1);          InsertMenu(GetMenu(IDM_SASI2), -1);
           InsertMenu(GetMenu(IDM_SCSI0), -1);
           InsertMenu(GetMenu(IDM_SCSI1), -1);
           InsertMenu(GetMenu(IDM_SCSI2), -1);
           InsertMenu(GetMenu(IDM_SCSI3), -1);
         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);
         DrawMenuBar();      ChangeMenuAttributes(GetMenuRef(IDM_EDIT), kMenuAttrAutoDisable, 0);
       DisableAllMenuItems(GetMenuHandle(IDM_EDIT));
       SetMenuItemModifiers(GetMenuRef(IDM_FDD2), IDM_FDD2OPEN, kMenuShiftModifier);
       SetMenuItemModifiers(GetMenuRef(IDM_FDD2), IDM_FDD2EJECT, kMenuShiftModifier);
       SetMenuItemModifiers(GetMenuRef(IDM_SASI2), IDM_SASI2OPEN, kMenuShiftModifier);
   #ifndef SUPPORT_KEYDISP
           DisableMenuItem(GetMenuRef(IDM_OTHER), IDM_KEYDISP);
 #endif  #endif
           DrawMenuBar();
   #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();
                   scrnmng_destroy();
                   if (scrnmng_create(mode) == SUCCESS) {
                           scrnmode = mode;
                   }
                   scrndraw_redraw();
                   soundmng_play();
           }
           else {
                   scrnmode = mode;
           }
 }  }
   
 static void HandleMenuChoice(long wParam) {  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 220  static void HandleMenuChoice(long wParam
                         break;                          break;
   
                 case IDM_RESET:                  case IDM_RESET:
                         pccore_cfgupdate();              if (ResetWarningDialogProc()) {
                         pccore_reset();                  pccore_cfgupdate();
                   pccore_reset();
               }
                         break;                          break;
                           
                 case IDM_CONFIGURE:                  case IDM_CONFIGURE:
                         initConfig();                          initConfig();
                         break;                          break;
   
 #if 0                  case IDM_NEWDISK:
                 case IDM_NEWFDD:              newdisk();
                         newdisk();  
                         break;                          break;
 #endif  
 #if 0  
                 case IDM_NEWHDD:  
                         newhdddisk();  
                         break;  
 #endif  
   
         case IDM_FONT:          case IDM_FONT:
             dialog_font();              dialog_font();
             break;              break;
                           
                 case IDM_EXIT:                  case IDM_EXIT:
                         np2running = FALSE;                          taskmng_exit();
                         break;                          break;
   
                 case IDM_FDD1OPEN:                  case IDM_FDD1OPEN:
Line 185  static void HandleMenuChoice(long wParam Line 248  static void HandleMenuChoice(long wParam
   
                 case IDM_FDD1EJECT:                  case IDM_FDD1EJECT:
                         diskdrv_setfdd(0, NULL, 0);                          diskdrv_setfdd(0, NULL, 0);
               toolwin_setfdd(0, NULL);
                         break;                          break;
   
                 case IDM_FDD2OPEN:                  case IDM_FDD2OPEN:
Line 193  static void HandleMenuChoice(long wParam Line 257  static void HandleMenuChoice(long wParam
   
                 case IDM_FDD2EJECT:                  case IDM_FDD2EJECT:
                         diskdrv_setfdd(1, NULL, 0);                          diskdrv_setfdd(1, NULL, 0);
               toolwin_setfdd(1, NULL);
                         break;                          break;
   
                 case IDM_SASI1OPEN:                  case IDM_SASI1OPEN:
Line 211  static void HandleMenuChoice(long wParam Line 276  static void HandleMenuChoice(long wParam
                         diskdrv_sethdd(1, NULL);                          diskdrv_sethdd(1, NULL);
                         break;                          break;
   
                   case IDM_SCSI0OPEN:
                           dialog_changehdd(0x20);
                           break;
   
                   case IDM_SCSI0REMOVE:
                           diskdrv_sethdd(0x20, NULL);
                           break;
   
                   case IDM_SCSI1OPEN:
                           dialog_changehdd(0x21);
                           break;
   
                   case IDM_SCSI1REMOVE:
                           diskdrv_sethdd(0x21, NULL);
                           break;
   
                   case IDM_SCSI2OPEN:
                           dialog_changehdd(0x22);
                           break;
   
                   case IDM_SCSI2REMOVE:
                           diskdrv_sethdd(0x22, NULL);
                           break;
   
                   case IDM_SCSI3OPEN:
                           dialog_changehdd(0x23);
                           break;
   
                   case IDM_SCSI3REMOVE:
                           diskdrv_sethdd(0x23, NULL);
                           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 268  static void HandleMenuChoice(long wParam Line 369  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;
   
         case IDM_MOUSE:          case IDM_MOUSE:
             mouse_running(MOUSE_XOR);                          mousemng_toggle(MOUSEPROC_SYSTEM);
             menu_setmouse(np2oscfg.MOUSE_SW ^ 1);              menu_setmouse(np2oscfg.MOUSE_SW ^ 1);
             sysmng_update(SYS_UPDATECFG);              sysmng_update(SYS_UPDATECFG);
                         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);
                         keystat_resetjoykey();                          keystat_resetjoykey();
                           update |= SYS_UPDATECFG;
                         break;                          break;
   
                 case IDM_JOY1:                  case IDM_JOY1:
                         menu_setkey(1);                          menu_setkey(1);
                         keystat_resetjoykey();                          keystat_resetjoykey();
                           update |= SYS_UPDATECFG;
                         break;                          break;
   
                 case IDM_JOY2:                  case IDM_JOY2:
                         menu_setkey(2);                          menu_setkey(2);
                         keystat_resetjoykey();                          keystat_resetjoykey();
                           update |= SYS_UPDATECFG;
                         break;                          break;
   
                 case IDM_MOUSEKEY:                  case IDM_MOUSEKEY:
                         menu_setkey(3);                          menu_setkey(3);
                         keystat_resetjoykey();                          keystat_resetjoykey();
                           update |= SYS_UPDATECFG;
                         break;                          break;
   
                 case IDM_XSHIFT:                  case IDM_XSHIFT:
                         menu_setxshift(np2cfg.XSHIFT ^ 1);                          menu_setxshift(np2cfg.XSHIFT ^ 1);
                         keystat_forcerelease(0x70);                          keystat_forcerelease(0x70);
                           update |= SYS_UPDATECFG;
                         break;                          break;
   
                 case IDM_XCTRL:                  case IDM_XCTRL:
                         menu_setxshift(np2cfg.XSHIFT ^ 2);                          menu_setxshift(np2cfg.XSHIFT ^ 2);
                         keystat_forcerelease(0x74);                          keystat_forcerelease(0x74);
                           update |= SYS_UPDATECFG;
                         break;                          break;
   
                 case IDM_XGRPH:                  case IDM_XGRPH:
                         menu_setxshift(np2cfg.XSHIFT ^ 4);                          menu_setxshift(np2cfg.XSHIFT ^ 4);
                         keystat_forcerelease(0x73);                          keystat_forcerelease(0x73);
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_F11KANA:
                           menu_setf11key(0);
                           mackbd_resetf11();
                           update |= SYS_UPDATEOSCFG;
                           break;
   
                   case IDM_F11STOP:
                           menu_setf11key(1);
                           mackbd_resetf11();
                           update |= SYS_UPDATEOSCFG;
                           break;
   
                   case IDM_F11EQU:
                           menu_setf11key(2);
                           mackbd_resetf11();
                           update |= SYS_UPDATEOSCFG;
                           break;
   
                   case IDM_F11NFER:
                           menu_setf11key(3);
                           mackbd_resetf11();
                           update |= SYS_UPDATEOSCFG;
                           break;
   
                   case IDM_F11USER:
                           menu_setf11key(4);
                           mackbd_resetf11();
                           update |= SYS_UPDATEOSCFG;
                         break;                          break;
   
                 case IDM_F12MOUSE:                  case IDM_F12MOUSE:
                         menu_setf12copy(0);                          menu_setf12key(0);
                         keystat_resetcopyhelp();                          mackbd_resetf12();
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                         break;                          break;
   
                 case IDM_F12COPY:                  case IDM_F12COPY:
                         menu_setf12copy(1);                          menu_setf12key(1);
                         keystat_resetcopyhelp();                          mackbd_resetf12();
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                         break;                          break;
   
                 case IDM_F12STOP:                  case IDM_F12COMMA:
                         menu_setf12copy(2);                          menu_setf12key(2);
                         keystat_resetcopyhelp();                          mackbd_resetf12();
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                           break;
   
                   case IDM_F12XFER:
                           menu_setf12key(3);
                           mackbd_resetf12();
                           update |= SYS_UPDATEOSCFG;
                           break;
   
                   case IDM_F12USER:
                           menu_setf12key(4);
                           mackbd_resetf12();
                           update |= SYS_UPDATEOSCFG;
                         break;                          break;
   
                 case IDM_BEEPOFF:                  case IDM_BEEPOFF:
Line 402  static void HandleMenuChoice(long wParam Line 564  static void HandleMenuChoice(long wParam
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                         break;                          break;
   
                   case IDM_AMD98:
                           menu_setsound(0x80);
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_JASTSOUND:
                           menu_setjastsound(np2oscfg.jastsnd ^ 1);
                           update |= SYS_UPDATEOSCFG;
                           break;
   
                 case IDM_SEEKSND:                  case IDM_SEEKSND:
                         menu_setmotorflg(np2cfg.MOTOR ^ 1);                          menu_setmotorflg(np2cfg.MOTOR ^ 1);
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
Line 427  static void HandleMenuChoice(long wParam Line 599  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 447  static void HandleMenuChoice(long wParam Line 627  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_RECORDING:
               menu_setrecording(false);
               break;
   
   #if defined(SUPPORT_KEYDISP)
                   case IDM_KEYDISP:
                           menu_setkeydisp(np2oscfg.keydisp ^ 1);
                           if (np2oscfg.keydisp) {
                                   kdispwin_create();
                           }
                           else {
                                   kdispwin_destroy();
                           }
                           break;
   #endif
   
                 case IDM_I286SAVE:                  case IDM_I286SAVE:
                         debugsub_status();                          debugsub_status();
                         break;                          break;
               
           case IDM_NP2HELP:
               {
                   ICInstance inst;
                   long start, fin;
                   const char      urlStr[] = "http://retropc.net/tk800/np2x/help/help.html";
   
                   ICStart(&inst, 'SMil');
                   start = 0;
                   fin = strlen(urlStr);
                   ICLaunchURL(inst, "\p", urlStr, strlen(urlStr), &start, &fin);
                   ICStop(inst);
               }
               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)) {  
                 case inMenuBar:  
                         HandleMenuChoice(MenuSelect(pevent->where));  
                         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;  
   
 #ifndef NP2GCC          if (FindWindow(pevent->where, &hWnd) == inMenuBar) {
                 case inGoAway:          soundmng_stop();
                         if (TrackGoAway(hWnd, pevent->where)) { }          mousemng_disable(MOUSEPROC_MACUI);
                         np2running = FALSE;          HandleMenuChoice(MenuSelect(pevent->where));
                         break;          mousemng_enable(MOUSEPROC_MACUI);
 #endif      }
         }      else {
     soundmng_play();          mousemng_buttonevent(MOUSEMNG_LEFTDOWN);
       }
 }  }
   
 #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:  static void framereset(UINT waitcnt) {
                         mackbd_f12up(((event->message) & keyCodeMask) >> 8);  
                         break;  
   
 #if defined(NP2GCC)          framecnt = 0;
         case mouseUp:          kdispwin_draw((BYTE)waitcnt);
             if (controlKey & GetCurrentKeyModifiers()) {          toolwin_draw((BYTE)waitcnt);
                 mouse_btn(MOUSE_RIGHTUP);          if (np2oscfg.DISPCLK & 3) {
             }                  if (sysmng_workclockrenewal()) {
             else {                          sysmng_updatecaption(3);
                 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) {
                 framecnt = 0;  
                 timing_setcount(0);                  timing_setcount(0);
                 if (np2oscfg.DISPCLK & 3) {                  framereset(waitcnt);
                         if (sysmng_workclockrenewal()) {  
                                 sysmng_updatecaption(3);  
                         }  
                 }  
         }          }
           soundmng_sync();
 }  }
   
 static void getstatfilename(char *path, const char *ext, int size) {  static void getstatfilename(char *path, const char *ext, int size) {
Line 593  static void flagsave(const char *ext) { Line 727  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];
         char    buf[1024];          char    buf[1024];
         int             ret;          int             ret, r;
   
       ret = IDOK;
         getstatfilename(path, ext, sizeof(path));          getstatfilename(path, ext, sizeof(path));
         ret = statsave_check(path, buf, sizeof(buf));          r = statsave_check(path, buf, sizeof(buf));
         if (ret == NP2FLAG_SUCCESS) {          if (r & (~STATFLAG_DISKCHG)) {
                   ResumeErrorDialogProc();
                   ret = IDCANCEL;
           }
           else if (r & STATFLAG_DISKCHG) {
                   ret = ResumeWarningDialogProc(buf);
           }
           if (ret == IDOK) {
                 statsave_load(path);                  statsave_load(path);
                   toolwin_setfdd(0, fdd_diskname(0));
                   toolwin_setfdd(1, fdd_diskname(1));
         }          }
           return;
 }  }
   
 #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;  
 #if 0  
         EventRecord     event;  
 #endif  
     EventRef            theEvent;      EventRef            theEvent;
     EventTargetRef      theTarget;      EventTargetRef      theTarget;
       Rect                        bounds;
 #ifdef OPENING_WAIT  #ifdef OPENING_WAIT
         UINT32          tick;          UINT32          tick;
 #endif  #endif
     
         dosio_init();          dosio_init();
         file_setcd(target);          file_setcd(target);
   
Line 677  int main(int argc, char *argv[]) { Line 778  int main(int argc, char *argv[]) {
         initload();          initload();
   
         TRACEINIT();          TRACEINIT();
       
           keystat_initialize();
           kdispwin_initialize();
   
           toolwin_readini();
           kdispwin_readini();
       if (!(setupMainWindow())) {
           return(0);
       }
   
         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(0);  
         }  
         scrnmng_initialize();  
         SizeWindow(hWndMain, 640, 400, TRUE);  
     setUpCarbonEvent();  
         ShowWindow(hWndMain);  
 #ifdef    NP2OPENING  #ifdef    NP2OPENING
     openingNP2();      openingNP2();
 #endif  #endif
Line 704  int main(int argc, char *argv[]) { Line 801  int main(int argc, char *argv[]) {
         menu_setframe(np2oscfg.DRAW_SKIP);          menu_setframe(np2oscfg.DRAW_SKIP);
         menu_setkey(0);          menu_setkey(0);
         menu_setxshift(0);          menu_setxshift(0);
         menu_setf12copy(np2oscfg.F12COPY);          menu_setf11key(np2oscfg.F11KEY);
           menu_setf12key(np2oscfg.F12KEY);
         menu_setbeepvol(np2cfg.BEEP_VOL);          menu_setbeepvol(np2cfg.BEEP_VOL);
         menu_setsound(np2cfg.SOUND_SW);          menu_setsound(np2cfg.SOUND_SW);
           menu_setjastsound(np2oscfg.jastsnd);
         menu_setmotorflg(np2cfg.MOTOR);          menu_setmotorflg(np2cfg.MOTOR);
         menu_setextmem(np2cfg.EXTMEM);          menu_setextmem(np2cfg.EXTMEM);
         menu_setdispclk(np2oscfg.DISPCLK);          menu_setdispclk(np2oscfg.DISPCLK);
         menu_setbtnrapid(np2cfg.BTN_RAPID);          menu_setbtnrapid(np2cfg.BTN_RAPID);
         menu_setbtnmode(np2cfg.BTN_MODE);          menu_setbtnmode(np2cfg.BTN_MODE);
   #if defined(SUPPORT_KEYDISP)
           menu_setkeydisp(np2oscfg.keydisp);
   #endif
       if (np2oscfg.I286SAVE) {
           AppendMenuItemTextWithCFString(GetMenuRef(IDM_OTHER), CFCopyLocalizedString(CFSTR("i286 save"),"i286"), kMenuItemAttrIconDisabled, NULL,NULL);
       }
   
         scrnmode = 0;          scrnmng_initialize();
         if (scrnmng_create(scrnmode) != SUCCESS) {          if (scrnmng_create(scrnmode) != SUCCESS) {
                 TRACETERM();                  TRACETERM();
                 macossub_term();                  macossub_term();
Line 728  int main(int argc, char *argv[]) { Line 833  int main(int argc, char *argv[]) {
         pccore_init();          pccore_init();
         S98_init();          S98_init();
   
       hid_init();
   #ifndef SUPPORT_SWSEEKSND
           if (soundmng_initialize() == SUCCESS) {
                   soundmng_pcmvolume(SOUND_PCMSEEK, np2cfg.MOTORVOL);
                   soundmng_pcmvolume(SOUND_PCMSEEK1, np2cfg.MOTORVOL);
           }
   #endif
   
 #if defined(NP2GCC)  #if defined(NP2GCC)
           mousemng_initialize();
         if (np2oscfg.MOUSE_SW) {                                                                                // ver0.30          if (np2oscfg.MOUSE_SW) {                                                                                // ver0.30
                 mouse_running(MOUSE_ON);                  mousemng_enable(MOUSEPROC_SYSTEM);
         }          }
 #endif  #endif
   
 #ifdef OPENING_WAIT  #ifdef OPENING_WAIT
         while((GETTICK() - tick) < OPENING_WAIT);          while((GETTICK() - tick) < OPENING_WAIT);
 #endif  #endif
         scrndraw_redraw();  
         pccore_reset();          pccore_reset();
   
 #if defined(USE_RESUME)  #if defined(USE_RESUME)
Line 744  int main(int argc, char *argv[]) { Line 858  int main(int argc, char *argv[]) {
         flagload(np2resume);          flagload(np2resume);
     }      }
 #endif  #endif
   #if defined(SUPPORT_KEYDISP)
 #if 0          if (np2oscfg.keydisp) {
         SetEventMask(everyEvent);                  kdispwin_create();
           }
 #endif  #endif
   
     theTarget = GetEventDispatcherTarget();      theTarget = GetEventDispatcherTarget();
       
         np2running = TRUE;          np2running = TRUE;
         while(np2running) {          while(np2running) {
         if (ReceiveNextEvent(0, NULL,kEventDurationNoWait,true, &theEvent)== noErr)          if (ReceiveNextEvent(0, NULL,kEventDurationNoWait,true, &theEvent)== noErr)
Line 757  int main(int argc, char *argv[]) { Line 873  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 0  
                                 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 783  int main(int argc, char *argv[]) { Line 892  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 0  
                     mackbd_callback();  
 #endif  
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         framecnt++;                                          framecnt++;
                                 }                                  }
Line 796  int main(int argc, char *argv[]) { Line 902  int main(int argc, char *argv[]) {
                         else {                                                          // auto skip                          else {                                                          // auto skip
                                 if (!waitcnt) {                                  if (!waitcnt) {
                                         UINT cnt;                                          UINT cnt;
 #if 0  
                     mackbd_callback();  
 #endif  
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         framecnt++;                                          framecnt++;
                                         cnt = timing_getcount();                                          cnt = timing_getcount();
Line 818  int main(int argc, char *argv[]) { Line 921  int main(int argc, char *argv[]) {
                                                 else {                                                  else {
                                                         timing_setcount(cnt - framecnt);                                                          timing_setcount(cnt - framecnt);
                                                 }                                                  }
                                                 processwait(0);                                                  framereset(0);
                                         }                                          }
                                 }                                  }
                                 else {                                  else {
Line 828  int main(int argc, char *argv[]) { Line 931  int main(int argc, char *argv[]) {
                         }                          }
                 }                  }
         }          }
       
         np2running = FALSE;          np2running = FALSE;
       menu_setrecording(true);
   
       if (scrnmode & SCRNMODE_FULLSCREEN) {
           toggleFullscreen();
       }
       
           GetWindowBounds(hWndMain, kWindowGlobalPortRgn, &bounds);
           if ((np2oscfg.winx != bounds.left) || (np2oscfg.winy != bounds.top)) {
                   np2oscfg.winx = bounds.left;
                   np2oscfg.winy = bounds.top;
                   sysmng_update(SYS_UPDATEOSCFG);
           }
   
         pccore_cfgupdate();          pccore_cfgupdate();
   
Line 836  int main(int argc, char *argv[]) { Line 952  int main(int argc, char *argv[]) {
     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);          mousemng_disable(MOUSEPROC_SYSTEM);
   #endif
   #ifndef SUPPORT_SWSEEKSND
           soundmng_deinitialize();
 #endif  #endif
   
         scrnmng_destroy();          scrnmng_destroy();
   
           kdispwin_destroy();
         if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {          if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {
                 initsave();                  initsave();                                             // np2.cfg create
               toolwin_writeini();                         // np2.cfg append
                   kdispwin_writeini();
         }          }
         TRACETERM();          TRACETERM();
         macossub_term();          macossub_term();
         dosio_term();          dosio_term();
   
       toolwin_close();
         DisposeWindow(hWndMain);          DisposeWindow(hWndMain);
   
         (void)argc;          (void)argc;
Line 864  int main(int argc, char *argv[]) { Line 990  int main(int argc, char *argv[]) {
 //以下、ごっそりIIxからマージ  //以下、ごっそりIIxからマージ
 static pascal OSStatus np2appevent (EventHandlerCallRef myHandlerChain, EventRef event, void* userData)  static pascal OSStatus np2appevent (EventHandlerCallRef myHandlerChain, EventRef event, void* userData)
 {  {
     UInt32          whatHappened;      OSStatus    result = eventNotHandledErr;
     OSStatus        result = eventNotHandledErr;  
           
     long                eventClass;      long                eventClass;
           UInt32              whatHappened;
     eventClass = GetEventClass(event);      eventClass = GetEventClass(event);
     whatHappened = GetEventKind(event);      whatHappened = GetEventKind(event);
   
     EventRecord         eve;      EventRecord eve;
     ConvertEventRefToEventRecord( event,&eve );      ConvertEventRefToEventRecord( event,&eve );
   
     if (IsDialogEvent(&eve)) return result;      if (IsDialogEvent(&eve)) return result;
   
     UInt32 modif;      UInt32              modif;
     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;      HIPoint             delta;
     EventMouseButton buttonKind;      EventMouseButton buttonKind;
     GetEventParameter (event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &buttonKind);      GetEventParameter (event, kEventParamMouseButton, typeMouseButton, NULL, sizeof(EventMouseButton), NULL, &buttonKind);
   
         BYTE ret;  
 #endif  #endif
                   
     switch (eventClass)      switch (eventClass)
         {      {
                 case kEventClassAppleEvent:            case kEventClassCommand:
                     if (whatHappened == kEventAppleEvent) {              if (GetEventKind(event)==kEventCommandProcess) {
                         AEProcessAppleEvent(&eve);                  HICommand       cmd;
                     }                  GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &cmd);
                     break;                  if (cmd.commandID == kHICommandAppHelp) {
                       ICInstance inst;
                       long start, fin;
                       const char  urlStr[] = "http://retropc.net/tk800/np2x/help/help.html";
   
                       ICStart(&inst, 'SMil');
                       start = 0;
                       fin = strlen(urlStr);
                       ICLaunchURL(inst, "\p", urlStr, strlen(urlStr), &start, &fin);
                       ICStop(inst);
                   }
               }
               break;
   
                 case kEventClassMouse:           case kEventClassAppleEvent:  
               if (whatHappened == kEventAppleEvent) {
                   AEProcessAppleEvent(&eve);
               }
               break;
   
           case kEventClassMouse: 
 #if defined(NP2GCC)  #if defined(NP2GCC)
                     switch (whatHappened)              switch (whatHappened)
                         {              {
                         case kEventMouseMoved:                  case kEventMouseMoved:
                             GetEventParameter (event, kEventParamMouseDelta, typeHIPoint, NULL, sizeof(HIPoint), NULL, &delta);                  case kEventMouseDragged:
                             mouse_callback(delta);                      GetEventParameter (event, kEventParamMouseDelta, typeHIPoint, NULL, sizeof(HIPoint), NULL, &delta);
                             result = noErr;                      mousemng_callback(delta);
                             break;                      result = noErr;
                        case kEventMouseDown:                      break;
                             if (buttonKind == kEventMouseButtonSecondary | modif & controlKey) {                  case kEventMouseDown:
                                 ret=mouse_btn(MOUSE_RIGHTDOWN);                      if (buttonKind == kEventMouseButtonSecondary || modif & cmdKey) {
                             }                          mousemng_buttonevent(MOUSEMNG_RIGHTDOWN);
                             else {                      }
                                 HandleMouseDown(&eve);                      else {
                             }                          HandleMouseDown(&eve);
                             result=noErr;                      }
                             break;                      result=noErr;
                         case kEventMouseUp:                      break;
                             if (buttonKind == kEventMouseButtonSecondary | modif & controlKey) {                  case kEventMouseUp:
                                 ret=mouse_btn(MOUSE_RIGHTUP);                      if (buttonKind == kEventMouseButtonSecondary || modif & cmdKey) {
                             }                          mousemng_buttonevent(MOUSEMNG_RIGHTUP);
                             else if (buttonKind == kEventMouseButtonTertiary) {                      }
                                 mouse_running(MOUSE_XOR);                      else if (buttonKind == kEventMouseButtonTertiary) {
                                 menu_setmouse(np2oscfg.MOUSE_SW ^ 1);                          mousemng_toggle(MOUSEPROC_SYSTEM);
                                 sysmng_update(SYS_UPDATECFG);                          menu_setmouse(np2oscfg.MOUSE_SW ^ 1);
                             }                          sysmng_update(SYS_UPDATECFG);
                             else {                      }
                                 ret=mouse_btn(MOUSE_LEFTUP);                      else {
                             }                          mousemng_buttonevent(MOUSEMNG_LEFTUP);
                             result=noErr;                      }
                             break;                          result=noErr;
                         }                      break;    
                   }
 #else  #else
                                                 if (whatHappened == kEventMouseDown) {                  if (whatHappened == kEventMouseDown) {
                                                         HandleMouseDown(&eve);                      HandleMouseDown(&eve);
                                                 }                  }
 #endif  #endif
                         break;                  break;
             default:                  case kEventClassKeyboard:
                     break;                   if (GetEventKind(event)==kEventRawKeyModifiersChanged) {
         }                                          static UInt32 backup = 0;
                       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; 
       }
   
         (void)myHandlerChain;          (void)myHandlerChain;
         (void)userData;          (void)userData;
Line 950  static pascal OSStatus np2windowevent(Ev Line 1107  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 958  static pascal OSStatus np2windowevent(Ev Line 1114  static pascal OSStatus np2windowevent(Ev
     whatHappened = GetEventKind(event);      whatHappened = GetEventKind(event);
                   
     switch (eventClass)      switch (eventClass)
         {              {        
             case kEventClassWindow:                      case kEventClassKeyboard:
                 if (whatHappened == kEventWindowClose) {              UInt32 key;
                     np2running = FALSE;              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_keyup(key);
                     result = noErr;                      result = noErr;
                 }                      break;
                 break;                  case kEventRawKeyRepeat:
             case kEventClassKeyboard:                      mackbd_keydown(key);
                 UInt32 key;                      result = noErr;
                 GetEventParameter (event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &key);                      break;
                 UInt32 modif;                  case kEventRawKeyDown:
                 GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modif);                      if (modif & cmdKey) {
                 switch (whatHappened)                          EventRecord     eve;
                 {                          ConvertEventRefToEventRecord( event,&eve );
                     case kEventRawKeyUp:                          mousemng_disable(MOUSEPROC_MACUI);
                         mackbd_f12up(key);                          HandleMenuChoice(MenuEvent(&eve));
                         result = noErr;                          mousemng_enable(MOUSEPROC_MACUI);
                         break;                      }
                     case kEventRawKeyRepeat:                      else {
                         mackbd_f12down(key);                          mackbd_keydown(key);
                         result = noErr;                      }
                         break;                      result = noErr;
                     case kEventRawKeyDown:                      break;
                         if (modif & cmdKey) {                  default: 
                             EventRecord eve;                      break;             
                             ConvertEventRefToEventRecord( event,&eve );              }
                             HandleMenuChoice(MenuEvent(&eve));              break;
                         }              
                         else {          case kEventClassWindow:
                             mackbd_f12down(key);              switch (whatHappened)
                         }              {
                         result = noErr;                  case kEventWindowClose:
                         break;                      taskmng_exit();
                     case kEventRawKeyModifiersChanged:                      result = noErr;
                         if (modif & shiftKey) keystat_senddata(0x70);                      break;
                         else keystat_senddata(0x70 | 0x80);                  case kEventWindowActivated:
                         if (modif & optionKey) keystat_senddata(0x73);                      DisableAllMenuItems(GetMenuHandle(IDM_EDIT));
                         else keystat_senddata(0x73 | 0x80);                      break;
                         if (modif & controlKey) keystat_senddata(0x74);                  case kEventWindowToolbarSwitchMode:
                         else keystat_senddata(0x74 | 0x80);                      toolwin_open();
                         if ((modif & alphaLock) != (backup & alphaLock)) {                      break;
                             keystat_senddata(0x71);                  case kEventWindowDragStarted:
                             backup = modif;                      soundmng_stop();
                         }                      break;
                         result = noErr;                  case kEventWindowDragCompleted:
                         break;                      soundmng_play();
                     default:                       break;
                         break;                               case kEventWindowShown:
                 }                      scrndraw_redraw();
             default:                       break;
                 break;                              }
         }              break;
           default: 
               break;                
       }
   
         (void)myHandler;          (void)myHandler;
         (void)userData;          (void)userData;
Line 1017  static pascal OSStatus np2windowevent(Ev Line 1182  static pascal OSStatus np2windowevent(Ev
 }  }
   
 static const EventTypeSpec appEventList[] = {  static const EventTypeSpec appEventList[] = {
                   {kEventClassCommand,    kEventCommandProcess },
                                 {kEventClassAppleEvent, kEventAppleEvent},                                  {kEventClassAppleEvent, kEventAppleEvent},
                                 {kEventClassMouse,              kEventMouseDown},                                  {kEventClassMouse,              kEventMouseDown},
 #if defined(NP2GCC)  #if defined(NP2GCC)
                                 {kEventClassMouse,              kEventMouseMoved},                                  {kEventClassMouse,              kEventMouseMoved},
                                   {kEventClassMouse,              kEventMouseDragged},
                                 {kEventClassMouse,              kEventMouseUp},                                  {kEventClassMouse,              kEventMouseUp},
 #endif  #endif
                                   {kEventClassKeyboard,   kEventRawKeyModifiersChanged},
                         };                          };
   
 static const EventTypeSpec windEventList[] = {  static const EventTypeSpec windEventList[] = {
                                 {kEventClassWindow,             kEventWindowClose},                                  {kEventClassWindow,             kEventWindowClose},
                                   {kEventClassWindow,             kEventWindowActivated},
                                   {kEventClassWindow,             kEventWindowToolbarSwitchMode},
                                   {kEventClassWindow,             kEventWindowDragStarted},
                                   {kEventClassWindow,             kEventWindowDragCompleted},
                                   {kEventClassWindow,             kEventWindowShown},
                                 {kEventClassKeyboard,   kEventRawKeyDown},                                  {kEventClassKeyboard,   kEventRawKeyDown},
                                 {kEventClassKeyboard,   kEventRawKeyUp},                                  {kEventClassKeyboard,   kEventRawKeyUp},
                                 {kEventClassKeyboard,   kEventRawKeyRepeat},                                  {kEventClassKeyboard,   kEventRawKeyRepeat},
                                 {kEventClassKeyboard,   kEventRawKeyModifiersChanged},  
                         };                          };
   
   
Line 1045  static void setUpCarbonEvent(void) { Line 1217  static void setUpCarbonEvent(void) {
                                                                 windEventList, 0, NULL);                                                                  windEventList, 0, NULL);
 }  }
   
   static short    backupwidth=0, backupheight=0;
   
   static bool setupMainWindow(void) {
   #if defined(NP2GCC)
       OSStatus    err;
       IBNibRef    nibRef;
   
       err = CreateNibReference(CFSTR("np2"), &nibRef);
       if (err ==noErr ) {
           CreateWindowFromNib(nibRef, CFSTR("MainWindow"), &hWndMain);
           DisposeNibReference ( nibRef);
       }
       else {
            return(false);
       }
       
   #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
       if (np2oscfg.winx != -1 && np2oscfg.winy != -1) {
           MoveWindow(hWndMain, np2oscfg.winx, np2oscfg.winy, false);
       }
       setUpCarbonEvent();
       if (backupwidth) scrnmng_setwidth(0, backupwidth);
       if (backupheight) scrnmng_setheight(0, backupheight);
           CFStringRef title = CFStringCreateWithCString(NULL, np2oscfg.titles, kCFStringEncodingUTF8);
           if (title) {
                   SetWindowTitleWithCFString(hWndMain, title);
                   CFRelease(title);
           }
           ShowWindow(hWndMain);
       return(true);
   }
   
   static void toggleFullscreen(void) {
       static Ptr  bkfullscreen;
       static BYTE mouse = 0;
       static bool toolwin = false;
       MenuRef     menu = GetMenuRef(IDM_SCREEN);
       Rect        bounds;
       short       w, h;
   
       soundmng_stop();
       if (!(scrnmode & SCRNMODE_FULLSCREEN)) {
           HandleMenuChoice(IDM_ROLNORMAL);
           GetWindowBounds(hWndMain, kWindowContentRgn, &bounds);
           backupwidth = bounds.right - bounds.left;
           backupheight = bounds.bottom - bounds.top;
                   w = backupwidth;
                   h = backupheight;
           toolwin = np2oscfg.toolwin;
           toolwin_close();
           np2oscfg.winx = bounds.left;
           np2oscfg.winy = bounds.top;
           DisposeWindow(hWndMain);
           BeginFullScreen(&bkfullscreen, 0, &w, &h, &hWndMain, NULL, fullScreenAllowEvents);      
           DisableMenuItem(menu, IDM_ROLNORMAL);
           DisableMenuItem(menu, IDM_ROLLEFT);
           DisableMenuItem(menu, IDM_ROLRIGHT);
           HideMenuBar();
           setUpCarbonEvent();
           if (!np2oscfg.MOUSE_SW) {
               mouse = np2oscfg.MOUSE_SW;
               mousemng_enable(MOUSEPROC_SYSTEM);
               menu_setmouse(1);
           }
           changescreen(scrnmode | SCRNMODE_FULLSCREEN);
       }
       else {
           scrnmng_destroy();
           EndFullScreen(bkfullscreen, 0);
           setupMainWindow();
           changescreen(scrnmode & (~SCRNMODE_FULLSCREEN));
           if (!mouse) {
               mousemng_disable(MOUSEPROC_SYSTEM);
               menu_setmouse(0);
           }
           EnableMenuItem(menu, IDM_ROLNORMAL);
           EnableMenuItem(menu, IDM_ROLLEFT);
           EnableMenuItem(menu, IDM_ROLRIGHT);
           ShowMenuBar();
           if (toolwin) {
               toolwin_open();
           }
       }
       CheckMenuItem(GetMenuHandle(IDM_SCREEN), LoWord(IDM_FULLSCREEN), scrnmode & SCRNMODE_FULLSCREEN);
       soundmng_play();
   }
Removed from v.1.19  
changed lines
  Added in v.1.56

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