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

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

version 1.25, 2003/10/30 19:39:52 version 1.33, 2003/11/08 17:54:26
Line 35 Line 35
 #include        "fdefine.h"  #include        "fdefine.h"
 #include        "hid.h"  #include        "hid.h"
 #include        "midiopt.h"  #include        "midiopt.h"
   #include        "macalert.h"
   #include        "np2opening.h"
   #include        "toolwin.h"
   
   #include        <QuickTime/QuickTime.h>
 #define USE_RESUME  #define USE_RESUME
 #define NP2OPENING  #define NP2OPENING
   
 #ifdef          NP2OPENING  
 #include        <QuickTime/QuickTime.h>  
 // #define      OPENING_WAIT    1500  // #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 53 Line 52
 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;
   
   
 #define DRAG_THRESHOLD          5  #define DRAG_THRESHOLD          5
Line 94  pascal OSErr OpenAppleEventHandler(const Line 93  pascal OSErr OpenAppleEventHandler(const
         AEKeyword       key;          AEKeyword       key;
         AEDescList      dlist;          AEDescList      dlist;
                   
         if( ! AEGetParamDesc( event,keyDirectObject,typeAEList,&dlist ) )       {          if(!AEGetParamDesc(event,keyDirectObject,typeAEList,&dlist))    {
                 AECountItems( &dlist,&ct );                  AECountItems( &dlist,&ct );
                 for( i=1;i<=ct;i++ )    {                  for( i=1;i<=ct;i++ )    {
             pp=&fsc;              pp=&fsc;
                         if( ! AEGetNthPtr( &dlist,i,typeFSS,&key,&rtype,(Ptr)pp,(long)sizeof(FSSpec),&len ) )   {                          if (!AEGetNthPtr( &dlist,i,typeFSS,&key,&rtype,(Ptr)pp,(long)sizeof(FSSpec),&len))      {
                 char            fname[MAX_PATH];                  setDropFile(fsc, i-1);
                 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 );                  AEDisposeDesc( &dlist );
Line 147  static void MenuBarInit(void) { Line 137  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);
       ChangeMenuAttributes(GetMenuRef(IDM_EDIT), kMenuAttrAutoDisable, 0);
     SetMenuItemModifiers(GetMenuRef(IDM_FDD2), IDM_FDD2OPEN, kMenuOptionModifier);      SetMenuItemModifiers(GetMenuRef(IDM_FDD2), IDM_FDD2OPEN, kMenuOptionModifier);
     SetMenuItemModifiers(GetMenuRef(IDM_FDD2), IDM_FDD2EJECT, kMenuOptionModifier);      SetMenuItemModifiers(GetMenuRef(IDM_FDD2), IDM_FDD2EJECT, kMenuOptionModifier);
     SetMenuItemModifiers(GetMenuRef(IDM_SASI2), IDM_SASI2OPEN, kMenuOptionModifier);      SetMenuItemModifiers(GetMenuRef(IDM_SASI2), IDM_SASI2OPEN, kMenuOptionModifier);
Line 202  static void HandleMenuChoice(long wParam Line 193  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:
Line 213  static void HandleMenuChoice(long wParam Line 206  static void HandleMenuChoice(long wParam
                 case IDM_NEWDISK:                  case IDM_NEWDISK:
             newdisk();              newdisk();
                         break;                          break;
 #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 232  static void HandleMenuChoice(long wParam Line 221  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 240  static void HandleMenuChoice(long wParam Line 230  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 327  static void HandleMenuChoice(long wParam Line 318  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;
                           
         case IDM_MIDIOPT:          case IDM_MIDIOPT:
Line 381  static void HandleMenuChoice(long wParam Line 371  static void HandleMenuChoice(long wParam
   
                 case IDM_F12MOUSE:                  case IDM_F12MOUSE:
                         menu_setf12copy(0);                          menu_setf12copy(0);
                         keystat_resetcopyhelp();                          mackbd_resetf12();
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                         break;                          break;
   
                 case IDM_F12COPY:                  case IDM_F12COPY:
                         menu_setf12copy(1);                          menu_setf12copy(1);
                         keystat_resetcopyhelp();                          mackbd_resetf12();
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                         break;                          break;
   
                 case IDM_F12STOP:                  case IDM_F12STOP:
                         menu_setf12copy(2);                          menu_setf12copy(2);
                         keystat_resetcopyhelp();                          mackbd_resetf12();
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_F12EQU:
                           menu_setf12copy(3);
                           mackbd_resetf12();
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_F12COMMA:
                           menu_setf12copy(4);
                           mackbd_resetf12();
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                         break;                          break;
   
Line 466  static void HandleMenuChoice(long wParam Line 468  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_SEEKSND:                  case IDM_SEEKSND:
                         menu_setmotorflg(np2cfg.MOTOR ^ 1);                          menu_setmotorflg(np2cfg.MOTOR ^ 1);
                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
Line 542  static void HandleMenuChoice(long wParam Line 549  static void HandleMenuChoice(long wParam
 static void HandleMouseDown(EventRecord *pevent) {  static void HandleMouseDown(EventRecord *pevent) {
   
         WindowPtr       hWnd;          WindowPtr       hWnd;
       BYTE                ret;
   
     soundmng_stop();          if (FindWindow(pevent->where, &hWnd) == inMenuBar) {
         switch(FindWindow(pevent->where, &hWnd)) {          soundmng_stop();
                 case inMenuBar:          HandleMenuChoice(MenuSelect(pevent->where));
                         HandleMenuChoice(MenuSelect(pevent->where));      }
                         break;      else {
         }          ret=mouse_btn(MOUSE_LEFTDOWN);
       }
 }  }
   
   
 // ----  // ----
   
   static void framereset(UINT waitcnt) {
   
           framecnt = 0;
           toolwin_draw((BYTE)waitcnt);
           if (np2oscfg.DISPCLK & 3) {
                   if (sysmng_workclockrenewal()) {
                           sysmng_updatecaption(3);
                   }
           }
   }
   
 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);  
                         }  
                 }  
         }          }
 }  }
   
Line 594  static void flagload(const char *ext) { Line 609  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 & (~NP2FLAG_DISKCHG)) {
                   ResumeErrorDialogProc();
                   ret = IDCANCEL;
           }
           else if (r & NP2FLAG_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;  
     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[]) {
   
     EventRef            theEvent;      EventRef            theEvent;
Line 653  int main(int argc, char *argv[]) { Line 636  int main(int argc, char *argv[]) {
 #ifdef OPENING_WAIT  #ifdef OPENING_WAIT
         UINT32          tick;          UINT32          tick;
 #endif  #endif
     
         dosio_init();          dosio_init();
         file_setcd(target);          file_setcd(target);
   
Line 664  int main(int argc, char *argv[]) { Line 647  int main(int argc, char *argv[]) {
         initload();          initload();
   
         TRACEINIT();          TRACEINIT();
       
       toolwin_readini();
     if (!(setupMainWindow())) {      if (!(setupMainWindow())) {
         return(0);          return(0);
     }      }
Line 785  int main(int argc, char *argv[]) { Line 769  int main(int argc, char *argv[]) {
                                                 else {                                                  else {
                                                         timing_setcount(cnt - framecnt);                                                          timing_setcount(cnt - framecnt);
                                                 }                                                  }
                                                 processwait(0);                                                  framereset(0);
                                         }                                          }
                                 }                                  }
                                 else {                                  else {
Line 825  int main(int argc, char *argv[]) { Line 809  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();                                             // np2.cfg create
               toolwin_writeini();                         // np2.cfg append
         }          }
         TRACETERM();          TRACETERM();
         macossub_term();          macossub_term();
         dosio_term();          dosio_term();
   
         DisposeWindow(hWndMain);          DisposeWindow(hWndMain);
       toolwin_close();
   
         (void)argc;          (void)argc;
         (void)argv;          (void)argv;
Line 841  int main(int argc, char *argv[]) { Line 827  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);
   
Line 866  static pascal OSStatus np2appevent (Even Line 850  static pascal OSStatus np2appevent (Even
 #endif  #endif
                   
     switch (eventClass)      switch (eventClass)
         {      {
                 case kEventClassAppleEvent:            case kEventClassAppleEvent:  
                     if (whatHappened == kEventAppleEvent) {              if (whatHappened == kEventAppleEvent) {
                         AEProcessAppleEvent(&eve);                  AEProcessAppleEvent(&eve);
                     }              }
                     break;              break;
   
                 case kEventClassMouse:           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);                      GetEventParameter (event, kEventParamMouseDelta, typeHIPoint, NULL, sizeof(HIPoint), NULL, &delta);
                             mouse_callback(delta);                      mouse_callback(delta);
                             result = noErr;                      result = noErr;
                             break;                      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);
                             }                      }
                             else {                      else {
                                 HandleMouseDown(&eve);                          HandleMouseDown(&eve);
                             }                      }
                             result=noErr;                      result=noErr;
                             break;                      break;
                         case kEventMouseUp:                  case kEventMouseUp:
                             if (buttonKind == kEventMouseButtonSecondary | modif & controlKey) {                      if (buttonKind == kEventMouseButtonSecondary | modif & controlKey) {
                                 ret=mouse_btn(MOUSE_RIGHTUP);                          ret=mouse_btn(MOUSE_RIGHTUP);
                             }                      }
                             else if (buttonKind == kEventMouseButtonTertiary) {                      else if (buttonKind == kEventMouseButtonTertiary) {
                                 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);
                             }                      }
                             else {                      else {
                                 ret=mouse_btn(MOUSE_LEFTUP);                          ret=mouse_btn(MOUSE_LEFTUP);
                             }                      }
                             result=noErr;                      result=noErr;
                             break;                          break;    
                         }                  }
 #else  #else
                                                 if (whatHappened == kEventMouseDown) {                  if (whatHappened == kEventMouseDown) {
                                                         HandleMouseDown(&eve);                      HandleMouseDown(&eve);
                                                 }                  }
 #endif  #endif
                         break;                  break;
             default:          default:
                     break;               break; 
         }      }
   
         (void)myHandlerChain;          (void)myHandlerChain;
         (void)userData;          (void)userData;
Line 927  static pascal OSStatus np2windowevent(Ev Line 911  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);
     eventClass = GetEventClass(event);      eventClass = GetEventClass(event);
     whatHappened = GetEventKind(event);      whatHappened = GetEventKind(event);
                   
       static UInt32 backup = 0;
     switch (eventClass)      switch (eventClass)
         {              {        
             case kEventClassWindow:          case kEventClassKeyboard:
                 switch (whatHappened)              UInt32 key;
                 {              GetEventParameter (event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &key);
                     case kEventWindowClose:              UInt32 modif;
                         np2running = FALSE;              GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modif);
                         result = noErr;              switch (whatHappened)
                         break;              {
                     case kEventWindowShowing:                  case kEventRawKeyUp:
                         scrndraw_redraw();                      mackbd_keyup(key);
                        break;                      result = noErr;
                     case kEventWindowActivated:                      break;
                         DisableAllMenuItems(GetMenuHandle(IDM_EDIT));                  case kEventRawKeyRepeat:
                         break;                      mackbd_keydown(key);
                 }                      result = noErr;
                 break;                      break;
             case kEventClassKeyboard:                  case kEventRawKeyDown:
                 UInt32 key;                      if (modif & cmdKey) {
                 GetEventParameter (event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &key);                          EventRecord     eve;
                 UInt32 modif;                          ConvertEventRefToEventRecord( event,&eve );
                 GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modif);                          HandleMenuChoice(MenuEvent(&eve));
                 switch (whatHappened)                      }
                 {                      else {
                     case kEventRawKeyUp:                          mackbd_keydown(key);
                         mackbd_f12up(key);                      }
                         result = noErr;                      result = noErr;
                         break;                      break;
                     case kEventRawKeyRepeat:                  case kEventRawKeyModifiersChanged:
                         mackbd_f12down(key);                      if (modif & shiftKey) keystat_senddata(0x70);
                         result = noErr;                      else keystat_senddata(0x70 | 0x80);
                         break;                      if (modif & optionKey) keystat_senddata(0x73);
                     case kEventRawKeyDown:                      else keystat_senddata(0x73 | 0x80);
                         if (modif & cmdKey) {                      if (modif & controlKey) keystat_senddata(0x74);
                             EventRecord eve;                      else keystat_senddata(0x74 | 0x80);
                             ConvertEventRefToEventRecord( event,&eve );                      if ((modif & alphaLock) != (backup & alphaLock)) {
                             HandleMenuChoice(MenuEvent(&eve));                          keystat_senddata(0x71);
                         }                          backup = modif;
                         else {                      }
                             mackbd_f12down(key);                      result = noErr;
                         }                      break;
                         result = noErr;                  default: 
                         break;                      break;             
                     case kEventRawKeyModifiersChanged:              }
                         if (modif & shiftKey) keystat_senddata(0x70);              break;
                         else keystat_senddata(0x70 | 0x80);              
                         if (modif & optionKey) keystat_senddata(0x73);          case kEventClassWindow:
                         else keystat_senddata(0x73 | 0x80);              switch (whatHappened)
                         if (modif & controlKey) keystat_senddata(0x74);              {
                         else keystat_senddata(0x74 | 0x80);                  case kEventWindowClose:
                         if ((modif & alphaLock) != (backup & alphaLock)) {                      taskmng_exit();
                             keystat_senddata(0x71);                      result = noErr;
                             backup = modif;                      break;
                         }                  case kEventWindowActivated:
                         result = noErr;                      DisableAllMenuItems(GetMenuHandle(IDM_EDIT));
                         break;                      break;
                     default:                   case kEventWindowToolbarSwitchMode:
                         break;                                   toolwin_open();
                 }                      break;
             default:                   case kEventWindowDragStarted:
                 break;                                      soundmng_stop();
         }                      break;
                   case kEventWindowDragCompleted:
                       soundmng_play();
                       break;
                   case kEventWindowShown:
                       scrndraw_redraw();
                       break;
               }
               break;
           default: 
               break;                
       }
   
         (void)myHandler;          (void)myHandler;
         (void)userData;          (void)userData;
Line 1013  static const EventTypeSpec appEventList[ Line 1008  static const EventTypeSpec appEventList[
   
 static const EventTypeSpec windEventList[] = {  static const EventTypeSpec windEventList[] = {
                                 {kEventClassWindow,             kEventWindowClose},                                  {kEventClassWindow,             kEventWindowClose},
                                 {kEventClassWindow,             kEventWindowShowing},  
                                 {kEventClassWindow,             kEventWindowActivated},                                  {kEventClassWindow,             kEventWindowActivated},
                                   {kEventClassWindow,             kEventWindowToolbarSwitchMode},
                                   {kEventClassWindow,             kEventWindowDragStarted},
                                   {kEventClassWindow,             kEventWindowDragCompleted},
                                   {kEventClassWindow,             kEventWindowShown},
                                 {kEventClassKeyboard,   kEventRawKeyDown},                                  {kEventClassKeyboard,   kEventRawKeyDown},
                                 {kEventClassKeyboard,   kEventRawKeyUp},                                  {kEventClassKeyboard,   kEventRawKeyUp},
                                 {kEventClassKeyboard,   kEventRawKeyRepeat},                                  {kEventClassKeyboard,   kEventRawKeyRepeat},
Line 1031  static void setUpCarbonEvent(void) { Line 1029  static void setUpCarbonEvent(void) {
         InstallWindowEventHandler(hWndMain, NewEventHandlerUPP(np2windowevent),          InstallWindowEventHandler(hWndMain, NewEventHandlerUPP(np2windowevent),
                                                                 GetEventTypeCount(windEventList),                                                                  GetEventTypeCount(windEventList),
                                                                 windEventList, 0, NULL);                                                                  windEventList, 0, NULL);
     InstallStandardEventHandler(GetWindowEventTarget(hWndMain));  
 }  }
   
 bool setupMainWindow(void) {  static bool setupMainWindow(void) {
 #if defined(NP2GCC) && 0  #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  #else
     Rect wRect;      Rect wRect;
           
Line 1090  static void toggleFullscreen(void) { Line 1099  static void toggleFullscreen(void) {
     soundmng_play();      soundmng_play();
 }  }
   
 void toggleMenubar(void) {  void recieveCommand(long param) {
     if (scrnmode & SCRNMODE_FULLSCREEN) {      HandleMenuChoice(param);
         if (!np2oscfg.MOUSE_SW) {  
             ShowMenuBar();  
         }  
         else {  
             HideMenuBar();  
         }  
     }  
 }  }
   
Removed from v.1.25  
changed lines
  Added in v.1.33

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