/**
* @param argc argument count
* @param argv array of argument strings
*
* Executes the application
* (contains main game loop)
*/
int SpringApp::Run(int argc, char *argv[])
{
cmdline = new CmdLineParams(argc, argv);
binaryName = argv[0];
if (!Initialize())
return -1;
GML::Init();
while (!gu->globalQuit) {
ResetScreenSaverTimeout();
{
SCOPED_TIMER("InputHandler::PushEvents");
SDL_Event event;
while (SDL_PollEvent(&event)) {
input.PushEvent(event);
}
}
if (!Update())
break;
}
SaveWindowPosition();
// Shutdown
Shutdown();
return 0;
}
/**
* Executes the application
* (contains main game loop)
*/
int SpringApp::Run()
{
try {
if (!Initialize())
return -1;
}
CATCH_SPRING_ERRORS
while (!gu->globalQuit) {
Watchdog::ClearTimer(WDT_MAIN);
input.PushEvents();
if (gu->globalReload) {
Reload(gameSetup->setupText);
} else {
if (!Update()) {
break;
}
}
}
SaveWindowPosition();
ShutDown();
LOG("[SpringApp::%s] exitCode=%d", __FUNCTION__, GetExitCode());
return (GetExitCode());
}
void DlgPropSheet::OnDestroy() {
CRect rc;
GetWindowRect(rc);
SaveWindowPosition(rc);
theApp.m_pMainWnd = &theApp.m_wnd;
CPropertySheet::OnDestroy();
}
void DeInitDownloadDlg()
{
if(sgProduct.mode != SILENT)
{
SaveWindowPosition(dlgInfo.hWndDlg);
DestroyWindow(dlgInfo.hWndDlg);
UnregisterClass("GaugeFile", hInst);
}
}
bool8 NPServerDialog (void)
{
OSStatus err;
IBNibRef nibRef;
npserver.dialogcancel = true;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
WindowRef tWindowRef;
err = CreateWindowFromNib(nibRef, CFSTR("ClientList"), &tWindowRef);
if (err == noErr)
{
EventHandlerRef eref;
EventLoopTimerRef tref;
EventHandlerUPP eventUPP;
EventLoopTimerUPP timerUPP;
EventTypeSpec windowEvents[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } };
HIViewRef ctl;
HIViewID cid = { 'Chse', 0 };
npserver.dialogprocess = kNPSDialogInit;
eventUPP = NewEventHandlerUPP(NPServerDialogEventHandler);
err = InstallWindowEventHandler(tWindowRef, eventUPP, GetEventTypeCount(windowEvents), windowEvents, (void *) tWindowRef, &eref);
timerUPP = NewEventLoopTimerUPP(NPServerDialogTimerHandler);
err = InstallEventLoopTimer(GetCurrentEventLoop(), 0.0f, 0.1f, timerUPP, (void *) tWindowRef, &tref);
HIViewFindByID(HIViewGetRoot(tWindowRef), cid, &ctl);
HIViewSetVisible(ctl, false);
MoveWindowPosition(tWindowRef, kWindowServer, false);
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowServer);
err = RemoveEventLoopTimer(tref);
DisposeEventLoopTimerUPP(timerUPP);
err = RemoveEventHandler(eref);
DisposeEventHandlerUPP(eventUPP);
CFRelease(tWindowRef);
}
DisposeNibReference(nibRef);
}
return (!npserver.dialogcancel);
}
/*----------------------------------------------------------------------------------------------
Save settings specific to this window.
----------------------------------------------------------------------------------------------*/
void DcMainWnd::SaveSettings(const achar * pszRoot, bool fRecursive)
{
AssertPszN(pszRoot);
SuperClass::SaveSettings(pszRoot, fRecursive);
SaveWindowPosition(pszRoot, "Position");
FwSettings * pfws;
pfws = AfApp::GetSettings();
// TODO: Use methods defined on pfws to save settings.
}
/*----------------------------------------------------------------------------------------------
Save settings specific to this window.
----------------------------------------------------------------------------------------------*/
void HwMainWnd::SaveSettings(const achar * pszRoot, bool fRecursive)
{
AssertPszN(pszRoot);
SuperClass::SaveSettings(pszRoot, fRecursive);
SaveWindowPosition(pszRoot, "Position");
FwSettings * pfws;
pfws = AfApp::GetSettings();
// TODO: Use methods defined on pfws to save settings.
// Store the settings for the toolbars.
SaveToolbars(pfws, pszRoot, "Toolbar Flags");
}
void cMainWindow::OnDestroy()
{
// Save the visited history
std::list<string_t> items;
const size_t n = comboBoxPath.GetItemCount();
for (size_t i = 0; i < n; i++) items.push_back(comboBoxPath.GetItem(i));
settings.SetPreviousPhotoBrowserFolders(items);
settings.SetLastPhotoBrowserFolder(comboBoxPath.GetText());
SaveWindowPosition();
photoBrowserViewController.Destroy();
photoBrowserView.Destroy();
comboBoxPath.Destroy();
scrollBar.Destroy();
}
Boolean MultiCartDialog (void)
{
OSStatus err;
IBNibRef nibRef;
multiCartDragHilite = -1;
multiCartDialogResult = false;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
WindowRef window;
err = CreateWindowFromNib(nibRef, CFSTR("MultiCart"), &window);
if (err == noErr)
{
static int index[2] = { 0, 1 };
EventHandlerRef wRef, cRef[2];
EventHandlerUPP wUPP, cUPP[2];
EventTypeSpec wEvent[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } },
cEvent[] = { { kEventClassControl, kEventControlDraw },
{ kEventClassControl, kEventControlDragEnter },
{ kEventClassControl, kEventControlDragWithin },
{ kEventClassControl, kEventControlDragLeave },
{ kEventClassControl, kEventControlDragReceive } };
HIViewRef ctl, root, pane[2];
HIViewID cid;
root = HIViewGetRoot(window);
wUPP = NewEventHandlerUPP(MultiCartEventHandler);
err = InstallWindowEventHandler(window, wUPP, GetEventTypeCount(wEvent), wEvent, (void *) window, &wRef);
err = SetAutomaticControlDragTrackingEnabledForWindow(window, true);
for (int i = 0; i < 2; i++)
{
cid.id = i;
cid.signature = 'MPan';
HIViewFindByID(root, cid, &pane[i]);
cUPP[i] = NewEventHandlerUPP(MultiCartPaneEventHandler);
err = InstallControlEventHandler(pane[i], cUPP[i], GetEventTypeCount(cEvent), cEvent, (void *) &index[i], &cRef[i]);
err = SetControlDragTrackingEnabled(pane[i], true);
cid.signature = 'MNAM';
HIViewFindByID(root, cid, &ctl);
SetStaticTextTrunc(ctl, truncEnd, false);
if (multiCartPath[i])
{
CFStringRef str;
CFURLRef url;
url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, multiCartPath[i], kCFURLPOSIXPathStyle, false);
str = CFURLCopyLastPathComponent(url);
SetStaticTextCFString(ctl, str, false);
CFRelease(str);
CFRelease(url);
}
else
SetStaticTextCFString(ctl, CFSTR(""), false);
}
MoveWindowPosition(window, kWindowMultiCart, false);
ShowWindow(window);
err = RunAppModalLoopForWindow(window);
HideWindow(window);
SaveWindowPosition(window, kWindowMultiCart);
for (int i = 0; i < 2; i++)
{
err = RemoveEventHandler(cRef[i]);
DisposeEventHandlerUPP(cUPP[i]);
}
err = RemoveEventHandler(wRef);
DisposeEventHandlerUPP(wUPP);
CFRelease(window);
}
DisposeNibReference(nibRef);
}
return (multiCartDialogResult);
}
void ConfigureCheat (void)
{
if (!cartOpen)
return;
OSStatus err;
IBNibRef nibRef;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
err = CreateWindowFromNib(nibRef, CFSTR("CheatEntry"), &wRef);
if (err == noErr)
{
DataBrowserCallbacks callbacks;
EventHandlerRef eref;
EventHandlerUPP eUPP;
EventTypeSpec events[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus },
{ kEventClassWindow, kEventWindowClose } };
HIViewRef ctl, root;
HIViewID cid;
root = HIViewGetRoot(wRef);
cid.id = 0;
cid.signature = kDataBrowser;
HIViewFindByID(root, cid, &dbRef);
#ifdef MAC_PANTHER_SUPPORT
if (systemVersion < 0x1040)
{
HISize minSize;
Rect rct;
GetWindowBounds(wRef, kWindowContentRgn, &rct);
minSize.width = (float) (rct.right - rct.left);
minSize.height = (float) (rct.bottom - rct.top );
err = SetWindowResizeLimits(wRef, &minSize, NULL);
}
#endif
callbacks.version = kDataBrowserLatestCallbacks;
err = InitDataBrowserCallbacks(&callbacks);
callbacks.u.v1.itemDataCallback = NewDataBrowserItemDataUPP(DBClientDataCallback);
callbacks.u.v1.itemCompareCallback = NewDataBrowserItemCompareUPP(DBCompareCallBack);
callbacks.u.v1.itemNotificationCallback = NewDataBrowserItemNotificationUPP(DBItemNotificationCallBack);
err = SetDataBrowserCallbacks(dbRef, &callbacks);
if (systemVersion >= 0x1040)
err = DataBrowserChangeAttributes(dbRef, kDataBrowserAttributeListViewAlternatingRowColors, kDataBrowserAttributeNone);
InitCheatItems();
ImportCheatItems();
DataBrowserItemID *id;
id = new DataBrowserItemID[MAC_MAX_CHEATS];
if (!id)
QuitWithFatalError(0, "cheat 01");
numofcheats = 0;
for (unsigned int i = 0; i < MAC_MAX_CHEATS; i++)
{
if (citem[i].valid)
{
id[numofcheats] = citem[i].id;
numofcheats++;
}
}
if (numofcheats)
err = AddDataBrowserItems(dbRef, kDataBrowserNoItem, numofcheats, id, kDataBrowserItemNoProperty);
delete [] id;
cid.signature = kNewButton;
HIViewFindByID(root, cid, &ctl);
if (numofcheats == MAC_MAX_CHEATS)
err = DeactivateControl(ctl);
else
err = ActivateControl(ctl);
cid.signature = kAllButton;
HIViewFindByID(root, cid, &ctl);
if (numofcheats == 0)
err = DeactivateControl(ctl);
else
err = ActivateControl(ctl);
cid.signature = kDelButton;
HIViewFindByID(root, cid, &ctl);
err = DeactivateControl(ctl);
eUPP = NewEventHandlerUPP(CheatEventHandler);
err = InstallWindowEventHandler(wRef, eUPP, GetEventTypeCount(events), events, (void *) wRef, &eref);
err = SetKeyboardFocus(wRef, dbRef, kControlFocusNextPart);
MoveWindowPosition(wRef, kWindowCheatEntry, true);
ShowWindow(wRef);
err = RunAppModalLoopForWindow(wRef);
HideWindow(wRef);
SaveWindowPosition(wRef, kWindowCheatEntry);
err = RemoveEventHandler(eref);
DisposeEventHandlerUPP(eUPP);
DisposeDataBrowserItemNotificationUPP(callbacks.u.v1.itemNotificationCallback);
DisposeDataBrowserItemCompareUPP(callbacks.u.v1.itemCompareCallback);
DisposeDataBrowserItemDataUPP(callbacks.u.v1.itemDataCallback);
CFRelease(wRef);
DetachCheatItems();
}
DisposeNibReference(nibRef);
}
}
bool8 NPClientDialog (void)
{
OSStatus err;
IBNibRef nibRef;
npclient.dialogcancel = true;
npclient.dialogsheet = false;
npclient.configsaved = false;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
err = CreateWindowFromNib(nibRef, CFSTR("Connect"), &mRef);
if (err == noErr)
{
err = CreateWindowFromNib(nibRef, CFSTR("PlayerList"), &sRef);
if (err == noErr)
{
EventHandlerRef eref, seref;
EventLoopTimerRef tref;
EventHandlerUPP eventUPP, sheetUPP;
EventLoopTimerUPP timerUPP;
EventTypeSpec windowEvents[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } };
CFStringRef ref;
HIViewRef ctl, root;
HIViewID cid;
npclient.dialogprocess = kNPCDialogInit;
eventUPP = NewEventHandlerUPP(NPClientDialogEventHandler);
err = InstallWindowEventHandler(mRef, eventUPP, GetEventTypeCount(windowEvents), windowEvents, (void *) mRef, &eref);
timerUPP = NewEventLoopTimerUPP(NPClientDialogTimerHandler);
err = InstallEventLoopTimer(GetCurrentEventLoop(), 0.0f, 0.1f, timerUPP, (void *) mRef, &tref);
sheetUPP = NewEventHandlerUPP(NPClientSheetEventHandler);
err = InstallWindowEventHandler(sRef, sheetUPP, GetEventTypeCount(windowEvents), windowEvents, (void *) sRef, &seref);
root = HIViewGetRoot(mRef);
cid.id = 0;
cid.signature = 'CHAS';
HIViewFindByID(root, cid, &ctl);
HIViewSetVisible(ctl, false);
cid.signature = 'SVIP';
HIViewFindByID(root, cid, &ctl);
SetEditTextCStr(ctl, npServerIP, false);
cid.signature = 'CLNM';
HIViewFindByID(root, cid, &ctl);
ref = CFStringCreateWithCString(kCFAllocatorDefault, npName, kCFStringEncodingUTF8);
if (ref)
{
SetEditTextCFString(ctl, ref, false);
CFRelease(ref);
}
else
SetEditTextCFString(ctl, CFSTR("unknown"), false);
MoveWindowPosition(mRef, kWindowClient, false);
ShowWindow(mRef);
err = HIViewAdvanceFocus(root, 0);
err = RunAppModalLoopForWindow(mRef);
HideWindow(mRef);
SaveWindowPosition(mRef, kWindowClient);
err = RemoveEventHandler(seref);
DisposeEventHandlerUPP(sheetUPP);
err = RemoveEventLoopTimer(tref);
DisposeEventLoopTimerUPP(timerUPP);
err = RemoveEventHandler(eref);
DisposeEventHandlerUPP(eventUPP);
CFRelease(sRef);
}
CFRelease(mRef);
}
DisposeNibReference(nibRef);
}
return (!npclient.dialogcancel);
}
bool SpringApp::MainEventHandler(const SDL_Event& event)
{
switch (event.type) {
case SDL_WINDOWEVENT: {
switch (event.window.event) {
case SDL_WINDOWEVENT_MOVED: {
SaveWindowPosition();
} break;
//case SDL_WINDOWEVENT_RESIZED: //this is event is always preceded by:
case SDL_WINDOWEVENT_SIZE_CHANGED: {
Watchdog::ClearTimer(WDT_MAIN, true);
SaveWindowPosition();
InitOpenGL();
activeController->ResizeEvent();
mouseInput->InstallWndCallback();
} break;
case SDL_WINDOWEVENT_SHOWN: {
// reactivate sounds and other
globalRendering->active = true;
if (ISound::IsInitialized()) {
sound->Iconified(false);
}
if (globalRendering->fullScreen) {
FBO::GLContextReinit();
}
} break;
case SDL_WINDOWEVENT_HIDDEN: {
// deactivate sounds and other
globalRendering->active = false;
if (ISound::IsInitialized()) {
sound->Iconified(true);
}
if (globalRendering->fullScreen) {
FBO::GLContextLost();
}
} break;
case SDL_WINDOWEVENT_FOCUS_GAINED: {
// update keydown table
KeyInput::Update(0, ((keyBindings != NULL)? keyBindings->GetFakeMetaKey(): -1));
} break;
case SDL_WINDOWEVENT_FOCUS_LOST: {
Watchdog::ClearTimer(WDT_MAIN, true);
// SDL has some bug and does not update modstate on alt+tab/minimize etc.
//FIXME check if still happens with SDL2 (2013)
SDL_SetModState((SDL_Keymod)(SDL_GetModState() & (KMOD_NUM | KMOD_CAPS | KMOD_MODE)));
// release all keyboard keys
KeyInput::ReleaseAllKeys();
// simulate mouse release to prevent hung buttons
for (int i = 1; i <= NUM_BUTTONS; ++i) {
if (!mouse)
continue;
if (!mouse->buttons[i].pressed)
continue;
SDL_Event event;
event.type = event.button.type = SDL_MOUSEBUTTONUP;
event.button.state = SDL_RELEASED;
event.button.which = 0;
event.button.button = i;
event.button.x = -1;
event.button.y = -1;
SDL_PushEvent(&event);
}
// unlock mouse
if (mouse && mouse->locked) {
mouse->ToggleMiddleClickScroll();
}
// and make sure to un-capture mouse
if (SDL_GetWindowGrab(window))
SDL_SetWindowGrab(window, SDL_FALSE);
break;
}
case SDL_WINDOWEVENT_CLOSE: {
gu->globalQuit = true;
break;
}
};
} break;
case SDL_QUIT: {
gu->globalQuit = true;
} break;
case SDL_TEXTEDITING: {
//FIXME don't known when this is called
} break;
case SDL_TEXTINPUT: {
if (!activeController) {
break;
}
std::string utf8Text = event.text.text;
const bool catched = eventHandler.TextInput(utf8Text);
if (activeController->userWriting && !catched){
auto ac = activeController;
if (ac->ignoreNextChar) {
utf8Text = utf8Text.substr(Utf8NextChar(utf8Text, 0));
}
ac->writingPos = Clamp<int>(ac->writingPos, 0, ac->userInput.length());
ac->userInput.insert(ac->writingPos, utf8Text);
ac->writingPos += utf8Text.length();
}
} break;
case SDL_KEYDOWN: {
KeyInput::Update(event.key.keysym.sym, ((keyBindings != NULL)? keyBindings->GetFakeMetaKey(): -1));
if (activeController) {
activeController->KeyPressed(KeyInput::GetNormalizedKeySymbol(event.key.keysym.sym), event.key.repeat);
}
} break;
case SDL_KEYUP: {
KeyInput::Update(event.key.keysym.sym, ((keyBindings != NULL)? keyBindings->GetFakeMetaKey(): -1));
if (activeController) {
if (activeController->ignoreNextChar) {
activeController->ignoreNextChar = false;
}
activeController->KeyReleased(KeyInput::GetNormalizedKeySymbol(event.key.keysym.sym));
}
} break;
};
return false;
}
void CSimpleFrame::OnMove(wxMoveEvent& event) {
SaveWindowPosition();
event.Skip();
}
void ConfigureExtraOptions (void)
{
OSStatus err;
IBNibRef nibRef;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
WindowRef tWindowRef;
err = CreateWindowFromNib(nibRef, CFSTR("ExtraOptions"), &tWindowRef);
if (err == noErr)
{
EventHandlerRef eref;
EventHandlerUPP eventUPP;
EventTypeSpec windowEvents[] = { { kEventClassWindow, kEventWindowClose },
{ kEventClassCommand, kEventCommandUpdateStatus } };
HIViewRef ctl, root;
HIViewID cid;
root = HIViewGetRoot(tWindowRef);
cid.id = 0;
cid.signature = 'BMrk';
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, extraOptions.benchmark);
cid.signature = 'NoTR';
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, extraOptions.glForceNoTextureRectangle);
cid.signature = 'CSAp';
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, extraOptions.glUseClientStrageApple);
cid.signature = 'AGPT';
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, extraOptions.glUseTexturePriority);
cid.signature = 'Hint';
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, extraOptions.glStorageHint);
eventUPP = NewEventHandlerUPP(DefaultEventHandler);
err = InstallWindowEventHandler(tWindowRef, eventUPP, GetEventTypeCount(windowEvents), windowEvents, (void *) tWindowRef, &eref);
MoveWindowPosition(tWindowRef, kWindowExtra, false);
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowExtra);
cid.signature = 'BMrk';
HIViewFindByID(root, cid, &ctl);
extraOptions.benchmark = GetControl32BitValue(ctl) ? true : false;
cid.signature = 'NoTR';
HIViewFindByID(root, cid, &ctl);
extraOptions.glForceNoTextureRectangle = GetControl32BitValue(ctl) ? true : false;
cid.signature = 'CSAp';
HIViewFindByID(root, cid, &ctl);
extraOptions.glUseClientStrageApple = GetControl32BitValue(ctl) ? true : false;
cid.signature = 'AGPT';
HIViewFindByID(root, cid, &ctl);
extraOptions.glUseTexturePriority = GetControl32BitValue(ctl) ? true : false;
cid.signature = 'Hint';
HIViewFindByID(root, cid, &ctl);
extraOptions.glStorageHint = GetControl32BitValue(ctl);
err = RemoveEventHandler(eref);
DisposeEventHandlerUPP(eventUPP);
CFRelease(tWindowRef);
}
DisposeNibReference(nibRef);
}
}
extern "C" LRESULT CALLBACK osd_hook(HWND wnd, UINT message, WPARAM wparam, LPARAM lparam, BOOL *pfhandled)
{
LRESULT iResult = 0;
static CController* pController = NULL;
static UINT uVPinMAMEAdjustWindowMsg = 0;
static BOOL fMoveWindow = FALSE;
static int iWindowMovedX = 0;
static int iWindowMovedY = 0;
static int iWindowStyle = -1;
switch ( message ) {
// Only some inits
case WM_CREATE:
pController = m_pController;
uVPinMAMEAdjustWindowMsg = RegisterWindowMessage(VPINMAMEADJUSTWINDOWMSG);
*pfhandled = TRUE;
break;
// Clear var for Move window as user drags it with left mouse button!
case WM_LBUTTONUP:
ReleaseCapture();
fMoveWindow = FALSE;
// save the new position to the registry
SaveWindowPosition(wnd, pController);
*pfhandled = TRUE;
break;
// Track vars for Move window as user drags it with left mouse button!
case WM_LBUTTONDOWN:
SetCapture(wnd);
fMoveWindow = TRUE;
RECT windowRect, clientRect;
GetWindowRect(wnd, &windowRect);
GetClientRect(wnd, &clientRect);
ClientToScreen(wnd, (LPPOINT) &clientRect.left);
ClientToScreen(wnd, (LPPOINT) &clientRect.right);
iWindowMovedX = LOWORD(lparam) - (windowRect.left-clientRect.left);
iWindowMovedY = HIWORD(lparam) - (windowRect.top-clientRect.top);
*pfhandled = TRUE;
break;
// Move window as user drags it with left mouse button!
case WM_MOUSEMOVE:
if ( fMoveWindow ) {
POINT pt = {(short) LOWORD(lparam), (short) HIWORD(lparam)};
ClientToScreen(wnd, &pt);
SetWindowPos(wnd, 0, pt.x-iWindowMovedX, pt.y-iWindowMovedY, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
}
*pfhandled = TRUE;
break;
// Show context menu if the user uses the right mouse button
case WM_RBUTTONUP:
// Get the menu from the resource
HMENU hMenu;
hMenu = GetSubMenu(LoadMenu(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_CTXMENU)), 0);
// Check the proper entry for the current display mode
switch ( iWindowStyle ) {
case 0: // title + border
CheckMenuItem(hMenu, ID_CTRLCTXMENU_DISPLAY_TITLE, MF_BYCOMMAND|MF_CHECKED);
CheckMenuItem(hMenu, ID_CTRLCTXMENU_DISPLAY_BORDER, MF_BYCOMMAND|MF_CHECKED);
break;
case 1: // no title
CheckMenuItem(hMenu, ID_CTRLCTXMENU_DISPLAY_TITLE, MF_BYCOMMAND|MF_UNCHECKED);
CheckMenuItem(hMenu, ID_CTRLCTXMENU_DISPLAY_BORDER, MF_BYCOMMAND|MF_CHECKED);
break;
case 2: // borderless
CheckMenuItem(hMenu, ID_CTRLCTXMENU_DISPLAY_TITLE, MF_BYCOMMAND|MF_UNCHECKED);
CheckMenuItem(hMenu, ID_CTRLCTXMENU_DISPLAY_BORDER, MF_BYCOMMAND|MF_UNCHECKED);
break;
}
POINT Pos;
Pos.x = LOWORD(lparam);
Pos.y = HIWORD(lparam);
ClientToScreen(wnd, &Pos);
TrackPopupMenu(hMenu, TPM_LEFTALIGN|TPM_TOPALIGN|TPM_LEFTBUTTON, Pos.x, Pos.y, 0, wnd, NULL);
*pfhandled = TRUE;
break;
// If the display is locked, return the active window state
// to the previous one
case WM_ACTIVATE:
if ( !pController->m_fDisplayLocked )
return 0;
if ( wparam==WA_INACTIVE )
return 0;
::SetActiveWindow((HWND) lparam);
*pfhandled = TRUE;
break;
// On destroy, save the current window position for future use
case WM_DESTROY:
SaveWindowPosition(wnd, pController);
*pfhandled = TRUE;
break;
// handle the messages from the context menu
case WM_COMMAND:
switch ( LOWORD(wparam) ) {
case ID_CTRLCTXMENU_GAMEOPTIONS:
pController->m_pGameSettings->ShowSettingsDlg(0);
*pfhandled = TRUE;
break;
case ID_CTRLCTXMENU_PATHES:
pController->m_pControllerSettings->ShowSettingsDlg(0);
*pfhandled = TRUE;
break;
case ID_CTRLCTXMENU_DISPLAY_TITLE:
{
CComVariant vValue((VARIANT_BOOL) VARIANT_TRUE);
pController->m_pGameSettings->put_Value(CComBSTR("dmd_border"), vValue);
vValue = (VARIANT_BOOL)((iWindowStyle == 0) ? VARIANT_FALSE : VARIANT_TRUE);
pController->m_pGameSettings->put_Value(CComBSTR("dmd_title"), vValue);
}
*pfhandled = TRUE;
break;
case ID_CTRLCTXMENU_DISPLAY_BORDER:
{
CComVariant vValue((VARIANT_BOOL) VARIANT_FALSE);
pController->m_pGameSettings->put_Value(CComBSTR("dmd_title"), vValue);
vValue = (VARIANT_BOOL)((iWindowStyle == 2) ? VARIANT_TRUE : VARIANT_FALSE);
pController->m_pGameSettings->put_Value(CComBSTR("dmd_border"), vValue);
}
*pfhandled = TRUE;
break;
#if 0 // not needed in new flat menu
case ID_CTRLCTXMENU_DISPLAY_DMDONLY:
{
CComVariant vValue((VARIANT_BOOL) VARIANT_FALSE);
pController->m_pGameSettings->put_Value(CComBSTR("dmd_title"), vValue);
pController->m_pGameSettings->put_Value(CComBSTR("dmd_border"), vValue);
}
*pfhandled = TRUE;
break;
#endif
case ID_CTRLCTXMENU_DISPLAY_RESTORESIZE:
{
CComVariant vValue((int) 0);
pController->m_pGameSettings->put_Value(CComBSTR("dmd_width"), vValue);
pController->m_pGameSettings->put_Value(CComBSTR("dmd_height"), vValue);
*pfhandled = TRUE;
}
break;
case ID_CTRLCTXMENU_INFO:
ShowAboutDlg(wnd);
*pfhandled = TRUE;
break;
case ID_CTRLCTXMENU_STOPEMULATION:
PostMessage(wnd, WM_CLOSE, 0, 0);
*pfhandled = TRUE;
break;
}
}
// adjust the window layout
if ( message==uVPinMAMEAdjustWindowMsg ) {
iWindowStyle = 0;
if ( !dmd_title ) {
if ( dmd_border )
iWindowStyle = 1; // Border without title
else
iWindowStyle = 2; // No border
}
SetWindowStyle(wnd, iWindowStyle);
AdjustWindowPosition(wnd, pController);
*pfhandled = TRUE;
iResult = 1;
}
return iResult;
}
void ConfigureAutofire (void)
{
OSStatus err;
IBNibRef nibRef;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
WindowRef tWindowRef;
err = CreateWindowFromNib(nibRef, CFSTR("AutoFire"), &tWindowRef);
if (err == noErr)
{
EventHandlerRef wRef, tRef;
EventHandlerUPP wUPP, tUPP;
EventTypeSpec wEvent[] = { { kEventClassWindow, kEventWindowClose },
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } },
tEvent[] = { { kEventClassControl, kEventControlHit } };
ControlActionUPP actionUPP;
HIViewRef ctl, root;
HIViewID cid;
root = HIViewGetRoot(tWindowRef);
wUPP = NewEventHandlerUPP(AutofireWindowEventHandler);
err = InstallWindowEventHandler(tWindowRef, wUPP, GetEventTypeCount(wEvent), wEvent, (void *) tWindowRef, &wRef);
cid.signature = 'Ftab';
cid.id = 256;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, autofireLastTabIndex);
AutofireSelectTabPane(ctl, autofireLastTabIndex);
tUPP = NewEventHandlerUPP(AutofireTabEventHandler);
err = InstallControlEventHandler(ctl, tUPP, GetEventTypeCount(tEvent), tEvent, 0, &tRef);
actionUPP = NewControlActionUPP(AutofireSliderActionProc);
for (int player = 0; player < 2; player++)
{
AutofireSetAllIconImages(player + 1, root);
AutofireReadAllSettings(player + 1, root);
cid.id = player + 1;
cid.signature = 'Slid';
HIViewFindByID(root, cid, &ctl);
SetControlAction(ctl, actionUPP);
}
MoveWindowPosition(tWindowRef, kWindowAutoFire, false);
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowAutoFire);
for (int player = 0; player < 2; player++)
AutofireWriteAllSettings(player + 1, root);
autofire = (autofireRec[0].buttonMask || autofireRec[1].buttonMask) ? true : false;
err = RemoveEventHandler(tRef);
DisposeEventHandlerUPP(tUPP);
err = RemoveEventHandler(wRef);
DisposeEventHandlerUPP(wUPP);
DisposeControlActionUPP(actionUPP);
CFRelease(tWindowRef);
}
DisposeNibReference(nibRef);
}
}
void AboutDialog (void)
{
OSStatus err;
IBNibRef nibRef;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
WindowRef tWindowRef;
err = CreateWindowFromNib(nibRef, CFSTR("About"), &tWindowRef);
if (err == noErr)
{
EventHandlerRef eref;
EventHandlerUPP eventUPP;
EventTypeSpec windowEvents[] = { { kEventClassWindow, kEventWindowClose },
{ kEventClassCommand, kEventCommandUpdateStatus } };
ControlFontStyleRec frec;
HIViewRef ctl, root;
HIViewID cid;
char text[32];
err = ChangeWindowAttributes(tWindowRef, kWindowNoAttributes, kWindowInWindowMenuAttribute);
if (systemVersion >= 0x1040)
frec.font = FMGetFontFromATSFontRef(ATSFontFindFromName(CFSTR("Lucida Grande"), kATSOptionFlagsDefault));
#ifdef MAC_PANTHER_SUPPORT
else
frec.font = kThemeSystemFont;
#endif
frec.just = teCenter;
root = HIViewGetRoot(tWindowRef);
cid.id = 0;
cid.signature = 'VERS';
HIViewFindByID(root, cid, &ctl);
sprintf(text, "Version %s (%s)", VERSION, MAC_VERSION);
SetStaticTextCStr(ctl, text, false);
frec.flags = kControlUseFontMask | kControlUseSizeMask | kControlUseJustMask;
frec.size = 10;
err = SetControlFontStyle(ctl, &frec);
cid.signature = 'NAME';
HIViewFindByID(root, cid, &ctl);
frec.flags = kControlUseFontMask | kControlUseSizeMask | kControlUseFaceMask | kControlUseJustMask;
frec.size = 14;
frec.style = 1;
err = SetControlFontStyle(ctl, &frec);
eventUPP = NewEventHandlerUPP(DefaultEventHandler);
err = InstallWindowEventHandler(tWindowRef, eventUPP, GetEventTypeCount(windowEvents), windowEvents, (void *) tWindowRef, &eref);
MoveWindowPosition(tWindowRef, kWindowAbout, false);
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowAbout);
err = RemoveEventHandler(eref);
DisposeEventHandlerUPP(eventUPP);
CFRelease(tWindowRef);
}
DisposeNibReference(nibRef);
}
}
void RomInfoDialog (void)
{
OSStatus err;
IBNibRef nibRef;
if (!cartOpen)
return;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
WindowRef tWindowRef;
err = CreateWindowFromNib(nibRef, CFSTR("RomInfo"), &tWindowRef);
if (err == noErr)
{
EventHandlerRef eref;
EventHandlerUPP eventUPP;
EventTypeSpec windowEvents[] = { { kEventClassWindow, kEventWindowClose },
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } };
CFStringRef sref;
HIViewRef ctl, root;
HIViewID cid;
char text[256];
eventUPP = NewEventHandlerUPP(RomInfoEventHandler);
err = InstallWindowEventHandler(tWindowRef, eventUPP, GetEventTypeCount(windowEvents), windowEvents, (void *) tWindowRef, &eref);
root = HIViewGetRoot(tWindowRef);
cid.id = 0;
cid.signature = 'Name'; // Cart Name
HIViewFindByID(root, cid, &ctl);
strcpy(text, Memory.RawROMName);
sref = CopyFixNameStrings(text, Memory.ROMRegion);
if (!sref)
SetStaticTextCFString(ctl, CFSTR("unknown"), false);
else
{
SetStaticTextCFString(ctl, sref, false);
CFRelease(sref);
}
cid.signature = 'Code'; // Game Code
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%s", Memory.ROMId);
SetStaticTextCStr(ctl, text, false);
cid.signature = 'Cont'; // Contents
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%s", Memory.KartContents());
SetStaticTextCStr(ctl, text, false);
cid.signature = 'Map '; // ROM Map
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%s", Memory.MapType());
SetStaticTextCStr(ctl, text, false);
cid.signature = 'Spee'; // ROM Speed
HIViewFindByID(root, cid, &ctl);
sprintf(text, "0x%02X (%s)", Memory.ROMSpeed, ((Memory.ROMSpeed & 0x10) != 0) ? "FastROM" : "SlowROM");
SetStaticTextCStr(ctl, text, false);
cid.signature = 'Type'; // ROM Type
HIViewFindByID(root, cid, &ctl);
sprintf(text, "0x%02X", Memory.ROMType);
SetStaticTextCStr(ctl, text, false);
cid.signature = 'SizC'; // Actual ROM Size
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%dMbits", Memory.CalculatedSize / 0x20000);
SetStaticTextCStr(ctl, text, false);
cid.signature = 'SizH'; // ROM Size written in info block
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%s", Memory.Size());
SetStaticTextCStr(ctl, text, false);
cid.signature = 'SRAM'; // SRAM Size
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%s", Memory.StaticRAMSize());
SetStaticTextCStr(ctl, text, false);
cid.signature = 'SumC'; // Actual checksum
HIViewFindByID(root, cid, &ctl);
sprintf(text, "0x%04X", Memory.CalculatedChecksum);
SetStaticTextCStr(ctl, text, false);
cid.signature = 'SumH'; // Checksum written in info block
HIViewFindByID(root, cid, &ctl);
sprintf(text, "0x%04X", Memory.ROMChecksum);
SetStaticTextCStr(ctl, text, false);
cid.signature = 'ComH'; // Checksum complement written in info block : SumH + ComH = 0xFFFF
HIViewFindByID(root, cid, &ctl);
sprintf(text, "0x%04X", Memory.ROMComplementChecksum);
SetStaticTextCStr(ctl, text, false);
cid.signature = 'Outp'; // Video output (NTSC or PAL)
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%s", (Memory.ROMRegion > 12 || Memory.ROMRegion < 2) ? "NTSC 60Hz" : "PAL 50Hz");
SetStaticTextCStr(ctl, text, false);
cid.signature = 'Vers'; // Revision
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%s", Memory.Revision());
SetStaticTextCStr(ctl, text, false);
cid.signature = 'Lice'; // Licensee
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%s", Memory.PublishingCompany());
SetStaticTextCStr(ctl, text, false);
cid.signature = 'Regi'; // Region
HIViewFindByID(root, cid, &ctl);
sprintf(text, "%s", Memory.Country());
SetStaticTextCStr(ctl, text, false);
cid.signature = 'CRC '; // CRC32
HIViewFindByID(root, cid, &ctl);
sprintf(text, "0x%08X", Memory.ROMCRC32);
SetStaticTextCStr(ctl, text, false);
MoveWindowPosition(tWindowRef, kWindowRomInfo, false);
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowRomInfo);
err = RemoveEventHandler(eref);
DisposeEventHandlerUPP(eventUPP);
CFRelease(tWindowRef);
}
DisposeNibReference(nibRef);
}
}
void MusicBoxDialog(void)
{
OSStatus err;
IBNibRef nibRef;
if (!cartOpen)
return;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
CFURLRef iconURL;
FSRef iconFSRef;
IconRef actIcon;
WindowRef tWindowRef;
actIcon = nil;
if (musicboxmode == kMBXSoundEmulation)
iconURL = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("musicbox_ledoff"), CFSTR("icns"), nil);
else
iconURL = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("musicbox_ledon" ), CFSTR("icns"), nil);
if (iconURL)
{
if (CFURLGetFSRef(iconURL, &iconFSRef))
err = RegisterIconRefFromFSRef('~9X~', 'micn', &iconFSRef, &actIcon);
CFRelease(iconURL);
}
err = CreateWindowFromNib(nibRef, CFSTR("MusicBox"), &tWindowRef);
if (err == noErr)
{
EventHandlerRef mboxRef, paneRef;
EventHandlerUPP mboxUPP, paneUPP;
EventLoopTimerRef timeRef;
EventLoopTimerUPP timeUPP;
EventTypeSpec mboxEvents[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } },
paneEvents[] = { { kEventClassControl, kEventControlDraw } };
CFStringRef sref;
CGDataProviderRef prov;
CGImageRef ipng;
CFURLRef iurl;
HIViewRef ctl, root, paneView, imageView, contentView;
HIViewID cid;
HIRect bounds;
Rect windowRect, barRect;
char drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT];
mboxPause = false;
mbxFinished = false;
showIndicator = false;
so.stereo_switch = ~0;
for (int i = 0; i < MAC_MAX_PLAYERS; i++)
controlPad[i] = 0;
switch (drawingMethod)
{
case kDrawingOpenGL:
Settings.OpenGLEnable = true;
break;
case kDrawingDirect:
case kDrawingBlitGL:
Settings.OpenGLEnable = false;
}
// 107's enhanced SPC player
root = HIViewGetRoot(tWindowRef);
cid.id = 0;
if (musicboxmode == kMBXSoundEmulation)
{
cid.signature = 'HEAD';
HIViewFindByID(root, cid, &ctl);
EnableControl(ctl);
StoredAPU = new SAPU;
StoredAPURegisters = new SAPURegisters;
StoredSoundData = new SSoundData;
StoredIAPURAM = new uint8 [0x10000];
SPCPlayFreeze();
}
else
MusicBoxForceFreeze();
cid.signature = 'Kart';
HIViewFindByID(root, cid, &ctl);
SetStaticTextTrunc(ctl, truncEnd, false);
_splitpath(Memory.ROMFilename, drive, dir, fname, ext);
sref = CFStringCreateWithCString(kCFAllocatorDefault, fname, MAC_PATH_ENCODING);
if (sref)
{
SetStaticTextCFString(ctl, sref, false);
CFRelease(sref);
}
ipng = nil;
iurl = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("musicbox_indicator"), CFSTR("png"), nil);
if (iurl)
{
prov = CGDataProviderCreateWithURL(iurl);
if (prov)
{
ipng = CGImageCreateWithPNGDataProvider(prov, nil, false, kCGRenderingIntentDefault);
CGDataProviderRelease(prov);
}
CFRelease(iurl);
}
imageView = nil;
if (ipng)
{
HIViewFindByID(root, kHIViewWindowContentID, &contentView);
err = HIImageViewCreate(ipng, &imageView);
if (err == noErr)
{
bounds = CGRectMake(30, 64, CGImageGetWidth(ipng), CGImageGetHeight(ipng));
HIViewSetFrame(imageView, &bounds);
HIImageViewSetOpaque(imageView, false);
HIViewSetVisible(imageView, true);
HIViewAddSubview(contentView, imageView);
cid.signature = 'iMaG';
SetControlID(imageView, &cid);
}
CGImageRelease(ipng);
}
cid.signature = 'Pane';
HIViewFindByID(root, cid, &paneView);
HIViewGetBounds(paneView, &bounds);
mbxViewWidth = bounds.size.width;
mbxViewHeight = bounds.size.height;
mbxMarginY = (mbxViewHeight - mbxBarHeight) / 2.0;
mbxMarginX = (mbxViewWidth - ((mbxBarWidth * 8.0 + mbxBarSpace * 7.0) * 2.0 + mbxLRSpace)) / 2.0;
if (imageView)
{
HIViewSetZOrder(imageView, kHIViewZOrderBelow, paneView);
HIViewAddSubview(imageView, paneView);
}
cid.signature = 'Tr_i';
HIViewFindByID(root, cid, &ctl);
HIViewGetFrame(ctl, &bounds);
GetWindowBounds(tWindowRef, kWindowTitleBarRgn, &barRect);
mbxClosedHeight = (short) (bounds.origin.y + bounds.size.height + 7.0) + (barRect.bottom - barRect.top);
GetWindowBounds(tWindowRef, kWindowStructureRgn, &windowRect);
mbxOpenedHeight = windowRect.bottom - windowRect.top;
windowRect.bottom = windowRect.top + mbxClosedHeight;
SetWindowBounds(tWindowRef, kWindowStructureRgn, &windowRect);
paneUPP = NewEventHandlerUPP(IndicatorEventHandler);
err = InstallControlEventHandler(paneView, paneUPP, GetEventTypeCount(paneEvents), paneEvents, (void *) paneView, &paneRef);
mboxUPP = NewEventHandlerUPP(MusicBoxEventHandler);
err = InstallWindowEventHandler(tWindowRef, mboxUPP, GetEventTypeCount(mboxEvents), mboxEvents, (void *) tWindowRef, &mboxRef);
timeUPP = NewEventLoopTimerUPP(MusicBoxTimerHandler);
err = InstallEventLoopTimer(GetCurrentEventLoop(), kEventDurationNoWait, kEventDurationSecond * 2.0 / (double) Memory.ROMFramesPerSecond, timeUPP, (void *) paneView, &timeRef);
MusicBoxInitIndicator();
stopNow = false;
MacStartSound();
pthread_create(&mbxThread, nil, SoundTask, nil);
MoveWindowPosition(tWindowRef, kWindowMusicBox, true);
GetWindowBounds(tWindowRef, kWindowStructureRgn, &windowRect);
if (windowRect.bottom - windowRect.top > mbxClosedHeight)
{
showIndicator = true;
SetControl32BitValue(ctl, 1); // Tr_i
}
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowMusicBox);
stopNow = true;
pthread_join(mbxThread, nil);
MacStopSound();
err = RemoveEventLoopTimer(timeRef);
DisposeEventLoopTimerUPP(timeUPP);
err = RemoveEventHandler(mboxRef);
DisposeEventHandlerUPP(mboxUPP);
err = RemoveEventHandler(paneRef);
DisposeEventHandlerUPP(paneUPP);
ReleaseWindow(tWindowRef);
so.stereo_switch = ~0;
mbxFinished = true;
if (musicboxmode == kMBXSoundEmulation)
{
SPCPlayDefrost();
delete StoredAPU;
delete StoredAPURegisters;
delete StoredSoundData;
delete [] StoredIAPURAM;
}
else
MusicBoxForceDefrost();
Settings.OpenGLEnable = false;
}
if (actIcon)
err = UnregisterIconRef('~9X~', 'micn');
DisposeNibReference(nibRef);
}
}
BOOL CALLBACK RulesDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
int i, iCount;
char str[256];
static HWND hWndList;
LV_COLUMN lvC;
LV_ITEM lvI;
LV_DISPINFO *pItem;
char tempString1[256], tempString2[256];
switch (uMsg)
{
case WM_INITDIALOG:
hWndList = GetDlgItem(hDlg, IDC_LIST);
ListView_SetExtendedListViewStyleEx(hWndList, LVS_EX_GRIDLINES, LVS_EX_GRIDLINES );
ListView_SetExtendedListViewStyleEx(hWndList, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES );
lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT;
lvC.cx = 525;
lvC.pszText = "Rule";
lvC.iSubItem = 0;
lvC.fmt = LVCFMT_LEFT;
ListView_InsertColumn(hWndList, 0, &lvC);
PopulateRulesList(hWndList, 0);
SendDlgItemMessage(hDlg, IDC_RULE, EM_SETLIMITTEXT, (WPARAM) 255, 0);
if (bEnableFilter == TRUE)
CheckRadioButton(hDlg, IDC_RADIO_FILTER, IDC_RADIO_NOFILTER, IDC_RADIO_FILTER);
else
{
CheckRadioButton(hDlg, IDC_RADIO_FILTER, IDC_RADIO_NOFILTER, IDC_RADIO_NOFILTER);
SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_RADIO_NOFILTER, 0), 0);
}
RestoreWindowPosition(hDlg);
return TRUE;
case WM_NOTIFY:
switch (((LPNMHDR) lParam)->code)
{
case LVN_ENDLABELEDIT:
pItem = (LV_DISPINFO *) lParam;
ListView_SetItemText(hWndList, pItem->item.iItem, 0, pItem->item.pszText);
return TRUE;
}
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_ADD:
GetDlgItemText(hDlg, IDC_RULE, str, 255);
iCount = getnumtokens(str);
if ((iCount != 8) && (iCount != 3))
{
MessageBox(hDlg, "Incorrect number of parameters, please correct rule.", APP_NAME, MB_ICONEXCLAMATION | MB_OK);
return TRUE;
}
lvI.mask = LVIF_TEXT;
lvI.iSubItem = 0;
lvI.cchTextMax = 255;
i = ListView_GetItemCount(hWndList);
lvI.iItem = i;
lvI.pszText = str;
ListView_InsertItem(hWndList, &lvI);
SetDlgItemText(hDlg, IDC_RULE, "");
ListView_SetCheckState(hWndList, i, TRUE);
ListView_EnsureVisible(hWndList, i, FALSE);
return TRUE;
case IDC_DELETE:
lvI.mask = LVIF_STATE;
lvI.stateMask =LVIS_SELECTED;
lvI.iSubItem = 0;
iCount = ListView_GetItemCount( hWndList );
for( i = 0; i < iCount; i++ )
{
lvI.iItem = i;
ListView_GetItem(hWndList, &lvI);
if( lvI.state == LVIS_SELECTED )
{
ListView_DeleteItem(hWndList, i);
--iCount; --i;
}
}
return TRUE;
case IDC_CANCEL:
SaveWindowPosition(hDlg);
EndDialog(hDlg, FALSE);
return TRUE;
case IDC_SAVE:
lvI.mask = LVIF_TEXT;
lvI.iSubItem = 0;
lvI.cchTextMax = 255;
memset(rule_text, 0, sizeof(rule_text));
iCount = ListView_GetItemCount(hWndList);
for (i = 0; i < iCount; i++)
{
lvI.iItem = i;
lvI.pszText = rule_text[i].rule;
ListView_GetItem(hWndList, &lvI);
rule_text[i].bEnabled = ListView_GetCheckState(hWndList, i);
}
if (SendDlgItemMessage(hDlg, IDC_RADIO_FILTER, BM_GETCHECK, 0, 0) == BST_CHECKED)
bEnableFilter = TRUE;
else
bEnableFilter = FALSE;
SaveWindowPosition(hDlg);
EndDialog(hDlg, TRUE);
return TRUE;
case IDC_RADIO_NOFILTER:
EnableWindow(GetDlgItem(hDlg, IDC_ADD), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_DELETE), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_RULE), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_MOVEUP), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_MOVEDOWN), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_DEFAULT), FALSE);
EnableWindow(hWndList, FALSE);
return TRUE;
case IDC_RADIO_FILTER:
EnableWindow(GetDlgItem(hDlg, IDC_ADD), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_DELETE), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_RULE), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_MOVEUP), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_MOVEDOWN), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_DEFAULT), TRUE);
EnableWindow(hWndList, TRUE);
return TRUE;
case IDC_MOVEUP:
iCount = ListView_GetItemCount( hWndList );
for( i = 1; i < iCount; i++ )
{
if( ListView_GetItemState(hWndList, i, LVIS_SELECTED) == LVIS_SELECTED )
{
ListView_GetItemText(hWndList, i-1, 0, tempString1, sizeof(tempString1));
ListView_GetItemText(hWndList, i, 0, tempString2, sizeof(tempString2));
ListView_SetItemText(hWndList, i-1, 0, tempString2);
ListView_SetItemText(hWndList, i, 0, tempString1);
ListView_SetItemState(hWndList, i-1, LVIS_SELECTED, LVIS_SELECTED );
ListView_SetItemState(hWndList, i, 0, LVIS_SELECTED);
break;
}
}
return TRUE;
case IDC_MOVEDOWN:
iCount = ListView_GetItemCount( hWndList );
for( i = iCount-2; i >= 0; i-- )
{
if( ListView_GetItemState(hWndList, i, LVIS_SELECTED) == LVIS_SELECTED )
{
ListView_GetItemText(hWndList, i+1, 0, tempString1, sizeof(tempString1));
ListView_GetItemText(hWndList, i, 0, tempString2, sizeof(tempString2));
ListView_SetItemText(hWndList, i+1, 0, tempString2);
ListView_SetItemText(hWndList, i, 0, tempString1);
ListView_SetItemState(hWndList, i+1, LVIS_SELECTED, LVIS_SELECTED);
ListView_SetItemState(hWndList, i, 0, LVIS_SELECTED);
break;
}
}
return TRUE;
case IDC_DEFAULT:
i = MessageBox(hDlg, "This action will erase existing rules. Proceed with setting up default rules?", "Network Spy", MB_YESNO | MB_ICONWARNING);
if (i == IDYES)
{
SetupDefaultRules();
PopulateRulesList(hWndList, 0);
}
return TRUE;
}
break;
case WM_CLOSE:
SaveWindowPosition(hDlg);
EndDialog(hDlg, 0);
return TRUE;
}
return FALSE;
}
void ConfigurePreferences (void)
{
OSStatus err;
IBNibRef nibRef;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
WindowRef tWindowRef;
SInt32 oldVolume;
uint32 oldPlaybackRate, oldInputRate, oldInterval, oldBufferSize;
bool8 oldSynchronize, old16BitPlayback, oldStereo, oldReverseStereo, oldLagEnable;
oldSynchronize = Settings.SoundSync;
old16BitPlayback = Settings.SixteenBitSound;
oldStereo = Settings.Stereo;
oldReverseStereo = Settings.ReverseStereo;
oldPlaybackRate = Settings.SoundPlaybackRate;
oldInputRate = Settings.SoundInputRate;
oldInterval = macSoundInterval_ms;
oldBufferSize = macSoundBuffer_ms;
oldLagEnable = macSoundLagEnable;
oldVolume = macSoundVolume;
if (cartOpen)
DeinitGameWindow();
S9xGraphicsDeinit();
err = CreateWindowFromNib(nibRef, CFSTR("Preferences"), &tWindowRef);
if (err == noErr)
{
EventHandlerUPP tUPP, iUPP, aUPP, pUPP;
EventHandlerRef tRef, iRef, aRef, pRef;
EventTypeSpec tEvents[] = { { kEventClassControl, kEventControlHit } },
iEvents[] = { { kEventClassControl, kEventControlClick } },
aEvents[] = { { kEventClassControl, kEventControlClick } },
pEvents[] = { { kEventClassWindow, kEventWindowClose },
{ kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } };
ControlActionUPP arrowsUPP, sliderUPP;
HIViewRef ctl, root;
HIViewID cid;
MenuRef menu;
char num[16];
root = HIViewGetRoot(tWindowRef);
cid.signature = 'tabs';
cid.id = 128;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, lastTabIndex);
SelectTabPane(ctl, lastTabIndex);
tUPP = NewEventHandlerUPP(TabEventHandler);
err = InstallControlEventHandler(ctl, tUPP, GetEventTypeCount(tEvents), tEvents, 0, &tRef);
cid.signature = 'snd_';
cid.id = iNibSInputRateText;
HIViewFindByID(root, cid, &ctl);
iUPP = NewEventHandlerUPP(InputRateTextEventHandler);
err = InstallControlEventHandler(ctl, iUPP, GetEventTypeCount(iEvents), iEvents, 0, &iRef);
cid.signature = 'grap';
cid.id = iNibGAspectRatioText;
HIViewFindByID(root, cid, &ctl);
aUPP = NewEventHandlerUPP(AspectRatioTextEventHandler);
err = InstallControlEventHandler(ctl, aUPP, GetEventTypeCount(aEvents), aEvents, 0, &aRef);
pUPP = NewEventHandlerUPP(PreferencesEventHandler);
err = InstallWindowEventHandler(tWindowRef, pUPP, GetEventTypeCount(pEvents), pEvents, (void *) tWindowRef, &pRef);
sliderUPP = NewControlActionUPP(InputRateSliderActionProc);
arrowsUPP = NewControlActionUPP(LittleArrowsActionProc);
cid.signature = 'grap';
cid.id = iNibGFullScreen;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, fullscreen);
cid.id = iNibGSwitchResolution;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, autoRes);
cid.id = iNibGShowFrameRate;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, Settings.DisplayFrameRate);
cid.id = iNibGTransparency;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, Settings.Transparency);
cid.id = iNibGGL32bit;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, gl32bit);
cid.id = iNibGGLStretch;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, glstretch);
cid.id = iNibGVideoMode;
HIViewFindByID(root, cid, &ctl);
switch (videoMode)
{
case VIDEOMODE_BLOCKY:
SetControl32BitValue(ctl, iOpenGLBlocky);
break;
case VIDEOMODE_TV:
SetControl32BitValue(ctl, iOpenGLTVMode);
break;
case VIDEOMODE_SMOOTH:
SetControl32BitValue(ctl, iOpenGLSmoothMode);
break;
case VIDEOMODE_BLEND:
SetControl32BitValue(ctl, iOpenGLBlendMode);
break;
case VIDEOMODE_SUPEREAGLE:
SetControl32BitValue(ctl, iOpenGLEagleMode);
break;
case VIDEOMODE_2XSAI:
SetControl32BitValue(ctl, iOpenGL2xSAIMode);
break;
case VIDEOMODE_SUPER2XSAI:
SetControl32BitValue(ctl, iOpenGLSuper2xSAIMode);
break;
case VIDEOMODE_EPX:
SetControl32BitValue(ctl, iOpenGLEPXMode);
break;
case VIDEOMODE_HQ2X:
SetControl32BitValue(ctl, iOpenGLHQ2xMode);
break;
case VIDEOMODE_HQ3X:
SetControl32BitValue(ctl, iOpenGLHQ3xMode);
break;
case VIDEOMODE_HQ4X:
SetControl32BitValue(ctl, iOpenGLHQ4xMode);
break;
case VIDEOMODE_NTSC_C:
SetControl32BitValue(ctl, iOpenGLNTSC_CMode);
break;
case VIDEOMODE_NTSC_S:
SetControl32BitValue(ctl, iOpenGLNTSC_SMode);
break;
case VIDEOMODE_NTSC_R:
SetControl32BitValue(ctl, iOpenGLNTSC_RMode);
break;
case VIDEOMODE_NTSC_M:
SetControl32BitValue(ctl, iOpenGLNTSC_MMode);
break;
case VIDEOMODE_NTSC_TV_C:
SetControl32BitValue(ctl, iOpenGLNTSC_TV_CMode);
break;
case VIDEOMODE_NTSC_TV_S:
SetControl32BitValue(ctl, iOpenGLNTSC_TV_SMode);
break;
case VIDEOMODE_NTSC_TV_R:
SetControl32BitValue(ctl, iOpenGLNTSC_TV_RMode);
break;
case VIDEOMODE_NTSC_TV_M:
SetControl32BitValue(ctl, iOpenGLNTSC_TV_MMode);
break;
}
cid.id = iNibGDirectMP;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, multiprocessor);
cid.id = iNibGGLVSync;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, vsync);
cid.id = iNibGDrawOverscan;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, drawoverscan);
cid.id = iNibGScreenCurvature;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, screencurvature);
cid.id = iNibGCurvatureWarp;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, macCurvatureWarp);
if (!screencurvature)
DeactivateControl(ctl);
cid.id = iNibGAspectRatio;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, macAspectRatio);
if (!glstretch)
DeactivateControl(ctl);
cid.id = iNibGCIFilterEnable;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, ciFilterEnable);
if (systemVersion < 0x1040)
DisableControl(ctl);
if (systemVersion < 0x1040)
{
cid.id = iNibGCoreImageFilter;
HIViewFindByID(root, cid, &ctl);
DisableControl(ctl);
}
cid.signature = 'snd_';
cid.id = iNibSSynchronize;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, Settings.SoundSync);
cid.id = iNibS16BitPlayback;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, Settings.SixteenBitSound);
DeactivateControl(ctl);
cid.id = iNibSStereo;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, Settings.Stereo);
DeactivateControl(ctl);
cid.id = iNibSReverseStereo;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, Settings.ReverseStereo);
DeactivateControl(ctl);
cid.id = iNibSPlaybackRate;
HIViewFindByID(root, cid, &ctl);
switch (Settings.SoundPlaybackRate)
{
case 48000:
SetControl32BitValue(ctl, 1);
break;
case 44100:
SetControl32BitValue(ctl, 2);
break;
case 35000:
SetControl32BitValue(ctl, 3);
break;
case 32000:
SetControl32BitValue(ctl, 4);
break;
case 30000:
SetControl32BitValue(ctl, 5);
break;
case 22050:
SetControl32BitValue(ctl, 6);
break;
case 16000:
SetControl32BitValue(ctl, 7);
break;
case 11025:
SetControl32BitValue(ctl, 8);
break;
case 8000:
SetControl32BitValue(ctl, 9);
break;
}
cid.id = iNibSInputRate;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, Settings.SoundInputRate);
SetControlAction(ctl, sliderUPP);
cid.id = iNibSInputRateText;
HIViewFindByID(root, cid, &ctl);
sprintf(num, "%d", Settings.SoundInputRate);
SetStaticTextCStr(ctl, num, false);
cid.id = iNibSInterval;
HIViewFindByID(root, cid, &ctl);
switch (macSoundInterval_ms)
{
case 8:
SetControl32BitValue(ctl, 1);
break;
case 16:
SetControl32BitValue(ctl, 2);
break;
case 32:
SetControl32BitValue(ctl, 3);
break;
case 64:
SetControl32BitValue(ctl, 4);
break;
case 0:
default:
SetControl32BitValue(ctl, 6);
break;
}
cid.id = iNibSBufferSize;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, macSoundBuffer_ms / 20);
cid.id = iNibSAllowLag;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, macSoundLagEnable);
DeactivateControl(ctl);
cid.id = iNibSVolume;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, macSoundVolume);
cid.signature = 'othe';
cid.id = iNibOSaveFolder;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, saveInROMFolder + 1);
err = GetControlData(ctl, kControlMenuPart, kControlPopupButtonMenuRefTag, sizeof(MenuRef), &menu, NULL);
if (saveFolderPath)
{
CFURLRef url;
CFStringRef ref;
url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, saveFolderPath, kCFURLPOSIXPathStyle, true);
ref = CFURLCopyLastPathComponent(url);
err = SetMenuItemTextWithCFString(menu, iNibSaveFolderNameMenuItem, ref);
CFRelease(ref);
CFRelease(url);
EnableMenuItem(menu, iNibSaveFolderNameMenuItem);
}
else
{
CFStringRef ref;
ref = CFCopyLocalizedString(CFSTR("NoneSelected"), "NoneSelected");
err = SetMenuItemTextWithCFString(menu, iNibSaveFolderNameMenuItem, ref);
CFRelease(ref);
DisableMenuItem(menu, iNibSaveFolderNameMenuItem);
}
cid.id = iNibOAutoSaveInterval;
HIViewFindByID(root, cid, &ctl);
sprintf(num, "%d", Settings.AutoSaveDelay);
SetEditTextCStr(ctl, num, false);
cid.signature = 'msc2';
cid.id = iNibMCPUCycles;
HIViewFindByID(root, cid, &ctl);
sprintf(num, "%" PRIi32, Settings.HDMATimingHack);
SetEditTextCStr(ctl, num, false);
cid.id = iNibMTurboSkipArrows;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, macFastForwardRate);
SetControlAction(ctl, arrowsUPP);
cid.id = iNibMTurboSkipText;
HIViewFindByID(root, cid, &ctl);
sprintf(num, "%d", macFastForwardRate);
SetStaticTextCStr(ctl, num, false);
cid.id = iNibMFrameSkip;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, macFrameSkip + 2);
cid.id = iNibMAllowInvalidVRAMAccess;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, !Settings.BlockInvalidVRAMAccessMaster);
cid.id = iNibMAllowSpecificGameHacks;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, !Settings.DisableGameSpecificHacks);
cid.signature = 'osx_';
cid.id = iNibXStartOpenDialog;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, startopendlog);
cid.id = iNibXShowTimeInFrz;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, showtimeinfrz);
cid.id = iNibXMusicBoxMode;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, musicboxmode);
cid.id = iNibXEnableToggle;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, enabletoggle);
cid.id = iNibXSaveWindowPos;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, savewindowpos);
cid.id = iNibXUseIPSPatch;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, !Settings.NoPatch);
cid.id = iNibXOnScreenInfo;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, onscreeninfo);
cid.id = iNibXInactiveMode;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, inactiveMode);
cid.id = iNibXBSXBootup;
HIViewFindByID(root, cid, &ctl);
SetControl32BitValue(ctl, Settings.BSXBootup);
MoveWindowPosition(tWindowRef, kWindowPreferences, false);
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowPreferences);
cid.signature = 'grap';
cid.id = iNibGFullScreen;
HIViewFindByID(root, cid, &ctl);
fullscreen = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGSwitchResolution;
HIViewFindByID(root, cid, &ctl);
autoRes = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGShowFrameRate;
HIViewFindByID(root, cid, &ctl);
Settings.DisplayFrameRate = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGTransparency;
HIViewFindByID(root, cid, &ctl);
Settings.Transparency = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGGL32bit;
HIViewFindByID(root, cid, &ctl);
gl32bit = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGGLStretch;
HIViewFindByID(root, cid, &ctl);
glstretch = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGVideoMode;
HIViewFindByID(root, cid, &ctl);
switch (GetControl32BitValue(ctl))
{
case iOpenGLBlocky:
drawingMethod = kDrawingOpenGL;
videoMode = VIDEOMODE_BLOCKY;
break;
case iOpenGLTVMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_TV;
break;
case iOpenGLSmoothMode:
drawingMethod = kDrawingOpenGL;
videoMode = VIDEOMODE_SMOOTH;
break;
case iOpenGLBlendMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_BLEND;
break;
case iOpenGLEagleMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_SUPEREAGLE;
break;
case iOpenGL2xSAIMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_2XSAI;
break;
case iOpenGLSuper2xSAIMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_SUPER2XSAI;
break;
case iOpenGLEPXMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_EPX;
break;
case iOpenGLHQ2xMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_HQ2X;
break;
case iOpenGLHQ3xMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_HQ3X;
break;
case iOpenGLHQ4xMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_HQ4X;
break;
case iOpenGLNTSC_CMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_NTSC_C;
S9xBlitNTSCFilterSet(&snes_ntsc_composite);
break;
case iOpenGLNTSC_SMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_NTSC_S;
S9xBlitNTSCFilterSet(&snes_ntsc_svideo);
break;
case iOpenGLNTSC_RMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_NTSC_R;
S9xBlitNTSCFilterSet(&snes_ntsc_rgb);
break;
case iOpenGLNTSC_MMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_NTSC_M;
S9xBlitNTSCFilterSet(&snes_ntsc_monochrome);
break;
case iOpenGLNTSC_TV_CMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_NTSC_TV_C;
S9xBlitNTSCFilterSet(&snes_ntsc_composite);
break;
case iOpenGLNTSC_TV_SMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_NTSC_TV_S;
S9xBlitNTSCFilterSet(&snes_ntsc_svideo);
break;
case iOpenGLNTSC_TV_RMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_NTSC_TV_R;
S9xBlitNTSCFilterSet(&snes_ntsc_rgb);
break;
case iOpenGLNTSC_TV_MMode:
drawingMethod = kDrawingBlitGL;
videoMode = VIDEOMODE_NTSC_TV_M;
S9xBlitNTSCFilterSet(&snes_ntsc_monochrome);
break;
}
cid.id = iNibGDirectMP;
HIViewFindByID(root, cid, &ctl);
multiprocessor = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGGLVSync;
HIViewFindByID(root, cid, &ctl);
vsync = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGDrawOverscan;
HIViewFindByID(root, cid, &ctl);
drawoverscan = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGScreenCurvature;
HIViewFindByID(root, cid, &ctl);
screencurvature = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibGCurvatureWarp;
HIViewFindByID(root, cid, &ctl);
macCurvatureWarp = GetControl32BitValue(ctl);
cid.id = iNibGAspectRatio;
HIViewFindByID(root, cid, &ctl);
macAspectRatio = GetControl32BitValue(ctl);
cid.id = iNibGCIFilterEnable;
HIViewFindByID(root, cid, &ctl);
ciFilterEnable = GetControl32BitValue(ctl) ? true : false;
cid.signature = 'snd_';
cid.id = iNibSSynchronize;
HIViewFindByID(root, cid, &ctl);
Settings.SoundSync = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibS16BitPlayback;
HIViewFindByID(root, cid, &ctl);
Settings.SixteenBitSound = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibSStereo;
HIViewFindByID(root, cid, &ctl);
Settings.Stereo = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibSReverseStereo;
HIViewFindByID(root, cid, &ctl);
Settings.ReverseStereo = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibSPlaybackRate;
HIViewFindByID(root, cid, &ctl);
switch (GetControl32BitValue(ctl))
{
case 1:
Settings.SoundPlaybackRate = 48000;
break;
case 2:
Settings.SoundPlaybackRate = 44100;
break;
case 3:
Settings.SoundPlaybackRate = 35000;
break;
case 4:
Settings.SoundPlaybackRate = 32000;
break;
case 5:
Settings.SoundPlaybackRate = 30000;
break;
case 6:
Settings.SoundPlaybackRate = 22050;
break;
case 7:
Settings.SoundPlaybackRate = 16000;
break;
case 8:
Settings.SoundPlaybackRate = 11025;
break;
case 9:
Settings.SoundPlaybackRate = 8000;
break;
}
cid.id = iNibSInputRate;
HIViewFindByID(root, cid, &ctl);
Settings.SoundInputRate = GetControl32BitValue(ctl);
cid.id = iNibSInterval;
HIViewFindByID(root, cid, &ctl);
switch (GetControl32BitValue(ctl))
{
case 1:
macSoundInterval_ms = 8;
break;
case 2:
macSoundInterval_ms = 16;
break;
case 3:
macSoundInterval_ms = 32;
break;
case 4:
macSoundInterval_ms = 64;
break;
case 6:
default:
macSoundInterval_ms = 0;
break;
}
cid.id = iNibSBufferSize;
HIViewFindByID(root, cid, &ctl);
macSoundBuffer_ms = GetControl32BitValue(ctl) * 20;
cid.id = iNibSAllowLag;
HIViewFindByID(root, cid, &ctl);
macSoundLagEnable = GetControl32BitValue(ctl);
cid.id = iNibSVolume;
HIViewFindByID(root, cid, &ctl);
macSoundVolume = GetControl32BitValue(ctl);
cid.signature = 'othe';
cid.id = iNibOSaveFolder;
HIViewFindByID(root, cid, &ctl);
saveInROMFolder = GetControl32BitValue(ctl) - 1;
cid.id = iNibOAutoSaveInterval;
HIViewFindByID(root, cid, &ctl);
GetEditTextCStr(ctl, num);
Settings.AutoSaveDelay = atoi(num);
cid.signature = 'msc2';
cid.id = iNibMCPUCycles;
HIViewFindByID(root, cid, &ctl);
GetEditTextCStr(ctl, num);
Settings.HDMATimingHack = atoi(num);
if ((Settings.HDMATimingHack <= 0) || (Settings.HDMATimingHack >= 200))
Settings.HDMATimingHack = 100;
cid.id = iNibMTurboSkipArrows;
HIViewFindByID(root, cid, &ctl);
macFastForwardRate = GetControl32BitValue(ctl);
cid.id = iNibMFrameSkip;
HIViewFindByID(root, cid, &ctl);
macFrameSkip = GetControl32BitValue(ctl) - 2;
cid.id = iNibMAllowInvalidVRAMAccess;
HIViewFindByID(root, cid, &ctl);
Settings.BlockInvalidVRAMAccessMaster = GetControl32BitValue(ctl) ? false : true;
cid.id = iNibMAllowSpecificGameHacks;
HIViewFindByID(root, cid, &ctl);
Settings.DisableGameSpecificHacks = GetControl32BitValue(ctl) ? false : true;
cid.signature = 'osx_';
cid.id = iNibXStartOpenDialog;
HIViewFindByID(root, cid, &ctl);
startopendlog = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibXShowTimeInFrz;
HIViewFindByID(root, cid, &ctl);
showtimeinfrz = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibXMusicBoxMode;
HIViewFindByID(root, cid, &ctl);
musicboxmode = GetControl32BitValue(ctl);
cid.id = iNibXEnableToggle;
HIViewFindByID(root, cid, &ctl);
enabletoggle = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibXSaveWindowPos;
HIViewFindByID(root, cid, &ctl);
savewindowpos = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibXUseIPSPatch;
HIViewFindByID(root, cid, &ctl);
Settings.NoPatch = GetControl32BitValue(ctl) ? false : true;
cid.id = iNibXOnScreenInfo;
HIViewFindByID(root, cid, &ctl);
onscreeninfo = GetControl32BitValue(ctl) ? true : false;
cid.id = iNibXInactiveMode;
HIViewFindByID(root, cid, &ctl);
inactiveMode = GetControl32BitValue(ctl);
cid.id = iNibXBSXBootup;
HIViewFindByID(root, cid, &ctl);
Settings.BSXBootup = GetControl32BitValue(ctl) ? true : false;
DisposeControlActionUPP(arrowsUPP);
DisposeControlActionUPP(sliderUPP);
err = RemoveEventHandler(pRef);
DisposeEventHandlerUPP(pUPP);
err = RemoveEventHandler(aRef);
DisposeEventHandlerUPP(aUPP);
err = RemoveEventHandler(iRef);
DisposeEventHandlerUPP(iUPP);
err = RemoveEventHandler(tRef);
DisposeEventHandlerUPP(tUPP);
CFRelease(tWindowRef);
}
DisposeNibReference(nibRef);
S9xGraphicsInit();
if (((oldSynchronize != Settings.SoundSync ) ||
(old16BitPlayback != Settings.SixteenBitSound ) ||
(oldStereo != Settings.Stereo ) ||
(oldReverseStereo != Settings.ReverseStereo ) ||
(oldPlaybackRate != Settings.SoundPlaybackRate) ||
(oldInputRate != Settings.SoundInputRate ) ||
(oldInterval != macSoundInterval_ms ) ||
(oldBufferSize != macSoundBuffer_ms ) ||
(oldLagEnable != macSoundLagEnable ) ||
(oldVolume != macSoundVolume )) && cartOpen)
SNES9X_InitSound();
if (!fullscreen && cartOpen)
{
InitGameWindow();
ShowWindow(gWindow);
}
if (cartOpen)
{
FSRef ref;
err = FSPathMakeRef((unsigned char *) Memory.ROMFilename, &ref, NULL);
if (err == noErr)
CheckSaveFolder(&ref);
}
}
}
bool CSimpleFrame::SaveState() {
CBOINCBaseFrame::SaveState();
return SaveWindowPosition();
}