//------------------------------------------------------------------------------------- // InputPanelHandler //------------------------------------------------------------------------------------- // Deal with events in our prompt panel. We merely respond to the cancel and OK commands // that are sent from the push buttons and terminate our modal loop. If OK is pressed, // we get the string and store it in our PanelInfo structure. // static OSStatus InputPanelHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData ) { HICommand command; OSStatus result = eventNotHandledErr; PanelInfo* info = (PanelInfo*)inUserData; GetEventParameter( inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof( HICommand ), NULL, &command ); if ( command.commandID == kHICommandCancel ) { QuitAppModalLoopForWindow( info->window ); result = noErr; } else if ( command.commandID == kHICommandOK ) { HIViewRef textField; HIViewFindByID( HIViewGetRoot( info->window ), kTextFieldID, &textField ); GetControlData( textField, 0, kControlEditTextCFStringTag, sizeof( CFStringRef ), &info->string, NULL ); QuitAppModalLoopForWindow( info->window ); } return result; }
static pascal OSStatus PickMonitorHandler( EventHandlerCallRef inHandler, EventRef inEvent, void* inUserData ) { #pragma unused( inHandler ) HICommand cmd; OSStatus result = eventNotHandledErr; WindowRef theWindow = (WindowRef)inUserData; // The direct object for a 'process commmand' event is the HICommand. // Extract it here and switch off the command ID. GetEventParameter( inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof( cmd ), NULL, &cmd ); switch ( cmd.commandID ) { case kHICommandOK: QuitAppModalLoopForWindow( theWindow ); result = noErr; break; case kHICommandCancel: // Setting sSelectedDevice to zero will signal that the user cancelled. sSelectedDevice = 0; QuitAppModalLoopForWindow( theWindow ); result = noErr; break; } return result; }
OSStatus simpleDialogHandler(EventHandlerCallRef handler, EventRef event, void *userdata) { OSStatus result = eventNotHandledErr; OSStatus err; UInt32 evtClass = GetEventClass(event); UInt32 evtKind = GetEventKind(event); WindowRef window = (WindowRef)userdata; if((evtClass == kEventClassCommand) && (evtKind == kEventCommandProcess)) { HICommand cmd; err = GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL, sizeof(cmd), NULL, &cmd); if(err == noErr) { switch(cmd.commandID) { case kHICommandOK: QuitAppModalLoopForWindow(window); result = noErr; break; case kHICommandCancel: QuitAppModalLoopForWindow(window); result = userCanceledErr; break; } } } return(result); }
static pascal OSStatus group_setting_event_proc(EventHandlerCallRef handler,EventRef event,void *data) { HICommand cmd; switch (GetEventKind(event)) { case kEventProcessCommand: GetEventParameter(event,kEventParamDirectObject,typeHICommand,NULL,sizeof(HICommand),NULL,&cmd); switch (cmd.commandID) { case kHICommandCancel: dialog_group_settings_cancel=TRUE; QuitAppModalLoopForWindow(dialog_group_settings_wind); return(noErr); case kHICommandOK: QuitAppModalLoopForWindow(dialog_group_settings_wind); return(noErr); } return(eventNotHandledErr); } return(eventNotHandledErr); }
static pascal OSStatus animation_settings_event_proc(EventHandlerCallRef handler,EventRef event,void *data) { HICommand cmd; switch (GetEventKind(event)) { case kEventProcessCommand: GetEventParameter(event,kEventParamDirectObject,typeHICommand,NULL,sizeof(HICommand),NULL,&cmd); switch (cmd.commandID) { // pose list buttons case kAnimationPoseAdd: dialog_pose_move_idx=model_animate_pose_insert(&model,dialog_animate_idx,dialog_pose_move_idx,0); dialog_pose_move_settings_load(); dialog_pose_list_reset(); return(noErr); case kAnimationPoseSub: if (model.animates[dialog_animate_idx].npose_move<=1) return(noErr); model_animate_pose_delete(&model,dialog_animate_idx,dialog_pose_move_idx); if (dialog_pose_move_idx>=model.animates[dialog_animate_idx].npose_move) dialog_pose_move_idx=0; dialog_pose_move_settings_load(); dialog_pose_list_reset(); return(noErr); case kAnimationPoseLoopStart: model_animate_set_loop_start(&model,dialog_animate_idx,dialog_pose_move_idx); dialog_pose_list_reset(); return(noErr); case kAnimationPoseLoopEnd: model_animate_set_loop_end(&model,dialog_animate_idx,dialog_pose_move_idx); dialog_pose_list_reset(); return(noErr); // dialog buttons case kAnimationPosePlay: model_wind_play(!play_animate,FALSE); return(noErr); case kHICommandCancel: dialog_animation_settings_cancel=TRUE; QuitAppModalLoopForWindow(dialog_animation_settings_wind); return(noErr); case kHICommandOK: QuitAppModalLoopForWindow(dialog_animation_settings_wind); return(noErr); } return(eventNotHandledErr); } return(eventNotHandledErr); }
static pascal OSStatus MacOSXDialogCommandProcess(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void* inUserData) { HICommand aCommand; OSStatus status = eventNotHandledErr; GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &aCommand); switch (aCommand.commandID) { case kHICommandOK: // we got a valid click on the OK button so let's quit our local run loop QuitAppModalLoopForWindow((WindowRef) inUserData); break; case 'CBED': { // we still enable or disable the custom spot view depending on whether the box is checked or not HIViewRef checkBox = ((HICommandExtended *)&aCommand)->source.control; SInt32 enable = GetControl32BitValue(checkBox); HIViewID hidcsv = {0, 13}; HIViewRef customSpotView; HIViewFindByID(HIViewGetRoot(GetControlOwner(checkBox)), hidcsv, &customSpotView); if (enable) ActivateControl(customSpotView); else DeactivateControl(customSpotView); HIViewSetNeedsDisplay(customSpotView, true); } break; } return status; }
//------------------------------------------------------------------------------------------------------- pascal OSStatus windowHandler (EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData) { OSStatus result = eventNotHandledErr; WindowRef window = (WindowRef) inUserData; UInt32 eventClass = GetEventClass (inEvent); UInt32 eventKind = GetEventKind (inEvent); switch (eventClass) { case kEventClassWindow: { switch (eventKind) { case kEventWindowClose: { QuitAppModalLoopForWindow (window); break; } } break; } } return result; }
pascal OSStatus AutofireWindowEventHandler(EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { #pragma unused (inHandlerRef) OSStatus err, result = eventNotHandledErr; WindowRef tWindowRef = (WindowRef) inUserData; switch (GetEventClass(inEvent)) { case kEventClassWindow: switch (GetEventKind(inEvent)) { case kEventWindowClose: QuitAppModalLoopForWindow(tWindowRef); result = noErr; } break; case kEventClassCommand: switch (GetEventKind(inEvent)) { case kEventCommandProcess: HICommand tHICommand; HIViewRef root; int player = -1; root = HIViewGetRoot(tWindowRef); err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, nil, sizeof(HICommand), nil, &tHICommand); if (err == noErr) { switch (tHICommand.commandID) { case 'DEF1': player = 0; break; case 'DEF2': player = 1; break; } if (player != -1) { autofireRec[player].buttonMask = 0x0000; autofireRec[player].toggleMask = 0xFFF0; autofireRec[player].tcMask = 0x0000; autofireRec[player].invertMask = 0x0000; autofireRec[player].frequency = 10; AutofireReadAllSettings(player + 1, root); result = noErr; } } } } return result; }
// Dialog event handler pascal OSStatus DialogWindowEventHandler (EventHandlerCallRef myHandler, EventRef event, void *userData) { OSStatus result = eventNotHandledErr; HICommand command; bool stopModalLoop = FALSE; // Get the HI Command GetEventParameter (event, kEventParamDirectObject, typeHICommand, NULL, sizeof (HICommand), NULL, &command); // Look for our 'YES ' and 'NO ' commands switch (command.commandID) { case 'YES ': HandleResponse(TRUE); stopModalLoop = TRUE; result = noErr; break; case 'NO ': HandleResponse(FALSE); stopModalLoop = TRUE; result = noErr; break; } // Stop the modal loop. if (stopModalLoop) { QuitAppModalLoopForWindow((WindowRef)userData); } //Return how we handled the event. return result; }
OSStatus dialogHandler(EventHandlerCallRef handler, EventRef event, void *userdata) { OSStatus result = eventNotHandledErr; OSStatus err; UInt32 evtClass = GetEventClass(event); UInt32 evtKind = GetEventKind(event); if((evtClass == kEventClassCommand) && (evtKind == kEventCommandProcess)) { HICommand cmd; err = GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL, sizeof(cmd), NULL, &cmd); if(err == noErr) { switch(cmd.commandID) { case kHICommandCancel: gCancelled = true; // QuitAppModalLoopForWindow(gWindow); result = noErr; break; } } } else if((evtClass == kEventClassCustom) && (evtKind == kEventCustomProgress)) { // Request to update the progress dialog long cur = 0; long max = 0; CFStringRef text = NULL; (void) GetEventParameter(event, kEventParamCustomCurValue, typeLongInteger, NULL, sizeof(cur), NULL, &cur); (void) GetEventParameter(event, kEventParamCustomMaxValue, typeLongInteger, NULL, sizeof(max), NULL, &max); (void) GetEventParameter(event, kEventParamCustomText, typeCFStringRef, NULL, sizeof(text), NULL, &text); err = setProgress(cur, max); if(err == noErr) { if(text != NULL) { setProgressText(text); } } result = noErr; } else if((evtClass == kEventClassCustom) && (evtKind == kEventCustomDone)) { // We're done. Exit the modal loop. QuitAppModalLoopForWindow(gWindow); result = noErr; } return(result); }
static pascal OSStatus set_vertex_bone_event_proc(EventHandlerCallRef handler,EventRef event,void *data) { int major_bone_idx,minor_bone_idx,bone_factor; HICommand cmd; switch (GetEventKind(event)) { case kEventProcessCommand: GetEventParameter(event,kEventParamDirectObject,typeHICommand,NULL,sizeof(HICommand),NULL,&cmd); switch (cmd.commandID) { case kHICommandCancel: dialog_set_vertex_bone_cancel=TRUE; QuitAppModalLoopForWindow(dialog_set_vertex_bone_wind); return(noErr); case kHICommandOK: // check factor bone_factor=((float)dialog_get_int(dialog_set_vertex_bone_wind,kVertexPercentage,0))/100.0; if (bone_factor!=1) { major_bone_idx=dialog_get_bone_combo(dialog_set_vertex_bone_wind,kVertexMajorBone,0); minor_bone_idx=dialog_get_bone_combo(dialog_set_vertex_bone_wind,kVertexMinorBone,0); if ((major_bone_idx==-1) || (minor_bone_idx==-1)) { StandardAlert(0,"\pBone Factors","\pYou need both a major and minor bone to set the factor to anything but 100%",NULL,NULL); return(noErr); } } // ok to end QuitAppModalLoopForWindow(dialog_set_vertex_bone_wind); return(noErr); }
void GDialog::EndModal(int Code) { if (d->IsModal) { d->IsModal = false; d->ModalStatus = Code; QuitAppModalLoopForWindow(Wnd); } else { LgiAssert(0); } }
static pascal OSStatus RomInfoEventHandler (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { OSStatus err, result = eventNotHandledErr; WindowRef tWindowRef = (WindowRef) inUserData; switch (GetEventClass(inEvent)) { case kEventClassWindow: switch (GetEventKind(inEvent)) { case kEventWindowClose: QuitAppModalLoopForWindow(tWindowRef); result = noErr; } break; case kEventClassCommand: switch (GetEventKind(inEvent)) { HICommand tHICommand; case kEventCommandUpdateStatus: err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr && tHICommand.commandID == 'clos') { UpdateMenuCommandStatus(true); result = noErr; } break; case kEventCommandProcess: err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr) { switch (tHICommand.commandID) { case 'Clip': RomInfoCopyToClipboard(); result = noErr; } } } } return (result); }
pascal OSStatus DefaultEventHandler(EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { #pragma unused (inHandlerRef) OSStatus result = eventNotHandledErr; WindowRef tWindowRef = (WindowRef) inUserData; switch (GetEventClass(inEvent)) { case kEventClassWindow: switch (GetEventKind(inEvent)) { case kEventWindowClose: QuitAppModalLoopForWindow(tWindowRef); result = noErr; } } return result; }
static pascal OSStatus RomInfoEventHandler(EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { #pragma unused (inHandlerRef) OSStatus err, result = eventNotHandledErr; WindowRef tWindowRef = (WindowRef) inUserData; switch (GetEventClass(inEvent)) { case kEventClassWindow: switch (GetEventKind(inEvent)) { case kEventWindowClose: QuitAppModalLoopForWindow(tWindowRef); result = noErr; } break; case kEventClassCommand: switch (GetEventKind(inEvent)) { case kEventCommandProcess: HICommand tHICommand; err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, nil, sizeof(HICommand), nil, &tHICommand); if (err == noErr) { switch (tHICommand.commandID) { case 'Clip': RomInfoCopyToClipboard(); result = noErr; } } } } return result; }
static pascal void NPServerDialogTimerHandler (EventLoopTimerRef inTimer, void *userData) { WindowRef window = (WindowRef) userData; CFStringRef ref; HIViewRef ctl, root; HIViewID cid; int n = 0; root = HIViewGetRoot(window); for (int c = 0; c < NP_MAX_PLAYERS; c++) { cid.id = c; cid.signature = 'Pnum'; HIViewFindByID(root, cid, &ctl); if (npplayer[c].ready) { char num[4]; num[0] = '1' + n; num[1] = 'P'; num[2] = 0; SetStaticTextCStr(ctl, num, true); n++; } cid.signature = 'IP__'; HIViewFindByID(root, cid, &ctl); if (npplayer[c].online) { ref = CFStringCreateWithCString(kCFAllocatorDefault, npplayer[c].ip, MAC_PATH_ENCODING); if (ref) { SetStaticTextCFString(ctl, ref, true); CFRelease(ref); } else SetStaticTextCFString(ctl, CFSTR("unknown"), true); } else SetStaticTextCFString(ctl, CFSTR(""), true); cid.signature = 'Name'; HIViewFindByID(root, cid, &ctl); if (npplayer[c].online) { ref = CFStringCreateWithCString(kCFAllocatorDefault, npplayer[c].name, MAC_PATH_ENCODING); if (ref) { SetStaticTextCFString(ctl, ref, true); CFRelease(ref); } else SetStaticTextCFString(ctl, CFSTR("unknown"), true); } else SetStaticTextCFString(ctl, CFSTR(""), true); cid.signature = 'Stat'; HIViewFindByID(root, cid, &ctl); if (npplayer[c].online) { if (npplayer[c].ready) ref = CFCopyLocalizedString(CFSTR("NPReady"), "NPReady"); else ref = CFCopyLocalizedString(CFSTR("NPConnecting"), "NPConnecting"); if (ref) { SetStaticTextCFString(ctl, ref, true); CFRelease(ref); } else SetStaticTextCFString(ctl, CFSTR("error"), true); } else SetStaticTextCFString(ctl, CFSTR(""), true); } switch (npserver.dialogprocess) { case kNPSDialogNone: break; case kNPSDialogInit: NPNotification(" kNPSDialogInit", -1); npserver.dialogprocess = kNPSDialogNone; NPServerBeginListenLoop(); break; case kNPSDialogProcess: NPNotification(" kNPSDialogProcess", -1); npserver.dialogprocess = kNPSDialogNone; NPServerEndListenLoop(); cid.id = 0; cid.signature = 'Chse'; HIViewFindByID(root, cid, &ctl); HIViewSetVisible(ctl, true); NPServerDetachProcessThread(); break; case kNPSDialogDone: NPNotification(" kNPSDialogDone", -1); npserver.dialogprocess = kNPSDialogNone; npserver.dialogcancel = false; QuitAppModalLoopForWindow(window); break; case kNPSDialogCancel: NPNotification(" kNPSDialogCancel", -1); npserver.dialogprocess = kNPSDialogNone; NPServerEndListenLoop(); npserver.dialogcancel = true; QuitAppModalLoopForWindow(window); break; } }
OSStatus dialogHandler(EventHandlerCallRef handler, EventRef event, void *userdata) { OSStatus result = eventNotHandledErr; OSStatus err; UInt32 evtClass = GetEventClass(event); UInt32 evtKind = GetEventKind(event); if((evtClass == kEventClassCommand) && (evtKind == kEventCommandProcess)) { HICommand cmd; err = GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL, sizeof(cmd), NULL, &cmd); if(err == noErr) { //Get the value of the checkbox ControlID id; ControlRef checkBox = NULL; id.signature = 'remb'; id.id = 0; err = GetControlByID(gWindow, &id, &checkBox); if(err == noErr) { if(GetControl32BitValue(checkBox) == kControlCheckBoxCheckedValue) { gRememberChoice = true; } else { gRememberChoice = false; } } switch(cmd.commandID) { case kHICommandOK: { char buffer[65535]; /* Flawfinder: ignore */ Size size = sizeof(buffer) - 1; ControlRef textField = NULL; id.signature = 'text'; id.id = 0; err = GetControlByID(gWindow, &id, &textField); if(err == noErr) { // Get the user response text err = GetControlData(textField, kControlNoPart, kControlEditTextTextTag, size, (Ptr)buffer, &size); } if(err == noErr) { // Make sure the string is terminated. buffer[size] = 0; gUserNotes = buffer; llinfos << buffer << llendl; } // Send the report. QuitAppModalLoopForWindow(gWindow); gSendReport = true; result = noErr; } break; case kHICommandCancel: QuitAppModalLoopForWindow(gWindow); result = noErr; break; default: result = eventNotHandledErr; } } } return(result); }
static pascal OSStatus MusicBoxEventHandler(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *userData) { #pragma unused (inHandlerCallRef) OSStatus err, result = eventNotHandledErr; WindowRef tWindowRef = (WindowRef) userData; switch (GetEventClass(inEvent)) { case kEventClassCommand: switch (GetEventKind(inEvent)) { HICommand cmd; case kEventCommandUpdateStatus: err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, nil, sizeof(HICommand), nil, &cmd); if (err == noErr && cmd.commandID == 'clos') { UpdateMenuCommandStatus(false); result = noErr; } break; case kEventCommandProcess: err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, nil, sizeof(HICommand), nil, &cmd); if (err == noErr) { HIViewRef root, c1, c2, c3, c4; HIViewID cid; Rect rct; switch (cmd.commandID) { case 'bar1': so.stereo_switch ^= (1 << 0); result = noErr; break; case 'bar2': so.stereo_switch ^= (1 << 1); result = noErr; break; case 'bar3': so.stereo_switch ^= (1 << 2); result = noErr; break; case 'bar4': so.stereo_switch ^= (1 << 3); result = noErr; break; case 'bar5': so.stereo_switch ^= (1 << 4); result = noErr; break; case 'bar6': so.stereo_switch ^= (1 << 5); result = noErr; break; case 'bar7': so.stereo_switch ^= (1 << 6); result = noErr; break; case 'bar8': so.stereo_switch ^= (1 << 7); result = noErr; break; case 'bar9': so.stereo_switch ^= (1 << 8); result = noErr; break; case 'bara': so.stereo_switch ^= (1 << 9); result = noErr; break; case 'barb': so.stereo_switch ^= (1 << 10); result = noErr; break; case 'barc': so.stereo_switch ^= (1 << 11); result = noErr; break; case 'bard': so.stereo_switch ^= (1 << 12); result = noErr; break; case 'bare': so.stereo_switch ^= (1 << 13); result = noErr; break; case 'barf': so.stereo_switch ^= (1 << 14); result = noErr; break; case 'bar0': so.stereo_switch ^= (1 << 15); result = noErr; break; case 'Paus': mboxPause = !mboxPause; S9xSetSoundMute(mboxPause); result = noErr; break; case 'Tr_i': showIndicator = !showIndicator; root = HIViewGetRoot(tWindowRef); cid.id = 0; cid.signature = 'Pane'; HIViewFindByID(root, cid, &c1); HIViewSetVisible(c1, false); cid.signature = 'iMaG'; HIViewFindByID(root, cid, &c2); HIViewSetVisible(c2, false); cid.signature = 'rCTL'; HIViewFindByID(root, cid, &c3); HIViewSetVisible(c3, false); cid.signature = 'bCTL'; HIViewFindByID(root, cid, &c4); HIViewSetVisible(c4, false); GetWindowBounds(tWindowRef, kWindowStructureRgn, &rct); rct.bottom = rct.top + (showIndicator ? mbxOpenedHeight : mbxClosedHeight); err = TransitionWindow(tWindowRef, kWindowSlideTransitionEffect, kWindowResizeTransitionAction, &rct); HIViewSetVisible(c1, true); HIViewSetVisible(c2, true); HIViewSetVisible(c3, true); HIViewSetVisible(c4, true); result = noErr; break; case 'DONE': QuitAppModalLoopForWindow(tWindowRef); result = noErr; break; case 'HEAD': showIndicator = !showIndicator; SPCPlayDefrost(); showIndicator = !showIndicator; result = noErr; break; case 'S_EF': HideWindow(tWindowRef); showIndicator = !showIndicator; ConfigureSoundEffects(); showIndicator = !showIndicator; ShowWindow(tWindowRef); result = noErr; } } } } return result; }
static pascal OSStatus PreferencesEventHandler (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { OSStatus err, result = eventNotHandledErr; WindowRef tWindowRef = (WindowRef) inUserData; switch (GetEventClass(inEvent)) { case kEventClassWindow: { switch (GetEventKind(inEvent)) { case kEventWindowClose: { QuitAppModalLoopForWindow(tWindowRef); result = noErr; break; } } break; } case kEventClassCommand: { switch (GetEventKind(inEvent)) { HICommand tHICommand; case kEventCommandUpdateStatus: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr && tHICommand.commandID == 'clos') { UpdateMenuCommandStatus(true); result = noErr; } break; } case kEventCommandProcess: { HIViewRef ctl, root; HIViewID cid; SInt32 value; FSRef ref; bool8 r; root = HIViewGetRoot(tWindowRef); err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr) { switch (tHICommand.commandID) { case 'S_EF': { HideWindow(tWindowRef); ConfigureSoundEffects(); ShowWindow(tWindowRef); result = noErr; break; } case 'G_FL': { if (systemVersion >= 0x1040) { HideWindow(tWindowRef); ConfigureCoreImageFilter(); ShowWindow(tWindowRef); } result = noErr; break; } case 'G__7': { cid.signature = 'grap'; cid.id = iNibGGLStretch; HIViewFindByID(root, cid, &ctl); value = GetControl32BitValue(ctl); cid.id = iNibGAspectRatio; HIViewFindByID(root, cid, &ctl); if (value) ActivateControl(ctl); else DeactivateControl(ctl); result = noErr; break; } case 'G_13': { cid.signature = 'grap'; cid.id = iNibGScreenCurvature; HIViewFindByID(root, cid, &ctl); value = GetControl32BitValue(ctl); cid.id = iNibGCurvatureWarp; HIViewFindByID(root, cid, &ctl); if (value) ActivateControl(ctl); else DeactivateControl(ctl); result = noErr; break; } case 'S__3': { cid.signature = 'snd_'; cid.id = iNibSStereo; HIViewFindByID(root, cid, &ctl); value = GetControl32BitValue(ctl); cid.id = iNibSReverseStereo; HIViewFindByID(root, cid, &ctl); if (value) ActivateControl(ctl); else DeactivateControl(ctl); result = noErr; break; } case 'F_FL': { UInt32 modifierkey; err = GetEventParameter(inEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifierkey); if (err == noErr) { if (modifierkey & optionKey) { CFStringRef str; MenuRef menu; str = CFCopyLocalizedString(CFSTR("NoneSelected"), "NoneSelected"); cid.signature = 'othe'; cid.id = iNibOSaveFolder; HIViewFindByID(root, cid, &ctl); SetControl32BitValue(ctl, 3); err = GetControlData(ctl, kControlMenuPart, kControlPopupButtonMenuRefTag, sizeof(MenuRef), &menu, NULL); err = SetMenuItemTextWithCFString(menu, iNibSaveFolderNameMenuItem, str); DisableMenuItem(menu, iNibSaveFolderNameMenuItem); HIViewSetNeedsDisplay(ctl, true); CFRelease(str); if (saveFolderPath) CFRelease(saveFolderPath); saveFolderPath = NULL; } else r = NavBeginChooseFolderSheet(tWindowRef); } result = noErr; break; } case 'NvDn': { r = NavEndChooseFolderSheet(&ref); if (r) { CFStringRef str; CFURLRef url; MenuRef menu; url = CFURLCreateFromFSRef(kCFAllocatorDefault, &ref); str = CFURLCopyLastPathComponent(url); cid.signature = 'othe'; cid.id = iNibOSaveFolder; HIViewFindByID(root, cid, &ctl); SetControl32BitValue(ctl, iNibSaveFolderNameMenuItem); err = GetControlData(ctl, kControlMenuPart, kControlPopupButtonMenuRefTag, sizeof(MenuRef), &menu, NULL); err = SetMenuItemTextWithCFString(menu, iNibSaveFolderNameMenuItem, str); EnableMenuItem(menu, iNibSaveFolderNameMenuItem); HIViewSetNeedsDisplay(ctl, true); CFRelease(str); str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); if (saveFolderPath) CFRelease(saveFolderPath); saveFolderPath = str; CFRelease(url); } result = noErr; break; } } } break; } } break; } } return (result); }
static pascal OSStatus MultiCartEventHandler (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { OSStatus err, result = eventNotHandledErr; WindowRef window = (WindowRef) inUserData; static int index = -1; switch (GetEventClass(inEvent)) { case kEventClassCommand: { switch (GetEventKind(inEvent)) { HICommand tHICommand; case kEventCommandUpdateStatus: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr && tHICommand.commandID == 'clos') { UpdateMenuCommandStatus(false); result = noErr; } break; } case kEventCommandProcess: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr) { HIViewRef ctl, root; HIViewID cid; FSRef ref; bool8 r; root = HIViewGetRoot(window); switch (tHICommand.commandID) { case 'Cho0': case 'Cho1': { index = (tHICommand.commandID & 0xFF) - '0'; r = NavBeginOpenROMImageSheet(window, NULL); result = noErr; break; } case 'NvDn': { r = NavEndOpenROMImageSheet(&ref); if (r) { CFStringRef str; CFURLRef url; url = CFURLCreateFromFSRef(kCFAllocatorDefault, &ref); str = CFURLCopyLastPathComponent(url); cid.signature = 'MNAM'; cid.id = index; HIViewFindByID(root, cid, &ctl); SetStaticTextCFString(ctl, str, true); CFRelease(str); str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); if (multiCartPath[index]) CFRelease(multiCartPath[index]); multiCartPath[index] = str; CFRelease(url); } index = -1; result = noErr; break; } case 'Cle0': case 'Cle1': { index = (tHICommand.commandID & 0xFF) - '0'; cid.signature = 'MNAM'; cid.id = index; HIViewFindByID(root, cid, &ctl); SetStaticTextCFString(ctl, CFSTR(""), true); if (multiCartPath[index]) { CFRelease(multiCartPath[index]); multiCartPath[index] = NULL; } index = -1; result = noErr; break; } case 'SWAP': { CFStringRef str; CFURLRef url; str = multiCartPath[0]; multiCartPath[0] = multiCartPath[1]; multiCartPath[1] = str; cid.signature = 'MNAM'; for (int i = 0; i < 2; i++) { cid.id = i; HIViewFindByID(root, cid, &ctl); if (multiCartPath[i]) { url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, multiCartPath[i], kCFURLPOSIXPathStyle, false); str = CFURLCopyLastPathComponent(url); SetStaticTextCFString(ctl, str, true); CFRelease(str); CFRelease(url); } else SetStaticTextCFString(ctl, CFSTR(""), true); } result = noErr; break; } case 'ok ': { QuitAppModalLoopForWindow(window); multiCartDialogResult = true; result = noErr; break; } case 'not!': { QuitAppModalLoopForWindow(window); multiCartDialogResult = false; result = noErr; break; } } } } } } } return (result); }
static pascal OSStatus CheatEventHandler (EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData) { OSStatus err, result = eventNotHandledErr; WindowRef tWindowRef; tWindowRef = (WindowRef) inUserData; switch (GetEventClass(inEvent)) { case kEventClassWindow: switch (GetEventKind(inEvent)) { case kEventWindowClose: QuitAppModalLoopForWindow(tWindowRef); result = noErr; break; } break; case kEventClassCommand: switch (GetEventKind(inEvent)) { HICommand tHICommand; case kEventCommandUpdateStatus: err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr && tHICommand.commandID == 'clos') { UpdateMenuCommandStatus(true); result = noErr; } break; case kEventCommandProcess: err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr) { switch (tHICommand.commandID) { case kNewButton: AddCheatItem(); result = noErr; break; case kDelButton: DeleteCheatItem(); result = noErr; break; case kAllButton: EnableAllCheatItems(); result = noErr; } } } } return (result); }
void wxModalEventLoop::DoStop() { wxMacAutoreleasePool autoreleasepool; QuitAppModalLoopForWindow(m_modalNativeWindow); }
static pascal void NPClientDialogTimerHandler (EventLoopTimerRef inTimer, void *userData) { WindowRef window = (WindowRef) userData; HIViewRef ctl; HIViewID cid = { 'CHAS', 0 }; HIViewFindByID(HIViewGetRoot(mRef), cid, &ctl); switch (npclient.dialogprocess) { case kNPCDialogNone: break; case kNPCDialogCancel: NPNotification(" kNPCDialogCancel", -1); npclient.dialogprocess = kNPCDialogNone; npclient.dialogcancel = true; QuitAppModalLoopForWindow(mRef); break; case kNPCDialogInit: NPNotification(" kNPCDialogInit", -1); npclient.dialogprocess = kNPCDialogNone; break; case kNPCDialogConnect: NPNotification(" kNPCDialogConnect", -1); npclient.dialogprocess = kNPCDialogNone; HIViewSetVisible(ctl, true); NPClientDetachConnectThread(); break; case kNPCDialogConnectFailed: NPNotification(" kNPCDialogConnectFailed", -1); npclient.dialogprocess = kNPCDialogNone; npclient.dialogcancel = true; QuitAppModalLoopForWindow(mRef); break; case kNPCDialogOpenBegin: NPNotification(" kNPCDialogOpenBegin", -1); npclient.dialogprocess = kNPCDialogNone; HIViewSetVisible(ctl, false); NPClientStoreConfig(); if (!NPClientBeginOpenROMImage(window)) { NPClientDisconnect(); NPClientRestoreConfig(); npclient.dialogprocess = kNPCDialogCancel; } break; case kNPCDialogOpenEnd: NPNotification(" kNPCDialogOpenEnd", -1); npclient.dialogprocess = kNPCDialogNone; if (!NPClientEndOpenROMImage()) { NPClientDisconnect(); NPClientRestoreConfig(); npclient.dialogprocess = kNPCDialogCancel; } else npclient.dialogprocess = kNPCDialogPrepare; break; case kNPCDialogPrepare: NPNotification(" kNPCDialogPrepare", -1); npclient.dialogprocess = kNPCDialogNone; HIViewSetVisible(ctl, true); NPClientDetachPrepareThread(); break; case kNPCDialogPrepareFailed: NPNotification(" kNPCDialogPrepareFailed", -1); npclient.dialogprocess = kNPCDialogNone; NPClientRestoreConfig(); npclient.dialogcancel = true; QuitAppModalLoopForWindow(mRef); break; case kNPCDialogShowList: NPNotification(" kNPCDialogShowList", -1); npclient.dialogprocess = kNPCDialogNone; HIViewSetVisible(ctl, false); npclient.dialogsheet = true; NPClientBeginPlayerListSheet(); break; case kNPCDialogDone: NPNotification(" kNPCDialogDone", -1); npclient.dialogprocess = kNPCDialogNone; NPClientEndPlayerListSheet(); npclient.dialogsheet = false; npclient.dialogcancel = false; QuitAppModalLoopForWindow(mRef); break; } }
static pascal OSStatus ControllerEventHandler (EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData) { OSStatus err, result = eventNotHandledErr; WindowRef tWindowRef; tWindowRef = (WindowRef) inUserData; switch (GetEventClass(inEvent)) { case kEventClassWindow: switch (GetEventKind(inEvent)) { case kEventWindowClose: QuitAppModalLoopForWindow(tWindowRef); result = noErr; break; } break; case kEventClassCommand: switch (GetEventKind(inEvent)) { HICommand tHICommand; case kEventCommandUpdateStatus: err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr && tHICommand.commandID == 'clos') { UpdateMenuCommandStatus(true); result = noErr; } break; case kEventCommandProcess: err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr) { if (tHICommand.commandID == 'CLRa') { ClearPadSetting(); result = noErr; } else { SInt32 command = -1, count; for (count = 0; count < kNeedCount; count++) if (tHICommand.commandID == gControlIDs[count].signature) command = count; if (command >= 0) { pRecDevice pDevice; pRecElement pElement; FlushEventQueue(GetCurrentEventQueue()); if (HIDConfigureAction(&pDevice, &pElement, 2.5f)) { if (command < MAC_MAX_PLAYERS * 4) // Direction { int i = command >> 2; // Player long curv = HIDGetElementValue(pDevice, pElement); if (pElement->usage == kHIDUsage_GD_Hatswitch) // Hat Switch { gActionRecs[kUp(i)].fDevice = gActionRecs[kDn(i)].fDevice = gActionRecs[kLf(i)].fDevice = gActionRecs[kRt(i)].fDevice = pDevice; gActionRecs[kUp(i)].fElement = gActionRecs[kDn(i)].fElement = gActionRecs[kLf(i)].fElement = gActionRecs[kRt(i)].fElement = pElement; if (pDevice->vendorID == 1103) // Thrustmaster gDirectionInfo[i].type = (pElement->max > 4) ? kPadElemTypeOtherHat8 : kPadElemTypeOtherHat4; else { if (pElement->max > 4) { if (((command % 4 == 0) && (curv == 0)) || // Up : 0 ((command % 4 == 1) && (curv == 4)) || // Down : 4 ((command % 4 == 2) && (curv == 6)) || // Left : 6 ((command % 4 == 3) && (curv == 2))) // Right : 2 gDirectionInfo[i].type = kPadElemTypeOtherHat8; else gDirectionInfo[i].type = kPadElemTypeHat8; } else { if (((command % 4 == 0) && (curv == 0)) || // Up : 0 ((command % 4 == 1) && (curv == 2)) || // Down : 2 ((command % 4 == 2) && (curv == 3)) || // Left : 3 ((command % 4 == 3) && (curv == 1))) // Right : 1 gDirectionInfo[i].type = kPadElemTypeOtherHat4; else gDirectionInfo[i].type = kPadElemTypeHat4; } } gDirectionInfo[i].device [kPadHat] = pDevice; gDirectionInfo[i].element[kPadHat] = pElement; gDirectionInfo[i].max [kPadHat] = pElement->max; gDirectionInfo[i].min [kPadHat] = pElement->min; } else if (pElement->max - pElement->min > 1) // Axis (maybe) { if ((command % 4 == 0) || (command % 4 == 1)) // Up or Dn { gActionRecs[kUp(i)].fDevice = gActionRecs[kDn(i)].fDevice = pDevice; gActionRecs[kUp(i)].fElement = gActionRecs[kDn(i)].fElement = pElement; gDirectionInfo[i].type = kPadElemTypeAxis; gDirectionInfo[i].device [kPadYAxis] = pDevice; gDirectionInfo[i].element[kPadYAxis] = pElement; gDirectionInfo[i].max [kPadYAxis] = pElement->max; gDirectionInfo[i].min [kPadYAxis] = pElement->min; gDirectionInfo[i].mid [kPadYAxis] = (gDirectionInfo[i].max[kPadYAxis] + gDirectionInfo[i].min[kPadYAxis]) >> 1; gDirectionInfo[i].maxmid [kPadYAxis] = (gDirectionInfo[i].max[kPadYAxis] + gDirectionInfo[i].mid[kPadYAxis]) >> 1; gDirectionInfo[i].midmin [kPadYAxis] = (gDirectionInfo[i].mid[kPadYAxis] + gDirectionInfo[i].min[kPadYAxis]) >> 1; } else // Lf or Rt { gActionRecs[kLf(i)].fDevice = gActionRecs[kRt(i)].fDevice = pDevice; gActionRecs[kLf(i)].fElement = gActionRecs[kRt(i)].fElement = pElement; gDirectionInfo[i].type = kPadElemTypeAxis; gDirectionInfo[i].device [kPadXAxis] = pDevice; gDirectionInfo[i].element[kPadXAxis] = pElement; gDirectionInfo[i].max [kPadXAxis] = pElement->max; gDirectionInfo[i].min [kPadXAxis] = pElement->min; gDirectionInfo[i].mid [kPadXAxis] = (gDirectionInfo[i].max[kPadXAxis] + gDirectionInfo[i].min[kPadXAxis]) >> 1; gDirectionInfo[i].maxmid [kPadXAxis] = (gDirectionInfo[i].max[kPadXAxis] + gDirectionInfo[i].mid[kPadXAxis]) >> 1; gDirectionInfo[i].midmin [kPadXAxis] = (gDirectionInfo[i].mid[kPadXAxis] + gDirectionInfo[i].min[kPadXAxis]) >> 1; } } else // Button (maybe) { gActionRecs[command].fDevice = pDevice; gActionRecs[command].fElement = pElement; gDirectionInfo[i].type = kPadElemTypeButton; } gDirectionHint[i] = gDirectionInfo[i].type; } else { gActionRecs[command].fDevice = pDevice; gActionRecs[command].fElement = pElement; } }