void OBS::Start()
{
if(bRunning) return;
OSEnterMutex (hStartupShutdownMutex);
scenesConfig.Save();
//-------------------------------------------------------------
fps = AppConfig->GetInt(TEXT("Video"), TEXT("FPS"), 30);
frameTime = 1000/fps;
//-------------------------------------------------------------
if(!bLoggedSystemStats)
{
LogSystemStats();
bLoggedSystemStats = TRUE;
}
//-------------------------------------------------------------
retryHookTest:
bool alreadyWarnedAboutModules = false;
if (OSIncompatibleModulesLoaded())
{
Log(TEXT("Incompatible modules (pre-D3D) detected."));
int ret = MessageBox(hwndMain, Str("IncompatibleModules"), NULL, MB_ICONERROR | MB_ABORTRETRYIGNORE);
if (ret == IDABORT)
{
OSLeaveMutex (hStartupShutdownMutex);
return;
}
else if (ret == IDRETRY)
{
goto retryHookTest;
}
alreadyWarnedAboutModules = true;
}
String strPatchesError;
if (OSIncompatiblePatchesLoaded(strPatchesError))
{
OSLeaveMutex (hStartupShutdownMutex);
MessageBox(hwndMain, strPatchesError.Array(), NULL, MB_ICONERROR);
Log(TEXT("Incompatible patches detected."));
return;
}
//-------------------------------------------------------------
String processPriority = AppConfig->GetString(TEXT("General"), TEXT("Priority"), TEXT("Normal"));
if (!scmp(processPriority, TEXT("Idle")))
SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
else if (!scmp(processPriority, TEXT("Above Normal")))
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
else if (!scmp(processPriority, TEXT("High")))
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
int networkMode = AppConfig->GetInt(TEXT("Publish"), TEXT("Mode"), 2);
DWORD delayTime = (DWORD)AppConfig->GetInt(TEXT("Publish"), TEXT("Delay"));
String strError;
bFirstConnect = !bReconnecting;
if(bTestStream)
network = CreateNullNetwork();
else
{
switch(networkMode)
{
case 0: network = (delayTime > 0) ? CreateDelayedPublisher(delayTime) : CreateRTMPPublisher(); break;
case 1: network = CreateNullNetwork(); break;
}
}
if(!network)
{
OSLeaveMutex (hStartupShutdownMutex);
if(!bReconnecting)
MessageBox(hwndMain, strError, NULL, MB_ICONERROR);
else
DialogBox(hinstMain, MAKEINTRESOURCE(IDD_RECONNECTING), hwndMain, OBS::ReconnectDialogProc);
return;
}
bReconnecting = false;
//-------------------------------------------------------------
Log(TEXT("=====Stream Start: %s==============================================="), CurrentDateTimeString().Array());
//-------------------------------------------------------------
int monitorID = AppConfig->GetInt(TEXT("Video"), TEXT("Monitor"));
if(monitorID >= (int)monitors.Num())
monitorID = 0;
RECT &screenRect = monitors[monitorID].rect;
int defCX = screenRect.right - screenRect.left;
int defCY = screenRect.bottom - screenRect.top;
downscaleType = AppConfig->GetInt(TEXT("Video"), TEXT("Filter"), 0);
downscale = AppConfig->GetFloat(TEXT("Video"), TEXT("Downscale"), 1.0f);
baseCX = AppConfig->GetInt(TEXT("Video"), TEXT("BaseWidth"), defCX);
baseCY = AppConfig->GetInt(TEXT("Video"), TEXT("BaseHeight"), defCY);
baseCX = MIN(MAX(baseCX, 128), 4096);
baseCY = MIN(MAX(baseCY, 128), 4096);
scaleCX = UINT(double(baseCX) / double(downscale));
scaleCY = UINT(double(baseCY) / double(downscale));
//align width to 128bit for fast SSE YUV4:2:0 conversion
outputCX = scaleCX & 0xFFFFFFFC;
outputCY = scaleCY & 0xFFFFFFFE;
bUseMultithreadedOptimizations = AppConfig->GetInt(TEXT("General"), TEXT("UseMultithreadedOptimizations"), TRUE) != 0;
Log(TEXT(" Multithreaded optimizations: %s"), (CTSTR)(bUseMultithreadedOptimizations ? TEXT("On") : TEXT("Off")));
//------------------------------------------------------------------
Log(TEXT(" Base resolution: %ux%u"), baseCX, baseCY);
Log(TEXT(" Output resolution: %ux%u"), outputCX, outputCY);
Log(TEXT("------------------------------------------"));
//------------------------------------------------------------------
GS = new D3D10System;
GS->Init();
//Thanks to ASUS OSD hooking the goddamn user mode driver framework (!!!!), we have to re-check for dangerous
//hooks after initializing D3D.
retryHookTestV2:
if (!alreadyWarnedAboutModules)
{
if (OSIncompatibleModulesLoaded())
{
Log(TEXT("Incompatible modules (post-D3D) detected."));
int ret = MessageBox(hwndMain, Str("IncompatibleModules"), NULL, MB_ICONERROR | MB_ABORTRETRYIGNORE);
if (ret == IDABORT)
{
//FIXME: really need a better way to abort startup than this...
delete network;
delete GS;
OSLeaveMutex (hStartupShutdownMutex);
return;
}
else if (ret == IDRETRY)
{
goto retryHookTestV2;
}
}
}
//-------------------------------------------------------------
mainVertexShader = CreateVertexShaderFromFile(TEXT("shaders/DrawTexture.vShader"));
mainPixelShader = CreatePixelShaderFromFile(TEXT("shaders/DrawTexture.pShader"));
solidVertexShader = CreateVertexShaderFromFile(TEXT("shaders/DrawSolid.vShader"));
solidPixelShader = CreatePixelShaderFromFile(TEXT("shaders/DrawSolid.pShader"));
//------------------------------------------------------------------
CTSTR lpShader;
if(CloseFloat(downscale, 1.0))
lpShader = TEXT("shaders/DrawYUVTexture.pShader");
else if(downscale < 2.01)
{
switch(downscaleType)
{
case 0: lpShader = TEXT("shaders/DownscaleBilinear1YUV.pShader"); break;
case 1: lpShader = TEXT("shaders/DownscaleBicubicYUV.pShader"); break;
case 2: lpShader = TEXT("shaders/DownscaleLanczos6tapYUV.pShader"); break;
}
}
else if(downscale < 3.01)
lpShader = TEXT("shaders/DownscaleBilinear9YUV.pShader");
else
CrashError(TEXT("Invalid downscale value (must be either 1.0, 1.5, 2.0, 2.25, or 3.0)"));
yuvScalePixelShader = CreatePixelShaderFromFile(lpShader);
if (!yuvScalePixelShader)
CrashError(TEXT("Unable to create shader from file %s"), lpShader);
//-------------------------------------------------------------
for(UINT i=0; i<NUM_RENDER_BUFFERS; i++)
{
mainRenderTextures[i] = CreateRenderTarget(baseCX, baseCY, GS_BGRA, FALSE);
yuvRenderTextures[i] = CreateRenderTarget(outputCX, outputCY, GS_BGRA, FALSE);
}
//-------------------------------------------------------------
D3D10_TEXTURE2D_DESC td;
zero(&td, sizeof(td));
td.Width = outputCX;
td.Height = outputCY;
td.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
td.MipLevels = 1;
td.ArraySize = 1;
td.SampleDesc.Count = 1;
td.ArraySize = 1;
td.Usage = D3D10_USAGE_STAGING;
td.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
for(UINT i=0; i<NUM_RENDER_BUFFERS; i++)
{
HRESULT err = GetD3D()->CreateTexture2D(&td, NULL, ©Textures[i]);
if(FAILED(err))
{
CrashError(TEXT("Unable to create copy texture"));
//todo - better error handling
}
}
//-------------------------------------------------------------
AudioDeviceList playbackDevices;
GetAudioDevices(playbackDevices, ADT_PLAYBACK);
String strPlaybackDevice = AppConfig->GetString(TEXT("Audio"), TEXT("PlaybackDevice"), TEXT("Default"));
if(strPlaybackDevice.IsEmpty() || !playbackDevices.HasID(strPlaybackDevice))
{
AppConfig->SetString(TEXT("Audio"), TEXT("PlaybackDevice"), TEXT("Default"));
strPlaybackDevice = TEXT("Default");
}
Log(TEXT("Playback device %s"), strPlaybackDevice.Array());
playbackDevices.FreeData();
desktopAudio = CreateAudioSource(false, strPlaybackDevice);
if(!desktopAudio) {
CrashError(TEXT("Cannot initialize desktop audio sound, more info in the log file."));
}
AudioDeviceList audioDevices;
GetAudioDevices(audioDevices, ADT_RECORDING);
String strDevice = AppConfig->GetString(TEXT("Audio"), TEXT("Device"), NULL);
if(strDevice.IsEmpty() || !audioDevices.HasID(strDevice))
{
AppConfig->SetString(TEXT("Audio"), TEXT("Device"), TEXT("Disable"));
strDevice = TEXT("Disable");
}
audioDevices.FreeData();
String strDefaultMic;
bool bHasDefault = GetDefaultMicID(strDefaultMic);
if(strDevice.CompareI(TEXT("Disable")))
EnableWindow(GetDlgItem(hwndMain, ID_MICVOLUME), FALSE);
else
{
bool bUseDefault = strDevice.CompareI(TEXT("Default")) != 0;
if(!bUseDefault || bHasDefault)
{
if(bUseDefault)
strDevice = strDefaultMic;
micAudio = CreateAudioSource(true, strDevice);
if(!micAudio)
MessageBox(hwndMain, Str("MicrophoneFailure"), NULL, 0);
else
micAudio->SetTimeOffset(AppConfig->GetInt(TEXT("Audio"), TEXT("MicTimeOffset"), 0));
EnableWindow(GetDlgItem(hwndMain, ID_MICVOLUME), micAudio != NULL);
}
else
EnableWindow(GetDlgItem(hwndMain, ID_MICVOLUME), FALSE);
}
//-------------------------------------------------------------
bool bDisableEncoding = false;
if (bTestStream)
bDisableEncoding = GlobalConfig->GetInt(TEXT("General"), TEXT("DisablePreviewEncoding"), false) != 0;
//-------------------------------------------------------------
UINT bitRate = (UINT)AppConfig->GetInt(TEXT("Audio Encoding"), TEXT("Bitrate"), 96);
String strEncoder = AppConfig->GetString(TEXT("Audio Encoding"), TEXT("Codec"), TEXT("AAC"));
if (bDisableEncoding)
audioEncoder = CreateNullAudioEncoder();
else
#ifdef USE_AAC
if(strEncoder.CompareI(TEXT("AAC")))// && OSGetVersion() >= 7)
audioEncoder = CreateAACEncoder(bitRate);
else
#endif
audioEncoder = CreateMP3Encoder(bitRate);
//-------------------------------------------------------------
desktopVol = AppConfig->GetFloat(TEXT("Audio"), TEXT("DesktopVolume"), 1.0f);
micVol = AppConfig->GetFloat(TEXT("Audio"), TEXT("MicVolume"), 1.0f);
//-------------------------------------------------------------
bRunning = true;
if(sceneElement)
{
scene = CreateScene(sceneElement->GetString(TEXT("class")), sceneElement->GetElement(TEXT("data")));
XElement *sources = sceneElement->GetElement(TEXT("sources"));
if(sources)
{
UINT numSources = sources->NumElements();
for(UINT i=0; i<numSources; i++)
{
SceneItem *item = scene->AddImageSource(sources->GetElementByID(i));
if(item)
{
if(ListView_GetItemState(GetDlgItem(hwndMain, ID_SOURCES), i, LVIS_SELECTED) > 0)
item->Select(true);
}
}
}
scene->BeginScene();
}
if(scene && scene->HasMissingSources())
MessageBox(hwndMain, Str("Scene.MissingSources"), NULL, 0);
//-------------------------------------------------------------
int maxBitRate = AppConfig->GetInt (TEXT("Video Encoding"), TEXT("MaxBitrate"), 1000);
int bufferSize = AppConfig->GetInt (TEXT("Video Encoding"), TEXT("BufferSize"), 1000);
int quality = AppConfig->GetInt (TEXT("Video Encoding"), TEXT("Quality"), 8);
String preset = AppConfig->GetString(TEXT("Video Encoding"), TEXT("Preset"), TEXT("veryfast"));
bUsing444 = AppConfig->GetInt (TEXT("Video Encoding"), TEXT("Use444"), 0) != 0;
bDupeFrames = AppConfig->GetInt(TEXT("Video Encoding"), TEXT("DupeFrames"), 0) != 0;
if(bUsing444)
bDupeFrames = bUseCFR = false;
else
{
bUseCFR = AppConfig->GetInt(TEXT("Video Encoding"), TEXT("UseCFR"), 0) != 0;
if(bUseCFR) bDupeFrames = true;
}
//-------------------------------------------------------------
bWriteToFile = networkMode == 1 || AppConfig->GetInt(TEXT("Publish"), TEXT("SaveToFile")) != 0;
String strOutputFile = AppConfig->GetString(TEXT("Publish"), TEXT("SavePath"));
strOutputFile.FindReplace(TEXT("\\"), TEXT("/"));
if (bWriteToFile)
{
OSFindData ofd;
HANDLE hFind = NULL;
bool bUseDateTimeName = true;
if(hFind = OSFindFirstFile(strOutputFile, ofd))
{
String strFileExtension = GetPathExtension(strOutputFile);
String strFileWithoutExtension = GetPathWithoutExtension(strOutputFile);
if(strFileExtension.IsValid() && !ofd.bDirectory)
{
String strNewFilePath;
UINT curFile = 0;
do
{
strNewFilePath.Clear() << strFileWithoutExtension << TEXT(" (") << FormattedString(TEXT("%02u"), ++curFile) << TEXT(").") << strFileExtension;
} while(OSFileExists(strNewFilePath));
strOutputFile = strNewFilePath;
bUseDateTimeName = false;
}
if(ofd.bDirectory)
strOutputFile.AppendChar('/');
OSFindClose(hFind);
}
if(bUseDateTimeName)
{
String strFileName = GetPathFileName(strOutputFile);
if(!strFileName.IsValid() || !IsSafeFilename(strFileName))
{
SYSTEMTIME st;
GetLocalTime(&st);
String strDirectory = GetPathDirectory(strOutputFile);
strOutputFile = FormattedString(TEXT("%s/%u-%02u-%02u-%02u%02u-%02u.mp4"), strDirectory.Array(), st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
}
}
}
//-------------------------------------------------------------
bufferingTime = GlobalConfig->GetInt(TEXT("General"), TEXT("SceneBufferingTime"), 400);
//-------------------------------------------------------------
bForceMicMono = AppConfig->GetInt(TEXT("Audio"), TEXT("ForceMicMono")) != 0;
bRecievedFirstAudioFrame = false;
//hRequestAudioEvent = CreateSemaphore(NULL, 0, 0x7FFFFFFFL, NULL);
hSoundDataMutex = OSCreateMutex();
hSoundThread = OSCreateThread((XTHREAD)OBS::MainAudioThread, NULL);
//-------------------------------------------------------------
StartBlankSoundPlayback(strPlaybackDevice);
//-------------------------------------------------------------
ctsOffset = 0;
videoEncoder = nullptr;
if (bDisableEncoding)
videoEncoder = CreateNullVideoEncoder();
else if(AppConfig->GetInt(TEXT("Video Encoding"), TEXT("UseQSV")) != 0)
videoEncoder = CreateQSVEncoder(fps, outputCX, outputCY, quality, preset, bUsing444, maxBitRate, bufferSize, bUseCFR, bDupeFrames);
if(!videoEncoder)
videoEncoder = CreateX264Encoder(fps, outputCX, outputCY, quality, preset, bUsing444, maxBitRate, bufferSize, bUseCFR, bDupeFrames);
//-------------------------------------------------------------
// Ensure that the render frame is properly sized
ResizeRenderFrame(true);
//-------------------------------------------------------------
if(!bTestStream && bWriteToFile && strOutputFile.IsValid())
{
String strFileExtension = GetPathExtension(strOutputFile);
if(strFileExtension.CompareI(TEXT("flv")))
fileStream = CreateFLVFileStream(strOutputFile);
else if(strFileExtension.CompareI(TEXT("mp4")))
fileStream = CreateMP4FileStream(strOutputFile);
if(!fileStream)
{
Log(TEXT("Warning - OBSCapture::Start: Unable to create the file stream. Check the file path in Broadcast Settings."));
MessageBox(hwndMain, Str("Capture.Start.FileStream.Warning"), Str("Capture.Start.FileStream.WarningCaption"), MB_OK | MB_ICONWARNING);
}
}
//-------------------------------------------------------------
hMainThread = OSCreateThread((XTHREAD)OBS::MainCaptureThread, NULL);
if(bTestStream)
{
EnableWindow(GetDlgItem(hwndMain, ID_STARTSTOP), FALSE);
SetWindowText(GetDlgItem(hwndMain, ID_TESTSTREAM), Str("MainWindow.StopTest"));
}
else
{
EnableWindow(GetDlgItem(hwndMain, ID_TESTSTREAM), FALSE);
SetWindowText(GetDlgItem(hwndMain, ID_STARTSTOP), Str("MainWindow.StopStream"));
}
EnableWindow(GetDlgItem(hwndMain, ID_SCENEEDITOR), TRUE);
//-------------------------------------------------------------
ReportStartStreamTrigger();
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 0, 0, 0);
SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_AWAYMODE_REQUIRED | ES_DISPLAY_REQUIRED);
UpdateRenderViewMessage();
//update notification icon to reflect current status
UpdateNotificationAreaIcon();
OSLeaveMutex (hStartupShutdownMutex);
}
void update_dialog_fields(HWND hwnd,
plugin_dlg_data * d,
plugin_data * info) {
wchar_t buf[256];
UINT resid;
wchar_t * t;
khm_handle csp_module = NULL;
d->selected = info;
if (info->plugin.reg.description)
SetDlgItemText(hwnd, IDC_CFG_DESC, info->plugin.reg.description);
else {
wchar_t fmt[128];
LoadString(khm_hInstance, IDS_CFG_NODESC, fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, info->plugin.reg.name);
SetDlgItemText(hwnd, IDC_CFG_DESC, buf);
}
switch(info->plugin.state) {
case KMM_PLUGIN_STATE_FAIL_INIT:
resid = IDS_PISTATE_FAILINIT;
break;
case KMM_PLUGIN_STATE_FAIL_UNKNOWN:
resid = IDS_PISTATE_FAILUNK;
break;
case KMM_PLUGIN_STATE_FAIL_MAX_FAILURE:
resid = IDS_PISTATE_FAILMAX;
break;
case KMM_PLUGIN_STATE_FAIL_NOT_REGISTERED:
resid = IDS_PISTATE_FAILREG;
break;
case KMM_PLUGIN_STATE_FAIL_DISABLED:
resid = IDS_PISTATE_FAILDIS;
break;
case KMM_PLUGIN_STATE_FAIL_LOAD:
resid = IDS_PISTATE_FAILLOD;
break;
case KMM_PLUGIN_STATE_NONE:
case KMM_PLUGIN_STATE_PLACEHOLDER:
resid = IDS_PISTATE_PLACEHOLD;
break;
case KMM_PLUGIN_STATE_REG:
case KMM_PLUGIN_STATE_PREINIT:
resid = IDS_PISTATE_REG;
break;
case KMM_PLUGIN_STATE_HOLD:
resid = IDS_PISTATE_HOLD;
break;
case KMM_PLUGIN_STATE_INIT:
resid = IDS_PISTATE_INIT;
break;
case KMM_PLUGIN_STATE_RUNNING:
resid = IDS_PISTATE_RUN;
break;
case KMM_PLUGIN_STATE_EXITED:
resid = IDS_PISTATE_EXIT;
break;
default:
#ifdef DEBUG
assert(FALSE);
#endif
resid = IDS_PISTATE_FAILUNK;
}
LoadString(khm_hInstance, resid,
buf, ARRAYLENGTH(buf));
SetDlgItemText(hwnd, IDC_CFG_STATE, buf);
SendDlgItemMessage(hwnd, IDC_CFG_DEPS,
LB_RESETCONTENT, 0, 0);
for (t = info->plugin.reg.dependencies; t && *t;
t = multi_string_next(t)) {
SendDlgItemMessage(hwnd, IDC_CFG_DEPS,
LB_INSERTSTRING, (WPARAM) -1, (LPARAM) t);
}
if (info->plugin.reg.module)
SetDlgItemText(hwnd, IDC_CFG_MODULE,
info->plugin.reg.module);
else
SetDlgItemText(hwnd, IDC_CFG_MODULE,
L"");
if (info->module.reg.vendor)
SetDlgItemText(hwnd, IDC_CFG_VENDOR,
info->module.reg.vendor);
else
SetDlgItemText(hwnd, IDC_CFG_VENDOR,
L"");
StringCbPrintf(buf, sizeof(buf), L"%u.%u.%u.%u",
(unsigned int) info->module.product_version.major,
(unsigned int) info->module.product_version.minor,
(unsigned int) info->module.product_version.patch,
(unsigned int) info->module.product_version.aux);
SetDlgItemText(hwnd, IDC_CFG_VERSION, buf);
if (info->plugin.reg.icon) {
SendDlgItemMessage(hwnd, IDC_CFG_ICON,
STM_SETICON,
(WPARAM) info->plugin.reg.icon,
0);
} else {
SendDlgItemMessage(hwnd, IDC_CFG_ICON,
STM_SETICON,
(WPARAM) d->plugin_ico,
0);
}
if (KHM_SUCCEEDED(kmm_get_module_config(info->module.reg.name,
0, &csp_module)) &&
(khc_value_exists(csp_module, L"ImagePath") &
(KCONF_FLAG_MACHINE | KCONF_FLAG_USER))) {
EnableWindow(GetDlgItem(hwnd, IDC_CFG_UNREGISTER), TRUE);
} else {
EnableWindow(GetDlgItem(hwnd, IDC_CFG_UNREGISTER), FALSE);
}
if (csp_module)
khc_close_space(csp_module);
if (info->plugin.flags & KMM_PLUGIN_FLAG_DISABLED) {
EnableWindow(GetDlgItem(hwnd, IDC_CFG_ENABLE), TRUE);
EnableWindow(GetDlgItem(hwnd, IDC_CFG_DISABLE), FALSE);
} else {
EnableWindow(GetDlgItem(hwnd, IDC_CFG_ENABLE), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_CFG_DISABLE), TRUE);
}
}
/***********************************************************************
* COMDLG32_FindReplaceDlgProc [internal]
* [Find/Replace]Text32[A/W] window procedure.
*/
static INT_PTR CALLBACK COMDLG32_FindReplaceDlgProc(HWND hDlgWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
COMDLG32_FR_Data *pdata = (COMDLG32_FR_Data *)GetPropA(hDlgWnd, (LPSTR)COMDLG32_Atom);
INT_PTR retval = TRUE;
if(iMsg == WM_INITDIALOG)
{
pdata = (COMDLG32_FR_Data *)lParam;
if(!SetPropA(hDlgWnd, (LPSTR)COMDLG32_Atom, (HANDLE)pdata))
{
ERR("Could not Set prop; invent a gracefull exit?...\n");
DestroyWindow(hDlgWnd);
return FALSE;
}
SendDlgItemMessageA(hDlgWnd, edt1, EM_SETLIMITTEXT, (WPARAM)pdata->fr.wFindWhatLen, 0);
SendDlgItemMessageA(hDlgWnd, edt1, WM_SETTEXT, 0, (LPARAM)pdata->fr.lpstrFindWhat);
if(pdata->fr.Flags & FR_WINE_REPLACE)
{
SendDlgItemMessageA(hDlgWnd, edt2, EM_SETLIMITTEXT, (WPARAM)pdata->fr.wReplaceWithLen, 0);
SendDlgItemMessageA(hDlgWnd, edt2, WM_SETTEXT, 0, (LPARAM)pdata->fr.lpstrReplaceWith);
}
if(!(pdata->fr.Flags & FR_SHOWHELP))
ShowWindow(GetDlgItem(hDlgWnd, pshHelp), SW_HIDE);
if(pdata->fr.Flags & FR_HIDEUPDOWN)
{
ShowWindow(GetDlgItem(hDlgWnd, rad1), SW_HIDE);
ShowWindow(GetDlgItem(hDlgWnd, rad2), SW_HIDE);
ShowWindow(GetDlgItem(hDlgWnd, grp1), SW_HIDE);
}
else if(pdata->fr.Flags & FR_NOUPDOWN)
{
EnableWindow(GetDlgItem(hDlgWnd, rad1), FALSE);
EnableWindow(GetDlgItem(hDlgWnd, rad2), FALSE);
EnableWindow(GetDlgItem(hDlgWnd, grp1), FALSE);
}
else
{
SendDlgItemMessageA(hDlgWnd, rad1, BM_SETCHECK, pdata->fr.Flags & FR_DOWN ? 0 : BST_CHECKED, 0);
SendDlgItemMessageA(hDlgWnd, rad2, BM_SETCHECK, pdata->fr.Flags & FR_DOWN ? BST_CHECKED : 0, 0);
}
if(pdata->fr.Flags & FR_HIDEMATCHCASE)
ShowWindow(GetDlgItem(hDlgWnd, chx2), SW_HIDE);
else if(pdata->fr.Flags & FR_NOMATCHCASE)
EnableWindow(GetDlgItem(hDlgWnd, chx2), FALSE);
else
SendDlgItemMessageA(hDlgWnd, chx2, BM_SETCHECK, pdata->fr.Flags & FR_MATCHCASE ? BST_CHECKED : 0, 0);
if(pdata->fr.Flags & FR_HIDEWHOLEWORD)
ShowWindow(GetDlgItem(hDlgWnd, chx1), SW_HIDE);
else if(pdata->fr.Flags & FR_NOWHOLEWORD)
EnableWindow(GetDlgItem(hDlgWnd, chx1), FALSE);
else
SendDlgItemMessageA(hDlgWnd, chx1, BM_SETCHECK, pdata->fr.Flags & FR_WHOLEWORD ? BST_CHECKED : 0, 0);
/* We did the init here, now call the hook if requested */
/* We do not do ShowWindow if hook exists and is FALSE */
/* per MSDN Article Q96135 */
if((pdata->fr.Flags & FR_ENABLEHOOK)
&& ! pdata->fr.lpfnHook(hDlgWnd, iMsg, wParam, (LPARAM) &pdata->fr))
return TRUE;
ShowWindow(hDlgWnd, SW_SHOWNORMAL);
UpdateWindow(hDlgWnd);
return TRUE;
}
if(pdata && (pdata->fr.Flags & FR_ENABLEHOOK))
{
retval = pdata->fr.lpfnHook(hDlgWnd, iMsg, wParam, lParam);
}
else
retval = FALSE;
if(pdata && !retval)
{
retval = TRUE;
switch(iMsg)
{
case WM_COMMAND:
COMDLG32_FR_HandleWMCommand(hDlgWnd, pdata, LOWORD(wParam), HIWORD(wParam));
break;
case WM_CLOSE:
COMDLG32_FR_HandleWMCommand(hDlgWnd, pdata, IDCANCEL, BN_CLICKED);
break;
case WM_HELP:
/* Heeeeelp! */
FIXME("Got WM_HELP. Who is gonna supply it?\n");
break;
case WM_CONTEXTMENU:
/* Heeeeelp! */
FIXME("Got WM_CONTEXTMENU. Who is gonna supply it?\n");
break;
/* FIXME: Handle F1 help */
default:
retval = FALSE; /* We did not handle the message */
}
}
/* WM_DESTROY is a special case.
* We need to ensure that the allocated memory is freed just before
* the dialog is killed. We also need to remove the added prop.
*/
if(iMsg == WM_DESTROY)
{
RemovePropA(hDlgWnd, (LPSTR)COMDLG32_Atom);
HeapFree(GetProcessHeap(), 0, pdata);
}
return retval;
}
INT_PTR CALLBACK EspServiceRecoveryDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
PSERVICE_RECOVERY_CONTEXT context;
if (uMsg == WM_INITDIALOG)
{
context = PhAllocate(sizeof(SERVICE_RECOVERY_CONTEXT));
memset(context, 0, sizeof(SERVICE_RECOVERY_CONTEXT));
SetProp(hwndDlg, L"Context", (HANDLE)context);
}
else
{
context = (PSERVICE_RECOVERY_CONTEXT)GetProp(hwndDlg, L"Context");
if (uMsg == WM_DESTROY)
RemoveProp(hwndDlg, L"Context");
}
if (!context)
return FALSE;
switch (uMsg)
{
case WM_INITDIALOG:
{
NTSTATUS status;
LPPROPSHEETPAGE propSheetPage = (LPPROPSHEETPAGE)lParam;
PPH_SERVICE_ITEM serviceItem = (PPH_SERVICE_ITEM)propSheetPage->lParam;
context->ServiceItem = serviceItem;
EspAddServiceActionStrings(GetDlgItem(hwndDlg, IDC_FIRSTFAILURE));
EspAddServiceActionStrings(GetDlgItem(hwndDlg, IDC_SECONDFAILURE));
EspAddServiceActionStrings(GetDlgItem(hwndDlg, IDC_SUBSEQUENTFAILURES));
status = EspLoadRecoveryInfo(hwndDlg, context);
if (status == STATUS_SOME_NOT_MAPPED)
{
if (context->NumberOfActions > 3)
{
PhShowWarning(
hwndDlg,
L"The service has %lu failure actions configured, but this program only supports editing 3. "
L"If you save the recovery information using this program, the additional failure actions will be lost.",
context->NumberOfActions
);
}
}
else if (!NT_SUCCESS(status))
{
SetDlgItemText(hwndDlg, IDC_RESETFAILCOUNT, L"0");
if (WindowsVersion >= WINDOWS_VISTA)
{
context->EnableFlagCheckBox = TRUE;
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLEFORERRORSTOPS), TRUE);
}
PhShowWarning(hwndDlg, L"Unable to query service recovery information: %s",
((PPH_STRING)PH_AUTO(PhGetNtMessage(status)))->Buffer);
}
EspFixControls(hwndDlg, context);
context->Ready = TRUE;
}
break;
case WM_DESTROY:
{
PhClearReference(&context->RebootMessage);
PhFree(context);
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_FIRSTFAILURE:
case IDC_SECONDFAILURE:
case IDC_SUBSEQUENTFAILURES:
{
if (HIWORD(wParam) == CBN_SELCHANGE)
{
EspFixControls(hwndDlg, context);
}
}
break;
case IDC_RESTARTCOMPUTEROPTIONS:
{
DialogBoxParam(
PluginInstance->DllBase,
MAKEINTRESOURCE(IDD_RESTARTCOMP),
hwndDlg,
RestartComputerDlgProc,
(LPARAM)context
);
}
break;
case IDC_BROWSE:
{
static PH_FILETYPE_FILTER filters[] =
{
{ L"Executable files (*.exe;*.cmd;*.bat)", L"*.exe;*.cmd;*.bat" },
{ L"All files (*.*)", L"*.*" }
};
PVOID fileDialog;
PPH_STRING fileName;
fileDialog = PhCreateOpenFileDialog();
PhSetFileDialogFilter(fileDialog, filters, sizeof(filters) / sizeof(PH_FILETYPE_FILTER));
fileName = PhaGetDlgItemText(hwndDlg, IDC_RUNPROGRAM);
PhSetFileDialogFileName(fileDialog, fileName->Buffer);
if (PhShowFileDialog(hwndDlg, fileDialog))
{
fileName = PH_AUTO(PhGetFileDialogFileName(fileDialog));
SetDlgItemText(hwndDlg, IDC_RUNPROGRAM, fileName->Buffer);
}
PhFreeFileDialog(fileDialog);
}
break;
case IDC_ENABLEFORERRORSTOPS:
{
context->Dirty = TRUE;
}
break;
}
switch (HIWORD(wParam))
{
case EN_CHANGE:
case CBN_SELCHANGE:
{
if (context->Ready)
context->Dirty = TRUE;
}
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
switch (header->code)
{
case PSN_KILLACTIVE:
{
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, FALSE);
}
return TRUE;
case PSN_APPLY:
{
NTSTATUS status;
PPH_SERVICE_ITEM serviceItem = context->ServiceItem;
SC_HANDLE serviceHandle;
ULONG restartServiceAfter;
SERVICE_FAILURE_ACTIONS failureActions;
SC_ACTION actions[3];
ULONG i;
BOOLEAN enableRestart = FALSE;
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
if (!context->Dirty)
{
return TRUE;
}
// Build the failure actions structure.
failureActions.dwResetPeriod = GetDlgItemInt(hwndDlg, IDC_RESETFAILCOUNT, NULL, FALSE) * 60 * 60 * 24;
failureActions.lpRebootMsg = PhGetStringOrEmpty(context->RebootMessage);
failureActions.lpCommand = PhaGetDlgItemText(hwndDlg, IDC_RUNPROGRAM)->Buffer;
failureActions.cActions = 3;
failureActions.lpsaActions = actions;
actions[0].Type = ComboBoxToServiceAction(GetDlgItem(hwndDlg, IDC_FIRSTFAILURE));
actions[1].Type = ComboBoxToServiceAction(GetDlgItem(hwndDlg, IDC_SECONDFAILURE));
actions[2].Type = ComboBoxToServiceAction(GetDlgItem(hwndDlg, IDC_SUBSEQUENTFAILURES));
restartServiceAfter = GetDlgItemInt(hwndDlg, IDC_RESTARTSERVICEAFTER, NULL, FALSE) * 1000 * 60;
for (i = 0; i < 3; i++)
{
switch (actions[i].Type)
{
case SC_ACTION_RESTART:
actions[i].Delay = restartServiceAfter;
enableRestart = TRUE;
break;
case SC_ACTION_REBOOT:
actions[i].Delay = context->RebootAfter;
break;
case SC_ACTION_RUN_COMMAND:
actions[i].Delay = 0;
break;
}
}
// Try to save the changes.
serviceHandle = PhOpenService(
serviceItem->Name->Buffer,
SERVICE_CHANGE_CONFIG | (enableRestart ? SERVICE_START : 0) // SC_ACTION_RESTART requires SERVICE_START
);
if (serviceHandle)
{
if (ChangeServiceConfig2(
serviceHandle,
SERVICE_CONFIG_FAILURE_ACTIONS,
&failureActions
))
{
if (context->EnableFlagCheckBox)
{
SERVICE_FAILURE_ACTIONS_FLAG failureActionsFlag;
failureActionsFlag.fFailureActionsOnNonCrashFailures =
Button_GetCheck(GetDlgItem(hwndDlg, IDC_ENABLEFORERRORSTOPS)) == BST_CHECKED;
ChangeServiceConfig2(
serviceHandle,
SERVICE_CONFIG_FAILURE_ACTIONS_FLAG,
&failureActionsFlag
);
}
CloseServiceHandle(serviceHandle);
}
else
{
CloseServiceHandle(serviceHandle);
goto ErrorCase;
}
}
else
{
if (GetLastError() == ERROR_ACCESS_DENIED && !PhGetOwnTokenAttributes().Elevated)
{
// Elevate using phsvc.
if (PhUiConnectToPhSvc(hwndDlg, FALSE))
{
if (NT_SUCCESS(status = PhSvcCallChangeServiceConfig2(
serviceItem->Name->Buffer,
SERVICE_CONFIG_FAILURE_ACTIONS,
&failureActions
)))
{
if (context->EnableFlagCheckBox)
{
SERVICE_FAILURE_ACTIONS_FLAG failureActionsFlag;
failureActionsFlag.fFailureActionsOnNonCrashFailures =
Button_GetCheck(GetDlgItem(hwndDlg, IDC_ENABLEFORERRORSTOPS)) == BST_CHECKED;
PhSvcCallChangeServiceConfig2(
serviceItem->Name->Buffer,
SERVICE_CONFIG_FAILURE_ACTIONS_FLAG,
&failureActionsFlag
);
}
}
PhUiDisconnectFromPhSvc();
if (!NT_SUCCESS(status))
{
SetLastError(PhNtStatusToDosError(status));
goto ErrorCase;
}
}
else
{
// User cancelled elevation.
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_INVALID);
}
}
else
{
goto ErrorCase;
}
}
return TRUE;
ErrorCase:
if (PhShowMessage(
hwndDlg,
MB_ICONERROR | MB_RETRYCANCEL,
L"Unable to change service recovery information: %s",
((PPH_STRING)PH_AUTO(PhGetWin32Message(GetLastError())))->Buffer
) == IDRETRY)
{
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_INVALID);
}
}
return TRUE;
}
}
break;
}
return FALSE;
}
INT_PTR CALLBACK DlgProcRecvFile(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
struct FileDlgData *dat;
dat=(struct FileDlgData*)GetWindowLongPtr(hwndDlg,GWLP_USERDATA);
switch (msg) {
case WM_INITDIALOG: {
TCHAR *contactName;
TCHAR szPath[450];
CLISTEVENT* cle = (CLISTEVENT*)lParam;
TranslateDialogDefault(hwndDlg);
dat=(struct FileDlgData*)mir_calloc(sizeof(struct FileDlgData));
SetWindowLongPtr(hwndDlg,GWLP_USERDATA,(LONG_PTR)dat);
dat->hContact = cle->hContact;
dat->hDbEvent = cle->hDbEvent;
dat->hPreshutdownEvent = HookEventMessage(ME_SYSTEM_PRESHUTDOWN,hwndDlg,M_PRESHUTDOWN);
dat->dwTicks = GetTickCount();
EnumChildWindows(hwndDlg,ClipSiblingsChildEnumProc,0);
Window_SetIcon_IcoLib(hwndDlg, SKINICON_EVENT_FILE);
Button_SetIcon_IcoLib(hwndDlg, IDC_ADD, SKINICON_OTHER_ADDCONTACT, LPGEN("Add Contact Permanently to List"));
Button_SetIcon_IcoLib(hwndDlg, IDC_DETAILS, SKINICON_OTHER_USERDETAILS, LPGEN("View User's Details"));
Button_SetIcon_IcoLib(hwndDlg, IDC_HISTORY, SKINICON_OTHER_HISTORY, LPGEN("View User's History"));
Button_SetIcon_IcoLib(hwndDlg, IDC_USERMENU, SKINICON_OTHER_DOWNARROW, LPGEN("User Menu"));
contactName = cli.pfnGetContactDisplayName( dat->hContact, 0 );
SetDlgItemText(hwndDlg,IDC_FROM,contactName);
GetContactReceivedFilesDir(dat->hContact,szPath,SIZEOF(szPath),TRUE);
SetDlgItemText(hwndDlg,IDC_FILEDIR,szPath);
{
int i;
char idstr[32];
DBVARIANT dbv;
if (shAutoComplete)
shAutoComplete(GetWindow(GetDlgItem(hwndDlg,IDC_FILEDIR),GW_CHILD),1);
for(i=0;i<MAX_MRU_DIRS;i++) {
mir_snprintf(idstr, SIZEOF(idstr), "MruDir%d",i);
if(DBGetContactSettingTString(NULL,"SRFile",idstr,&dbv)) break;
SendDlgItemMessage(hwndDlg,IDC_FILEDIR,CB_ADDSTRING,0,(LPARAM)dbv.ptszVal);
DBFreeVariant(&dbv);
}
}
CallService(MS_DB_EVENT_MARKREAD,(WPARAM)dat->hContact,(LPARAM)dat->hDbEvent);
{
DBEVENTINFO dbei={0};
TCHAR datetimestr[64];
char buf[540];
dbei.cbSize=sizeof(dbei);
dbei.cbBlob=CallService(MS_DB_EVENT_GETBLOBSIZE,(WPARAM)dat->hDbEvent,0);
dbei.pBlob=(PBYTE)mir_alloc(dbei.cbBlob);
CallService(MS_DB_EVENT_GET,(WPARAM)dat->hDbEvent,(LPARAM)&dbei);
dat->fs = cle->lParam ? (HANDLE)cle->lParam : (HANDLE)*(PDWORD)dbei.pBlob;
lstrcpynA(buf, (char*)dbei.pBlob+4, min(dbei.cbBlob+1,SIZEOF(buf)));
TCHAR* ptszFileName = DbGetEventStringT( &dbei, buf );
SetDlgItemText(hwndDlg,IDC_FILENAMES,ptszFileName);
mir_free(ptszFileName);
lstrcpynA(buf, (char*)dbei.pBlob+4+strlen((char*)dbei.pBlob+4)+1, min((int)(dbei.cbBlob-4-strlen((char*)dbei.pBlob+4)),SIZEOF(buf)));
TCHAR* ptszDescription = DbGetEventStringT( &dbei, buf );
SetDlgItemText(hwndDlg,IDC_MSG,ptszDescription);
mir_free(ptszDescription);
mir_free(dbei.pBlob);
tmi.printTimeStamp(NULL, dbei.timestamp, _T("t d"), datetimestr, SIZEOF(datetimestr), 0);
SetDlgItemText(hwndDlg, IDC_DATE, datetimestr);
}
{
char* szProto = (char*)CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)dat->hContact, 0);
if (szProto) {
CONTACTINFO ci;
int hasName = 0;
char buf[128];
ZeroMemory(&ci,sizeof(ci));
ci.cbSize = sizeof(ci);
ci.hContact = dat->hContact;
ci.szProto = szProto;
ci.dwFlag = CNF_UNIQUEID;
if (!CallService(MS_CONTACT_GETCONTACTINFO,0,(LPARAM)&ci)) {
switch(ci.type) {
case CNFT_ASCIIZ:
hasName = 1;
mir_snprintf(buf, SIZEOF(buf), "%s", ci.pszVal);
mir_free(ci.pszVal);
break;
case CNFT_DWORD:
hasName = 1;
mir_snprintf(buf, SIZEOF(buf),"%u",ci.dVal);
break;
} }
if (hasName)
SetDlgItemTextA(hwndDlg, IDC_NAME, buf );
else
SetDlgItemText(hwndDlg, IDC_NAME, contactName);
} }
if(DBGetContactSettingByte(dat->hContact,"CList","NotOnList",0)) {
RECT rcBtn1,rcBtn2,rcDateCtrl;
GetWindowRect(GetDlgItem(hwndDlg,IDC_ADD),&rcBtn1);
GetWindowRect(GetDlgItem(hwndDlg,IDC_USERMENU),&rcBtn2);
GetWindowRect(GetDlgItem(hwndDlg,IDC_DATE),&rcDateCtrl);
SetWindowPos(GetDlgItem(hwndDlg,IDC_DATE),0,0,0,rcDateCtrl.right-rcDateCtrl.left-(rcBtn2.left-rcBtn1.left),rcDateCtrl.bottom-rcDateCtrl.top,SWP_NOZORDER|SWP_NOMOVE);
}
else if(DBGetContactSettingByte(NULL,"SRFile","AutoAccept",0)) {
//don't check auto-min here to fix BUG#647620
PostMessage(hwndDlg,WM_COMMAND,MAKEWPARAM(IDOK,BN_CLICKED),(LPARAM)GetDlgItem(hwndDlg,IDOK));
}
if(!DBGetContactSettingByte(dat->hContact,"CList","NotOnList",0))
ShowWindow(GetDlgItem(hwndDlg, IDC_ADD),SW_HIDE);
return TRUE;
}
case WM_MEASUREITEM:
return CallService(MS_CLIST_MENUMEASUREITEM,wParam,lParam);
case WM_DRAWITEM:
{ LPDRAWITEMSTRUCT dis=(LPDRAWITEMSTRUCT)lParam;
if(dis->hwndItem==GetDlgItem(hwndDlg, IDC_PROTOCOL)) {
char *szProto;
szProto=(char*)CallService(MS_PROTO_GETCONTACTBASEPROTO,(WPARAM)dat->hContact,0);
if (szProto) {
HICON hIcon;
hIcon=(HICON)CallProtoService(szProto,PS_LOADICON,PLI_PROTOCOL|PLIF_SMALL,0);
if (hIcon) {
DrawIconEx(dis->hDC,dis->rcItem.left,dis->rcItem.top,hIcon,GetSystemMetrics(SM_CXSMICON),GetSystemMetrics(SM_CYSMICON),0,NULL,DI_NORMAL);
DestroyIcon(hIcon);
} } } }
return CallService(MS_CLIST_MENUDRAWITEM,wParam,lParam);
case WM_COMMAND:
if ( CallService(MS_CLIST_MENUPROCESSCOMMAND, MAKEWPARAM(LOWORD(wParam),MPCF_CONTACTMENU), (LPARAM)dat->hContact ))
break;
switch ( LOWORD( wParam )) {
case IDC_FILEDIRBROWSE:
{
TCHAR szDirName[MAX_PATH],szExistingDirName[MAX_PATH];
GetDlgItemText(hwndDlg,IDC_FILEDIR,szDirName,SIZEOF(szDirName));
GetLowestExistingDirName(szDirName,szExistingDirName,SIZEOF(szExistingDirName));
if(BrowseForFolder(hwndDlg,szExistingDirName))
SetDlgItemText(hwndDlg,IDC_FILEDIR,szExistingDirName);
}
break;
case IDOK:
{ //most recently used directories
TCHAR szRecvDir[MAX_PATH],szDefaultRecvDir[MAX_PATH];
GetDlgItemText(hwndDlg,IDC_FILEDIR,szRecvDir,SIZEOF(szRecvDir));
RemoveInvalidPathChars(szRecvDir);
GetContactReceivedFilesDir(NULL,szDefaultRecvDir,SIZEOF(szDefaultRecvDir),TRUE);
if(_tcsnicmp(szRecvDir,szDefaultRecvDir,lstrlen(szDefaultRecvDir))) {
char idstr[32];
int i;
DBVARIANT dbv;
for(i=MAX_MRU_DIRS-2;i>=0;i--) {
mir_snprintf(idstr, SIZEOF(idstr), "MruDir%d",i);
if(DBGetContactSettingTString(NULL,"SRFile",idstr,&dbv)) continue;
mir_snprintf(idstr, SIZEOF(idstr), "MruDir%d",i+1);
DBWriteContactSettingTString(NULL,"SRFile",idstr,dbv.ptszVal);
DBFreeVariant(&dbv);
}
DBWriteContactSettingTString(NULL,"SRFile",idstr,szRecvDir);
}
}
EnableWindow(GetDlgItem(hwndDlg,IDC_FILENAMES),FALSE);
EnableWindow(GetDlgItem(hwndDlg,IDC_MSG),FALSE);
EnableWindow(GetDlgItem(hwndDlg,IDC_FILEDIR),FALSE);
EnableWindow(GetDlgItem(hwndDlg,IDC_FILEDIRBROWSE),FALSE);
GetDlgItemText(hwndDlg,IDC_FILEDIR,dat->szSavePath,SIZEOF(dat->szSavePath));
GetDlgItemText(hwndDlg,IDC_FILE,dat->szFilenames,SIZEOF(dat->szFilenames));
GetDlgItemText(hwndDlg,IDC_MSG,dat->szMsg,SIZEOF(dat->szMsg));
dat->hwndTransfer = FtMgr_AddTransfer(dat);
SetWindowLongPtr( hwndDlg, GWLP_USERDATA, 0);
//check for auto-minimize here to fix BUG#647620
if(DBGetContactSettingByte(NULL,"SRFile","AutoAccept",0) && DBGetContactSettingByte(NULL,"SRFile","AutoMin",0)) {
ShowWindow(hwndDlg,SW_HIDE);
ShowWindow(hwndDlg,SW_SHOWMINNOACTIVE);
}
DestroyWindow(hwndDlg);
break;
case IDCANCEL:
if (dat->fs) CallContactService(dat->hContact,PSS_FILEDENYT,(WPARAM)dat->fs,(LPARAM)TranslateT("Cancelled"));
dat->fs=NULL; /* the protocol will free the handle */
DestroyWindow(hwndDlg);
break;
case IDC_ADD:
{ ADDCONTACTSTRUCT acs={0};
acs.handle=dat->hContact;
acs.handleType=HANDLE_CONTACT;
acs.szProto="";
CallService(MS_ADDCONTACT_SHOW,(WPARAM)hwndDlg,(LPARAM)&acs);
if(!DBGetContactSettingByte(dat->hContact,"CList","NotOnList",0))
ShowWindow(GetDlgItem(hwndDlg,IDC_ADD), SW_HIDE);
}
break;
case IDC_USERMENU:
{ RECT rc;
HMENU hMenu=(HMENU)CallService(MS_CLIST_MENUBUILDCONTACT,(WPARAM)dat->hContact,0);
GetWindowRect((HWND)lParam,&rc);
TrackPopupMenu(hMenu,0,rc.left,rc.bottom,0,hwndDlg,NULL);
DestroyMenu(hMenu);
}
break;
case IDC_DETAILS:
CallService(MS_USERINFO_SHOWDIALOG,(WPARAM)dat->hContact,0);
break;
case IDC_HISTORY:
CallService(MS_HISTORY_SHOWCONTACTHISTORY,(WPARAM)dat->hContact,0);
break;
}
break;
case WM_DESTROY:
Window_FreeIcon_IcoLib(hwndDlg);
Button_FreeIcon_IcoLib(hwndDlg,IDC_ADD);
Button_FreeIcon_IcoLib(hwndDlg,IDC_DETAILS);
Button_FreeIcon_IcoLib(hwndDlg,IDC_HISTORY);
Button_FreeIcon_IcoLib(hwndDlg,IDC_USERMENU);
if ( dat ) FreeFileDlgData( dat );
break;
}
return FALSE;
}
void enableTimeInput(HWND hDlg, BOOL enable)
{
EnableWindow(GetDlgItem(hDlg, IDC_MINUTES), enable);
EnableWindow(GetDlgItem(hDlg, IDC_SECONDS), enable);
}
static INT_PTR CALLBACK OptionsDlgProc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
{
OptionsPageData *opd;
OptionsDlgData *dat = (OptionsDlgData*)GetWindowLongPtr(hdlg, GWLP_USERDATA);
HWND hwndTree = GetDlgItem(hdlg, IDC_PAGETREE);
switch (message) {
case WM_CTLCOLORSTATIC:
switch (GetDlgCtrlID((HWND)lParam)) {
case IDC_WHITERECT:
case IDC_KEYWORD_FILTER:
SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
return (INT_PTR)GetSysColorBrush(COLOR_WINDOW);
}
break;
case WM_INITDIALOG:
TranslateDialogDefault(hdlg);
if (!ServiceExists(MS_MODERNOPT_SHOW))
ShowWindow(GetDlgItem(hdlg, IDC_MODERN), FALSE);
dat = new OptionsDlgData;
SetWindowLongPtr(hdlg, GWLP_USERDATA, (LONG_PTR)dat);
Utils_RestoreWindowPositionNoSize(hdlg, NULL, "Options", "");
Window_SetIcon_IcoLib(hdlg, SKINICON_OTHER_OPTIONS);
EnableWindow(GetDlgItem(hdlg, IDC_APPLY), FALSE);
{
COMBOBOXINFO cbi;
cbi.cbSize = sizeof(COMBOBOXINFO);
GetComboBoxInfo(GetDlgItem(hdlg, IDC_KEYWORD_FILTER), &cbi);
mir_subclassWindow(cbi.hwndItem, OptionsFilterSubclassProc);
if (IsAeroMode()) {
mir_subclassWindow(cbi.hwndCombo, AeroPaintSubclassProc);
mir_subclassWindow(cbi.hwndItem, AeroPaintSubclassProc);
}
PROPSHEETHEADER *psh = (PROPSHEETHEADER*)lParam;
SetWindowText(hdlg, psh->pszCaption);
LOGFONT lf;
dat->hBoldFont = (HFONT)SendDlgItemMessage(hdlg, IDC_APPLY, WM_GETFONT, 0, 0);
GetObject(dat->hBoldFont, sizeof(lf), &lf);
lf.lfWeight = FW_BOLD;
dat->hBoldFont = CreateFontIndirect(&lf);
dat->hPluginLoad = HookEventMessage(ME_SYSTEM_MODULELOAD, hdlg, HM_MODULELOAD);
dat->hPluginUnload = HookEventMessage(ME_SYSTEM_MODULEUNLOAD, hdlg, HM_MODULEUNLOAD);
dat->currentPage = -1;
ptrT lastPage, lastGroup, lastTab;
OPENOPTIONSDIALOG *ood = (OPENOPTIONSDIALOG*)psh->pStartPage;
if (ood->pszPage == NULL) {
lastPage = db_get_tsa(NULL, "Options", "LastPage");
if (ood->pszGroup == NULL)
lastGroup = db_get_tsa(NULL, "Options", "LastGroup");
else
lastGroup = mir_a2t(ood->pszGroup);
}
else {
lastPage = mir_a2t(ood->pszPage);
lastGroup = mir_a2t(ood->pszGroup);
}
if (ood->pszTab == NULL)
lastTab = db_get_tsa(NULL, "Options", "LastTab");
else
lastTab = mir_a2t(ood->pszTab);
OPTIONSDIALOGPAGE *odp = (OPTIONSDIALOGPAGE*)psh->ppsp;
for (UINT i = 0; i < psh->nPages; i++, odp++) {
opd = new OptionsPageData(odp);
if (opd->pDialog == NULL) // smth went wrong
delete opd;
else
dat->arOpd.insert(opd);
if (!mir_tstrcmp(lastPage, odp->ptszTitle) && !mir_tstrcmp(lastGroup, odp->ptszGroup))
if ((ood->pszTab == NULL && dat->currentPage == -1) || !mir_tstrcmp(lastTab, odp->ptszTab))
dat->currentPage = (int)i;
}
GetWindowRect(GetDlgItem(hdlg, IDC_STNOPAGE), &dat->rcDisplay);
MapWindowPoints(NULL, hdlg, (LPPOINT)&dat->rcDisplay, 2);
// Add an item to count in height
TCITEM tie;
tie.mask = TCIF_TEXT | TCIF_IMAGE;
tie.iImage = -1;
tie.pszText = _T("X");
TabCtrl_InsertItem(GetDlgItem(hdlg, IDC_TAB), 0, &tie);
GetWindowRect(GetDlgItem(hdlg, IDC_TAB), &dat->rcTab);
MapWindowPoints(NULL, hdlg, (LPPOINT)&dat->rcTab, 2);
TabCtrl_AdjustRect(GetDlgItem(hdlg, IDC_TAB), FALSE, &dat->rcTab);
FillFilterCombo(hdlg, dat);
PostMessage(hdlg, DM_REBUILDPAGETREE, 0, 0);
}
return TRUE;
case DM_REBUILDPAGETREE:
RebuildPageTree(hdlg, dat);
break;
case HM_MODULELOAD:
LoadOptionsModule(hdlg, dat, (HINSTANCE)lParam);
break;
case HM_MODULEUNLOAD:
UnloadOptionsModule(hdlg, dat, (HINSTANCE)lParam);
break;
case PSM_CHANGED:
EnableWindow(GetDlgItem(hdlg, IDC_APPLY), TRUE);
opd = dat->getCurrent();
if (opd)
opd->changed = 1;
return TRUE;
case PSM_GETBOLDFONT:
SetWindowLongPtr(hdlg, DWLP_MSGRESULT, (LONG_PTR)dat->hBoldFont);
return TRUE;
case WM_NOTIFY:
switch (wParam) {
case IDC_TAB:
case IDC_PAGETREE:
switch (((LPNMHDR)lParam)->code) {
case TVN_ITEMEXPANDING:
SetWindowLongPtr(hdlg, DWLP_MSGRESULT, FALSE);
return TRUE;
case TCN_SELCHANGING:
case TVN_SELCHANGING:
opd = dat->getCurrent();
if (opd && opd->getHwnd() != NULL) {
PSHNOTIFY pshn;
pshn.hdr.code = PSN_KILLACTIVE;
pshn.hdr.hwndFrom = dat->arOpd[dat->currentPage]->getHwnd();
pshn.hdr.idFrom = 0;
pshn.lParam = 0;
if (SendMessage(dat->arOpd[dat->currentPage]->getHwnd(), WM_NOTIFY, 0, (LPARAM)&pshn)) {
SetWindowLongPtr(hdlg, DWLP_MSGRESULT, TRUE);
return TRUE;
}
}
break;
case TCN_SELCHANGE:
case TVN_SELCHANGED:
ShowWindow(GetDlgItem(hdlg, IDC_STNOPAGE), SW_HIDE);
opd = dat->getCurrent();
if (opd && opd->getHwnd() != NULL)
ShowWindow(opd->getHwnd(), SW_HIDE);
if (wParam != IDC_TAB) {
TVITEM tvi;
tvi.hItem = dat->hCurrentPage = TreeView_GetSelection(hwndTree);
if (tvi.hItem == NULL) {
ShowWindow(GetDlgItem(hdlg, IDC_TAB), SW_HIDE);
break;
}
tvi.mask = TVIF_HANDLE | TVIF_PARAM;
TreeView_GetItem(hwndTree, &tvi);
dat->currentPage = tvi.lParam;
ShowWindow(GetDlgItem(hdlg, IDC_TAB), SW_HIDE);
}
else {
TCITEM tie;
tie.mask = TCIF_PARAM;
TabCtrl_GetItem(GetDlgItem(hdlg, IDC_TAB), TabCtrl_GetCurSel(GetDlgItem(hdlg, IDC_TAB)), &tie);
dat->currentPage = tie.lParam;
TVITEM tvi;
tvi.hItem = dat->hCurrentPage;
tvi.mask = TVIF_PARAM;
tvi.lParam = dat->currentPage;
TreeView_SetItem(hwndTree, &tvi);
}
opd = dat->getCurrent();
if (opd == NULL) {
ShowWindow(GetDlgItem(hdlg, IDC_STNOPAGE), SW_SHOW);
break;
}
if (opd->getHwnd() == NULL) {
CreateOptionWindow(opd, hdlg);
if (opd->flags & ODPF_BOLDGROUPS)
EnumChildWindows(opd->getHwnd(), BoldGroupTitlesEnumChildren, (LPARAM)dat->hBoldFont);
RECT rcPage;
GetClientRect(opd->getHwnd(), &rcPage);
int w = opd->width = rcPage.right;
int h = opd->height = rcPage.bottom;
RECT rc;
GetWindowRect(opd->getHwnd(), &rc);
opd->insideTab = IsInsideTab(hdlg, dat, dat->currentPage);
if (opd->insideTab) {
SetWindowPos(opd->getHwnd(), HWND_TOP, (dat->rcTab.left + dat->rcTab.right - w) >> 1, dat->rcTab.top, w, h, 0);
ThemeDialogBackground(opd->getHwnd(), TRUE);
}
else {
SetWindowPos(opd->getHwnd(), HWND_TOP, (dat->rcDisplay.left + dat->rcDisplay.right - w) >> 1, (dat->rcDisplay.top + dat->rcDisplay.bottom - h) >> 1, w, h, 0);
ThemeDialogBackground(opd->getHwnd(), FALSE);
}
}
if (wParam != IDC_TAB) {
opd->insideTab = IsInsideTab(hdlg, dat, dat->currentPage);
if (opd->insideTab) {
// Make tabbed pane
int pages = 0, sel = 0;
HWND hwndTab = GetDlgItem(hdlg, IDC_TAB);
TabCtrl_DeleteAllItems(hwndTab);
TCITEM tie;
tie.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_PARAM;
tie.iImage = -1;
for (int i = 0; i < dat->arOpd.getCount(); i++) {
if (!CheckPageShow(hdlg, dat, i))
continue;
OptionsPageData *p = dat->arOpd[i];
if (mir_tstrcmp(opd->ptszTitle, p->ptszTitle) || mir_tstrcmp(opd->ptszGroup, p->ptszGroup))
continue;
tie.pszText = TranslateTH(p->hLangpack, p->ptszTab);
tie.lParam = i;
TabCtrl_InsertItem(hwndTab, pages, &tie);
if (!mir_tstrcmp(opd->ptszTab, p->ptszTab))
sel = pages;
pages++;
}
TabCtrl_SetCurSel(hwndTab, sel);
ShowWindow(hwndTab, opd->insideTab ? SW_SHOW : SW_HIDE);
}
ThemeDialogBackground(opd->getHwnd(), opd->insideTab);
}
ShowWindow(opd->getHwnd(), SW_SHOW);
if (((LPNMTREEVIEW)lParam)->action == TVC_BYMOUSE)
PostMessage(hdlg, DM_FOCUSPAGE, 0, 0);
else
SetFocus(hwndTree);
}
INT_PTR CALLBACK DlgProcPopupGeneral(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
static bool bDlgInit = false; // some controls send WM_COMMAND before or during WM_INITDIALOG
static OPTTREE_OPTION *statusOptions = NULL;
static int statusOptionsCount = 0;
if (statusOptions) {
int index;
if (OptTree_ProcessMessage(hwnd, msg, wParam, lParam, &index, IDC_STATUSES, statusOptions, statusOptionsCount))
return TRUE;
}
switch (msg) {
case WM_INITDIALOG:
// Seconds of delay
CheckDlgButton(hwnd, IDC_INFINITEDELAY, PopupOptions.InfiniteDelay ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwnd, IDC_LEAVEHOVERED, PopupOptions.LeaveHovered ? BST_CHECKED : BST_UNCHECKED);
EnableWindow(GetDlgItem(hwnd, IDC_SECONDS), !PopupOptions.InfiniteDelay);
EnableWindow(GetDlgItem(hwnd, IDC_SECONDS_STATIC1), !PopupOptions.InfiniteDelay);
EnableWindow(GetDlgItem(hwnd, IDC_SECONDS_STATIC2), !PopupOptions.InfiniteDelay);
EnableWindow(GetDlgItem(hwnd, IDC_LEAVEHOVERED), !PopupOptions.InfiniteDelay);
SetDlgItemInt(hwnd, IDC_SECONDS, PopupOptions.Seconds, FALSE);
SendDlgItemMessage(hwnd, IDC_SECONDS_SPIN, UDM_SETRANGE, 0, (LPARAM)MAKELONG(SETTING_LIFETIME_MAX, SETTING_LIFETIME_MIN));
// Dynamic Resize
CheckDlgButton(hwnd, IDC_DYNAMICRESIZE, PopupOptions.DynamicResize ? BST_CHECKED : BST_UNCHECKED);
SetDlgItemText(hwnd, IDC_USEMAXIMUMWIDTH, PopupOptions.DynamicResize ? LPGENT("Maximum width") : LPGENT("Width"));
// Minimum Width
CheckDlgButton(hwnd, IDC_USEMINIMUMWIDTH, PopupOptions.UseMinimumWidth ? BST_CHECKED : BST_UNCHECKED);
SendDlgItemMessage(hwnd, IDC_MINIMUMWIDTH_SPIN, UDM_SETRANGE, 0, (LPARAM)MAKELONG(SETTING_MAXIMUMWIDTH_MAX, SETTING_MINIMUMWIDTH_MIN));
SetDlgItemInt(hwnd, IDC_MINIMUMWIDTH, PopupOptions.MinimumWidth, FALSE);
// Maximum Width
PopupOptions.UseMaximumWidth = PopupOptions.DynamicResize ? PopupOptions.UseMaximumWidth : TRUE;
CheckDlgButton(hwnd, IDC_USEMAXIMUMWIDTH, PopupOptions.UseMaximumWidth ? BST_CHECKED : BST_UNCHECKED);
SendDlgItemMessage(hwnd, IDC_MAXIMUMWIDTH_SPIN, UDM_SETRANGE, 0, (LPARAM)MAKELONG(SETTING_MAXIMUMWIDTH_MAX, SETTING_MINIMUMWIDTH_MIN));
SetDlgItemInt(hwnd, IDC_MAXIMUMWIDTH, PopupOptions.MaximumWidth, FALSE);
// And finally let's enable/disable them.
EnableWindow(GetDlgItem(hwnd, IDC_USEMINIMUMWIDTH), PopupOptions.DynamicResize);
EnableWindow(GetDlgItem(hwnd, IDC_MINIMUMWIDTH), PopupOptions.DynamicResize && PopupOptions.UseMinimumWidth);
EnableWindow(GetDlgItem(hwnd, IDC_MINIMUMWIDTH_SPIN), PopupOptions.DynamicResize && PopupOptions.UseMinimumWidth);
EnableWindow(GetDlgItem(hwnd, IDC_MAXIMUMWIDTH), PopupOptions.UseMaximumWidth);
EnableWindow(GetDlgItem(hwnd, IDC_MAXIMUMWIDTH_SPIN), PopupOptions.UseMaximumWidth);
// Position combobox.
{
HWND hCtrl = GetDlgItem(hwnd, IDC_WHERE);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("Upper left corner")), POS_UPPERLEFT);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("Lower left corner")), POS_LOWERLEFT);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("Lower right corner")), POS_LOWERRIGHT);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("Upper right corner")), POS_UPPERRIGHT);
SendDlgItemMessage(hwnd, IDC_WHERE, CB_SETCURSEL, PopupOptions.Position, 0);
}
// Configure popup area
{
HWND hCtrl = GetDlgItem(hwnd, IDC_CUSTOMPOS);
SendMessage(hCtrl, BUTTONSETASFLATBTN, TRUE, 0);
SendMessage(hCtrl, BUTTONADDTOOLTIP, (WPARAM)_T("Popup area"), BATF_TCHAR);
SendMessage(hCtrl, BM_SETIMAGE, IMAGE_ICON, (LPARAM)LoadIconEx(IDI_RESIZE));
}
// Spreading combobox
{
HWND hCtrl = GetDlgItem(hwnd, IDC_LAYOUT);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("Horizontal")), SPREADING_HORIZONTAL);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("Vertical")), SPREADING_VERTICAL);
SendDlgItemMessage(hwnd, IDC_LAYOUT, CB_SETCURSEL, PopupOptions.Spreading, 0);
}
// miscellaneous
CheckDlgButton(hwnd, IDC_REORDERPOPUPS, PopupOptions.ReorderPopups ? BST_CHECKED : BST_UNCHECKED);
// Popup enabled
CheckDlgButton(hwnd, IDC_POPUPENABLED, PopupOptions.ModuleIsEnabled ? BST_UNCHECKED : BST_CHECKED);
CheckDlgButton(hwnd, IDC_DISABLEINFS, PopupOptions.DisableWhenFullscreen ? BST_CHECKED : BST_UNCHECKED);
EnableWindow(GetDlgItem(hwnd, IDC_DISABLEINFS), PopupOptions.ModuleIsEnabled);
EnableWindow(GetDlgItem(hwnd, IDC_STATUSES), PopupOptions.ModuleIsEnabled);
// new status options
{
int protocolCount = 0;
PROTOACCOUNT **protocols;
Proto_EnumAccounts(&protocolCount, &protocols);
DWORD globalFlags = 0;
for (int i = 0; i < protocolCount; ++i) {
if (!protocols[i]->bIsVirtual) {
DWORD protoFlags = CallProtoService(protocols[i]->szModuleName, PS_GETCAPS, PFLAGNUM_2, 0);
globalFlags |= protoFlags;
statusOptionsCount += CountStatusModes(protoFlags);
}
}
statusOptionsCount += CountStatusModes(globalFlags);
statusOptions = new OPTTREE_OPTION[statusOptionsCount];
int pos = AddStatusModes(statusOptions, 0, LPGENT("Global Status"), globalFlags);
for (int i = 0; i < protocolCount; ++i) {
if (!protocols[i]->bIsVirtual) {
DWORD protoFlags = CallProtoService(protocols[i]->szModuleName, PS_GETCAPS, PFLAGNUM_2, 0);
if (!CountStatusModes(protoFlags))
continue;
TCHAR prefix[128];
mir_sntprintf(prefix, _countof(prefix), LPGENT("Protocol Status")_T("/%s"), protocols[i]->tszAccountName);
pos = AddStatusModes(statusOptions, pos, prefix, protoFlags);
}
}
int index;
OptTree_ProcessMessage(hwnd, msg, wParam, lParam, &index, IDC_STATUSES, statusOptions, statusOptionsCount);
for (int i = 0; i < protocolCount; ++i) {
if (!protocols[i]->bIsVirtual) {
DWORD protoFlags = CallProtoService(protocols[i]->szModuleName, PS_GETCAPS, PFLAGNUM_2, 0);
if (!CountStatusModes(protoFlags))
continue;
char prefix[128];
mir_snprintf(prefix, _countof(prefix), "Protocol Status/%s", protocols[i]->szModuleName);
TCHAR pszSettingName[256];
mir_sntprintf(pszSettingName, _countof(pszSettingName), LPGENT("Protocol Status")_T("/%s"), protocols[i]->tszAccountName);
OptTree_SetOptions(hwnd, IDC_STATUSES, statusOptions, statusOptionsCount, db_get_dw(NULL, MODULNAME, prefix, 0), pszSettingName);
}
}
OptTree_SetOptions(hwnd, IDC_STATUSES, statusOptions, statusOptionsCount, db_get_dw(NULL, MODULNAME, "Global Status", 0), LPGENT("Global Status"));
}
TranslateDialogDefault(hwnd); // do it on end of WM_INITDIALOG
bDlgInit = true;
return TRUE;
case WM_COMMAND:
switch (HIWORD(wParam)) {
case BN_CLICKED: // Button controls
switch (LOWORD(wParam)) {
case IDC_INFINITEDELAY:
PopupOptions.InfiniteDelay = !PopupOptions.InfiniteDelay;
EnableWindow(GetDlgItem(hwnd, IDC_SECONDS), !PopupOptions.InfiniteDelay);
EnableWindow(GetDlgItem(hwnd, IDC_SECONDS_STATIC1), !PopupOptions.InfiniteDelay);
EnableWindow(GetDlgItem(hwnd, IDC_SECONDS_STATIC2), !PopupOptions.InfiniteDelay);
EnableWindow(GetDlgItem(hwnd, IDC_LEAVEHOVERED), !PopupOptions.InfiniteDelay);
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
case IDC_LEAVEHOVERED:
PopupOptions.LeaveHovered = !PopupOptions.LeaveHovered;
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
case IDC_DYNAMICRESIZE:
PopupOptions.DynamicResize = !PopupOptions.DynamicResize;
EnableWindow(GetDlgItem(hwnd, IDC_USEMINIMUMWIDTH), PopupOptions.DynamicResize);
EnableWindow(GetDlgItem(hwnd, IDC_MINIMUMWIDTH), PopupOptions.DynamicResize && PopupOptions.UseMinimumWidth);
EnableWindow(GetDlgItem(hwnd, IDC_MINIMUMWIDTH_SPIN), PopupOptions.DynamicResize && PopupOptions.UseMinimumWidth);
SetDlgItemText(hwnd, IDC_USEMAXIMUMWIDTH, PopupOptions.DynamicResize ? TranslateT("Maximum width") : TranslateT("Width"));
if (!PopupOptions.DynamicResize) {
PopupOptions.UseMaximumWidth = TRUE;
CheckDlgButton(hwnd, IDC_USEMAXIMUMWIDTH, BST_CHECKED);
EnableWindow(GetDlgItem(hwnd, IDC_USEMAXIMUMWIDTH), TRUE);
EnableWindow(GetDlgItem(hwnd, IDC_MAXIMUMWIDTH), TRUE);
EnableWindow(GetDlgItem(hwnd, IDC_MAXIMUMWIDTH_SPIN), TRUE);
}
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
case IDC_USEMINIMUMWIDTH:
PopupOptions.UseMinimumWidth = !PopupOptions.UseMinimumWidth;
EnableWindow(GetDlgItem(hwnd, IDC_MINIMUMWIDTH), PopupOptions.UseMinimumWidth);
EnableWindow(GetDlgItem(hwnd, IDC_MINIMUMWIDTH_SPIN), PopupOptions.UseMinimumWidth);
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
case IDC_USEMAXIMUMWIDTH:
PopupOptions.UseMaximumWidth = Button_GetCheck((HWND)lParam);
if (!PopupOptions.DynamicResize) { // ugly - set always on if DynamicResize = off
CheckDlgButton(hwnd, LOWORD(wParam), BST_CHECKED);
PopupOptions.UseMaximumWidth = TRUE;
}
EnableWindow(GetDlgItem(hwnd, IDC_MAXIMUMWIDTH), PopupOptions.UseMaximumWidth);
EnableWindow(GetDlgItem(hwnd, IDC_MAXIMUMWIDTH_SPIN), PopupOptions.UseMaximumWidth);
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
case IDC_CUSTOMPOS:
{
RECT rcButton, rcBox;
HWND hwndBox = CreateDialog(hInst, MAKEINTRESOURCE(IDD_POSITION), NULL, PositionBoxDlgProc);
GetWindowRect((HWND)lParam, &rcButton);
GetWindowRect(hwndBox, &rcBox);
MoveWindow(hwndBox,
rcButton.right - (rcBox.right - rcBox.left) + 15,
rcButton.bottom + 3,
rcBox.right - rcBox.left,
rcBox.bottom - rcBox.top,
FALSE);
SetWindowLongPtr(hwndBox, GWL_EXSTYLE, GetWindowLongPtr(hwndBox, GWL_EXSTYLE) | WS_EX_LAYERED);
SetLayeredWindowAttributes(hwndBox, NULL, 0, LWA_ALPHA);
ShowWindow(hwndBox, SW_SHOW);
for (int i = 0; i <= 255; i += 15) {
SetLayeredWindowAttributes(hwndBox, NULL, i, LWA_ALPHA);
UpdateWindow(hwndBox);
Sleep(1);
}
SetWindowLongPtr(hwndBox, GWL_EXSTYLE, GetWindowLongPtr(hwndBox, GWL_EXSTYLE) & ~WS_EX_LAYERED);
ShowWindow(hwndBox, SW_SHOW);
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
break;
case IDC_REORDERPOPUPS:
{
PopupOptions.ReorderPopups = !PopupOptions.ReorderPopups;
PopupOptions.ReorderPopupsWarning = PopupOptions.ReorderPopups ? db_get_b(NULL, MODULNAME, "ReorderPopupsWarning", TRUE) : TRUE;
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
break;
case IDC_POPUPENABLED:
{
int chk = IsDlgButtonChecked(hwnd, IDC_POPUPENABLED);
if (PopupOptions.ModuleIsEnabled&&chk || !PopupOptions.ModuleIsEnabled && !chk)
svcEnableDisableMenuCommand(0, 0);
EnableWindow(GetDlgItem(hwnd, IDC_STATUSES), PopupOptions.ModuleIsEnabled);
EnableWindow(GetDlgItem(hwnd, IDC_DISABLEINFS), PopupOptions.ModuleIsEnabled);
}
break;
case IDC_DISABLEINFS:
PopupOptions.DisableWhenFullscreen = !PopupOptions.DisableWhenFullscreen;
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
case IDC_PREVIEW:
PopupPreview();
break;
}
break;
case CBN_SELCHANGE: // ComboBox controls
switch (LOWORD(wParam)) {
// lParam = Handle to the control
case IDC_WHERE:
PopupOptions.Position = ComboBox_GetItemData((HWND)lParam, ComboBox_GetCurSel((HWND)lParam));
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
case IDC_LAYOUT:
PopupOptions.Spreading = ComboBox_GetItemData((HWND)lParam, ComboBox_GetCurSel((HWND)lParam));
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
}
break;
case EN_CHANGE: // Edit controls change
if (!bDlgInit) break;
switch (LOWORD(wParam)) {
// lParam = Handle to the control
case IDC_SECONDS:
{
int seconds = GetDlgItemInt(hwnd, LOWORD(wParam), NULL, FALSE);
if (seconds >= SETTING_LIFETIME_MIN &&
seconds <= SETTING_LIFETIME_MAX &&
seconds != PopupOptions.Seconds) {
PopupOptions.Seconds = seconds;
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
}
break;
case IDC_MINIMUMWIDTH:
{
int temp = GetDlgItemInt(hwnd, IDC_MINIMUMWIDTH, NULL, FALSE);
if (temp >= SETTING_MINIMUMWIDTH_MIN &&
temp <= SETTING_MAXIMUMWIDTH_MAX &&
temp != PopupOptions.MinimumWidth) {
PopupOptions.MinimumWidth = temp;
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
}
break;
case IDC_MAXIMUMWIDTH:
{
int temp = GetDlgItemInt(hwnd, IDC_MAXIMUMWIDTH, NULL, FALSE);
if (temp >= SETTING_MINIMUMWIDTH_MIN &&
temp <= SETTING_MAXIMUMWIDTH_MAX &&
temp != PopupOptions.MaximumWidth) {
PopupOptions.MaximumWidth = temp;
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
}
break;
}// end switch(idCtrl)
break;
case EN_KILLFOCUS: // Edit controls lost fokus
switch (LOWORD(wParam)) {
// lParam = Handle to the control
case IDC_SECONDS:
{
int seconds = GetDlgItemInt(hwnd, LOWORD(wParam), NULL, FALSE);
if (seconds > SETTING_LIFETIME_MAX)
PopupOptions.Seconds = SETTING_LIFETIME_MAX;
else if (seconds < SETTING_LIFETIME_MIN)
PopupOptions.Seconds = SETTING_LIFETIME_MIN;
if (seconds != PopupOptions.Seconds) {
SetDlgItemInt(hwnd, LOWORD(wParam), PopupOptions.Seconds, FALSE);
ErrorMSG(SETTING_LIFETIME_MIN, SETTING_LIFETIME_MAX);
SetFocus((HWND)lParam);
}
}
break;
case IDC_MINIMUMWIDTH:
{
int temp = GetDlgItemInt(hwnd, LOWORD(wParam), NULL, FALSE);
if (temp < SETTING_MINIMUMWIDTH_MIN)
PopupOptions.MinimumWidth = SETTING_MINIMUMWIDTH_MIN;
else if (temp > SETTING_MAXIMUMWIDTH_MAX)
PopupOptions.MinimumWidth = SETTING_MAXIMUMWIDTH_MAX;
if (temp != PopupOptions.MinimumWidth) {
SetDlgItemInt(hwnd, LOWORD(wParam), PopupOptions.MinimumWidth, FALSE);
ErrorMSG(SETTING_MINIMUMWIDTH_MIN, SETTING_MAXIMUMWIDTH_MAX);
SetFocus((HWND)lParam);
break;
}
if (temp > PopupOptions.MaximumWidth) {
PopupOptions.MaximumWidth = min(temp, SETTING_MAXIMUMWIDTH_MAX);
SetDlgItemInt(hwnd, IDC_MAXIMUMWIDTH, PopupOptions.MaximumWidth, FALSE);
}
}
break;
case IDC_MAXIMUMWIDTH:
{
int temp = GetDlgItemInt(hwnd, LOWORD(wParam), NULL, FALSE);
if (temp >= SETTING_MAXIMUMWIDTH_MAX)
PopupOptions.MaximumWidth = SETTING_MAXIMUMWIDTH_MAX;
else if (temp < SETTING_MINIMUMWIDTH_MIN)
PopupOptions.MaximumWidth = SETTING_MINIMUMWIDTH_MIN;
if (temp != PopupOptions.MaximumWidth) {
SetDlgItemInt(hwnd, LOWORD(wParam), PopupOptions.MaximumWidth, FALSE);
ErrorMSG(SETTING_MINIMUMWIDTH_MIN, SETTING_MAXIMUMWIDTH_MAX);
SetFocus((HWND)lParam);
break;
}
if (temp < PopupOptions.MinimumWidth) {
PopupOptions.MinimumWidth = max(temp, SETTING_MINIMUMWIDTH_MIN);
SetDlgItemInt(hwnd, IDC_MINIMUMWIDTH, PopupOptions.MinimumWidth, FALSE);
}
}
break;
}
break;
}
break;
case WM_NOTIFY:
switch (((LPNMHDR)lParam)->idFrom) {
case 0:
switch (((LPNMHDR)lParam)->code) {
case PSN_RESET:
LoadOption_General();
return TRUE;
case PSN_APPLY:
// Seconds
db_set_b(NULL, MODULNAME, "InfiniteDelay", PopupOptions.InfiniteDelay);
db_set_w(NULL, MODULNAME, "Seconds", (WORD)PopupOptions.Seconds);
db_set_b(NULL, MODULNAME, "LeaveHovered", PopupOptions.LeaveHovered);
// Dynamic Resize
db_set_b(NULL, MODULNAME, "DynamicResize", PopupOptions.DynamicResize);
db_set_b(NULL, MODULNAME, "UseMinimumWidth", PopupOptions.UseMinimumWidth);
db_set_w(NULL, MODULNAME, "MinimumWidth", PopupOptions.MinimumWidth);
db_set_b(NULL, MODULNAME, "UseMaximumWidth", PopupOptions.UseMaximumWidth);
db_set_w(NULL, MODULNAME, "MaximumWidth", PopupOptions.MaximumWidth);
// Position
db_set_b(NULL, MODULNAME, "Position", (BYTE)PopupOptions.Position);
// Configure popup area
db_set_w(NULL, MODULNAME, "gapTop", (WORD)PopupOptions.gapTop);
db_set_w(NULL, MODULNAME, "gapBottom", (WORD)PopupOptions.gapBottom);
db_set_w(NULL, MODULNAME, "gapLeft", (WORD)PopupOptions.gapLeft);
db_set_w(NULL, MODULNAME, "gapRight", (WORD)PopupOptions.gapRight);
db_set_w(NULL, MODULNAME, "spacing", (WORD)PopupOptions.spacing);
// Spreading
db_set_b(NULL, MODULNAME, "Spreading", (BYTE)PopupOptions.Spreading);
// miscellaneous
Check_ReorderPopups(hwnd); // this save also PopupOptions.ReorderPopups
// disable When
db_set_b(NULL, MODULNAME, "DisableWhenFullscreen", PopupOptions.DisableWhenFullscreen);
// new status options
{
int protocolCount;
PROTOACCOUNT **protocols;
Proto_EnumAccounts(&protocolCount, &protocols);
for (int i = 0; i < protocolCount; ++i) {
if (!protocols[i]->bIsVirtual) {
char prefix[128];
mir_snprintf(prefix, _countof(prefix), "Protocol Status/%s", protocols[i]->szModuleName);
TCHAR pszSettingName[256];
mir_sntprintf(pszSettingName, _countof(pszSettingName), _T("Protocol Status/%s"), protocols[i]->tszAccountName);
db_set_dw(NULL, MODULNAME, prefix, OptTree_GetOptions(hwnd, IDC_STATUSES, statusOptions, statusOptionsCount, pszSettingName));
}
}
db_set_dw(NULL, MODULNAME, "Global Status", OptTree_GetOptions(hwnd, IDC_STATUSES, statusOptions, statusOptionsCount, _T("Global Status")));
}
return TRUE;
}
break;
case IDC_MINIMUMWIDTH_SPIN:
{
LPNMUPDOWN lpnmud = (LPNMUPDOWN)lParam;
int temp = lpnmud->iPos + lpnmud->iDelta;
if (temp > PopupOptions.MaximumWidth) {
PopupOptions.MaximumWidth = min(temp, SETTING_MAXIMUMWIDTH_MAX);
SetDlgItemInt(hwnd, IDC_MAXIMUMWIDTH, PopupOptions.MaximumWidth, FALSE);
}
}
break;
case IDC_MAXIMUMWIDTH_SPIN:
{
LPNMUPDOWN lpnmud = (LPNMUPDOWN)lParam;
int temp = lpnmud->iPos + lpnmud->iDelta;
if (temp < PopupOptions.MinimumWidth) {
PopupOptions.MinimumWidth = max(temp, SETTING_MINIMUMWIDTH_MIN);
SetDlgItemInt(hwnd, IDC_MINIMUMWIDTH, PopupOptions.MinimumWidth, FALSE);
}
}
}
break;
case WM_DESTROY:
if (statusOptions) {
for (int i = 0; i < statusOptionsCount; ++i) {
mir_free(statusOptions[i].pszOptionName);
mir_free(statusOptions[i].pszSettingName);
}
delete[] statusOptions;
statusOptions = NULL;
statusOptionsCount = 0;
bDlgInit = false;
}
break;
}
return FALSE;
}
VOID PhpAdvancedPageLoad(
_In_ HWND hwndDlg
)
{
HWND changeButton;
SetDlgItemCheckForSetting(hwndDlg, IDC_ENABLEWARNINGS, L"EnableWarnings");
SetDlgItemCheckForSetting(hwndDlg, IDC_ENABLEKERNELMODEDRIVER, L"EnableKph");
SetDlgItemCheckForSetting(hwndDlg, IDC_HIDEUNNAMEDHANDLES, L"HideUnnamedHandles");
SetDlgItemCheckForSetting(hwndDlg, IDC_ENABLESTAGE2, L"EnableStage2");
SetDlgItemCheckForSetting(hwndDlg, IDC_ENABLENETWORKRESOLVE, L"EnableNetworkResolve");
SetDlgItemCheckForSetting(hwndDlg, IDC_PROPAGATECPUUSAGE, L"PropagateCpuUsage");
SetDlgItemCheckForSetting(hwndDlg, IDC_ENABLEINSTANTTOOLTIPS, L"EnableInstantTooltips");
if (WindowsVersion >= WINDOWS_7)
SetDlgItemCheckForSetting(hwndDlg, IDC_ENABLECYCLECPUUSAGE, L"EnableCycleCpuUsage");
SetDlgItemInt(hwndDlg, IDC_SAMPLECOUNT, PhGetIntegerSetting(L"SampleCount"), FALSE);
SetDlgItemCheckForSetting(hwndDlg, IDC_SAMPLECOUNTAUTOMATIC, L"SampleCountAutomatic");
if (PhGetIntegerSetting(L"SampleCountAutomatic"))
EnableWindow(GetDlgItem(hwndDlg, IDC_SAMPLECOUNT), FALSE);
// Replace Task Manager
changeButton = GetDlgItem(hwndDlg, IDC_CHANGE);
if (PhElevated)
{
ShowWindow(changeButton, SW_HIDE);
}
else
{
SendMessage(changeButton, BCM_SETSHIELD, 0, TRUE);
}
{
HANDLE taskmgrKeyHandle = NULL;
ULONG disposition;
BOOLEAN success = FALSE;
BOOLEAN alreadyReplaced = FALSE;
// See if we can write to the key.
if (NT_SUCCESS(PhCreateKey(
&taskmgrKeyHandle,
KEY_READ | KEY_WRITE,
PH_KEY_LOCAL_MACHINE,
&TaskMgrImageOptionsKeyName,
0,
0,
&disposition
)))
{
success = TRUE;
}
if (taskmgrKeyHandle || NT_SUCCESS(PhOpenKey(
&taskmgrKeyHandle,
KEY_READ,
PH_KEY_LOCAL_MACHINE,
&TaskMgrImageOptionsKeyName,
0
)))
{
if (OldTaskMgrDebugger)
PhDereferenceObject(OldTaskMgrDebugger);
if (OldTaskMgrDebugger = PhQueryRegistryString(taskmgrKeyHandle, L"Debugger"))
{
alreadyReplaced = PathMatchesPh(OldTaskMgrDebugger);
}
NtClose(taskmgrKeyHandle);
}
if (!success)
EnableWindow(GetDlgItem(hwndDlg, IDC_REPLACETASKMANAGER), FALSE);
OldReplaceTaskMgr = alreadyReplaced;
Button_SetCheck(GetDlgItem(hwndDlg, IDC_REPLACETASKMANAGER), alreadyReplaced ? BST_CHECKED : BST_UNCHECKED);
}
}
//=======================================================
//Custom status message windows handling
//=======================================================
static INT_PTR CALLBACK DlgProcSetCustStat(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
DBVARIANT dbv;
switch (msg) {
case WM_INITDIALOG:
TranslateDialogDefault(hwndDlg);
{
CYahooProto* ppro = (CYahooProto*)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, lParam);
SendMessage(hwndDlg, WM_SETICON, ICON_BIG, (LPARAM)ppro->LoadIconEx("yahoo", true));
SendMessage(hwndDlg, WM_SETICON, ICON_SMALL, (LPARAM)ppro->LoadIconEx("yahoo"));
if (!ppro->getString(YAHOO_CUSTSTATDB, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_CUSTSTAT, dbv.pszVal);
EnableWindow(GetDlgItem(hwndDlg, IDOK), mir_strlen(dbv.pszVal) > 0);
db_free(&dbv);
}
else {
SetDlgItemTextA(hwndDlg, IDC_CUSTSTAT, "");
EnableWindow(GetDlgItem(hwndDlg, IDOK), FALSE);
}
CheckDlgButton(hwndDlg, IDC_CUSTSTATBUSY, ppro->getByte("BusyCustStat", 0) ? BST_CHECKED : BST_UNCHECKED);
}
return TRUE;
case WM_COMMAND:
switch (wParam) {
case IDOK:
{
char str[255 + 1];
CYahooProto* ppro = (CYahooProto*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
/* Get String from dialog */
GetDlgItemTextA(hwndDlg, IDC_CUSTSTAT, str, _countof(str));
/* Save it for later use */
ppro->setString(YAHOO_CUSTSTATDB, str);
ppro->setByte("BusyCustStat", (BYTE)IsDlgButtonChecked(hwndDlg, IDC_CUSTSTATBUSY));
/* set for Idle/AA */
if (ppro->m_startMsg) mir_free(ppro->m_startMsg);
ppro->m_startMsg = mir_strdup(str);
/* notify Server about status change */
ppro->set_status(YAHOO_CUSTOM_STATUS, str, (BYTE)IsDlgButtonChecked(hwndDlg, IDC_CUSTSTATBUSY));
/* change local/miranda status */
ppro->BroadcastStatus((BYTE)IsDlgButtonChecked(hwndDlg, IDC_CUSTSTATBUSY) ? ID_STATUS_AWAY : ID_STATUS_ONLINE);
}
case IDCANCEL:
DestroyWindow(hwndDlg);
break;
}
if (HIWORD(wParam) == EN_CHANGE && (HWND)lParam == GetFocus()) {
if (LOWORD(wParam) == IDC_CUSTSTAT) {
char str[255 + 1];
BOOL toSet;
toSet = GetDlgItemTextA(hwndDlg, IDC_CUSTSTAT, str, _countof(str)) != 0;
EnableWindow(GetDlgItem(hwndDlg, IDOK), toSet);
}
}
break; /* case WM_COMMAND */
case WM_CLOSE:
DestroyWindow(hwndDlg);
break;
case WM_DESTROY:
{
CYahooProto* ppro = (CYahooProto*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
ppro->ReleaseIconEx("yahoo", true);
ppro->ReleaseIconEx("yahoo");
}
break;
}
return FALSE;
}
void CDisasm::SetDebugMode(bool _bDebug)
{
HWND hDlg = m_hDlg;
// Update Dialog Windows
if (_bDebug)
{
Core_WaitInactive(TEMP_BREAKPOINT_WAIT_MS);
CBreakPoints::ClearTemporaryBreakPoints();
updateBreakpointList();
threadList->reloadThreads();
updateThreadLabel(false);
EnableWindow( GetDlgItem(hDlg, IDC_GO), TRUE);
EnableWindow( GetDlgItem(hDlg, IDC_STEP), TRUE);
EnableWindow( GetDlgItem(hDlg, IDC_STEPOVER), TRUE);
EnableWindow( GetDlgItem(hDlg, IDC_STEPHLE), TRUE);
EnableWindow( GetDlgItem(hDlg, IDC_STOP), FALSE);
EnableWindow( GetDlgItem(hDlg, IDC_SKIP), TRUE);
CtrlDisAsmView *ptr = CtrlDisAsmView::getFrom(GetDlgItem(m_hDlg,IDC_DISASMVIEW));
ptr->setDontRedraw(false);
ptr->gotoPC();
CtrlMemView *mem = CtrlMemView::getFrom(GetDlgItem(m_hDlg,IDC_DEBUGMEMVIEW));
mem->redraw();
// update the callstack
//CDisam::blah blah
UpdateDialog();
}
else
{
updateThreadLabel(true);
EnableWindow( GetDlgItem(hDlg, IDC_GO), FALSE);
EnableWindow( GetDlgItem(hDlg, IDC_STEP), FALSE);
EnableWindow( GetDlgItem(hDlg, IDC_STEPOVER), FALSE);
EnableWindow( GetDlgItem(hDlg, IDC_STEPHLE), FALSE);
EnableWindow( GetDlgItem(hDlg, IDC_STOP), TRUE);
EnableWindow( GetDlgItem(hDlg, IDC_SKIP), FALSE);
CtrlRegisterList *reglist = CtrlRegisterList::getFrom(GetDlgItem(m_hDlg,IDC_REGLIST));
reglist->redraw();
}
}
void ButtonX::enable(bool enable) {
EnableWindow(this->_hwnd, enable);
}
void GetData(HANDLE hContact)
{
int statpos = 0, dispos = 0, statposend = 0;
char*pos;
DBVARIANT dbv;
char tempstring[300], tempstring2[300];
int MallocSize = 0;
int DownloadSuccess = 0;
char*raw;
char*szInfo;
char truncated[MAXSIZE1];
char truncated2[MAXSIZE2];
int trunccount = 0;
char url[300];
unsigned long downloadsize = 0;
int AmountWspcRem = 0;
static char contactname[100];
int TherewasAlert = 0;
int PosButnClick = 0;
char tstr[128];
static char timestring[128];
int eventIndex = 0;
int location = 0;
int location2 = 0;
if (Startingup)
Sleep(2000);
HWND hwndDlg = (WindowList_Find(hWindowList, hContact));
Startingup = 0;
ZeroMemory(&url, sizeof(url));
ZeroMemory(&contactname, sizeof(contactname));
ZeroMemory(&tempstring, sizeof(tempstring));
ZeroMemory(&tempstring2, sizeof(tempstring2));
ZeroMemory(&szInfo, sizeof(szInfo));
ZeroMemory(&dbv, sizeof(dbv));
ZeroMemory(&tstr, sizeof(tstr));
ZeroMemory(×tring, sizeof(timestring));
db_set_b(hContact, MODULENAME, STOP_KEY, 0);
if (db_get_s(hContact, MODULENAME, PRESERVE_NAME_KEY, &dbv)) {
if ( !db_get_s(hContact, "CList", "MyHandle", &dbv)) {
db_set_s(hContact, MODULENAME, PRESERVE_NAME_KEY, dbv.pszVal);
db_free(&dbv);
}
}
if ( !db_get_s(hContact, MODULENAME, PRESERVE_NAME_KEY, &dbv)) {
strncpy_s(contactname, SIZEOF(contactname), dbv.pszVal, _TRUNCATE);
db_free(&dbv);
}
url[0] = '\0';
if (!Startingup)
db_set_b(NULL, MODULENAME, HAS_CRASHED_KEY, 1);
if ( !db_get_s(hContact, MODULENAME, START_STRING_KEY, &dbv)) {
strncpy_s(tempstring, SIZEOF(tempstring), dbv.pszVal, _TRUNCATE);
db_free(&dbv);
}
if ( !db_get_s(hContact, MODULENAME, END_STRING_KEY, &dbv)) {
strncpy_s(tempstring2, SIZEOF(tempstring2), dbv.pszVal, _TRUNCATE);
db_free(&dbv);
}
if ( !db_get_s(hContact, MODULENAME, URL_KEY, &dbv)) {
strncpy_s(url, SIZEOF(url), dbv.pszVal, _TRUNCATE);
db_free(&dbv);
}
if (strlen(url) < 3)
WErrorPopup(hContact, TranslateT("URL not supplied"));
NETLIBHTTPREQUEST nlhr = { sizeof(nlhr) };
nlhr.requestType = REQUEST_GET;
nlhr.flags = NLHRF_DUMPASTEXT;
nlhr.szUrl = url;
nlhr.headersCount = 2;
NETLIBHTTPHEADER headers[2];
headers[0].szName = "User-Agent";
headers[0].szValue = "Mozilla/4.0 (compatible; MSIE 6.0; Win32)";
headers[1].szName = "Content-Length";
headers[1].szValue = NULL;
nlhr.headers = headers;
if ( db_get_b(NULL, MODULENAME, NO_PROTECT_KEY, 0)) // disable
AlreadyDownloading = 0;
// //try site////
if (!AlreadyDownloading) { // not already downloading
if (IsWindowEnabled(GetDlgItem(hwndDlg, IDC_UPDATE_BUTTON)))
PosButnClick = 0;
else
PosButnClick = 1;
EnableWindow(GetDlgItem(hwndDlg, IDC_UPDATE_BUTTON), 1);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Download in progress, please wait..."));
db_set_ts(hContact, "CList", "StatusMsg", TranslateT("Updating..."));
db_set_w(hContact, MODULENAME, "Status", ID_STATUS_DND); // download
NETLIBHTTPREQUEST *nlhrReply = (NETLIBHTTPREQUEST *) CallService(MS_NETLIB_HTTPTRANSACTION, (WPARAM) hNetlibUser, (LPARAM) & nlhr);
if (nlhrReply) {
if (nlhrReply->resultCode < 200 || nlhrReply->resultCode >= 300) {
db_set_w(hContact, MODULENAME, "Status", ID_STATUS_AWAY);
TCHAR *statusText = TranslateT("The server replied with a failure code");
HWND hwndDlg = WindowList_Find(hWindowList, hContact);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, statusText);
WErrorPopup(hContact, statusText);
db_set_ts(hContact, "CList", "StatusMsg", statusText);
}
if (nlhrReply->dataLength) {
int cbLen = lstrlenA(nlhrReply->pData);
szInfo = (char*)malloc(cbLen + 2);
lstrcpynA(szInfo, nlhrReply->pData, cbLen);
downloadsize = lstrlenA(nlhrReply->pData);
trunccount = 0;
lstrcpynA(truncated2, szInfo, MAXSIZE2);
free(szInfo);
////////////////////////////////////////////
sprintf(truncated2, "%s", nlhrReply->pData);
AlreadyDownloading = 1;
} // END DATELENGTH
} // END REPLY
if (!nlhrReply) {
db_set_w(hContact, MODULENAME, "Status", ID_STATUS_NA);
HWND hwndDlg = (WindowList_Find(hWindowList, hContact));
TCHAR *statusText = TranslateT("The server is down or lagging.");
SetDlgItemText(hwndDlg, IDC_STATUSBAR, statusText);
WErrorPopup(hContact, statusText);
db_set_ts(hContact, "CList", "StatusMsg", statusText);
}
if (!(nlhrReply))
DownloadSuccess = 0;
if ((nlhrReply) && (nlhrReply->resultCode < 200 || nlhrReply->resultCode >= 300))
DownloadSuccess = 0;
else if (nlhrReply)
DownloadSuccess = 1;
CallService(MS_NETLIB_FREEHTTPREQUESTSTRUCT, 0, (LPARAM) nlhrReply);
if (DownloadSuccess) {
HWND hwndDlg = (WindowList_Find(hWindowList, hContact));
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Download successful; about to process data..."));
}
///get data in desired range
// download successful
if (DownloadSuccess) {
// all the site
if (db_get_b(hContact, MODULENAME, U_ALLSITE_KEY, 0) == 1)
lstrcpynA(truncated, truncated2, MAXSIZE1);
else { // use start and end string
// putting data into string
if (((strstr(truncated2, tempstring)) != 0) && ((strstr(truncated2, tempstring2)) != 0)) {
// start string
pos = strstr(truncated2, tempstring);
statpos = pos - truncated2;
ZeroMemory(&pos, sizeof(pos));
// end string
pos = strstr(truncated2, tempstring2);
statposend = pos - truncated2 + (int)strlen(tempstring2);
if (statpos > statposend) {
memset(&truncated2, ' ', statpos);
ZeroMemory(&pos, sizeof(pos));
pos = strstr(truncated2, tempstring2);
statposend = pos - truncated2 + (int)strlen(tempstring2);
}
if (statpos < statposend) {
ZeroMemory(&raw, sizeof(raw));
// get size for malloc
MallocSize = statposend - statpos;
raw = (char *) malloc(MallocSize + 1);
// start string
pos = strstr(truncated2, tempstring);
statpos = pos - truncated2;
// end string
pos = strstr(truncated2, tempstring2);
statposend = pos - truncated2 + (int)strlen(tempstring2);
if (statpos > statposend) {
memset(&truncated2, ' ', statpos);
ZeroMemory(&pos, sizeof(pos));
pos = strstr(truncated2, tempstring2);
statposend = pos - truncated2 + (int)strlen(tempstring2);
}
dispos = 0;
strncpy(raw, &truncated2[statpos], MallocSize);
raw[MallocSize] = '\0';
trunccount = 0;
lstrcpynA(truncated, raw, MAXSIZE1);
free(raw);
DownloadSuccess = 1;
}
else if (db_get_b(hContact, MODULENAME, U_ALLSITE_KEY, 0) == 0) {
TCHAR *szStatusText = TranslateT("Invalid search parameters.");
WErrorPopup(hContact, szStatusText);
HWND hwndDlg = WindowList_Find(hWindowList, hContact);
DownloadSuccess = 0;
SetDlgItemText(hwndDlg, IDC_STATUSBAR, szStatusText);
db_set_w(hContact, MODULENAME, "Status", ID_STATUS_AWAY);
}
} // end putting data into string
} // end use start and end strings
} // end download success
if (DownloadSuccess) { // download success
if (statpos == 0 && statposend == 0) {
if (db_get_b(hContact, MODULENAME, U_ALLSITE_KEY, 0) == 0) {
TCHAR *statusText = TranslateT("Both search strings not found or strings not set.");
WErrorPopup(hContact, statusText);
db_set_ts(hContact, "CList", "StatusMsg", statusText);
HWND hwndDlg = WindowList_Find(hWindowList, hContact);
DownloadSuccess = 0;
SetDlgItemText(hwndDlg, IDC_STATUSBAR, statusText);
TherewasAlert = ProcessAlerts(hContact, _T2A(statusText), contactname, contactname, 1);
db_set_w(hContact, MODULENAME, "Status", ID_STATUS_AWAY);
}
}
} // end download success
if (DownloadSuccess) { // download success
char timeprefix[32];
char temptime1[32];
char timeat[16];
char temptime2[32];
char temptime[128];
time_t ftime;
struct tm *nTime;
setlocale(LC_ALL, "");
if (!db_get_s(hContact, MODULENAME, PRESERVE_NAME_KEY, &dbv)) {
ZeroMemory(&temptime, sizeof(temptime));
ZeroMemory(&tstr, sizeof(tstr));
ftime = time(NULL);
nTime = localtime(&ftime);
// 12 hour
if (db_get_b(hContact, MODULENAME, USE_24_HOUR_KEY, 0) == 0)
strftime(temptime, 128, "(%b %d,%I:%M %p)", nTime);
// 24 hour
if (db_get_b(hContact, MODULENAME, USE_24_HOUR_KEY, 0) == 1)
strftime(temptime, 128, "(%b %d,%H:%M:%S)", nTime);
if (db_get_b(hContact, MODULENAME, CONTACT_PREFIX_KEY, 1) == 1)
mir_snprintf(tstr, SIZEOF(tstr), "%s %s", temptime, dbv.pszVal);
if (db_get_b(hContact, MODULENAME, CONTACT_PREFIX_KEY, 1) == 0)
mir_snprintf(tstr, SIZEOF(tstr), "%s %s", dbv.pszVal, temptime);
db_free(&dbv);
}
else {
db_get_ts(hContact, "CList", "MyHandle", &dbv);
ZeroMemory(&temptime, sizeof(temptime));
ZeroMemory(&tstr, sizeof(tstr));
ftime = time(NULL);
nTime = localtime(&ftime);
// 12 hour
if (db_get_b(hContact, MODULENAME, USE_24_HOUR_KEY, 0) == 0)
strftime(temptime, 128, "(%b %d,%I:%M %p)", nTime);
// 24 hour
if (db_get_b(hContact, MODULENAME, USE_24_HOUR_KEY, 0) == 1)
strftime(temptime, 128, "(%b %d,%H:%M:%S)", nTime);
db_set_ts(hContact, MODULENAME, PRESERVE_NAME_KEY, dbv.ptszVal);
if (db_get_b(hContact, MODULENAME, CONTACT_PREFIX_KEY, 1) == 1)
mir_snprintf(tstr, SIZEOF(tstr), "%s %s", temptime, dbv.pszVal);
if (db_get_b(hContact, MODULENAME, CONTACT_PREFIX_KEY, 1) == 0)
mir_snprintf(tstr, SIZEOF(tstr), "%s %s", dbv.pszVal, temptime);
db_free(&dbv);
}
ftime = time(NULL);
nTime = localtime(&ftime);
strncpy_s(timeprefix, SIZEOF(timeprefix), Translate("Last updated on"), _TRUNCATE);
strncpy_s(timeat, SIZEOF(timeat), Translate("at the time"), _TRUNCATE);
strftime(temptime1, 32, " %a, %b %d, %Y ", nTime);
strftime(temptime2, 32, " %I:%M %p.", nTime);
mir_snprintf(timestring, SIZEOF(timestring), " %s %s%s%s", timeprefix, temptime1, timeat, temptime2);
} // end download success
if (DownloadSuccess) {
TherewasAlert = ProcessAlerts(hContact, truncated, tstr, contactname, 0);
// get range of text to be highlighted when part of change changes
if (TherewasAlert) {
// ////////////////////////
static char buff[MAXSIZE1];
char Alerttempstring[300], Alerttempstring2[300];
eventIndex = db_get_b(hContact, MODULENAME, EVNT_INDEX_KEY, 0);
if (eventIndex == 2) {
strncpy(buff, truncated, SIZEOF(buff));
Filter(buff);
if ( !db_get_s(hContact, MODULENAME, ALRT_S_STRING_KEY, &dbv)) {
strncpy_s(Alerttempstring, SIZEOF(Alerttempstring), dbv.pszVal, _TRUNCATE);
db_free(&dbv);
}
if ( !db_get_s(hContact, MODULENAME, ALRT_E_STRING_KEY, &dbv)) {
strncpy_s(Alerttempstring2, SIZEOF(Alerttempstring2), dbv.pszVal, _TRUNCATE);
db_free(&dbv);
}
// putting data into string
if (((strstr(buff, Alerttempstring)) != 0) && ((strstr(buff, Alerttempstring2)) != 0)) {
location = (strstr(buff, Alerttempstring)) - buff;
location2 = (strstr(buff, Alerttempstring2)) - buff;
}
}
}
if ((((strstr(truncated2, tempstring)) != 0) && ((strstr(truncated2, tempstring2)) != 0) && (db_get_b(hContact, MODULENAME, U_ALLSITE_KEY, 0) == 0)) || (db_get_b(hContact, MODULENAME, U_ALLSITE_KEY, 0) == 1)) {
RemoveTabs(truncated);
if ( db_get_b(hContact, MODULENAME, CLEAR_DISPLAY_KEY, 0)) {
HWND hwndDlg = (WindowList_Find(hWindowList, hContact));
SendToRichEdit(hwndDlg, truncated, TextClr, BackgoundClr);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Processing data (Stage 1)"));
if (db_get_b(hContact, MODULENAME, STOP_KEY, 1) == 1) {
LBL_Stop: TCHAR *statusText = TranslateT("Processing data stopped by user.");
SetDlgItemText(hwndDlg, IDC_STATUSBAR, statusText);
db_set_b(hContact, MODULENAME, STOP_KEY, 0);
db_set_w(hContact, MODULENAME, "Status", ID_STATUS_ONLINE);
db_set_ts(hContact, "CList", "StatusMsg", statusText);
AlreadyDownloading = 0;
return;
}
CodetoSymbol(truncated);
Sleep(100); // avoid 100% CPU
SendToRichEdit(hwndDlg, truncated, TextClr, BackgoundClr);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Processing data (Stage 2)"));
if (db_get_b(hContact, MODULENAME, STOP_KEY, 1) == 1)
goto LBL_Stop;
EraseBlock(truncated);
Sleep(100); // avoid 100% CPU
SendToRichEdit(hwndDlg, truncated, TextClr, BackgoundClr);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Processing data (Stage 3)"));
if (db_get_b(hContact, MODULENAME, STOP_KEY, 1) == 1)
goto LBL_Stop;
FastTagFilter(truncated);
Sleep(100); // avoid 100% CPU
SendToRichEdit(hwndDlg, truncated, TextClr, BackgoundClr);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Processing data (Stage 4)"));
if (db_get_b(hContact, MODULENAME, STOP_KEY, 1) == 1)
goto LBL_Stop;
NumSymbols(truncated);
Sleep(100); // avoid 100% CPU
SendToRichEdit(hwndDlg, truncated, TextClr, BackgoundClr);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Processing data (Stage 5)"));
if (db_get_b(hContact, MODULENAME, STOP_KEY, 1) == 1)
goto LBL_Stop;
EraseSymbols(truncated);
Sleep(100); // avoid 100% CPU
SendToRichEdit(hwndDlg, truncated, TextClr, BackgoundClr);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Processing data (Stage 6)"));
AmountWspcRem = db_get_b(hContact, MODULENAME, RWSPACE_KEY, 0);
if (db_get_b(hContact, MODULENAME, STOP_KEY, 1) == 1)
goto LBL_Stop;
RemoveInvis(truncated, AmountWspcRem);
Sleep(100); // avoid 100% CPU
SendToRichEdit(hwndDlg, truncated, TextClr, BackgoundClr);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Processing data (Stage 7)"));
if (db_get_b(hContact, MODULENAME, STOP_KEY, 1) == 1)
goto LBL_Stop;
Removewhitespace(truncated);
SendToRichEdit(hwndDlg, truncated, TextClr, BackgoundClr);
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Processing data (Stage 8)"));
//data in popup
if (TherewasAlert)
if ( db_get_b(NULL, MODULENAME, DATA_POPUP_KEY, 0))
WAlertPopup(hContact, _A2T(truncated));
if (db_get_b(hContact, MODULENAME, STOP_KEY, 1) == 1)
goto LBL_Stop;
// removed any excess characters at the end.
if ((truncated[strlen(truncated) - 1] == truncated[strlen(truncated) - 2]) && (truncated[strlen(truncated) - 2] == truncated[strlen(truncated) - 3])) {
int counterx = 0;
while (true) {
counterx++;
if (truncated[strlen(truncated) - counterx] != truncated[strlen(truncated) - 1]) {
truncated[(strlen(truncated) - counterx) + 2] = '\0';
break;
}
}
}
}
}
if (TherewasAlert) {
db_set_w(hContact, MODULENAME, "Status", ID_STATUS_OCCUPIED);
db_set_ts(hContact, "CList", "StatusMsg", TranslateT("Alert!"));
}
else {
db_set_w(hContact, MODULENAME, "Status", ID_STATUS_ONLINE);
db_set_ts(hContact, "CList", "StatusMsg", TranslateT("Online"));
}
}
if (db_get_b(hContact, MODULENAME, U_ALLSITE_KEY, 0) == 0) {
if (statpos > statposend)
DownloadSuccess = 0;
else if (statpos == 0 && statposend == 0)
DownloadSuccess = 0;
else
DownloadSuccess = 1;
}
AlreadyDownloading = 0;
} // end not already downloading
if (AlreadyDownloading)
SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("A site is already downloading, try again in a moment."));
if (DownloadSuccess) { // download success
char BytesString[128];
HWND hwndDlg = (WindowList_Find(hWindowList, hContact));
// update window if the update only on alert option isn't ticked or
// there was an alert or the update button was clicked
if ((!(db_get_b(NULL, MODULENAME, UPDATE_ONALERT_KEY, 0))) || (TherewasAlert == 1) || (PosButnClick == 1)) {
SendToRichEdit(hwndDlg, truncated, TextClr, BackgoundClr);
if (TherewasAlert) {
// highlight text when part of change changes
if (eventIndex == 2) {
CHARRANGE sel2 = {location, location2};
SendMessage(GetDlgItem(hwndDlg, IDC_DATA), EM_EXSETSEL, 0, (LPARAM) & sel2);
SetFocus(GetDlgItem(hwndDlg, IDC_DATA));
DWORD HiBackgoundClr = db_get_dw(NULL, MODULENAME, BG_COLOR_KEY, Def_color_bg);
DWORD HiTextClr = db_get_dw(NULL, MODULENAME, TXT_COLOR_KEY, Def_color_txt);
CHARFORMAT2 Format;
memset(&Format, 0, sizeof(Format));
Format.cbSize = sizeof(Format);
Format.dwMask = CFM_BOLD | CFM_COLOR | CFM_BACKCOLOR;
Format.dwEffects = CFE_BOLD;
Format.crBackColor = ((~HiBackgoundClr) & 0x00ffffff);
Format.crTextColor = ((~HiTextClr) & 0x00ffffff);
SendMessage(GetDlgItem(hwndDlg, IDC_DATA), EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM) & Format);
}
}
SetDlgItemTextA(hwndDlg, IDC_STATUSBAR, timestring);
sprintf(BytesString, "%s: %d | %s: %lu", (Translate("Bytes in display")), (GetWindowTextLength(GetDlgItem(hwndDlg, IDC_DATA))), (Translate("Bytes downloaded")), downloadsize);
SendMessage(GetDlgItem(hwndDlg, IDC_STATUSBAR), SB_SETTEXT, 1, (LPARAM) BytesString);
}
else SetDlgItemText(hwndDlg, IDC_STATUSBAR, TranslateT("Alert test conditions not met; press the refresh button to view content."));
}
EnableWindow(GetDlgItem(hwndDlg, IDC_UPDATE_BUTTON), 1);
if (!Startingup)
db_set_b(NULL, MODULENAME, HAS_CRASHED_KEY, 0);
}
static INT_PTR CALLBACK PhpHiddenProcessesDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
HWND lvHandle;
PhCenterWindow(hwndDlg, GetParent(hwndDlg));
PhHiddenProcessesListViewHandle = lvHandle = GetDlgItem(hwndDlg, IDC_PROCESSES);
PhInitializeLayoutManager(&WindowLayoutManager, hwndDlg);
PhAddLayoutItem(&WindowLayoutManager, GetDlgItem(hwndDlg, IDC_INTRO),
NULL, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT | PH_LAYOUT_FORCE_INVALIDATE);
PhAddLayoutItem(&WindowLayoutManager, lvHandle,
NULL, PH_ANCHOR_ALL);
PhAddLayoutItem(&WindowLayoutManager, GetDlgItem(hwndDlg, IDC_DESCRIPTION),
NULL, PH_ANCHOR_LEFT | PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM | PH_LAYOUT_FORCE_INVALIDATE);
PhAddLayoutItem(&WindowLayoutManager, GetDlgItem(hwndDlg, IDC_METHOD),
NULL, PH_ANCHOR_LEFT | PH_ANCHOR_BOTTOM);
PhAddLayoutItem(&WindowLayoutManager, GetDlgItem(hwndDlg, IDC_TERMINATE),
NULL, PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
PhAddLayoutItem(&WindowLayoutManager, GetDlgItem(hwndDlg, IDC_SAVE),
NULL, PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
PhAddLayoutItem(&WindowLayoutManager, GetDlgItem(hwndDlg, IDC_SCAN),
NULL, PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
PhAddLayoutItem(&WindowLayoutManager, GetDlgItem(hwndDlg, IDOK),
NULL, PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
MinimumSize.left = 0;
MinimumSize.top = 0;
MinimumSize.right = 330;
MinimumSize.bottom = 140;
MapDialogRect(hwndDlg, &MinimumSize);
PhRegisterDialog(hwndDlg);
PhLoadWindowPlacementFromSetting(L"HiddenProcessesWindowPosition", L"HiddenProcessesWindowSize", hwndDlg);
PhSetListViewStyle(lvHandle, TRUE, TRUE);
PhSetControlTheme(lvHandle, L"explorer");
PhAddListViewColumn(lvHandle, 0, 0, 0, LVCFMT_LEFT, 320, L"Process");
PhAddListViewColumn(lvHandle, 1, 1, 1, LVCFMT_LEFT, 60, L"PID");
PhSetExtendedListView(lvHandle);
PhLoadListViewColumnsFromSetting(L"HiddenProcessesListViewColumns", lvHandle);
ExtendedListView_AddFallbackColumn(lvHandle, 0);
ExtendedListView_AddFallbackColumn(lvHandle, 1);
ExtendedListView_SetItemColorFunction(lvHandle, PhpHiddenProcessesColorFunction);
ComboBox_AddString(GetDlgItem(hwndDlg, IDC_METHOD), L"Brute Force");
ComboBox_AddString(GetDlgItem(hwndDlg, IDC_METHOD), L"CSR Handles");
PhSelectComboBoxString(GetDlgItem(hwndDlg, IDC_METHOD), L"CSR Handles", FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_TERMINATE), FALSE);
}
break;
case WM_DESTROY:
{
PhSaveWindowPlacementToSetting(L"HiddenProcessesWindowPosition", L"HiddenProcessesWindowSize", hwndDlg);
PhSaveListViewColumnsToSetting(L"HiddenProcessesListViewColumns", PhHiddenProcessesListViewHandle);
}
break;
case WM_CLOSE:
{
// Hide, don't close.
ShowWindow(hwndDlg, SW_HIDE);
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, 0);
}
return TRUE;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDCANCEL:
case IDOK:
{
SendMessage(hwndDlg, WM_CLOSE, 0, 0);
}
break;
case IDC_SCAN:
{
NTSTATUS status;
PPH_STRING method;
method = PhGetWindowText(GetDlgItem(hwndDlg, IDC_METHOD));
PhAutoDereferenceObject(method);
if (ProcessesList)
{
ULONG i;
for (i = 0; i < ProcessesList->Count; i++)
{
PPH_HIDDEN_PROCESS_ENTRY entry = ProcessesList->Items[i];
if (entry->FileName)
PhDereferenceObject(entry->FileName);
PhFree(entry);
}
PhDereferenceObject(ProcessesList);
}
ListView_DeleteAllItems(PhHiddenProcessesListViewHandle);
ProcessesList = PhCreateList(40);
ProcessesMethod =
PhEqualString2(method, L"Brute Force", TRUE) ?
BruteForceScanMethod :
CsrHandlesScanMethod;
NumberOfHiddenProcesses = 0;
NumberOfTerminatedProcesses = 0;
ExtendedListView_SetRedraw(PhHiddenProcessesListViewHandle, FALSE);
status = PhEnumHiddenProcesses(
ProcessesMethod,
PhpHiddenProcessesCallback,
NULL
);
ExtendedListView_SortItems(PhHiddenProcessesListViewHandle);
ExtendedListView_SetRedraw(PhHiddenProcessesListViewHandle, TRUE);
if (NT_SUCCESS(status))
{
SetDlgItemText(hwndDlg, IDC_DESCRIPTION,
PhaFormatString(L"%u hidden process(es), %u terminated process(es).",
NumberOfHiddenProcesses, NumberOfTerminatedProcesses)->Buffer
);
InvalidateRect(GetDlgItem(hwndDlg, IDC_DESCRIPTION), NULL, TRUE);
}
else
{
PhShowStatus(hwndDlg, L"Unable to perform the scan", status, 0);
}
}
break;
case IDC_TERMINATE:
{
PPH_HIDDEN_PROCESS_ENTRY *entries;
ULONG numberOfEntries;
ULONG i;
PhGetSelectedListViewItemParams(PhHiddenProcessesListViewHandle, &entries, &numberOfEntries);
if (numberOfEntries != 0)
{
if (!PhGetIntegerSetting(L"EnableWarnings") ||
PhShowConfirmMessage(
hwndDlg,
L"terminate",
L"the selected process(es)",
L"Terminating a hidden process may cause the system to become unstable "
L"or crash.",
TRUE
))
{
NTSTATUS status;
HANDLE processHandle;
BOOLEAN refresh;
refresh = FALSE;
for (i = 0; i < numberOfEntries; i++)
{
if (ProcessesMethod == BruteForceScanMethod)
{
status = PhOpenProcess(
&processHandle,
PROCESS_TERMINATE,
entries[i]->ProcessId
);
}
else
{
status = PhOpenProcessByCsrHandles(
&processHandle,
PROCESS_TERMINATE,
entries[i]->ProcessId
);
}
if (NT_SUCCESS(status))
{
status = PhTerminateProcess(processHandle, STATUS_SUCCESS);
NtClose(processHandle);
if (NT_SUCCESS(status))
refresh = TRUE;
}
else
{
PhShowStatus(hwndDlg, L"Unable to terminate the process", status, 0);
}
}
if (refresh)
{
LARGE_INTEGER interval;
// Sleep for a bit before continuing. It seems to help avoid
// BSODs.
interval.QuadPart = -250 * PH_TIMEOUT_MS;
NtDelayExecution(FALSE, &interval);
SendMessage(hwndDlg, WM_COMMAND, IDC_SCAN, 0);
}
}
}
PhFree(entries);
}
break;
case IDC_SAVE:
{
static PH_FILETYPE_FILTER filters[] =
{
{ L"Text files (*.txt)", L"*.txt" },
{ L"All files (*.*)", L"*.*" }
};
PVOID fileDialog;
fileDialog = PhCreateSaveFileDialog();
PhSetFileDialogFilter(fileDialog, filters, sizeof(filters) / sizeof(PH_FILETYPE_FILTER));
PhSetFileDialogFileName(fileDialog, L"Hidden Processes.txt");
if (PhShowFileDialog(hwndDlg, fileDialog))
{
NTSTATUS status;
PPH_STRING fileName;
PPH_FILE_STREAM fileStream;
fileName = PhGetFileDialogFileName(fileDialog);
PhAutoDereferenceObject(fileName);
if (NT_SUCCESS(status = PhCreateFileStream(
&fileStream,
fileName->Buffer,
FILE_GENERIC_WRITE,
FILE_SHARE_READ,
FILE_OVERWRITE_IF,
0
)))
{
PhWriteStringAsUtf8FileStream(fileStream, &PhUnicodeByteOrderMark);
PhWritePhTextHeader(fileStream);
PhWriteStringAsUtf8FileStream2(fileStream, L"Method: ");
PhWriteStringAsUtf8FileStream2(fileStream,
ProcessesMethod == BruteForceScanMethod ? L"Brute Force\r\n" : L"CSR Handles\r\n");
PhWriteStringFormatAsUtf8FileStream(
fileStream,
L"Hidden: %u\r\nTerminated: %u\r\n\r\n",
NumberOfHiddenProcesses,
NumberOfTerminatedProcesses
);
if (ProcessesList)
{
ULONG i;
for (i = 0; i < ProcessesList->Count; i++)
{
PPH_HIDDEN_PROCESS_ENTRY entry = ProcessesList->Items[i];
if (entry->Type == HiddenProcess)
PhWriteStringAsUtf8FileStream2(fileStream, L"[HIDDEN] ");
else if (entry->Type == TerminatedProcess)
PhWriteStringAsUtf8FileStream2(fileStream, L"[Terminated] ");
else if (entry->Type != NormalProcess)
continue;
PhWriteStringFormatAsUtf8FileStream(
fileStream,
L"%s (%u)\r\n",
entry->FileName->Buffer,
HandleToUlong(entry->ProcessId)
);
}
}
PhDereferenceObject(fileStream);
}
if (!NT_SUCCESS(status))
PhShowStatus(hwndDlg, L"Unable to create the file", status, 0);
}
PhFreeFileDialog(fileDialog);
}
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
PhHandleListViewNotifyBehaviors(lParam, PhHiddenProcessesListViewHandle, PH_LIST_VIEW_DEFAULT_1_BEHAVIORS);
switch (header->code)
{
case LVN_ITEMCHANGED:
{
if (header->hwndFrom == PhHiddenProcessesListViewHandle)
{
EnableWindow(
GetDlgItem(hwndDlg, IDC_TERMINATE),
ListView_GetSelectedCount(PhHiddenProcessesListViewHandle) > 0
);
}
}
break;
case NM_DBLCLK:
{
if (header->hwndFrom == PhHiddenProcessesListViewHandle)
{
PPH_HIDDEN_PROCESS_ENTRY entry;
entry = PhGetSelectedListViewItemParam(PhHiddenProcessesListViewHandle);
if (entry)
{
PPH_PROCESS_ITEM processItem;
if (processItem = PhpCreateProcessItemForHiddenProcess(entry))
{
ProcessHacker_ShowProcessProperties(PhMainWndHandle, processItem);
PhDereferenceObject(processItem);
}
else
{
PhShowError(hwndDlg, L"Unable to create a process structure for the selected process.");
}
}
}
}
break;
}
}
break;
case WM_SIZE:
{
PhLayoutManagerLayout(&WindowLayoutManager);
}
break;
case WM_SIZING:
{
PhResizingMinimumSize((PRECT)lParam, wParam, MinimumSize.right, MinimumSize.bottom);
}
break;
case WM_CTLCOLORSTATIC:
{
if ((HWND)lParam == GetDlgItem(hwndDlg, IDC_DESCRIPTION))
{
if (NumberOfHiddenProcesses != 0)
{
SetTextColor((HDC)wParam, RGB(0xff, 0x00, 0x00));
}
SetBkColor((HDC)wParam, GetSysColor(COLOR_3DFACE));
return (INT_PTR)GetSysColorBrush(COLOR_3DFACE);
}
}
break;
}
REFLECT_MESSAGE_DLG(hwndDlg, PhHiddenProcessesListViewHandle, uMsg, wParam, lParam);
return FALSE;
}
static void FixCDis(HWND hParent, int how) {
int x;
for (x = 200; x <= 206; x++)
EnableWindow(GetDlgItem(hParent, x), how);
}
INT_PTR CALLBACK PhpOptionsAdvancedDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
PhpPageInit(hwndDlg);
PhpAdvancedPageLoad(hwndDlg);
if (PhStartupParameters.ShowOptions)
{
// Disable all controls except for Replace Task Manager.
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLEWARNINGS), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLEKERNELMODEDRIVER), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_HIDEUNNAMEDHANDLES), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLESTAGE2), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLENETWORKRESOLVE), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_PROPAGATECPUUSAGE), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLEINSTANTTOOLTIPS), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLECYCLECPUUSAGE), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_SAMPLECOUNTLABEL), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_SAMPLECOUNT), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_SAMPLECOUNTAUTOMATIC), FALSE);
}
else
{
if (WindowsVersion < WINDOWS_7)
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLECYCLECPUUSAGE), FALSE); // cycle-based CPU usage not available before Windows 7
}
}
break;
case WM_DESTROY:
{
if (OldTaskMgrDebugger)
PhDereferenceObject(OldTaskMgrDebugger);
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_CHANGE:
{
HANDLE threadHandle;
RECT windowRect;
// Save the options so they don't get "overwritten" when
// WM_PH_CHILD_EXIT gets sent.
PhpAdvancedPageSave(hwndDlg);
GetWindowRect(GetParent(hwndDlg), &windowRect);
WindowHandleForElevate = hwndDlg;
threadHandle = PhCreateThread(0, PhpElevateAdvancedThreadStart, PhFormatString(
L"-showoptions -hwnd %Ix -point %u,%u",
(ULONG_PTR)GetParent(hwndDlg),
windowRect.left + 20,
windowRect.top + 20
));
if (threadHandle)
NtClose(threadHandle);
}
break;
case IDC_SAMPLECOUNTAUTOMATIC:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_SAMPLECOUNT), Button_GetCheck(GetDlgItem(hwndDlg, IDC_SAMPLECOUNTAUTOMATIC)) != BST_CHECKED);
}
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
switch (header->code)
{
case PSN_APPLY:
{
PhpAdvancedPageSave(hwndDlg);
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
}
return TRUE;
}
}
break;
case WM_PH_CHILD_EXIT:
{
PhpAdvancedPageLoad(hwndDlg);
}
break;
}
return FALSE;
}
INT_PTR CALLBACK DlgProcAlarm(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
WindowData *wd = (WindowData*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
switch (msg) {
case WM_INITDIALOG:
TranslateDialogDefault(hwndDlg);
Utils_RestoreWindowPositionNoSize(hwndDlg, 0, MODULENAME, "Notify");
SetFocus(GetDlgItem(hwndDlg, IDC_SNOOZE));
wd = new WindowData;
wd->moving = false;
wd->alarm = nullptr;
wd->win_num = win_num++;
if (wd->win_num > 0) {
RECT r;
GetWindowRect(hwndDlg, &r);
r.top += 20;
r.left += 20;
SetWindowPos(hwndDlg, nullptr, r.left, r.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
Utils_SaveWindowPosition(hwndDlg, 0, MODULENAME, "Notify");
}
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)wd);
// options
SendMessage(hwndDlg, WMU_SETOPT, 0, 0);
// fonts
SendMessage(hwndDlg, WMU_SETFONTS, 0, 0);
return FALSE;
case WMU_REFRESH:
InvalidateRect(hwndDlg, nullptr, TRUE);
return TRUE;
case WM_CTLCOLORSTATIC:
{
HDC hdc = (HDC)wParam;
HWND hwndCtrl = (HWND)lParam;
if (hBackgroundBrush) {
if (hTitleFont && GetDlgItem(hwndDlg, IDC_TITLE) == hwndCtrl)
SetTextColor(hdc, title_font_colour);
else if (hWindowFont)
SetTextColor(hdc, window_font_colour);
SetBkMode(hdc, TRANSPARENT);
return (INT_PTR)hBackgroundBrush;
}
}
break;
case WM_CTLCOLORDLG:
if (hBackgroundBrush)
return (INT_PTR)hBackgroundBrush;
break;
case WMU_SETFONTS:
// fonts
if (hWindowFont)
SendMessage(hwndDlg, WM_SETFONT, (WPARAM)hWindowFont, TRUE);
if (hTitleFont)
SendDlgItemMessage(hwndDlg, IDC_TITLE, WM_SETFONT, (WPARAM)hTitleFont, TRUE);
if (hBackgroundBrush) {
SetClassLongPtr(hwndDlg, GCLP_HBRBACKGROUND, (LONG_PTR)hBackgroundBrush);
InvalidateRect(hwndDlg, nullptr, TRUE);
}
return TRUE;
case WMU_SETOPT:
Options *opt;
if (lParam)
opt = (Options*)lParam;
else
opt = &options;
// round corners
if (opt->aw_roundcorners) {
HRGN hRgn1;
RECT r;
int w = 10;
GetWindowRect(hwndDlg, &r);
int h = (r.right - r.left) > (w * 2) ? w : (r.right - r.left);
int v = (r.bottom - r.top) > (w * 2) ? w : (r.bottom - r.top);
h = (h < v) ? h : v;
hRgn1 = CreateRoundRectRgn(0, 0, (r.right - r.left + 1), (r.bottom - r.top + 1), h, h);
SetWindowRgn(hwndDlg, hRgn1, 1);
}
else {
HRGN hRgn1;
RECT r;
int w = 10;
GetWindowRect(hwndDlg, &r);
int h = (r.right - r.left) > (w * 2) ? w : (r.right - r.left);
int v = (r.bottom - r.top) > (w * 2) ? w : (r.bottom - r.top);
h = (h < v) ? h : v;
hRgn1 = CreateRectRgn(0, 0, (r.right - r.left + 1), (r.bottom - r.top + 1));
SetWindowRgn(hwndDlg, hRgn1, 1);
}
// transparency
#ifdef WS_EX_LAYERED
SetWindowLongPtr(hwndDlg, GWL_EXSTYLE, GetWindowLongPtr(hwndDlg, GWL_EXSTYLE) | WS_EX_LAYERED);
#endif
#ifdef LWA_ALPHA
SetLayeredWindowAttributes(hwndDlg, RGB(0, 0, 0), (int)((100 - opt->aw_trans) / 100.0 * 255), LWA_ALPHA);
#endif
return TRUE;
case WMU_SETALARM:
{
ALARM *data = (ALARM *)lParam;
SetWindowText(hwndDlg, data->szTitle);
SetWindowText(GetDlgItem(hwndDlg, IDC_TITLE), data->szTitle);
SetDlgItemText(hwndDlg, IDC_ED_DESC, data->szDesc);
wd->alarm = data;
if (data->action & AAF_SOUND && options.loop_sound) {
if (data->sound_num <= 3)
SetTimer(hwndDlg, ID_TIMER_SOUND, SOUND_REPEAT_PERIOD, nullptr);
else if (data->sound_num == 4)
SetTimer(hwndDlg, ID_TIMER_SOUND, SPEACH_REPEAT_PERIOD, nullptr);
}
HWND hw = GetDlgItem(hwndDlg, IDC_SNOOZE);
EnableWindow(hw, !(data->flags & ALF_NOSNOOZE));
ShowWindow(hw, (data->flags & ALF_NOSNOOZE) ? SW_HIDE : SW_SHOWNA);
}
return TRUE;
case WMU_FAKEALARM:
SetWindowText(hwndDlg, TranslateT("Example alarm"));
SetDlgItemText(hwndDlg, IDC_TITLE, TranslateT("Example alarm"));
SetDlgItemText(hwndDlg, IDC_ED_DESC, TranslateT("Some example text. Example, example, example."));
return TRUE;
case WM_TIMER:
if (wParam == ID_TIMER_SOUND && wd) {
ALARM *data = wd->alarm;
if (data && data->action & AAF_SOUND) {
if (data->sound_num <= 3) {
char buff[128];
mir_snprintf(buff, "Triggered%d", data->sound_num);
Skin_PlaySound(buff);
}
else if (data->sound_num == 4) {
if (data->szTitle != nullptr && data->szTitle[0] != '\0') {
if (ServiceExists("Speak/Say")) {
CallService("Speak/Say", 0, (LPARAM)data->szTitle);
}
}
}
}
}
return TRUE;
case WM_MOVE:
Utils_SaveWindowPosition(hwndDlg, 0, MODULENAME, "Notify");
break;
case WMU_ADDSNOOZER:
if (wd) {
ALARM *data = wd->alarm;
if (data) {
// add snooze minutes to current time
FILETIME ft;
GetLocalTime(&data->time);
SystemTimeToFileTime(&data->time, &ft);
ULARGE_INTEGER uli;
uli.LowPart = ft.dwLowDateTime;
uli.HighPart = ft.dwHighDateTime;
// there are 10000000 100-nanosecond blocks in a second...
uli.QuadPart += mult.QuadPart * (int)(wParam);
ft.dwHighDateTime = uli.HighPart;
ft.dwLowDateTime = uli.LowPart;
FileTimeToSystemTime(&ft, &data->time);
data->occurrence = OC_ONCE;
data->snoozer = true;
data->flags = data->flags & ~ALF_NOSTARTUP;
data->id = next_alarm_id++;
append_to_list(data);
}
}
return TRUE;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED) {
switch (LOWORD(wParam)) {
case IDCANCEL: // no button - esc pressed
case IDOK: // space?
case IDC_SNOOZE:
SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)options.snooze_minutes, 0);
//drop through
case IDC_DISMISS:
KillTimer(hwndDlg, ID_TIMER_SOUND);
if (wd) {
if (wd->alarm) {
free_alarm_data(wd->alarm);
delete wd->alarm;
}
delete wd;
}
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, 0);
win_num--;
WindowList_Remove(hAlarmWindowList, hwndDlg);
DestroyWindow(hwndDlg);
break;
case IDC_SNOOZELIST:
POINT pt, pt_rel;
GetCursorPos(&pt);
pt_rel = pt;
ScreenToClient(hwndDlg, &pt_rel);
HMENU hMenu = CreatePopupMenu();
MENUITEMINFO mii = { 0 };
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID | MIIM_STRING;
#define AddItem(x) \
mii.wID++; \
mii.dwTypeData = TranslateW(x); \
mii.cch = ( UINT )mir_wstrlen(mii.dwTypeData); \
InsertMenuItem(hMenu, mii.wID, FALSE, &mii);
AddItem(LPGENW("5 mins"));
AddItem(LPGENW("15 mins"));
AddItem(LPGENW("30 mins"));
AddItem(LPGENW("1 hour"));
AddItem(LPGENW("1 day"));
AddItem(LPGENW("1 week"));
TPMPARAMS tpmp = { 0 };
tpmp.cbSize = sizeof(tpmp);
LRESULT ret = (LRESULT)TrackPopupMenuEx(hMenu, TPM_RETURNCMD, pt.x, pt.y, hwndDlg, &tpmp);
switch (ret) {
case 0: DestroyMenu(hMenu); return 0; // dismis menu
case 1: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)5, 0); break;
case 2: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)15, 0); break;
case 3: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)30, 0); break;
case 4: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)60, 0); break;
case 5: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)(60 * 24), 0); break;
case 6: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)(60 * 24 * 7), 0); break;
}
DestroyMenu(hMenu);
SendMessage(hwndDlg, WM_COMMAND, IDC_DISMISS, 0);
break;
}
}
return TRUE;
case WM_MOUSEMOVE:
if (wParam & MK_LBUTTON) {
SetCapture(hwndDlg);
POINT newp;
newp.x = (short)LOWORD(lParam);
newp.y = (short)HIWORD(lParam);
ClientToScreen(hwndDlg, &newp);
if (!wd->moving)
wd->moving = true;
else {
RECT r;
GetWindowRect(hwndDlg, &r);
SetWindowPos(hwndDlg, nullptr, r.left + (newp.x - wd->p.x), r.top + (newp.y - wd->p.y), 0, 0, SWP_NOSIZE | SWP_NOZORDER);
}
wd->p.x = newp.x;
wd->p.y = newp.y;
}
else {
ReleaseCapture();
wd->moving = false;
}
return TRUE;
}
return FALSE;
}
INT_PTR CALLBACK PhpOptionsHighlightingDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
ULONG i;
PhpPageInit(hwndDlg);
// Highlighting Duration
SetDlgItemInt(hwndDlg, IDC_HIGHLIGHTINGDURATION, PhCsHighlightingDuration, FALSE);
// New Objects
ColorBox_SetColor(GetDlgItem(hwndDlg, IDC_NEWOBJECTS), PhCsColorNew);
// Removed Objects
ColorBox_SetColor(GetDlgItem(hwndDlg, IDC_REMOVEDOBJECTS), PhCsColorRemoved);
// Highlighting
HighlightingListViewHandle = GetDlgItem(hwndDlg, IDC_LIST);
PhSetListViewStyle(HighlightingListViewHandle, FALSE, TRUE);
ListView_SetExtendedListViewStyleEx(HighlightingListViewHandle, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
PhAddListViewColumn(HighlightingListViewHandle, 0, 0, 0, LVCFMT_LEFT, 240, L"Name");
PhSetExtendedListView(HighlightingListViewHandle);
ExtendedListView_SetItemColorFunction(HighlightingListViewHandle, PhpColorItemColorFunction);
for (i = 0; i < sizeof(ColorItems) / sizeof(COLOR_ITEM); i++)
{
INT lvItemIndex;
lvItemIndex = PhAddListViewItem(HighlightingListViewHandle, MAXINT, ColorItems[i].Name, &ColorItems[i]);
ColorItems[i].CurrentColor = PhGetIntegerSetting(ColorItems[i].SettingName);
ColorItems[i].CurrentUse = !!PhGetIntegerSetting(ColorItems[i].UseSettingName);
ListView_SetCheckState(HighlightingListViewHandle, lvItemIndex, ColorItems[i].CurrentUse);
}
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLE), FALSE);
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_ENABLEALL:
{
ULONG i;
for (i = 0; i < sizeof(ColorItems) / sizeof(COLOR_ITEM); i++)
ListView_SetCheckState(HighlightingListViewHandle, i, TRUE);
}
break;
case IDC_DISABLEALL:
{
ULONG i;
for (i = 0; i < sizeof(ColorItems) / sizeof(COLOR_ITEM); i++)
ListView_SetCheckState(HighlightingListViewHandle, i, FALSE);
}
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
switch (header->code)
{
case PSN_APPLY:
{
ULONG i;
PH_SET_INTEGER_CACHED_SETTING(HighlightingDuration, GetDlgItemInt(hwndDlg, IDC_HIGHLIGHTINGDURATION, NULL, FALSE));
PH_SET_INTEGER_CACHED_SETTING(ColorNew, ColorBox_GetColor(GetDlgItem(hwndDlg, IDC_NEWOBJECTS)));
PH_SET_INTEGER_CACHED_SETTING(ColorRemoved, ColorBox_GetColor(GetDlgItem(hwndDlg, IDC_REMOVEDOBJECTS)));
for (i = 0; i < sizeof(ColorItems) / sizeof(COLOR_ITEM); i++)
{
ColorItems[i].CurrentUse = !!ListView_GetCheckState(HighlightingListViewHandle, i);
PhSetIntegerSetting(ColorItems[i].SettingName, ColorItems[i].CurrentColor);
PhSetIntegerSetting(ColorItems[i].UseSettingName, ColorItems[i].CurrentUse);
}
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
}
return TRUE;
case NM_DBLCLK:
{
if (header->hwndFrom == HighlightingListViewHandle)
{
PCOLOR_ITEM item;
if (item = PhGetSelectedListViewItemParam(HighlightingListViewHandle))
{
CHOOSECOLOR chooseColor = { sizeof(chooseColor) };
COLORREF customColors[16] = { 0 };
chooseColor.hwndOwner = hwndDlg;
chooseColor.rgbResult = item->CurrentColor;
chooseColor.lpCustColors = customColors;
chooseColor.Flags = CC_ANYCOLOR | CC_FULLOPEN | CC_RGBINIT;
if (ChooseColor(&chooseColor))
{
item->CurrentColor = chooseColor.rgbResult;
InvalidateRect(HighlightingListViewHandle, NULL, TRUE);
}
}
}
}
break;
case LVN_GETINFOTIP:
{
if (header->hwndFrom == HighlightingListViewHandle)
{
NMLVGETINFOTIP *getInfoTip = (NMLVGETINFOTIP *)lParam;
PH_STRINGREF tip;
PhInitializeStringRefLongHint(&tip, ColorItems[getInfoTip->iItem].Description);
PhCopyListViewInfoTip(getInfoTip, &tip);
}
}
break;
}
}
break;
}
REFLECT_MESSAGE_DLG(hwndDlg, HighlightingListViewHandle, uMsg, wParam, lParam);
return FALSE;
}
static INT_PTR CALLBACK settingsDialogProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_INITDIALOG:
saved_mute_mask = mute_mask;
settingsDialogSet(hDlg, song_length, silence_seconds, play_loops, mute_mask);
return TRUE;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED) {
WORD wCtrl = LOWORD(wParam);
BOOL enabled;
switch (wCtrl) {
case IDC_UNLIMITED:
enableTimeInput(hDlg, FALSE);
return TRUE;
case IDC_LIMITED:
enableTimeInput(hDlg, TRUE);
setFocusAndSelect(hDlg, IDC_MINUTES);
return TRUE;
case IDC_SILENCE:
enabled = (IsDlgButtonChecked(hDlg, IDC_SILENCE) == BST_CHECKED);
EnableWindow(GetDlgItem(hDlg, IDC_SILSECONDS), enabled);
if (enabled)
setFocusAndSelect(hDlg, IDC_SILSECONDS);
return TRUE;
case IDC_LOOPS:
case IDC_NOLOOPS:
return TRUE;
case IDC_MUTE1:
case IDC_MUTE1 + 1:
case IDC_MUTE1 + 2:
case IDC_MUTE1 + 3:
case IDC_MUTE1 + 4:
case IDC_MUTE1 + 5:
case IDC_MUTE1 + 6:
case IDC_MUTE1 + 7:
{
int mask = 1 << (wCtrl - IDC_MUTE1);
if (IsDlgButtonChecked(hDlg, wCtrl) == BST_CHECKED)
mute_mask |= mask;
else
mute_mask &= ~mask;
ASAP_MutePokeyChannels(asap, mute_mask);
return TRUE;
}
case IDOK:
{
int new_song_length;
if (IsDlgButtonChecked(hDlg, IDC_UNLIMITED) == BST_CHECKED)
new_song_length = -1;
else {
int minutes;
int seconds;
if (!getDlgInt(hDlg, IDC_MINUTES, &minutes)
|| !getDlgInt(hDlg, IDC_SECONDS, &seconds))
return TRUE;
new_song_length = 60 * minutes + seconds;
}
if (IsDlgButtonChecked(hDlg, IDC_SILENCE) != BST_CHECKED)
silence_seconds = -1;
else if (!getDlgInt(hDlg, IDC_SILSECONDS, &silence_seconds))
return TRUE;
song_length = new_song_length;
play_loops = (IsDlgButtonChecked(hDlg, IDC_LOOPS) == BST_CHECKED);
EndDialog(hDlg, IDOK);
return TRUE;
}
case IDCANCEL:
mute_mask = saved_mute_mask;
ASAP_MutePokeyChannels(asap, mute_mask);
EndDialog(hDlg, IDCANCEL);
return TRUE;
}
}
break;
default:
break;
}
return FALSE;
}
BOOL CALLBACK DlgProcCAP(HWND hwnd, UINT uMsg,
WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_INITDIALOG:
{
initdone5=false;
SendMessage(GetDlgItem(hwnd, IDC_TURBOMODE), BM_SETCHECK, TurboMode, 0);
SendMessage(GetDlgItem(hwnd, IDC_DRIVER),BM_SETCHECK,Driver,0);
SendMessage(GetDlgItem(hwnd, IDC_HOOK),BM_SETCHECK,Hook,0);
SendMessage(GetDlgItem(hwnd, IDC_POLL_FULLSCREEN),BM_SETCHECK,PollFullScreen,0);
SendMessage(GetDlgItem(hwnd, IDC_POLL_FOREGROUND),BM_SETCHECK,PollForeground,0);
SendMessage(GetDlgItem(hwnd, IDC_POLL_UNDER_CURSOR),BM_SETCHECK,PollUnderCursor,0);
SendMessage(GetDlgItem(hwnd, IDC_CONSOLE_ONLY),BM_SETCHECK,PollConsoleOnly,0);
SendMessage(GetDlgItem(hwnd, IDC_REMOVE_WALLPAPER),BM_SETCHECK,RemoveWallpaper,0);
SendMessage(GetDlgItem(hwnd, IDC_REMOVE_Aero),BM_SETCHECK,RemoveAero,0);
SendMessage(GetDlgItem(hwnd, IDC_ONEVENT_ONLY),BM_SETCHECK,PollOnEventOnly,0);
EnableWindow(GetDlgItem(hwnd, IDC_CONSOLE_ONLY),PollUnderCursor ||PollForeground);
EnableWindow(GetDlgItem(hwnd, IDC_ONEVENT_ONLY),PollUnderCursor ||PollForeground);
SendMessage(GetDlgItem(hwnd, IDC_PRIM),BM_SETCHECK,Primary,0);
SendMessage(GetDlgItem(hwnd, IDC_SEC),BM_SETCHECK,Secondary,0);
SetDlgItemInt(hwnd, IDC_MAXCPU, MaxCpu, false);
initdone5=true;
return TRUE;
}
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_HELP2:
if (lParam==4)
{
char link[256];
strcpy(link,"http://www.uvnc.com/webhelp/");
strcat(link,"screencapture");
strcat(link,".html");
ShellExecute(GetDesktopWindow(), "open", link, "", 0, SW_SHOWNORMAL);
}
break;
case IDOK:
{
TurboMode=SendDlgItemMessage(hwnd, IDC_TURBOMODE, BM_GETCHECK, 0, 0);
PollUnderCursor=SendDlgItemMessage(hwnd, IDC_POLL_UNDER_CURSOR, BM_GETCHECK, 0, 0);
PollForeground=SendDlgItemMessage(hwnd, IDC_POLL_FOREGROUND, BM_GETCHECK, 0, 0);
PollFullScreen=SendDlgItemMessage(hwnd, IDC_POLL_FULLSCREEN, BM_GETCHECK, 0, 0);
PollConsoleOnly=SendDlgItemMessage(hwnd, IDC_CONSOLE_ONLY, BM_GETCHECK, 0, 0);
PollOnEventOnly=SendDlgItemMessage(hwnd, IDC_ONEVENT_ONLY, BM_GETCHECK, 0, 0);
Driver=SendDlgItemMessage(hwnd, IDC_DRIVER, BM_GETCHECK, 0, 0);
Primary=SendDlgItemMessage(hwnd, IDC_PRIM, BM_GETCHECK, 0, 0);
Secondary=SendDlgItemMessage(hwnd, IDC_SEC, BM_GETCHECK, 0, 0);
Hook=SendDlgItemMessage(hwnd, IDC_HOOK, BM_GETCHECK, 0, 0);
RemoveWallpaper=SendDlgItemMessage(hwnd, IDC_REMOVE_WALLPAPER, BM_GETCHECK, 0, 0);
RemoveAero=SendDlgItemMessage(hwnd, IDC_REMOVE_Aero, BM_GETCHECK, 0, 0);
MaxCpu = GetDlgItemInt(hwnd, IDC_MAXCPU, NULL, FALSE);
}
break;
case IDCANCEL:
EndDialog(hwnd, IDCANCEL);
return TRUE;
case IDC_POLL_FOREGROUND:
case IDC_POLL_UNDER_CURSOR:
// User has clicked on one of the polling mode buttons
// affected by the pollconsole and pollonevent options
{
// Get the poll-mode buttons
HWND hPollForeground = GetDlgItem(hwnd, IDC_POLL_FOREGROUND);
HWND hPollUnderCursor = GetDlgItem(hwnd, IDC_POLL_UNDER_CURSOR);
// Determine whether to enable the modifier options
BOOL enabled = (SendMessage(hPollForeground, BM_GETCHECK, 0, 0) == BST_CHECKED) ||
(SendMessage(hPollUnderCursor, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hPollConsoleOnly = GetDlgItem(hwnd, IDC_CONSOLE_ONLY);
EnableWindow(hPollConsoleOnly, enabled);
HWND hPollOnEventOnly = GetDlgItem(hwnd, IDC_ONEVENT_ONLY);
EnableWindow(hPollOnEventOnly, enabled);
}
return TRUE;
case IDC_CHECKDRIVER:
{
CheckVideoDriver(1);
}
return TRUE;
}
return 0;
}
return 0;
}
extern
BOOL _EXPORT FAR PASCAL OptionsDlgProc( HWND hwnd, unsigned msg,
UINT wparam, LONG lparam )
{
HWND edit;
int num = NumPrinters();
char buff[20];
lparam = lparam; /* turn off warning */
edit = GetDlgItem( hwnd, IDDI_PORT_EDIT );
switch( msg ) {
case WM_INITDIALOG:
EnableWindow( edit, FALSE );
if( TrapParm[0] >= '1' && TrapParm[0] <= '3' ) {
if( TrapParm[0] > num + '0' ) TrapParm[0] = num + '0';
}
switch( TrapParm[0] ) {
case '1':
default:
if( num >= 1 ) {
SendDlgItemMessage( hwnd, IDDI_LPT1, BM_SETCHECK, 1, 0 );
SetDlgItemText( hwnd, IDDI_PORT_EDIT, utoa( PrnAddress( 0 ), buff, 16 ) );
}
break;
case '2':
if( num >= 2 ) {
SendDlgItemMessage( hwnd, IDDI_LPT2, BM_SETCHECK, 1, 0 );
SetDlgItemText( hwnd, IDDI_PORT_EDIT, utoa( PrnAddress( 1 ), buff, 16 ) );
}
break;
case '3':
if( num >= 3 ) {
SendDlgItemMessage( hwnd, IDDI_LPT3, BM_SETCHECK, 1, 0 );
SetDlgItemText( hwnd, IDDI_PORT_EDIT, utoa( PrnAddress( 2 ), buff, 16 ) );
}
break;
case 'p':
case 'P':
SendDlgItemMessage( hwnd, IDDI_PORT, BM_SETCHECK, 1, 0 );
SetDlgItemText( hwnd, IDDI_PORT_EDIT, TrapParm+1 );
EnableWindow( edit, TRUE );
}
if( num < 3 ) EnableWindow( GetDlgItem( hwnd, IDDI_LPT3 ), FALSE );
if( num < 2 ) EnableWindow( GetDlgItem( hwnd, IDDI_LPT2 ), FALSE );
if( num < 1 ) EnableWindow( GetDlgItem( hwnd, IDDI_LPT1 ), FALSE );
return( TRUE );
case WM_COMMAND:
switch( LOWORD( wparam ) ) {
case IDOK:
TrapParm[1] = '\0';
if( SendDlgItemMessage( hwnd, IDDI_LPT1, BM_GETCHECK, 0, 0 ) ) {
TrapParm[0] = '1';
} else if( SendDlgItemMessage( hwnd, IDDI_LPT2, BM_GETCHECK, 0, 0 ) ) {
TrapParm[0] = '2';
} else if( SendDlgItemMessage( hwnd, IDDI_LPT3, BM_GETCHECK, 0, 0 ) ) {
TrapParm[0] = '3';
} else if( SendDlgItemMessage( hwnd, IDDI_PORT, BM_GETCHECK, 0, 0 ) ) {
TrapParm[0] = 'p';
GetDlgItemText( hwnd, IDDI_PORT_EDIT, TrapParm+1, 256 );
} else {
TrapParm[0] = '1';
}
case IDCANCEL:
EndDialog( hwnd, TRUE );
return( TRUE );
case IDDI_LPT1:
SetDlgItemText( hwnd, IDDI_PORT_EDIT, utoa( PrnAddress( 0 ), buff, 16 ) );
EnableWindow( edit, FALSE );
break;
case IDDI_LPT2:
SetDlgItemText( hwnd, IDDI_PORT_EDIT, utoa( PrnAddress( 1 ), buff, 16 ) );
EnableWindow( edit, FALSE );
break;
case IDDI_LPT3:
SetDlgItemText( hwnd, IDDI_PORT_EDIT, utoa( PrnAddress( 2 ), buff, 16 ) );
EnableWindow( edit, FALSE );
break;
case IDDI_PORT:
SetDlgItemText( hwnd, IDDI_PORT_EDIT, TrapParm[0] == '\0' ? "" : TrapParm+1 );
EnableWindow( edit, TRUE );
break;
}
break;
}
return( FALSE );
}
void CGitPropertyPage::InitWorkfileView()
{
if (filenames.empty())
return;
CTGitPath path(filenames.front().c_str());
CString ProjectTopDir;
if(!path.HasAdminDir(&ProjectTopDir))
return;
CAutoRepository repository(CUnicodeUtils::GetUTF8(ProjectTopDir));
if (!repository)
return;
CString username;
CString useremail;
CString autocrlf;
CString safecrlf;
CAutoConfig config(repository);
if (config)
{
config.GetString(L"user.name", username);
config.GetString(L"user.email", useremail);
config.GetString(L"core.autocrlf", autocrlf);
config.GetString(L"core.safecrlf", safecrlf);
}
CString branch;
CString remotebranch;
if (!git_repository_head_detached(repository))
{
CAutoReference head;
if (git_repository_head_unborn(repository))
{
git_reference_lookup(head.GetPointer(), repository, "HEAD");
branch = CUnicodeUtils::GetUnicode(git_reference_symbolic_target(head));
if (branch.Find(_T("refs/heads/")) == 0)
branch = branch.Mid(11); // 11 = len("refs/heads/")
}
else if (!git_repository_head(head.GetPointer(), repository))
{
const char * branchChar = git_reference_shorthand(head);
branch = CUnicodeUtils::GetUnicode(branchChar);
const char * branchFullChar = git_reference_name(head);
CAutoBuf upstreambranchname;
if (!git_branch_upstream_name(upstreambranchname, repository, branchFullChar))
{
remotebranch = CUnicodeUtils::GetUnicode(CStringA(upstreambranchname->ptr, (int)upstreambranchname->size));
remotebranch = remotebranch.Mid(13); // 13=len("refs/remotes/")
}
}
}
else
branch = _T("detached HEAD");
if (autocrlf.Trim().IsEmpty())
autocrlf = _T("false");
if (safecrlf.Trim().IsEmpty())
safecrlf = _T("false");
SetDlgItemText(m_hwnd,IDC_CONFIG_USERNAME,username.Trim());
SetDlgItemText(m_hwnd,IDC_CONFIG_USEREMAIL,useremail.Trim());
SetDlgItemText(m_hwnd,IDC_CONFIG_AUTOCRLF,autocrlf.Trim());
SetDlgItemText(m_hwnd,IDC_CONFIG_SAFECRLF,safecrlf.Trim());
SetDlgItemText(m_hwnd,IDC_SHELL_CURRENT_BRANCH,branch.Trim());
SetDlgItemText(m_hwnd,IDC_SHELL_REMOTE_BRANCH, remotebranch);
git_oid oid;
CAutoCommit HEADcommit;
if (!git_reference_name_to_id(&oid, repository, "HEAD") && !git_commit_lookup(HEADcommit.GetPointer(), repository, &oid) && HEADcommit)
DisplayCommit(HEADcommit, IDC_HEAD_HASH, IDC_HEAD_SUBJECT, IDC_HEAD_AUTHOR, IDC_HEAD_DATE);
{
int stripLength = ProjectTopDir.GetLength();
if (ProjectTopDir[stripLength - 1] != _T('\\'))
++stripLength;
bool allAreFiles = true;
for (auto it = filenames.cbegin(); it < filenames.cend(); ++it)
{
if (PathIsDirectory(it->c_str()))
{
allAreFiles = false;
break;
}
}
if (allAreFiles)
{
size_t assumevalid = 0;
size_t skipworktree = 0;
size_t executable = 0;
size_t symlink = 0;
do
{
CAutoIndex index;
if (git_repository_index(index.GetPointer(), repository))
break;
for (auto it = filenames.cbegin(); it < filenames.cend(); ++it)
{
CTGitPath file;
file.SetFromWin(CString(it->c_str()).Mid(stripLength));
CStringA pathA = CUnicodeUtils::GetMulti(file.GetGitPathString(), CP_UTF8);
size_t idx;
if (!git_index_find(&idx, index, pathA))
{
const git_index_entry *e = git_index_get_byindex(index, idx);
if (e->flags & GIT_IDXENTRY_VALID)
++assumevalid;
if (e->flags_extended & GIT_IDXENTRY_SKIP_WORKTREE)
++skipworktree;
if (e->mode & 0111)
++executable;
if ((e->mode & GIT_FILEMODE_LINK) == GIT_FILEMODE_LINK)
++symlink;
}
else
{
// do not show checkboxes for unversioned files
ShowWindow(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), SW_HIDE);
ShowWindow(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), SW_HIDE);
ShowWindow(GetDlgItem(m_hwnd, IDC_EXECUTABLE), SW_HIDE);
ShowWindow(GetDlgItem(m_hwnd, IDC_SYMLINK), SW_HIDE);
break;
}
}
} while (0);
if (assumevalid != 0 && assumevalid != filenames.size())
{
SendMessage(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), BM_SETSTYLE, (DWORD)GetWindowLong(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), GWL_STYLE) & ~BS_AUTOCHECKBOX | BS_AUTO3STATE, 0);
SendMessage(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), BM_SETCHECK, BST_INDETERMINATE, 0);
}
else
SendMessage(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), BM_SETCHECK, (assumevalid == 0) ? BST_UNCHECKED : BST_CHECKED, 0);
if (skipworktree != 0 && skipworktree != filenames.size())
{
SendMessage(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), BM_SETSTYLE, (DWORD)GetWindowLong(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), GWL_STYLE) & ~BS_AUTOCHECKBOX | BS_AUTO3STATE, 0);
SendMessage(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), BM_SETCHECK, BST_INDETERMINATE, 0);
}
else
SendMessage(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), BM_SETCHECK, (skipworktree == 0) ? BST_UNCHECKED : BST_CHECKED, 0);
if (executable != 0 && executable != filenames.size())
{
SendMessage(GetDlgItem(m_hwnd, IDC_EXECUTABLE), BM_SETSTYLE, (DWORD)GetWindowLong(GetDlgItem(m_hwnd, IDC_EXECUTABLE), GWL_STYLE) & ~BS_AUTOCHECKBOX | BS_AUTO3STATE, 0);
SendMessage(GetDlgItem(m_hwnd, IDC_EXECUTABLE), BM_SETCHECK, BST_INDETERMINATE, 0);
EnableWindow(GetDlgItem(m_hwnd, IDC_SYMLINK), TRUE);
}
else
{
SendMessage(GetDlgItem(m_hwnd, IDC_EXECUTABLE), BM_SETCHECK, (executable == 0) ? BST_UNCHECKED : BST_CHECKED, 0);
EnableWindow(GetDlgItem(m_hwnd, IDC_SYMLINK), (executable == 0) ? TRUE : FALSE);
}
if (symlink != 0 && symlink != filenames.size())
{
SendMessage(GetDlgItem(m_hwnd, IDC_SYMLINK), BM_SETSTYLE, (DWORD)GetWindowLong(GetDlgItem(m_hwnd, IDC_SYMLINK), GWL_STYLE) & ~BS_AUTOCHECKBOX | BS_AUTO3STATE, 0);
SendMessage(GetDlgItem(m_hwnd, IDC_SYMLINK), BM_SETCHECK, BST_INDETERMINATE, 0);
EnableWindow(GetDlgItem(m_hwnd, IDC_EXECUTABLE), TRUE);
}
else
{
SendMessage(GetDlgItem(m_hwnd, IDC_SYMLINK), BM_SETCHECK, (symlink == 0) ? BST_UNCHECKED : BST_CHECKED, 0);
EnableWindow(GetDlgItem(m_hwnd, IDC_EXECUTABLE), (symlink == 0) ? TRUE : FALSE);
}
}
else
{
ShowWindow(GetDlgItem(m_hwnd, IDC_ASSUMEVALID), SW_HIDE);
ShowWindow(GetDlgItem(m_hwnd, IDC_SKIPWORKTREE), SW_HIDE);
ShowWindow(GetDlgItem(m_hwnd, IDC_EXECUTABLE), SW_HIDE);
ShowWindow(GetDlgItem(m_hwnd, IDC_SYMLINK), SW_HIDE);
}
}
if (filenames.size() == 1 && !PathIsDirectory(filenames[0].c_str()))
{
SetDlgItemText(m_hwnd, IDC_LAST_SUBJECT, CString(MAKEINTRESOURCE(IDS_LOADING)));
_beginthread(LogThreadEntry, 0, this);
}
else
ShowWindow(GetDlgItem(m_hwnd, IDC_STATIC_LASTMODIFIED), SW_HIDE);
}
INT_PTR CALLBACK InesHeader (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
static TCHAR *filename;
static char header[16];
int i;
FILE *rom;
TCHAR name[MAX_PATH];
switch (message)
{
case WM_INITDIALOG:
filename = (TCHAR *)lParam;
rom = _tfopen(filename, _T("rb"));
if (!rom)
{
MessageBox(hMainWnd, _T("Unable to open ROM!"), _T("Nintendulator"), MB_OK | MB_ICONERROR);
EndDialog(hDlg, 0);
}
fread(header, 16, 1, rom);
fclose(rom);
if (memcmp(header, "NES\x1A", 4))
{
MessageBox(hMainWnd, _T("Selected file is not an iNES ROM image!"), _T("Nintendulator"), MB_OK | MB_ICONERROR);
EndDialog(hDlg, 0);
}
if ((header[7] & 0x0C) == 0x08)
{
MessageBox(hMainWnd, _T("Selected ROM contains iNES 2.0 information, which is not yet supported. Please use a stand-alone editor."), _T("Nintendulator"), MB_OK | MB_ICONERROR);
EndDialog(hDlg, 0);
}
if ((header[7] & 0x0C) == 0x04)
{
MessageBox(hMainWnd, _T("Selected ROM appears to have been corrupted by \"DiskDude!\" - cleaning..."), _T("Nintendulator"), MB_OK | MB_ICONWARNING);
for (i = 7; i < 16; i++)
header[i] = 0;
}
else if (((header[8] || header[9] || header[10] || header[11] || header[12] || header[13] || header[14] || header[15])) &&
(MessageBox(hDlg, _T("Unrecognized data has been detected in the reserved region of this ROM's header! Do you wish to clean it?"), _T("Nintendulator"), MB_YESNO | MB_ICONQUESTION) == IDYES))
{
for (i = 7; i < 16; i++)
header[i] = 0;
}
i = (int)_tcslen(filename)-1;
while ((i >= 0) && (filename[i] != _T('\\')))
i--;
_tcscpy(name, filename+i+1);
name[_tcslen(name)-4] = 0;
SetDlgItemText(hDlg, IDC_INES_NAME, name);
SetDlgItemInt(hDlg, IDC_INES_PRG, header[4], FALSE);
SetDlgItemInt(hDlg, IDC_INES_CHR, header[5], FALSE);
SetDlgItemInt(hDlg, IDC_INES_MAP, ((header[6] >> 4) & 0xF) | (header[7] & 0xF0), FALSE);
CheckDlgButton(hDlg, IDC_INES_BATT, (header[6] & 0x02) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hDlg, IDC_INES_TRAIN, (header[6] & 0x04) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hDlg, IDC_INES_4SCR, (header[6] & 0x08) ? BST_CHECKED : BST_UNCHECKED);
if (header[6] & 0x01)
CheckRadioButton(hDlg, IDC_INES_HORIZ, IDC_INES_VERT, IDC_INES_VERT);
else CheckRadioButton(hDlg, IDC_INES_HORIZ, IDC_INES_VERT, IDC_INES_HORIZ);
CheckDlgButton(hDlg, IDC_INES_VS, (header[7] & 0x01) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hDlg, IDC_INES_PC10, (header[7] & 0x02) ? BST_CHECKED : BST_UNCHECKED);
if (IsDlgButtonChecked(hDlg, IDC_INES_4SCR))
{
EnableWindow(GetDlgItem(hDlg, IDC_INES_HORIZ), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_INES_VERT), FALSE);
}
else
{
EnableWindow(GetDlgItem(hDlg, IDC_INES_HORIZ), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_INES_VERT), TRUE);
}
if (IsDlgButtonChecked(hDlg, IDC_INES_VS))
EnableWindow(GetDlgItem(hDlg, IDC_INES_PC10), FALSE);
else if (IsDlgButtonChecked(hDlg, IDC_INES_PC10))
EnableWindow(GetDlgItem(hDlg, IDC_INES_VS), FALSE);
else
{
EnableWindow(GetDlgItem(hDlg, IDC_INES_VS), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_INES_PC10), TRUE);
}
return TRUE;
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_INES_PRG:
i = GetDlgItemInt(hDlg, IDC_INES_PRG, NULL, FALSE);
if ((i < 0) || (i > 255))
SetDlgItemInt(hDlg, IDC_INES_PRG, i = 0, FALSE);
header[4] = (char)(i & 0xFF);
break;
case IDC_INES_CHR:
i = GetDlgItemInt(hDlg, IDC_INES_CHR, NULL, FALSE);
if ((i < 0) || (i > 255))
SetDlgItemInt(hDlg, IDC_INES_CHR, i = 0, FALSE);
header[5] = (char)(i & 0xFF);
break;
case IDC_INES_MAP:
i = GetDlgItemInt(hDlg, IDC_INES_MAP, NULL, FALSE);
if ((i < 0) || (i > 255))
SetDlgItemInt(hDlg, IDC_INES_MAP, i = 0, FALSE);
header[6] = (char)((header[6] & 0x0F) | ((i & 0x0F) << 4));
header[7] = (char)((header[7] & 0x0F) | (i & 0xF0));
break;
case IDC_INES_BATT:
if (IsDlgButtonChecked(hDlg, IDC_INES_BATT))
header[6] |= 0x02;
else header[6] &= ~0x02;
break;
case IDC_INES_TRAIN:
if (IsDlgButtonChecked(hDlg, IDC_INES_TRAIN))
{
MessageBox(hDlg, _T("Trained ROMs are not supported in Nintendulator!"), _T("Nintendulator"), MB_OK | MB_ICONWARNING);
header[6] |= 0x04;
}
else header[6] &= ~0x04;
break;
case IDC_INES_4SCR:
if (IsDlgButtonChecked(hDlg, IDC_INES_4SCR))
{
EnableWindow(GetDlgItem(hDlg, IDC_INES_HORIZ), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_INES_VERT), FALSE);
header[6] |= 0x08;
}
else
{
EnableWindow(GetDlgItem(hDlg, IDC_INES_HORIZ), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_INES_VERT), TRUE);
header[6] &= ~0x08;
}
break;
case IDC_INES_HORIZ:
if (IsDlgButtonChecked(hDlg, IDC_INES_HORIZ))
header[6] &= ~0x01;
break;
case IDC_INES_VERT:
if (IsDlgButtonChecked(hDlg, IDC_INES_VERT))
header[6] |= 0x01;
break;
case IDC_INES_VS:
if (IsDlgButtonChecked(hDlg, IDC_INES_VS))
{
EnableWindow(GetDlgItem(hDlg, IDC_INES_PC10), FALSE);
header[7] |= 0x01;
}
else
{
EnableWindow(GetDlgItem(hDlg, IDC_INES_PC10), TRUE);
header[7] &= ~0x01;
}
break;
case IDC_INES_PC10:
if (IsDlgButtonChecked(hDlg, IDC_INES_PC10))
{
EnableWindow(GetDlgItem(hDlg, IDC_INES_VS), FALSE);
header[7] |= 0x02;
}
else
{
EnableWindow(GetDlgItem(hDlg, IDC_INES_VS), TRUE);
header[7] &= ~0x02;
}
break;
case IDOK:
rom = _tfopen(filename, _T("r+b"));
if (rom)
{
fwrite(header, 16, 1, rom);
fclose(rom);
}
else MessageBox(hMainWnd, _T("Failed to open ROM!"), _T("Nintendulator"), MB_OK | MB_ICONERROR);
// fall through
case IDCANCEL:
EndDialog(hDlg, 0);
break;
}
}
return FALSE;
}
LRESULT CALLBACK BasicSettingsDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam)
{
static helpballoon_struct hb[9];
switch (uMsg)
{
case WM_INITDIALOG:
{
BOOL imagebool=FALSE;
char current_drive=0;
int i;
// Setup Combo Boxes
// Disc Type Box
SendDlgItemMessage(hDlg, IDC_DISCTYPECB, CB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hDlg, IDC_DISCTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("CD"));
SendDlgItemMessage(hDlg, IDC_DISCTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("Image"));
// Drive Letter Box
SendDlgItemMessage(hDlg, IDC_DRIVELETTERCB, CB_RESETCONTENT, 0, 0);
// figure out which drive letters are available
GenerateCDROMList(hDlg);
// Set Disc Type Selection
if (IsPathCdrom(cdrompath))
{
current_drive = cdrompath[0];
imagebool = FALSE;
}
else
{
// Assume it's a file
current_drive = 0;
imagebool = TRUE;
}
if (current_drive != 0)
{
for (i = 0; i < num_cdroms; i++)
{
if (toupper(current_drive) == toupper(drive_list[i]))
{
SendDlgItemMessage(hDlg, IDC_DRIVELETTERCB, CB_SETCURSEL, i, 0);
}
}
}
else
{
// set it to the first drive
SendDlgItemMessage(hDlg, IDC_DRIVELETTERCB, CB_SETCURSEL, 0, 0);
}
// disable/enable menu options depending on whether or not
// image is selected
if (imagebool == FALSE)
{
SendDlgItemMessage(hDlg, IDC_DISCTYPECB, CB_SETCURSEL, 0, 0);
EnableWindow(GetDlgItem(hDlg, IDC_IMAGEEDIT), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_IMAGEBROWSE), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_DRIVELETTERCB), TRUE);
}
else
{
SendDlgItemMessage(hDlg, IDC_DISCTYPECB, CB_SETCURSEL, 1, 0);
EnableWindow(GetDlgItem(hDlg, IDC_IMAGEEDIT), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_IMAGEBROWSE), TRUE);
SetDlgItemText(hDlg, IDC_IMAGEEDIT, _16(cdrompath));
EnableWindow(GetDlgItem(hDlg, IDC_DRIVELETTERCB), FALSE);
}
/*
// Setup Bios Language Combo box
SendDlgItemMessage(hDlg, IDC_BIOSLANGCB, CB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hDlg, IDC_BIOSLANGCB, CB_ADDSTRING, 0, (long)"English");
SendDlgItemMessage(hDlg, IDC_BIOSLANGCB, CB_ADDSTRING, 0, (long)"German");
SendDlgItemMessage(hDlg, IDC_BIOSLANGCB, CB_ADDSTRING, 0, (long)"French");
SendDlgItemMessage(hDlg, IDC_BIOSLANGCB, CB_ADDSTRING, 0, (long)"Spanish");
SendDlgItemMessage(hDlg, IDC_BIOSLANGCB, CB_ADDSTRING, 0, (long)"Italian");
SendDlgItemMessage(hDlg, IDC_BIOSLANGCB, CB_ADDSTRING, 0, (long)"Japanese");
// Set Selected Bios Language
SendDlgItemMessage(hDlg, IDC_BIOSLANGCB, CB_SETCURSEL, bioslang, 0);
// Since it's not fully working, let's disable it
EnableWindow(GetDlgItem(hDlg, IDC_BIOSLANGCB), FALSE);
*/
// Setup SH2 Core Combo box
SendDlgItemMessage(hDlg, IDC_SH2CORECB, CB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hDlg, IDC_SH2CORECB, CB_ADDSTRING, 0, (LPARAM)_16("Fast Interpreter"));
SendDlgItemMessage(hDlg, IDC_SH2CORECB, CB_ADDSTRING, 0, (LPARAM)_16("Debug Interpreter"));
// Set Selected SH2 Core
SendDlgItemMessage(hDlg, IDC_SH2CORECB, CB_SETCURSEL, sh2coretype, 0);
// Setup Region Combo box
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_ADDSTRING, 0, (LPARAM)_16("Auto-detect"));
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_ADDSTRING, 0, (LPARAM)_16("Japan(NTSC)"));
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_ADDSTRING, 0, (LPARAM)_16("Asia(NTSC)"));
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_ADDSTRING, 0, (LPARAM)_16("North America(NTSC)"));
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_ADDSTRING, 0, (LPARAM)_16("Central/South America(NTSC)"));
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_ADDSTRING, 0, (LPARAM)_16("Korea(NTSC)"));
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_ADDSTRING, 0, (LPARAM)_16("Asia(PAL)"));
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_ADDSTRING, 0, (LPARAM)_16("Europe + others(PAL)"));
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_ADDSTRING, 0, (LPARAM)_16("Central/South America(PAL)"));
// Set Selected Region
switch(regionid)
{
case 0:
case 1:
case 2:
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_SETCURSEL, regionid, 0);
break;
case 4:
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_SETCURSEL, 3, 0);
break;
case 5:
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_SETCURSEL, 4, 0);
break;
case 6:
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_SETCURSEL, 5, 0);
break;
case 0xA:
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_SETCURSEL, 6, 0);
break;
case 0xC:
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_SETCURSEL, 7, 0);
break;
case 0xD:
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_SETCURSEL, 8, 0);
break;
default:
SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_SETCURSEL, 0, 0);
break;
}
// Set Default Bios ROM File
SetDlgItemText(hDlg, IDC_BIOSEDIT, _16(biosfilename));
// Set Default Backup RAM File
SetDlgItemText(hDlg, IDC_BACKUPRAMEDIT, _16(backupramfilename));
// Set Default MPEG ROM File
SetDlgItemText(hDlg, IDC_MPEGROMEDIT, _16(mpegromfilename));
// Setup Cart Type Combo box
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("None"));
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("Pro Action Replay"));
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("4 Mbit Backup Ram"));
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("8 Mbit Backup Ram"));
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("16 Mbit Backup Ram"));
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("32 Mbit Backup Ram"));
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("8 Mbit Dram"));
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("32 Mbit Dram"));
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("Netlink"));
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)_16("16 Mbit Rom"));
// SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_ADDSTRING, 0, (LPARAM)"Japanese Modem");
// Set Selected Cart Type
SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_SETCURSEL, carttype, 0);
// Set Default Cart File
SetDlgItemText(hDlg, IDC_CARTEDIT, _16(cartfilename));
// Set Cart File window status
switch (carttype)
{
case CART_NONE:
case CART_DRAM8MBIT:
case CART_DRAM32MBIT:
case CART_NETLINK:
case CART_JAPMODEM:
EnableWindow(GetDlgItem(hDlg, IDC_CARTEDIT), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CARTBROWSE), FALSE);
break;
case CART_PAR:
case CART_BACKUPRAM4MBIT:
case CART_BACKUPRAM8MBIT:
case CART_BACKUPRAM16MBIT:
case CART_BACKUPRAM32MBIT:
case CART_ROM16MBIT:
EnableWindow(GetDlgItem(hDlg, IDC_CARTEDIT), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_CARTBROWSE), TRUE);
break;
default: break;
}
// Setup Tooltips
hb[0].string = "Select whether to use a cdrom or a disc image";
hb[0].hParent = GetDlgItem(hDlg, IDC_DISCTYPECB);
hb[1].string = "Use this to select the SH2 emulation method. If in doubt, leave it as 'Fast Interpreter'";
hb[1].hParent = GetDlgItem(hDlg, IDC_SH2CORECB);
hb[2].string = "Use this to select the region of the CD. Normally it's best to leave it as 'Auto-detect'";
hb[2].hParent = GetDlgItem(hDlg, IDC_REGIONCB);
hb[3].string = "This is where you put the path to a Saturn bios rom image. If you don't have one, just leave it blank";
hb[3].hParent = GetDlgItem(hDlg, IDC_BIOSEDIT);
hb[4].string = "This is where you put the path to internal backup ram file. This holds all your saves.";
hb[4].hParent = GetDlgItem(hDlg, IDC_BACKUPRAMEDIT);
hb[5].string = "If you don't know what this is, just leave it blank.";
hb[5].hParent = GetDlgItem(hDlg, IDC_MPEGROMEDIT);
hb[6].string = "Use this to select what kind of cartridge to emulate. If in doubt, leave it as 'None'";
hb[6].hParent = GetDlgItem(hDlg, IDC_CARTTYPECB);
hb[7].string = "This is where you put the path to the file used by the emulated cartridge. The kind of file that goes here depends on what Cartridge Type is set to";
hb[7].hParent = GetDlgItem(hDlg, IDC_CARTEDIT);
hb[8].string = NULL;
CreateHelpBalloons(hb);
return TRUE;
}
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_DISCTYPECB:
{
switch(HIWORD(wParam))
{
case CBN_SELCHANGE:
{
u8 cursel=0;
cursel = (u8)SendDlgItemMessage(hDlg, IDC_DISCTYPECB, CB_GETCURSEL, 0, 0);
if (cursel == 0)
{
EnableWindow(GetDlgItem(hDlg, IDC_IMAGEEDIT), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_IMAGEBROWSE), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_DRIVELETTERCB), TRUE);
}
else
{
EnableWindow(GetDlgItem(hDlg, IDC_IMAGEEDIT), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_IMAGEBROWSE), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_DRIVELETTERCB), FALSE);
}
return TRUE;
}
default: break;
}
return TRUE;
}
case IDC_CARTTYPECB:
{
switch(HIWORD(wParam))
{
case CBN_SELCHANGE:
{
u8 cursel=0;
cursel = (u8)SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_GETCURSEL, 0, 0);
switch (cursel)
{
case CART_NONE:
case CART_DRAM8MBIT:
case CART_DRAM32MBIT:
case CART_NETLINK:
EnableWindow(GetDlgItem(hDlg, IDC_CARTEDIT), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CARTBROWSE), FALSE);
break;
case CART_PAR:
case CART_BACKUPRAM4MBIT:
case CART_BACKUPRAM8MBIT:
case CART_BACKUPRAM16MBIT:
case CART_BACKUPRAM32MBIT:
case CART_ROM16MBIT:
EnableWindow(GetDlgItem(hDlg, IDC_CARTEDIT), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_CARTBROWSE), TRUE);
break;
default: break;
}
return TRUE;
}
default: break;
}
return TRUE;
}
case IDC_IMAGEBROWSE:
{
WCHAR tempwstr[MAX_PATH];
WCHAR filter[1024];
OPENFILENAME ofn;
// setup ofn structure
ZeroMemory(&ofn, sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hDlg;
CreateFilter(filter, 1024,
"Supported image files (*.cue, *.iso)", "*.cue;*.iso",
"Cue files (*.cue)", "*.cue",
"Iso files (*.iso)", "*.iso",
"All files (*.*)", "*.*", NULL);
ofn.lpstrFilter = filter;
GetDlgItemText(hDlg, IDC_IMAGEEDIT, tempwstr, MAX_PATH);
ofn.lpstrFile = tempwstr;
ofn.nMaxFile = sizeof(tempwstr);
ofn.Flags = OFN_FILEMUSTEXIST;
if (GetOpenFileName(&ofn))
{
// adjust appropriate edit box
SetDlgItemText(hDlg, IDC_IMAGEEDIT, tempwstr);
}
return TRUE;
}
case IDC_BIOSBROWSE:
{
WCHAR tempwstr[MAX_PATH];
WCHAR filter[1024];
OPENFILENAME ofn;
// setup ofn structure
ZeroMemory(&ofn, sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hDlg;
CreateFilter(filter, 1024,
"Binaries (*.bin)", "*.bin",
"All Files", "*.*", NULL);
ofn.lpstrFilter = filter;
GetDlgItemText(hDlg, IDC_BIOSEDIT, tempwstr, MAX_PATH);
ofn.lpstrFile = tempwstr;
ofn.nMaxFile = sizeof(tempwstr);
ofn.Flags = OFN_FILEMUSTEXIST;
if (GetOpenFileName(&ofn))
{
// adjust appropriate edit box
SetDlgItemText(hDlg, IDC_BIOSEDIT, tempwstr);
WideCharToMultiByte(CP_ACP, 0, tempwstr, -1, biosfilename, MAX_PATH, NULL, NULL);
}
return TRUE;
}
case IDC_BACKUPRAMBROWSE:
{
WCHAR tempwstr[MAX_PATH];
WCHAR filter[1024];
OPENFILENAME ofn;
// setup ofn structure
ZeroMemory(&ofn, sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hDlg;
CreateFilter(filter, 1024,
"Binaries (*.bin)", "*.bin",
"All Files", "*.*", NULL);
ofn.lpstrFilter = filter;
GetDlgItemText(hDlg, IDC_BACKUPRAMEDIT, tempwstr, MAX_PATH);
ofn.lpstrFile = tempwstr;
ofn.nMaxFile = sizeof(tempwstr);
if (GetOpenFileName(&ofn))
{
// adjust appropriate edit box
SetDlgItemText(hDlg, IDC_BACKUPRAMEDIT, tempwstr);
WideCharToMultiByte(CP_ACP, 0, tempwstr, -1, backupramfilename, MAX_PATH, NULL, NULL);
}
return TRUE;
}
case IDC_MPEGROMBROWSE:
{
WCHAR tempwstr[MAX_PATH];
WCHAR filter[1024];
OPENFILENAME ofn;
// setup ofn structure
ZeroMemory(&ofn, sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hDlg;
CreateFilter(filter, 1024,
"Binaries (*.bin)", "*.bin",
"All Files", "*.*", NULL);
ofn.lpstrFilter = filter;
GetDlgItemText(hDlg, IDC_MPEGROMEDIT, tempwstr, MAX_PATH);
ofn.lpstrFile = tempwstr;
ofn.nMaxFile = sizeof(tempwstr);
ofn.Flags = OFN_FILEMUSTEXIST;
if (GetOpenFileName(&ofn))
{
// adjust appropriate edit box
SetDlgItemText(hDlg, IDC_MPEGROMEDIT, tempwstr);
WideCharToMultiByte(CP_ACP, 0, tempwstr, -1, mpegromfilename, MAX_PATH, NULL, NULL);
}
return TRUE;
}
case IDC_CARTBROWSE:
{
WCHAR tempwstr[MAX_PATH];
WCHAR filter[1024];
OPENFILENAME ofn;
u8 cursel=0;
// setup ofn structure
ZeroMemory(&ofn, sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hDlg;
CreateFilter(filter, 1024,
"Binaries (*.bin)", "*.bin",
"All Files", "*.*", NULL);
ofn.lpstrFilter = filter;
GetDlgItemText(hDlg, IDC_CARTEDIT, tempwstr, MAX_PATH);
ofn.lpstrFile = tempwstr;
ofn.nMaxFile = sizeof(tempwstr);
cursel = (u8)SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_GETCURSEL, 0, 0);
switch (cursel)
{
case CART_PAR:
case CART_ROM16MBIT:
ofn.Flags = OFN_FILEMUSTEXIST;
break;
default: break;
}
if (GetOpenFileName(&ofn))
{
// adjust appropriate edit box
SetDlgItemText(hDlg, IDC_CARTEDIT, tempwstr);
WideCharToMultiByte(CP_ACP, 0, tempwstr, -1, cartfilename, MAX_PATH, NULL, NULL);
}
return TRUE;
}
default: break;
}
break;
}
case WM_NOTIFY:
switch (((NMHDR *) lParam)->code)
{
case PSN_SETACTIVE:
break;
case PSN_APPLY:
{
WCHAR tempwstr[MAX_PATH];
char tempstr[MAX_PATH];
char current_drive=0;
BOOL imagebool;
BOOL cdromchanged=FALSE;
// Convert Dialog items back to variables
GetDlgItemText(hDlg, IDC_BIOSEDIT, tempwstr, MAX_PATH);
WideCharToMultiByte(CP_ACP, 0, tempwstr, -1, biosfilename, MAX_PATH, NULL, NULL);
GetDlgItemText(hDlg, IDC_BACKUPRAMEDIT, tempwstr, MAX_PATH);
WideCharToMultiByte(CP_ACP, 0, tempwstr, -1, backupramfilename, MAX_PATH, NULL, NULL);
GetDlgItemText(hDlg, IDC_MPEGROMEDIT, tempwstr, MAX_PATH);
WideCharToMultiByte(CP_ACP, 0, tempwstr, -1, mpegromfilename, MAX_PATH, NULL, NULL);
carttype = (int)SendDlgItemMessage(hDlg, IDC_CARTTYPECB, CB_GETCURSEL, 0, 0);
GetDlgItemText(hDlg, IDC_CARTEDIT, tempwstr, MAX_PATH);
WideCharToMultiByte(CP_ACP, 0, tempwstr, -1, cartfilename, MAX_PATH, NULL, NULL);
// write path/filenames
WritePrivateProfileStringA("General", "BiosPath", biosfilename, inifilename);
WritePrivateProfileStringA("General", "BackupRamPath", backupramfilename, inifilename);
WritePrivateProfileStringA("General", "MpegRomPath", mpegromfilename, inifilename);
sprintf(tempstr, "%d", carttype);
WritePrivateProfileStringA("General", "CartType", tempstr, inifilename);
// figure out cart type, write cartfilename if necessary
switch (carttype)
{
case CART_PAR:
case CART_BACKUPRAM4MBIT:
case CART_BACKUPRAM8MBIT:
case CART_BACKUPRAM16MBIT:
case CART_BACKUPRAM32MBIT:
case CART_ROM16MBIT:
WritePrivateProfileStringA("General", "CartPath", cartfilename, inifilename);
break;
default: break;
}
imagebool = (BOOL)SendDlgItemMessage(hDlg, IDC_DISCTYPECB, CB_GETCURSEL, 0, 0);
if (imagebool == FALSE)
{
// convert drive letter to string
current_drive = (char)SendDlgItemMessage(hDlg, IDC_DRIVELETTERCB, CB_GETCURSEL, 0, 0);
sprintf(tempstr, "%c:", toupper(drive_list[(int)current_drive]));
if (strcmp(tempstr, cdrompath) != 0)
{
strcpy(cdrompath, tempstr);
cdromchanged = TRUE;
}
}
else
{
// retrieve image filename string instead
GetDlgItemText(hDlg, IDC_IMAGEEDIT, tempwstr, MAX_PATH);
WideCharToMultiByte(CP_ACP, 0, tempwstr, -1, tempstr, MAX_PATH, NULL, NULL);
if (strcmp(tempstr, cdrompath) != 0)
{
strcpy(cdrompath, tempstr);
cdromchanged = TRUE;
}
}
WritePrivateProfileStringA("General", "CDROMDrive", cdrompath, inifilename);
/*
// Convert ID to language string
bioslang = (char)SendDlgItemMessage(hDlg, IDC_BIOSLANGCB, CB_GETCURSEL, 0, 0);
switch (bioslang)
{
case 0:
sprintf(tempstr, "English");
break;
case 1:
sprintf(tempstr, "German");
break;
case 2:
sprintf(tempstr, "French");
break;
case 3:
sprintf(tempstr, "Spanish");
break;
case 4:
sprintf(tempstr, "Italian");
break;
case 5:
sprintf(tempstr, "Japanese");
break;
default:break;
}
// WritePrivateProfileStringA("General", "BiosLanguage", tempstr, inifilename);
*/
// Write SH2 core type
sh2coretype = (char)SendDlgItemMessage(hDlg, IDC_SH2CORECB, CB_GETCURSEL, 0, 0);
sprintf(tempstr, "%d", sh2coretype);
WritePrivateProfileStringA("General", "SH2Core", tempstr, inifilename);
// Convert Combo Box ID to Region ID
regionid = (char)SendDlgItemMessage(hDlg, IDC_REGIONCB, CB_GETCURSEL, 0, 0);
switch(regionid)
{
case 0:
WritePrivateProfileStringA("General", "Region", "Auto", inifilename);
break;
case 1:
WritePrivateProfileStringA("General", "Region", "J", inifilename);
break;
case 2:
WritePrivateProfileStringA("General", "Region", "T", inifilename);
break;
case 3:
WritePrivateProfileStringA("General", "Region", "U", inifilename);
regionid = 4;
break;
case 4:
WritePrivateProfileStringA("General", "Region", "B", inifilename);
regionid = 5;
break;
case 5:
WritePrivateProfileStringA("General", "Region", "K", inifilename);
regionid = 6;
break;
case 6:
WritePrivateProfileStringA("General", "Region", "A", inifilename);
regionid = 0xA;
break;
case 7:
WritePrivateProfileStringA("General", "Region", "E", inifilename);
regionid = 0xC;
break;
case 8:
WritePrivateProfileStringA("General", "Region", "L", inifilename);
regionid = 0xD;
break;
default:
regionid = 0;
break;
}
if (cdromchanged && nocorechange == 0)
{
StartGame();
#ifndef USETHREADS
if (IsPathCdrom(cdrompath))
Cs2ChangeCDCore(CDCORE_SPTI, cdrompath);
else
Cs2ChangeCDCore(CDCORE_ISO, cdrompath);
#else
corechanged = 0;
changecore |= 1;
while (corechanged == 0) { Sleep(0); }
#endif
YabauseReset();
}
SetWindowLong(hDlg, DWL_MSGRESULT, PSNRET_NOERROR);
break;
}
case PSN_KILLACTIVE:
SetWindowLong(hDlg, DWL_MSGRESULT, FALSE);
return 1;
break;
case PSN_RESET:
break;
}
break;
case WM_DESTROY:
{
DestroyHelpBalloons(hb);
break;
}
default: break;
}
return FALSE;
}
INT_PTR CALLBACK
khm_cfg_plugins_proc(HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam) {
plugin_dlg_data * d;
switch(uMsg) {
case WM_INITDIALOG:
{
kmm_plugin p;
kmm_plugin pn;
kmm_module m;
khm_size i;
LVCOLUMN lvc;
RECT r;
HWND hw;
wchar_t buf[256];
HIMAGELIST h_ilist;
HICON h_icon;
d = PMALLOC(sizeof(*d));
#ifdef DEBUG
assert(d);
#endif
ZeroMemory(d, sizeof(*d));
#pragma warning(push)
#pragma warning(disable: 4244)
SetWindowLongPtr(hwnd, DWLP_USER, (LONG_PTR) d);
#pragma warning(pop)
p = NULL;
i = 0;
do {
if (KHM_FAILED(kmm_get_next_plugin(p, &pn)))
break;
if (p)
kmm_release_plugin(p);
p = pn;
#ifdef DEBUG
assert(d->info[i] == NULL);
#endif
d->info[i] = PMALLOC(sizeof(*(d->info[i])));
#ifdef DEBUG
assert(d->info[i]);
#endif
ZeroMemory(&d->info[i]->plugin,
sizeof(d->info[i]->plugin));
if (KHM_FAILED(kmm_get_plugin_info_i(p, &d->info[i]->plugin))) {
PFREE(d->info[i]);
d->info[i] = NULL;
break;
}
ZeroMemory(&d->info[i]->module,
sizeof(d->info[i]->module));
if (KHM_SUCCEEDED(kmm_load_module(d->info[i]->plugin.reg.module,
KMM_LM_FLAG_NOLOAD,
&m))) {
kmm_get_module_info_i(m, &d->info[i]->module);
kmm_release_module(m);
}
i ++;
if (i == MAX_PLUGINS)
break;
} while(p);
if (p)
kmm_release_plugin(p);
d->n_info = i;
/* now populate the list view */
hw = GetDlgItem(hwnd, IDC_CFG_PLUGINS);
#ifdef DEBUG
assert(hw);
#endif
h_ilist = ImageList_Create(GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
ILC_COLOR8,
4, 4);
h_icon = LoadImage(khm_hInstance,
MAKEINTRESOURCE(IDI_CFG_PLUGIN),
IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
LR_DEFAULTCOLOR);
#ifdef DEBUG
assert(h_icon);
#endif
ImageList_AddIcon(h_ilist, h_icon);
DestroyIcon(h_icon);
h_icon = LoadImage(khm_hInstance,
MAKEINTRESOURCE(IDI_CFG_PLUGIN_DIS),
IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
LR_DEFAULTCOLOR);
#ifdef DEBUG
assert(h_icon);
#endif
ImageList_AddIcon(h_ilist, h_icon);
DestroyIcon(h_icon);
h_icon = LoadImage(khm_hInstance,
MAKEINTRESOURCE(IDI_CFG_PLUGIN_ERR),
IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
LR_DEFAULTCOLOR);
#ifdef DEBUG
assert(h_icon);
#endif
ImageList_AddIcon(h_ilist, h_icon);
DestroyIcon(h_icon);
ListView_SetImageList(hw, h_ilist, LVSIL_STATE);
ZeroMemory(&lvc, sizeof(lvc));
lvc.mask = LVCF_TEXT | LVCF_WIDTH;
GetWindowRect(hw, &r);
lvc.cx = ((r.right - r.left) * 95) / 100;
lvc.pszText = buf;
LoadString(khm_hInstance, IDS_CFG_PI_COL_PLUGINS,
buf, ARRAYLENGTH(buf));
ListView_InsertColumn(hw, 0, &lvc);
for(i=0; i<d->n_info; i++) {
LVITEM lvi;
ZeroMemory(&lvi, sizeof(lvi));
lvi.mask = LVIF_PARAM | LVIF_TEXT | LVIF_STATE;
lvi.lParam = (LPARAM) d->info[i];
lvi.pszText = d->info[i]->plugin.reg.name;
if (d->info[i]->plugin.flags & KMM_PLUGIN_FLAG_DISABLED) {
lvi.state = INDEXTOSTATEIMAGEMASK(IDX_PLUGIN_DISABLED);
} else if (d->info[i]->plugin.state < 0) {
lvi.state = INDEXTOSTATEIMAGEMASK(IDX_PLUGIN_ERROR);
} else {
lvi.state = INDEXTOSTATEIMAGEMASK(IDX_PLUGIN_NORMAL);
}
ListView_InsertItem(hw, &lvi);
}
d->plugin_ico =
(HICON) LoadImage(khm_hInstance,
MAKEINTRESOURCE(IDI_CFG_PLUGIN),
IMAGE_ICON,
GetSystemMetrics(SM_CXICON),
GetSystemMetrics(SM_CYICON),
LR_DEFAULTCOLOR);
}
return FALSE;
case WM_NOTIFY:
{
LPNMHDR lpnm;
HWND hw;
d = (plugin_dlg_data *) (LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
if (d == NULL)
return FALSE;
if (wParam == IDC_CFG_PLUGINS &&
(lpnm = (LPNMHDR) lParam) &&
lpnm->code == LVN_ITEMCHANGED) {
LVITEM lvi;
hw = GetDlgItem(hwnd, IDC_CFG_PLUGINS);
#ifdef DEBUG
assert(hw);
#endif
if (ListView_GetSelectedCount(hw) != 1) {
SetDlgItemText(hwnd, IDC_CFG_DESC, L"");
SetDlgItemText(hwnd, IDC_CFG_STATE, L"");
SetDlgItemText(hwnd, IDC_CFG_MODULE, L"");
SetDlgItemText(hwnd, IDC_CFG_VENDOR, L"");
SetDlgItemText(hwnd, IDC_CFG_VERSION, L"");
EnableWindow(GetDlgItem(hwnd, IDC_CFG_ENABLE), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_CFG_DISABLE), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_CFG_UNREGISTER), FALSE);
SendDlgItemMessage(hwnd, IDC_CFG_DEPS,
LB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hwnd, IDC_CFG_ICON, STM_SETICON,
(WPARAM) d->plugin_ico, 0);
d->selected = NULL;
} else {
int idx;
plugin_data * info;
idx = ListView_GetNextItem(hw, -1, LVNI_SELECTED);
#ifdef DEBUG
assert(idx != -1);
#endif
ZeroMemory(&lvi, sizeof(lvi));
lvi.iItem = idx;
lvi.iSubItem = 0;
lvi.mask = LVIF_PARAM;
ListView_GetItem(hw, &lvi);
#ifdef DEBUG
assert(lvi.lParam != 0);
#endif
info = (plugin_data *) lvi.lParam;
update_dialog_fields(hwnd, d, info);
}
}
}
return TRUE;
case WM_COMMAND:
{
d = (plugin_dlg_data *) (LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
if (d == NULL)
return FALSE;
switch (wParam) {
case MAKEWPARAM(IDC_CFG_ENABLE, BN_CLICKED):
if (d->selected != NULL) {
khui_alert * alert = NULL;
wchar_t buf[KHUI_MAXCCH_MESSAGE];
wchar_t fmt[KHUI_MAXCCH_MESSAGE];
kmm_plugin p;
khui_alert_create_empty(&alert);
LoadString(khm_hInstance, IDS_CFG_P_ENBCNFT,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, d->selected->plugin.reg.name);
khui_alert_set_title(alert, buf);
LoadString(khm_hInstance, IDS_CFG_P_ENBCNFM,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, d->selected->plugin.reg.name);
khui_alert_set_message(alert, buf);
khui_alert_set_severity(alert, KHERR_INFO);
khui_alert_show_modal(alert);
kmm_enable_plugin(d->selected->plugin.h_plugin, TRUE);
khui_alert_release(alert);
p = d->selected->plugin.h_plugin;
kmm_hold_plugin(p);
kmm_release_plugin_info_i(&d->selected->plugin);
kmm_get_plugin_info_i(p, &d->selected->plugin);
kmm_release_plugin(p);
update_dialog_fields(hwnd, d, d->selected);
}
break;
case MAKEWPARAM(IDC_CFG_DISABLE, BN_CLICKED):
if (d->selected != NULL) {
khui_alert * alert = NULL;
wchar_t buf[KHUI_MAXCCH_MESSAGE];
wchar_t fmt[KHUI_MAXCCH_MESSAGE];
wchar_t depends[KHUI_MAXCCH_MESSAGE];
khm_size i;
kmm_plugin p;
khui_alert_create_empty(&alert);
#ifdef DEBUG
assert(alert);
#endif
if (alert == NULL)
break;
LoadString(khm_hInstance, IDS_CFG_P_DELCNFT,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, d->selected->plugin.reg.name);
khui_alert_set_title(alert, buf);
LoadString(khm_hInstance, IDS_CFG_P_DELCNFM,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, d->selected->plugin.reg.name);
khui_alert_set_message(alert, buf);
depends[0] = L'\0';
for (i=0; i<d->n_info; i++) {
wchar_t * t;
t = d->info[i]->plugin.reg.dependencies;
while(t) {
if (!wcscmp(t, d->selected->plugin.reg.name)) {
if (depends[0])
StringCbCat(depends, sizeof(depends), L", ");
StringCbCat(depends, sizeof(depends),
d->info[i]->plugin.reg.name);
break;
}
t = multi_string_next(t);
}
}
if (depends[0]) {
LoadString(khm_hInstance, IDS_CFG_P_DELCNFS,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, depends);
khui_alert_set_suggestion(alert, buf);
} else {
LoadString(khm_hInstance, IDS_CFG_P_DELNDEP,
buf, ARRAYLENGTH(buf));
khui_alert_set_suggestion(alert, buf);
}
khui_alert_add_command(alert, KHUI_PACTION_YES);
khui_alert_add_command(alert, KHUI_PACTION_NO);
khui_alert_set_severity(alert, KHERR_WARNING);
if (KHM_SUCCEEDED(khui_alert_show_modal(alert)) &&
alert->response == KHUI_PACTION_YES) {
kmm_enable_plugin(d->selected->plugin.h_plugin, FALSE);
}
khui_alert_release(alert);
p = d->selected->plugin.h_plugin;
kmm_hold_plugin(p);
kmm_release_plugin_info_i(&d->selected->plugin);
kmm_get_plugin_info_i(p, &d->selected->plugin);
kmm_release_plugin(p);
update_dialog_fields(hwnd, d, d->selected);
}
break;
case MAKEWPARAM(IDC_CFG_UNREGISTER, BN_CLICKED):
{
khui_alert * alert = NULL;
wchar_t buf[KHUI_MAXCCH_MESSAGE];
wchar_t fmt[KHUI_MAXCCH_MESSAGE];
wchar_t plist[KHUI_MAXCCH_MESSAGE];
khm_size i;
if (d->selected == NULL) {
#ifdef DEBUG
assert(FALSE);
#endif
break;
}
khui_alert_create_empty(&alert);
LoadString(khm_hInstance, IDS_CFG_P_UNRCNFT,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt,
d->selected->plugin.reg.name);
khui_alert_set_title(alert, buf);
LoadString(khm_hInstance, IDS_CFG_P_UNRCNFM,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt,
d->selected->plugin.reg.name);
khui_alert_set_message(alert, buf);
plist[0] = L'\0';
for (i=0; i < d->n_info; i++) {
if (!wcscmp(d->info[i]->module.reg.name,
d->selected->module.reg.name)) {
if (plist[0])
StringCbCat(plist, sizeof(plist), L", ");
StringCbCat(plist, sizeof(plist),
d->info[i]->plugin.reg.name);
}
}
#ifdef DEBUG
/* there should have been at least one plugin */
assert(plist[0]);
#endif
LoadString(khm_hInstance, IDS_CFG_P_UNRCNFS,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, plist);
khui_alert_set_suggestion(alert, buf);
khui_alert_add_command(alert, KHUI_PACTION_YES);
khui_alert_add_command(alert, KHUI_PACTION_NO);
khui_alert_set_severity(alert, KHERR_WARNING);
if (KHM_SUCCEEDED(khui_alert_show_modal(alert)) &&
alert->response == KHUI_PACTION_YES) {
kmm_unregister_module(d->selected->module.reg.name, 0);
update_dialog_fields(hwnd, d, d->selected);
}
}
break;
case MAKEWPARAM(IDC_CFG_REGISTER, BN_CLICKED):
{
}
break;
}
}
return TRUE;
case WM_DESTROY:
{
khm_size i;
d = (plugin_dlg_data *) (LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
#ifdef DEBUG
assert(d);
#endif
if (d == NULL)
return TRUE;
for (i=0; i<d->n_info; i++) {
#ifdef DEBUG
assert(d->info[i]);
#endif
kmm_release_plugin_info_i(&d->info[i]->plugin);
kmm_release_module_info_i(&d->info[i]->module);
PFREE(d->info[i]);
}
PFREE(d);
SetWindowLongPtr(hwnd, DWLP_USER, 0);
khm_set_dialog_result(hwnd, 0);
}
return TRUE;
}
return FALSE;
}
void ShowContactsDialog(BOOL *negated, BOOL *set1, char *name)
{
BOOL set1Save = *set1;
char nameSave[MAX_NAME_LEN];
strcpy(nameSave, name);
ContactsDialog = CreateWindowClient(0, "LDmicroDialog",
_("Contacts"), WS_OVERLAPPED | WS_SYSMENU,
100, 100, 404, 135, NULL, NULL, Instance, NULL);
MakeControls();
switch (name[0]) {
case 'R':
SendMessage(SourceInternalRelayRadio, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'Y':
SendMessage(SourceOutputPinRadio, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'X':
SendMessage(SourceInputPinRadio, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'I':
SendMessage(SourceModbusContactRadio, BM_SETCHECK, BST_CHECKED, 0);
break;
case 'M':
SendMessage(SourceModbusCoilRadio, BM_SETCHECK, BST_CHECKED, 0);
break;
default:
oops();
break;
}
if(*negated) {
SendMessage(NegatedCheckbox, BM_SETCHECK, BST_CHECKED, 0);
}
if(*set1) {
SendMessage(Set1Checkbox, BM_SETCHECK, BST_CHECKED, 0);
}
EnableWindow(Set1Checkbox, SendMessage(SourceInputPinRadio, BM_GETSTATE, 0, 0) & BST_CHECKED);
SendMessage(NameTextbox, WM_SETTEXT, 0, (LPARAM)(name + 1));
EnableWindow(MainWindow, FALSE);
ShowWindow(ContactsDialog, TRUE);
SetFocus(NameTextbox);
SendMessage(NameTextbox, EM_SETSEL, 0, -1);
MSG msg;
DWORD ret;
DialogDone = FALSE;
DialogCancel = FALSE;
while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
if(msg.message == WM_KEYDOWN) {
if(msg.wParam == VK_RETURN) {
DialogDone = TRUE;
break;
} else if(msg.wParam == VK_ESCAPE) {
DialogDone = TRUE;
DialogCancel = TRUE;
break;
}
}
EnableWindow(Set1Checkbox, SendMessage(SourceInputPinRadio, BM_GETSTATE, 0, 0) & BST_CHECKED);
if(IsDialogMessage(ContactsDialog, &msg)) continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if(!DialogCancel) {
if(SendMessage(NegatedCheckbox, BM_GETSTATE, 0, 0) & BST_CHECKED) {
*negated = TRUE;
} else {
*negated = FALSE;
}
if(SendMessage(SourceInternalRelayRadio, BM_GETSTATE, 0, 0)
& BST_CHECKED)
{
name[0] = 'R';
} else if(SendMessage(SourceInputPinRadio, BM_GETSTATE, 0, 0)
& BST_CHECKED)
{
name[0] = 'X';
} else if (SendMessage(SourceModbusContactRadio, BM_GETSTATE, 0, 0)
& BST_CHECKED)
{
name[0] = 'I';
} else if (SendMessage(SourceModbusCoilRadio, BM_GETSTATE, 0, 0)
& BST_CHECKED)
{
name[0] = 'M';
} else {
name[0] = 'Y';
}
SendMessage(NameTextbox, WM_GETTEXT, (WPARAM)(MAX_NAME_LEN-1), (LPARAM)(name+1));
if(SendMessage(Set1Checkbox, BM_GETSTATE, 0, 0) & BST_CHECKED) {
*set1 = TRUE;
} else {
*set1 = FALSE;
}
if((*set1 != set1Save) || strcmp(name, nameSave)) {
int n = CountWhich(ELEM_CONTACTS, ELEM_COIL, nameSave);
if(n >= 1) {
BOOL rename = FALSE;
if(strcmp(name, nameSave)) {
char str[1000];
sprintf(str, _("Rename the ALL other %d contacts/coils named '%s' to '%s' ?"), n, nameSave, name);
rename = IDYES == MessageBox(MainWindow,
str, "LDmicro",
MB_YESNO | MB_ICONQUESTION);
}
if(rename)
if(name[0] == 'X')
RenameSet1(ELEM_CONTACTS, nameSave, name, *set1); // rename and set as set1
else
RenameSet1(ELEM_CONTACTS, nameSave, name, FALSE); // rename and reset
else
if(name[0] == 'X')
RenameSet1(ELEM_CONTACTS, name, NULL, *set1); // set as set1
else
RenameSet1(ELEM_CONTACTS, name, NULL, FALSE); // reset
}
}
}
EnableWindow(MainWindow, TRUE);
DestroyWindow(ContactsDialog);
return;
}
/* Property page dialog callback */
INT_PTR CALLBACK
GeneralPageProc(HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
PGLOBAL_DATA pGlobalData;
LPPSHNOTIFY lppsn;
pGlobalData = (PGLOBAL_DATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
switch (uMsg)
{
case WM_INITDIALOG:
pGlobalData = (PGLOBAL_DATA)((LPPROPSHEETPAGE)lParam)->lParam;
if (pGlobalData == NULL)
return FALSE;
SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pGlobalData);
/* Set access timeout info */
CheckDlgButton(hwndDlg,
IDC_RESET_BOX,
pGlobalData->accessTimeout.dwFlags & ATF_TIMEOUTON ? BST_CHECKED : BST_UNCHECKED);
FillResetComboBox(GetDlgItem(hwndDlg, IDC_RESET_COMBO));
SendDlgItemMessage(hwndDlg, IDC_RESET_COMBO, CB_SETCURSEL,
(pGlobalData->accessTimeout.iTimeOutMSec / 300000) - 1, 0);
EnableWindow(GetDlgItem(hwndDlg, IDC_RESET_COMBO),
pGlobalData->accessTimeout.dwFlags & ATF_TIMEOUTON ? TRUE : FALSE);
CheckDlgButton(hwndDlg,
IDC_NOTIFICATION_MESSAGE,
pGlobalData->bWarningSounds ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg,
IDC_NOTIFICATION_SOUND,
pGlobalData->bSoundOnActivation ? BST_CHECKED : BST_UNCHECKED);
/* Set serial keys info */
CheckDlgButton(hwndDlg,
IDC_SERIAL_BOX,
pGlobalData->serialKeys.dwFlags & SERKF_SERIALKEYSON ? BST_CHECKED : BST_UNCHECKED);
EnableWindow(GetDlgItem(hwndDlg, IDC_SERIAL_BOX),
pGlobalData->serialKeys.dwFlags & SERKF_AVAILABLE ? TRUE : FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_SERIAL_BUTTON),
pGlobalData->serialKeys.dwFlags & SERKF_AVAILABLE ? TRUE : FALSE);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_RESET_BOX:
pGlobalData->accessTimeout.dwFlags ^= ATF_TIMEOUTON;
EnableWindow(GetDlgItem(hwndDlg, IDC_RESET_COMBO),
pGlobalData->accessTimeout.dwFlags & ATF_TIMEOUTON ? TRUE : FALSE);
PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
break;
case IDC_RESET_COMBO:
if (HIWORD(wParam) == CBN_CLOSEUP)
{
INT nSel;
nSel = SendDlgItemMessage(hwndDlg, IDC_RESET_COMBO, CB_GETCURSEL, 0, 0);
pGlobalData->accessTimeout.iTimeOutMSec = (ULONG)((nSel + 1) * 300000);
PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
}
break;
case IDC_NOTIFICATION_MESSAGE:
pGlobalData->bWarningSounds = !pGlobalData->bWarningSounds;
PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
break;
case IDC_NOTIFICATION_SOUND:
pGlobalData->bSoundOnActivation = !pGlobalData->bSoundOnActivation;
PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
break;
case IDC_SERIAL_BOX:
pGlobalData->serialKeys.dwFlags ^= SERKF_SERIALKEYSON;
PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
break;
case IDC_SERIAL_BUTTON:
if (DialogBoxParam(hApplet,
MAKEINTRESOURCE(IDD_SERIALKEYSOPTIONS),
hwndDlg,
(DLGPROC)SerialKeysDlgProc,
(LPARAM)pGlobalData))
PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
break;
case IDC_ADMIN_LOGON_BOX:
break;
case IDC_ADMIN_USERS_BOX:
break;
default:
break;
}
break;
case WM_NOTIFY:
lppsn = (LPPSHNOTIFY)lParam;
if (lppsn->hdr.code == PSN_APPLY)
{
WriteGlobalData(pGlobalData);
return TRUE;
}
break;
}
return FALSE;
}
LRESULT CALLBACK EdfReaderDlgHandler( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam )
{
EDF_READEROBJ * st;
int x;
static int actchn;
char strfloat[21];
st = (EDF_READEROBJ *) actobject;
if ((st==NULL)||(st->type!=OB_EDF_READER)) return(FALSE);
switch( message )
{
case WM_INITDIALOG:
actchn=0;
update_header(hDlg,&st->header);
update_channelcombo(hDlg, st->channel, st->header.channels);
update_channel(hDlg,st->channel,actchn);
update_state(hDlg,st->state);
sprintf(strfloat,"%.2f",(float)st->offset/(float)PACKETSPERSECOND);
SetDlgItemText(hDlg,IDC_OFFSET,strfloat);
if (st->edffile!=INVALID_HANDLE_VALUE)
SetDlgItemText(hDlg, IDC_EDFFILE, st->filename);
else
SetDlgItemText(hDlg, IDC_EDFFILE, "none");
return TRUE;
case WM_CLOSE:
EndDialog(hDlg, LOWORD(wParam));
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_SELECT:
st->filename[0]=0;
if ((st->edffile=open_edf_file(&st->header,st->channel,st->filename))==INVALID_HANDLE_VALUE) st->state=0;
else if (st->header.channels==0)
{
SendMessage(hDlg,WM_COMMAND,IDC_CLOSE,0);
report("EDF-File contained no channel inforamtion, file closed.");
st->state=0;
}
else st->state=1;
update_state(hDlg,st->state);
if (!st->state) break;
st->calc_session_length();
get_session_length();
//set_session_pos(0);
st->session_pos(0);
st->packetcount=0;
st->sampos=0;
if (st->outports!=st->header.channels)
{
for (x=0; x<MAX_CONNECTS; x++)
{
st->out[x].from_port=-1;
st->out[x].to_port=-1;
st->out[x].to_object=-1;
}
for (x=0; x<MAX_PORTS; x++)
st->out_ports[x].out_name[0]=0;
}
st->outports=st->header.channels;
st->height=CON_START+st->outports*CON_HEIGHT+5;
update_header(hDlg,&st->header);
update_channelcombo(hDlg, st->channel, st->header.channels);
update_channel(hDlg,st->channel,actchn);
st->get_captions();
update_dimensions();
SetDlgItemText(hDlg, IDC_EDFFILE, st->filename);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_SELECT), FALSE);
InvalidateRect(ghWndDesign,NULL,TRUE);
break;
case IDC_CLOSE:
st->state=0;
update_state(hDlg,st->state);
SetDlgItemText(hDlg, IDC_EDFFILE, "none");
add_to_listbox(hDlg,IDC_LIST, "file closed.");
strcpy(st->filename,"none");
if (st->edffile==INVALID_HANDLE_VALUE) break;
CloseHandle(st->edffile);
st->edffile=INVALID_HANDLE_VALUE;
get_session_length();
InvalidateRect(ghWndDesign,NULL,TRUE);
break;
case IDC_APPLYOFFSET:
GetDlgItemText(hDlg, IDC_OFFSET, strfloat, 20);
st->offset = (int)((float)atof(strfloat) * (float) PACKETSPERSECOND);
st->calc_session_length();
get_session_length();
break;
case IDC_CHANNELCOMBO:
if (HIWORD(wParam)==CBN_SELCHANGE)
{
get_channel(hDlg, st->channel, actchn);
actchn=SendMessage(GetDlgItem(hDlg, IDC_CHANNELCOMBO), CB_GETCURSEL , 0, 0);
update_channel(hDlg, st->channel,actchn);
}
break;
}
return TRUE;
case WM_SIZE:
case WM_MOVE:
update_toolbox_position(hDlg);
break;
return TRUE;
}
return FALSE;
}
/***********************************************************************
* COMDLG32_FR_HandleWMCommand [internal]
* Handle WM_COMMAND messages...
*/
static void COMDLG32_FR_HandleWMCommand(HWND hDlgWnd, COMDLG32_FR_Data *pData, int Id, int NotifyCode)
{
DWORD flag;
pData->user_fr.fra->Flags &= ~FR_MASK; /* Clear return flags */
if(pData->fr.Flags & FR_WINE_REPLACE) /* Replace always goes down... */
pData->user_fr.fra->Flags |= FR_DOWN;
if(NotifyCode == BN_CLICKED)
{
switch(Id)
{
case IDOK: /* Find Next */
if(GetDlgItemTextA(hDlgWnd, edt1, pData->fr.lpstrFindWhat, pData->fr.wFindWhatLen) > 0)
{
pData->user_fr.fra->Flags |= COMDLG32_FR_GetFlags(hDlgWnd) | FR_FINDNEXT;
if(pData->fr.Flags & FR_WINE_UNICODE)
{
MultiByteToWideChar( CP_ACP, 0, pData->fr.lpstrFindWhat, -1,
pData->user_fr.frw->lpstrFindWhat,
0x7fffffff );
}
else
{
strcpy(pData->user_fr.fra->lpstrFindWhat, pData->fr.lpstrFindWhat);
}
SendMessageA(pData->fr.hwndOwner, FindReplaceMessage, 0, (LPARAM)pData->user_fr.fra);
}
break;
case IDCANCEL:
pData->user_fr.fra->Flags |= COMDLG32_FR_GetFlags(hDlgWnd) | FR_DIALOGTERM;
SendMessageA(pData->fr.hwndOwner, FindReplaceMessage, 0, (LPARAM)pData->user_fr.fra);
DestroyWindow(hDlgWnd);
break;
case psh2: /* Replace All */
flag = FR_REPLACEALL;
goto Replace;
case psh1: /* Replace */
flag = FR_REPLACE;
Replace:
if((pData->fr.Flags & FR_WINE_REPLACE)
&& GetDlgItemTextA(hDlgWnd, edt1, pData->fr.lpstrFindWhat, pData->fr.wFindWhatLen) > 0)
{
pData->fr.lpstrReplaceWith[0] = 0; /* In case the next GetDlgItemText Fails */
GetDlgItemTextA(hDlgWnd, edt2, pData->fr.lpstrReplaceWith, pData->fr.wReplaceWithLen);
pData->user_fr.fra->Flags |= COMDLG32_FR_GetFlags(hDlgWnd) | flag;
if(pData->fr.Flags & FR_WINE_UNICODE)
{
MultiByteToWideChar( CP_ACP, 0, pData->fr.lpstrFindWhat, -1,
pData->user_fr.frw->lpstrFindWhat,
0x7fffffff );
MultiByteToWideChar( CP_ACP, 0, pData->fr.lpstrReplaceWith, -1,
pData->user_fr.frw->lpstrReplaceWith,
0x7fffffff );
}
else
{
strcpy(pData->user_fr.fra->lpstrFindWhat, pData->fr.lpstrFindWhat);
strcpy(pData->user_fr.fra->lpstrReplaceWith, pData->fr.lpstrReplaceWith);
}
SendMessageA(pData->fr.hwndOwner, FindReplaceMessage, 0, (LPARAM)pData->user_fr.fra);
}
break;
case pshHelp:
pData->user_fr.fra->Flags |= COMDLG32_FR_GetFlags(hDlgWnd);
SendMessageA(pData->fr.hwndOwner, HelpMessage, (WPARAM)hDlgWnd, (LPARAM)pData->user_fr.fra);
break;
}
}
else if(NotifyCode == EN_CHANGE && Id == edt1)
{
BOOL enable = SendDlgItemMessageA(hDlgWnd, edt1, WM_GETTEXTLENGTH, 0, 0) > 0;
EnableWindow(GetDlgItem(hDlgWnd, IDOK), enable);
if(pData->fr.Flags & FR_WINE_REPLACE)
{
EnableWindow(GetDlgItem(hDlgWnd, psh1), enable);
EnableWindow(GetDlgItem(hDlgWnd, psh2), enable);
}
}
}
void OBS::Stop()
{
if(!bRunning) return;
OSEnterMutex(hStartupShutdownMutex);
//we only want the capture thread to stop first, so we can ensure all packets are flushed
bShutdownMainThread = true;
if(hMainThread)
{
OSTerminateThread(hMainThread, 20000);
hMainThread = NULL;
}
bShutdownMainThread = false;
bRunning = false;
ReportStopStreamTrigger();
for(UINT i=0; i<globalSources.Num(); i++)
globalSources[i].source->EndScene();
if(scene)
scene->EndScene();
//-------------------------------------------------------------
if(hSoundThread)
{
//ReleaseSemaphore(hRequestAudioEvent, 1, NULL);
OSTerminateThread(hSoundThread, 20000);
}
//if(hRequestAudioEvent)
// CloseHandle(hRequestAudioEvent);
if(hSoundDataMutex)
OSCloseMutex(hSoundDataMutex);
hSoundThread = NULL;
//hRequestAudioEvent = NULL;
hSoundDataMutex = NULL;
//-------------------------------------------------------------
StopBlankSoundPlayback();
//-------------------------------------------------------------
delete network;
network = NULL;
delete fileStream;
fileStream = NULL;
delete micAudio;
micAudio = NULL;
delete desktopAudio;
desktopAudio = NULL;
delete audioEncoder;
audioEncoder = NULL;
delete videoEncoder;
videoEncoder = NULL;
//-------------------------------------------------------------
for(UINT i=0; i<pendingAudioFrames.Num(); i++)
pendingAudioFrames[i].audioData.Clear();
pendingAudioFrames.Clear();
//-------------------------------------------------------------
if(GS)
GS->UnloadAllData();
//-------------------------------------------------------------
delete scene;
scene = NULL;
for(UINT i=0; i<globalSources.Num(); i++)
globalSources[i].FreeData();
globalSources.Clear();
//-------------------------------------------------------------
for(UINT i=0; i<auxAudioSources.Num(); i++)
delete auxAudioSources[i];
auxAudioSources.Clear();
//-------------------------------------------------------------
for(UINT i=0; i<NUM_RENDER_BUFFERS; i++)
{
delete mainRenderTextures[i];
delete yuvRenderTextures[i];
mainRenderTextures[i] = NULL;
yuvRenderTextures[i] = NULL;
}
for(UINT i=0; i<NUM_RENDER_BUFFERS; i++)
{
SafeRelease(copyTextures[i]);
}
delete transitionTexture;
transitionTexture = NULL;
//-------------------------------------------------------------
delete mainVertexShader;
delete mainPixelShader;
delete yuvScalePixelShader;
delete solidVertexShader;
delete solidPixelShader;
mainVertexShader = NULL;
mainPixelShader = NULL;
yuvScalePixelShader = NULL;
solidVertexShader = NULL;
solidPixelShader = NULL;
//-------------------------------------------------------------
delete GS;
GS = NULL;
//-------------------------------------------------------------
ResizeRenderFrame(false);
RedrawWindow(hwndRenderFrame, NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW);
//-------------------------------------------------------------
AudioDeviceList audioDevices;
GetAudioDevices(audioDevices, ADT_RECORDING);
String strDevice = AppConfig->GetString(TEXT("Audio"), TEXT("Device"), NULL);
if(strDevice.IsEmpty() || !audioDevices.HasID(strDevice))
{
AppConfig->SetString(TEXT("Audio"), TEXT("Device"), TEXT("Disable"));
strDevice = TEXT("Disable");
}
audioDevices.FreeData();
EnableWindow(GetDlgItem(hwndMain, ID_MICVOLUME), !strDevice.CompareI(TEXT("Disable")));
//-------------------------------------------------------------
ClearStreamInfo();
Log(TEXT("=====Stream End: %s================================================="), CurrentDateTimeString().Array());
//update notification icon to reflect current status
UpdateNotificationAreaIcon();
SetWindowText(GetDlgItem(hwndMain, ID_TESTSTREAM), Str("MainWindow.TestStream"));
EnableWindow(GetDlgItem(hwndMain, ID_STARTSTOP), TRUE);
SetWindowText(GetDlgItem(hwndMain, ID_STARTSTOP), Str("MainWindow.StartStream"));
EnableWindow(GetDlgItem(hwndMain, ID_TESTSTREAM), TRUE);
bEditMode = false;
SendMessage(GetDlgItem(hwndMain, ID_SCENEEDITOR), BM_SETCHECK, BST_UNCHECKED, 0);
EnableWindow(GetDlgItem(hwndMain, ID_SCENEEDITOR), FALSE);
ClearStatusBar();
InvalidateRect(hwndRenderFrame, NULL, TRUE);
SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 1, 0, 0);
SetThreadExecutionState(ES_CONTINUOUS);
String processPriority = AppConfig->GetString(TEXT("General"), TEXT("Priority"), TEXT("Normal"));
if (scmp(processPriority, TEXT("Normal")))
SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
bTestStream = false;
UpdateRenderViewMessage();
OSLeaveMutex(hStartupShutdownMutex);
}