/*
* Utility Functions _________________________________________________________________
*
*/
static BOOL OnSalvage()
{
if (IsButtonChecked(hDlg, IDC_SERVER)) {
pszPartitionName = 0;
pszVolumeName = 0;
} else if (IsButtonChecked(hDlg, IDC_PARTITION)) {
pszPartitionName = szPartitionName;
pszVolumeName = 0;
} else if (IsButtonChecked(hDlg, IDC_VOLUME)) {
pszPartitionName = szPartitionName;
pszVolumeName = szVolumeName;
}
nNumProcesses = DEFAULT_NUM_PROCESSES;
if (IsButtonChecked(hDlg, IDC_NUM_PROCESSES_CHECKBOX)) {
nNumProcesses = _ttoi(szNumProcesses);
if ((nNumProcesses < MIN_NUM_PROCESSES) || (nNumProcesses > MAX_NUM_PROCESSES)) {
ShowError(hDlg, 0, IDS_INVALID_NUM_SALVAGE_PROCESSSES);
return FALSE;
}
}
if (!g_CfgData.bReuseAdminInfo) {
if (!GetAdminInfo(hDlg, GAIO_LOGIN_ONLY))
return FALSE;
if (!GetHandles(hDlg))
return FALSE;
}
return TRUE;
}
static void UpdateControls()
{
// Update volume name controls
BOOL bVolume = IsButtonChecked(hDlg, IDC_VOLUME);
ENABLE_STATE es = bVolume ? ES_ENABLE : ES_DISABLE;
SetEnable(hDlg, IDC_VOLUME_NAME, es);
SetEnable(hDlg, IDC_VOLUME_NAME_LABEL, es);
GetWndText(hDlg, IDC_VOLUME_NAME, szVolumeName);
// Num processes edit control
BOOL bParallel = IsButtonChecked(hDlg, IDC_NUM_PROCESSES_CHECKBOX);
SetEnable(hDlg, IDC_NUM_PROCESSES, (ENABLE_STATE)bParallel);
GetWndText(hDlg, IDC_NUM_PROCESSES, szNumProcesses, NUM_PROCS_BUF_SIZE);
GetWndText(hDlg, IDC_LOG_FILE, g_CfgData.szSalvageLogFileName, _MAX_PATH);
GetWndText(hDlg, IDC_TEMP_DIR, szTempDir, _MAX_PATH);
// Should OK button be enabled or disabled?
BOOL bEnable = TRUE;
if (bVolume)
bEnable = !!lstrlen(szVolumeName);
if (bEnable && bParallel)
bEnable = !!lstrlen(szNumProcesses);
SetEnable(hDlg, IDOK, (ENABLE_STATE)bEnable);
}
void VDVideoFilterInterlaceDialog::OnDataExchange(bool write) {
if (write) {
mConfig.mbLaceFields = IsButtonChecked(IDC_SOURCE_ALTERNATING);
mConfig.mbOddFieldFirst = IsButtonChecked(IDC_FIELDORDER_ODDFIRST);
} else {
CheckButton(mConfig.mbLaceFields ? IDC_SOURCE_ALTERNATING : IDC_SOURCE_PROGRESSIVE, true);
CheckButton(mConfig.mbOddFieldFirst ? IDC_FIELDORDER_ODDFIRST : IDC_FIELDORDER_EVENFIRST, true);
}
}
void VDVideoFilterGammaCorrectDialog::OnDataExchange(bool write) {
if (write) {
mConfig.mbConvertToLinear = IsButtonChecked(IDC_SRGBTOLINEAR);
} else {
if (mConfig.mbConvertToLinear)
CheckButton(IDC_SRGBTOLINEAR, true);
else
CheckButton(IDC_LINEARTOSRGB, true);
}
}
uint64 GetSizeBoxMultiplier(HWND hwndDlg)
{
const uint64 Muliplier[] = {BYTES_PER_KB, BYTES_PER_MB, BYTES_PER_GB};
const int IdRadioBtn[] = {IDC_KB, IDC_MB, IDC_GB};
const int nMaxSuffix = sizeof(Muliplier)/sizeof(uint64) - 1;
int i;
for (i=nMaxSuffix; i>0 && !IsButtonChecked (GetDlgItem (hwndDlg, IdRadioBtn[i])); --i) ;
return Muliplier[i];
}
bool CPasswordDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
{
if (buttonID == IDC_CHECK_PASSWORD_SHOW)
{
_passwordControl.SetPasswordChar((IsButtonChecked(
IDC_CHECK_PASSWORD_SHOW) == BST_CHECKED) ? 0: TEXT('*'));
UString password;
_passwordControl.GetText(password);
_passwordControl.SetText(password);
return true;
}
return CDialog::OnButtonClicked(buttonID, buttonHWND);
}
static void CheckEnableButtons()
{
if (IsButtonChecked(hDlg, IDC_CREATE_PARTITION)) {
TCHAR szBuf[MAX_PARTITION_NAME_LEN];
GetWindowText(GetDlgItem(hDlg, IDC_PARTITION_NAME), szBuf, MAX_PARTITION_NAME_LEN);
if ((hSelectedItem == 0) || (szBuf[0] == 0)) {
g_pWiz->EnableButtons(BACK_BUTTON);
g_pWiz->SetDefaultControl(IDBACK);
return;
}
}
g_pWiz->EnableButtons(BACK_BUTTON | NEXT_BUTTON);
}
static BOOL SavePageInfo()
{
TCHAR szText[cchRESOURCE];
GetWndText(hDlg, IDC_CELL_NAME, szText);
if (lstrlen(szText) > MAX_CELL_NAME_LEN) {
MsgBox(hDlg, IDS_CELL_NAME_LEN_ERROR, GetAppTitleID(), MB_ICONSTOP | MB_OK);
return FALSE;
}
lstrcpy(g_CfgData.szCellName, szText);
lstrncpy(g_CfgData.szServerPW, GetWndText(hDlg, IDC_SERVER_PW, szText), MAX_SERVER_PW_LEN);
g_CfgData.bFirstServer = IsButtonChecked(hDlg, IDC_FIRST_SERVER);
return TRUE;
}
inline int CDialogWnd::GetCheckedRadioButton(int nIDFirst, int nIDLast)
{
int i;
if (nIDLast < nIDFirst)
{
i = nIDFirst;
nIDFirst = nIDLast;
nIDLast = i;
}
for (i = nIDFirst; i <= nIDLast; i++)
{
if (IsButtonChecked(i))
return(i);
}
return( -1 );
}
/*
* Utility Functions _________________________________________________________________
*
*/
static void CheckEnableButtons()
{
BOOL bDisable = FALSE;
TCHAR szCellName[cchRESOURCE];
TCHAR szPW[cchRESOURCE];
TCHAR szVerifyPW[cchRESOURCE];
bDisable = lstrlen(GetWndText(hDlg, IDC_CELL_NAME, szCellName)) == 0;
GetWndText(hDlg, IDC_SERVER_PW, szPW);
GetWndText(hDlg, IDC_VERIFY_PW, szVerifyPW);
if (IsButtonChecked(hDlg, IDC_FIRST_SERVER))
bDisable |= !lstrlen(szPW) || !lstrlen(szVerifyPW) || lstrcmp(szPW, szVerifyPW);
if (bDisable)
g_pWiz->EnableButtons(BACK_BUTTON);
else
g_pWiz->EnableButtons(BACK_BUTTON | NEXT_BUTTON);
}
static void ShowServiceStates()
{
// FS
if (bFsOn) {
if (bFsRunning)
SetWndText(hDlg, IDC_FS_ACTION_MSG, IDS_FS_HOW_TO_STOP);
else
SetWndText(hDlg, IDC_FS_ACTION_MSG, IDS_FS_WILL_RUN);
} else {
if (bFsRunning)
SetWndText(hDlg, IDC_FS_ACTION_MSG, IDS_FS_WILL_STOP);
else
SetWndText(hDlg, IDC_FS_ACTION_MSG, IDS_FS_HOW_TO_RUN);
}
// DB
switch (GetButtonState(hDlg, IDC_DB_SERVICE)) {
case BST_CHECKED:
if (bDbRunning)
SetWndText(hDlg, IDC_DB_ACTION_MSG, IDS_DB_HOW_TO_STOP);
else
SetWndText(hDlg, IDC_DB_ACTION_MSG, IDS_DB_WILL_RUN);
break;
case BST_UNCHECKED:
if (bDbRunning)
SetWndText(hDlg, IDC_DB_ACTION_MSG, IDS_DB_WILL_STOP);
else
SetWndText(hDlg, IDC_DB_ACTION_MSG, IDS_DB_HOW_TO_RUN);
break;
case BST_INDETERMINATE:
SetWndText(hDlg, IDC_DB_ACTION_MSG, IDS_DB_DETAILS);
break;
}
// For the ones below, in addition to setting the action message, we also
// set the status message. This is because the status can change to the
// disabled state depending on how other servers are configured. The
// servers before this cannot have their status change except by re-
// configuring them.
// BK
if (bDbOn) {
if (IsButtonChecked(hDlg, IDC_BK_SERVICE)) {
if (bBakRunning) {
SetWndText(hDlg, IDC_BK_STATUS_MSG, IDS_BK_RUNNING);
SetWndText(hDlg, IDC_BK_ACTION_MSG, IDS_BK_HOW_TO_STOP);
} else {
SetWndText(hDlg, IDC_BK_STATUS_MSG, IDS_BK_STOPPED);
SetWndText(hDlg, IDC_BK_ACTION_MSG, IDS_BK_WILL_RUN);
}
} else {
if (bBakRunning) {
SetWndText(hDlg, IDC_BK_STATUS_MSG, IDS_BK_RUNNING);
SetWndText(hDlg, IDC_BK_ACTION_MSG, IDS_BK_WILL_STOP);
} else {
SetWndText(hDlg, IDC_BK_STATUS_MSG, IDS_BK_STOPPED);
SetWndText(hDlg, IDC_BK_ACTION_MSG, IDS_BK_HOW_TO_RUN);
}
}
}
CheckEnableBak();
// SC Server
if (bFsOn || bDbOn && !bSccOn) {
if (bScsOn) {
if (bScsRunning) {
SetWndText(hDlg, IDC_SCS_STATUS_MSG, IDS_SCS_RUNNING);
SetWndText(hDlg, IDC_SCS_ACTION_MSG, IDS_SCS_HOW_TO_STOP);
} else {
SetWndText(hDlg, IDC_SCS_STATUS_MSG, IDS_SCS_STOPPED);
SetWndText(hDlg, IDC_SCS_ACTION_MSG, IDS_SCS_WILL_RUN);
}
} else {
if (bScsRunning) {
SetWndText(hDlg, IDC_SCS_STATUS_MSG, IDS_SCS_RUNNING);
SetWndText(hDlg, IDC_SCS_ACTION_MSG, IDS_SCS_WILL_STOP);
} else {
SetWndText(hDlg, IDC_SCS_STATUS_MSG, IDS_SCS_STOPPED);
SetWndText(hDlg, IDC_SCS_ACTION_MSG, IDS_SCS_HOW_TO_RUN);
}
}
}
// SC Client
if (bFsOn || bDbOn && !bScsOn) {
if (bSccOn) {
if (bSccRunning) {
SetWndText(hDlg, IDC_SCC_STATUS_MSG, IDS_SCC_RUNNING);
SetWndText(hDlg, IDC_SCC_ACTION_MSG, IDS_SCC_HOW_TO_STOP);
} else {
SetWndText(hDlg, IDC_SCC_STATUS_MSG, IDS_SCC_STOPPED);
SetWndText(hDlg, IDC_SCC_ACTION_MSG, IDS_SCC_WILL_RUN);
}
} else {
if (bSccRunning) {
SetWndText(hDlg, IDC_SCC_STATUS_MSG, IDS_SCC_RUNNING);
SetWndText(hDlg, IDC_SCC_ACTION_MSG, IDS_SCC_WILL_STOP);
} else {
SetWndText(hDlg, IDC_SCC_STATUS_MSG, IDS_SCC_STOPPED);
SetWndText(hDlg, IDC_SCC_ACTION_MSG, IDS_SCC_HOW_TO_RUN);
}
}
}
CheckEnableSc();
}
static void OnScMachineChange()
{
if (!bSettingScMachine && IsButtonChecked(hDlg, IDC_SCC))
GetWndText(hDlg, IDC_SC_MACHINE, szScMachine, sizeof(szScMachine) / sizeof(szScMachine[0]));
}
BOOL WardShaderDlg::PanelProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
int id = LOWORD(wParam);
int code = HIWORD(wParam);
switch (msg) {
case WM_INITDIALOG:
{
int i;
HDC theHDC = GetDC(hwndDlg);
hOldPal = GetGPort()->PlugPalette(theHDC);
ReleaseDC(hwndDlg,theHDC);
for (i=0; i<WARD_NCOLBOX; i++) {
cs[i] = GetIColorSwatch(GetDlgItem(hwndDlg, colID[i]),
GetMtlColor(i, pShader), GetColorName(i));
}
hwHilite = GetDlgItem(hwndDlg, IDC_HIGHLIGHT);
SetWindowLongPtr( hwHilite, GWLP_WNDPROC, (LONG_PTR)Hilite2WndProc);
slevSpin = SetupIntSpinner(hwndDlg, IDC_SLEV_SPIN, IDC_SLEV_EDIT, 0,400, 0);
dlevSpin = SetupIntSpinner(hwndDlg, IDC_DLEV_SPIN, IDC_DLEV_EDIT, 0, 400, 0);
glxSpin = SetupIntSpinner(hwndDlg, IDC_GLX_SPIN, IDC_GLX_EDIT, 0,100, 0);
glySpin = SetupIntSpinner(hwndDlg, IDC_GLY_SPIN, IDC_GLY_EDIT, 0,100, 0);
trSpin = SetupIntSpinner(hwndDlg, IDC_TR_SPIN, IDC_TR_EDIT, 0,100, 0);
for (int j=0; j<NMBUTS; j++) {
texMBut[j] = GetICustButton(GetDlgItem(hwndDlg,texMButtonsIDC[j]));
assert( texMBut[j] );
texMBut[j]->SetRightClickNotify(TRUE);
texMBut[j]->SetDADMgr(&dadMgr);
}
SetupLockButton(hwndDlg,IDC_LOCK_AD,FALSE);
SetupLockButton(hwndDlg,IDC_LOCK_DS,FALSE);
SetupPadLockButton(hwndDlg,IDC_LOCK_ADTEX, TRUE);
LoadDialog(TRUE);
}
break;
case WM_COMMAND:
{
for ( int i=0; i<NMBUTS; i++) {
if (id == texMButtonsIDC[i]) {
PostMessage(hwmEdit,WM_TEXMAP_BUTTON, texmapFromMBut[i],(LPARAM)pMtl );
UpdateMapButtons();
goto exit;
}
}
}
switch (id) {
case IDC_NORMALIZE_CHECK:
pShader->SetNormalizeOn( ! GetCheckBox(hwndDlg, IDC_NORMALIZE_CHECK) );
UpdateHilite();
NotifyChanged();
UpdateMtlDisplay();
break;
case IDC_LOCK_AD:
SetLockAD(IsButtonChecked(hwndDlg, IDC_LOCK_AD));
UpdateMtlDisplay();
break;
case IDC_LOCK_DS:
SetLockDS(IsButtonChecked(hwndDlg, IDC_LOCK_DS));
UpdateMtlDisplay();
break;
case IDC_LOCK_ADTEX:{
BOOL on = IsButtonChecked(hwndDlg, IDC_LOCK_ADTEX);
SetLockADTex(on);
UpdateMtlDisplay();
} break;
}
break;
case CC_COLOR_SEL: {
int id = LOWORD(wParam);
SelectEditColor(ColorIDCToIndex(id));
}
break;
case CC_COLOR_DROP: {
int id = LOWORD(wParam);
SelectEditColor(ColorIDCToIndex(id));
UpdateMtlDisplay();
}
break;
case CC_COLOR_BUTTONDOWN:
theHold.Begin();
break;
case CC_COLOR_BUTTONUP:
if (HIWORD(wParam)) theHold.Accept(GetString(IDS_DS_PARAMCHG));
else theHold.Cancel();
UpdateMtlDisplay();
break;
case CC_COLOR_CHANGE: {
int id = LOWORD(wParam);
int buttonUp = HIWORD(wParam);
int n = ColorIDCToIndex(id);
if (buttonUp) theHold.Begin();
Color curColor(cs[n]->GetColor());
SetMtlColor(n, curColor, pShader, cs, curTime);
if (buttonUp) {
theHold.Accept(GetString(IDS_DS_PARAMCHG));
// DS: 5/11/99- this was commented out. I put it back in, because
// it is necessary for the Reset button in the color picker to
// update the viewport.
UpdateMtlDisplay();
}
} break;
case WM_PAINT:
if (!valid) {
valid = TRUE;
ReloadDialog();
}
return FALSE;
case WM_CLOSE:
case WM_DESTROY:
break;
case CC_SPINNER_CHANGE:
if (!theHold.Holding()) theHold.Begin();
switch (id) {
case IDC_GLX_SPIN:
pShader->SetGlossiness(ALPHA_MAX - PcToFrac( glxSpin->GetIVal() ) * ALPHA_SZ, curTime);
UpdateHilite();
break;
case IDC_GLY_SPIN:
pShader->SetGlossinessY(ALPHA_MAX - PcToFrac(glySpin->GetIVal()) * ALPHA_SZ, curTime);
UpdateHilite();
break;
case IDC_SLEV_SPIN:
pShader->SetSpecularLevel(SPEC_MAX * PcToFrac(slevSpin->GetIVal()),curTime);
UpdateHilite();
break;
case IDC_DLEV_SPIN:
pShader->SetDiffuseLevel(PcToFrac(dlevSpin->GetIVal()),curTime);
break;
//******** >>>><<<< required handling for opacity....must be present in all dialogs
case IDC_TR_SPIN:
pMtl->SetOpacity(PcToFrac( trSpin->GetIVal()),curTime);
break;
}
// UpdateMtlDisplay();
break;
case CC_SPINNER_BUTTONDOWN:
theHold.Begin();
break;
case WM_CUSTEDIT_ENTER:
case CC_SPINNER_BUTTONUP:
if (HIWORD(wParam) || msg==WM_CUSTEDIT_ENTER)
theHold.Accept(GetString(IDS_DS_PARAMCHG));
else
theHold.Cancel();
UpdateMtlDisplay();
break;
}
exit:
return FALSE;
}
BOOL CALLBACK ExpandVolProgressDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static EXPAND_VOL_THREAD_PARAMS *pProgressDlgParam;
static BOOL bVolTransformStarted = FALSE;
static BOOL showRandPool = TRUE;
WORD lw = LOWORD (wParam);
switch (msg)
{
case WM_INITDIALOG:
{
char szOldHostSize[512], szNewHostSize[512];
pProgressDlgParam = (EXPAND_VOL_THREAD_PARAMS*)lParam;
bVolTransformStarted = FALSE;
showRandPool = TRUE;
hCurPage = hwndDlg;
nPbar = IDC_PROGRESS_BAR;
GetSpaceString(szOldHostSize,sizeof(szOldHostSize),pProgressDlgParam->oldSize,pProgressDlgParam->bIsDevice);
GetSpaceString(szNewHostSize,sizeof(szNewHostSize),pProgressDlgParam->newSize,pProgressDlgParam->bIsDevice);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_OLDSIZE), szOldHostSize);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NEWSIZE), szNewHostSize);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NAME), pProgressDlgParam->szVolumeName);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_FILE_SYSTEM), szFileSystemStr[pProgressDlgParam->FileSystem]);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_INITSPACE), pProgressDlgParam->bInitFreeSpace?"Yes":"No");
SendMessage (GetDlgItem (hwndDlg, IDC_BOX_STATUS), WM_SETFONT, (WPARAM) hBoldFont, (LPARAM) TRUE);
SendMessage (GetDlgItem (hwndDlg, IDC_RANDOM_BYTES), WM_SETFONT, (WPARAM) hFixedDigitFont, (LPARAM) TRUE);
// set status text
if ( !pProgressDlgParam->bInitFreeSpace && pProgressDlgParam->bIsLegacy )
{
showRandPool = FALSE;
EnableWindow (GetDlgItem (hwndDlg, IDC_DISPLAY_POOL_CONTENTS), FALSE);
EnableWindow (GetDlgItem (hwndDlg, IDC_RANDOM_BYTES), FALSE);
SetDlgItemText(hwndDlg, IDC_BOX_STATUS, "Click 'Continue' to expand the volume.");
}
else
{
SetDlgItemText(hwndDlg, IDC_BOX_STATUS, "IMPORTANT: Move your mouse as randomly as possible within this window. The longer you move it, the better. This significantly increases the cryptographic strength of the encryption keys. Then click 'Continue' to expand the volume.");
}
SendMessage (GetDlgItem (hwndDlg, IDC_DISPLAY_POOL_CONTENTS), BM_SETCHECK, showRandPool ? BST_CHECKED : BST_UNCHECKED, 0);
SetTimer (hwndDlg, TIMER_ID_RANDVIEW, TIMER_INTERVAL_RANDVIEW, NULL);
}
return 0;
case TC_APPMSG_VOL_TRANSFORM_THREAD_ENDED:
{
int nStatus = (int)lParam;
NormalCursor ();
if (nStatus != 0)
{
if ( nStatus != ERR_USER_ABORT )
AddProgressDlgStatus (hwndDlg, "Error: volume expansion failed.");
else
AddProgressDlgStatus (hwndDlg, "Error: operation aborted by user.");
}
else
{
AddProgressDlgStatus (hwndDlg, "Finished. Volume successfully expanded.");
}
SetWindowText (GetDlgItem (hwndDlg, IDOK), "Exit");
EnableWindow (GetDlgItem (hwndDlg, IDOK), TRUE);
EnableWindow (GetDlgItem (hwndDlg, IDCANCEL), FALSE);
}
return 1;
case WM_TIMER:
switch (wParam)
{
case TIMER_ID_RANDVIEW:
{
unsigned char tmp[16];
char szRndPool[64], *t;
DWORD *p;
if (!showRandPool)
return 1;
RandpeekBytes (hwndDlg, tmp, sizeof (tmp));
for ( p = (DWORD*)(tmp + sizeof(tmp)), t=szRndPool; p > (DWORD*)tmp; )
{
int len;
if ( (len = sprintf ( t, "%08X", *--p)) < 0 )
return 1;
t += len;
}
SetWindowText (GetDlgItem (hwndDlg, IDC_RANDOM_BYTES), szRndPool);
burn (tmp, sizeof(tmp));
burn (szRndPool, sizeof(szRndPool));
}
return 1;
}
return 0;
case WM_COMMAND:
if (lw == IDC_DISPLAY_POOL_CONTENTS)
{
showRandPool = IsButtonChecked (GetDlgItem (hwndDlg, IDC_DISPLAY_POOL_CONTENTS));
return 1;
}
if (lw == IDCANCEL)
{
if (bVolTransformStarted)
{
if (MessageBoxW (hwndDlg, L"Warning: Volume expansion is in progress!\n\nStopping now may result in a damaged volume.\n\nDo you really want to cancel?", lpszTitle, YES_NO|MB_ICONQUESTION|MB_DEFBUTTON2) == IDNO)
return 1;
// tell the volume transform thread to terminate
bVolTransformThreadCancel = TRUE;
}
EndDialog (hwndDlg, lw);
return 1;
}
if (lw == IDOK)
{
if (bVolTransformStarted)
{
// TransformThreadFunction finished -> OK button is now exit
EndDialog (hwndDlg, lw);
}
else
{
showRandPool = FALSE;
KillTimer (hwndDlg, TIMER_ID_RANDVIEW);
EnableWindow (GetDlgItem (hwndDlg, IDC_DISPLAY_POOL_CONTENTS), FALSE);
EnableWindow (GetDlgItem (hwndDlg, IDOK), FALSE);
SetProgressDlgStatus (hwndDlg, "Starting volume expansion ...\r\n");
bVolTransformStarted = TRUE;
pProgressDlgParam->hwndDlg = hwndDlg;
if ( _beginthread (volTransformThreadFunction, 0, pProgressDlgParam) == -1L )
{
handleError (hwndDlg, ERR_OS_ERROR);
EndDialog (hwndDlg, lw);
}
WaitCursor();
}
return 1;
}
return 0;
}
return 0;
}
BOOL CALLBACK ExpandVolSizeDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static EXPAND_VOL_THREAD_PARAMS *pVolExpandParam;
WORD lw = LOWORD (wParam);
switch (msg)
{
case WM_INITDIALOG:
{
char szTemp[4096];
pVolExpandParam = (EXPAND_VOL_THREAD_PARAMS*)lParam;
EnableWindow (GetDlgItem (hwndDlg, IDC_SIZEBOX), !pVolExpandParam->bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_KB), !pVolExpandParam->bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_MB), !pVolExpandParam->bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_GB), !pVolExpandParam->bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_INIT_NEWSPACE),
!(pVolExpandParam->bIsLegacy && pVolExpandParam->bIsDevice));
SendDlgItemMessage (hwndDlg, IDC_INIT_NEWSPACE, BM_SETCHECK,
pVolExpandParam->bInitFreeSpace ? BST_CHECKED : BST_UNCHECKED, 0);
if (!pVolExpandParam->bIsDevice)
SetCurrentVolSize(hwndDlg,pVolExpandParam->oldSize);
SendMessage (GetDlgItem (hwndDlg, IDC_BOX_HELP), WM_SETFONT, (WPARAM) hBoldFont, (LPARAM) TRUE);
GetSpaceString(szTemp,sizeof(szTemp),pVolExpandParam->oldSize,pVolExpandParam->bIsDevice);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_OLDSIZE), szTemp);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NAME), pVolExpandParam->szVolumeName);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_FILE_SYSTEM), szFileSystemStr[pVolExpandParam->FileSystem]);
if (pVolExpandParam->bIsDevice)
{
GetSpaceString(szTemp,sizeof(szTemp),pVolExpandParam->newSize,TRUE);
}
else
{
char szHostFreeStr[256];
SetWindowText (GetDlgItem (hwndDlg, IDT_NEW_SIZE), "");
GetSpaceString(szHostFreeStr,sizeof(szHostFreeStr),pVolExpandParam->hostSizeFree,FALSE);
sprintf (szTemp,"%s available on host drive", szHostFreeStr);
}
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NEWSIZE), szTemp);
// set help text
if (pVolExpandParam->bIsDevice)
{
sprintf (szTemp,"This is a device-based VeraCrypt volume.\n\nThe new volume size will be choosen automatically as the size of the host device.");
if (pVolExpandParam->bIsLegacy)
strcat(szTemp," Note: filling the new space with random data is not supported for legacy volumes.");
}
else
{
sprintf (szTemp,"Please specify the new size of the VeraCrypt volume (must be at least %I64u KB larger than the current size).",TC_MINVAL_FS_EXPAND/1024);
}
SetWindowText (GetDlgItem (hwndDlg, IDC_BOX_HELP), szTemp);
}
return 0;
case WM_COMMAND:
if (lw == IDCANCEL)
{
EndDialog (hwndDlg, lw);
return 1;
}
if (lw == IDOK)
{
char szTemp[4096];
pVolExpandParam->bInitFreeSpace = IsButtonChecked (GetDlgItem (hwndDlg, IDC_INIT_NEWSPACE));
if (!pVolExpandParam->bIsDevice) // for devices new size is set by calling function
{
GetWindowText (GetDlgItem (hwndDlg, IDC_SIZEBOX), szTemp, sizeof (szTemp));
pVolExpandParam->newSize = _atoi64(szTemp) * GetSizeBoxMultiplier(hwndDlg);
}
EndDialog (hwndDlg, lw);
return 1;
}
return 0;
}
return 0;
}
BOOL OrenNayarShaderDlg::PanelProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
int id = LOWORD(wParam);
int code = HIWORD(wParam);
switch (msg) {
case WM_INITDIALOG:
{
int i;
HDC theHDC = GetDC(hwndDlg);
hOldPal = GetGPort()->PlugPalette(theHDC);
ReleaseDC(hwndDlg,theHDC);
for (i=0; i<NCOLBOX; i++) {
cs[i] = GetIColorSwatch(GetDlgItem(hwndDlg, colID[i]),
GetMtlColor(i, pShader), GetColorName(i));
}
hwHilite = GetDlgItem(hwndDlg, IDC_HIGHLIGHT);
SetWindowLongPtr( hwHilite, GWLP_WNDPROC, (LONG_PTR)HiliteWndProc);
shSpin = SetupIntSpinner(hwndDlg, IDC_SH_SPIN, IDC_SH_EDIT, 0,100, 0);
ssSpin = SetupIntSpinner(hwndDlg, IDC_SS_SPIN, IDC_SS_EDIT, 0,999, 0);
softSpin = SetupFloatSpinner(hwndDlg, IDC_SOFT_SPIN, IDC_SOFT_EDIT, 0.0f,1.0f,0.0f,.01f);
trSpin = SetupIntSpinner(hwndDlg, IDC_TR_SPIN, IDC_TR_EDIT, 0,100, 0);
dlevSpin = SetupIntSpinner(hwndDlg, IDC_DIFFLEV_SPIN, IDC_DIFFLEV_EDIT, 0, 400, 0);
roughSpin = SetupIntSpinner(hwndDlg, IDC_DIFFROUGH_SPIN, IDC_DIFFROUGH_EDIT, 0, 100, 0);
for (int j=0; j<NMBUTS; j++) {
texMBut[j] = GetICustButton(GetDlgItem(hwndDlg,texMButtonsIDC[j]));
assert( texMBut[j] );
texMBut[j]->SetRightClickNotify(TRUE);
texMBut[j]->SetDADMgr(&dadMgr);
}
SetupLockButton(hwndDlg,IDC_LOCK_AD,FALSE);
SetupLockButton(hwndDlg,IDC_LOCK_DS,FALSE);
SetupPadLockButton(hwndDlg,IDC_LOCK_ADTEX, TRUE);
/* // mjm - 5.10.99 - isn't this already created above when i == N_SI_CLR?
// create both a self-illum color as well as a spinner
cs[N_SI_CLR] = GetIColorSwatch(GetDlgItem(hwndDlg, colID[N_SI_CLR] ),
GetMtlColor(N_SI_CLR, pShader), GetColorName(N_SI_CLR));
*/
siSpin = SetupIntSpinner(hwndDlg, IDC_SI_SPIN, IDC_SI_EDIT, 0,100, 0);
if( pShader->IsSelfIllumClrOn() ) {
// enable the color swatch, disable the spinner
ShowWindow( GetDlgItem(hwndDlg, IDC_SI_EDIT), SW_HIDE );
ShowWindow( GetDlgItem(hwndDlg, IDC_SI_SPIN), SW_HIDE );
} else {
// disable the color swatch
ShowWindow( cs[N_SI_CLR]->GetHwnd(), SW_HIDE );
}
LoadDialog(TRUE);
}
break;
case WM_COMMAND:
{
for ( int i=0; i<NMBUTS; i++) {
if (id == texMButtonsIDC[i]) {
PostMessage(hwmEdit,WM_TEXMAP_BUTTON, texmapFromMBut[i],(LPARAM)pMtl );
UpdateMapButtons();
goto exit;
}
}
}
switch (id) {
case IDC_LOCK_AD:
SetLockAD(IsButtonChecked(hwndDlg, IDC_LOCK_AD));
UpdateMtlDisplay();
break;
case IDC_LOCK_DS:
SetLockDS(IsButtonChecked(hwndDlg, IDC_LOCK_DS));
UpdateMtlDisplay();
break;
case IDC_LOCK_ADTEX:{
BOOL on = IsButtonChecked(hwndDlg, IDC_LOCK_ADTEX);
SetLockADTex(on);
UpdateMtlDisplay();
} break;
case IDC_SI_COLORON:{
int isOn = GetCheckBox(hwndDlg, IDC_SI_COLORON );
pShader->SetSelfIllumClrOn( isOn );
if ( isOn ) {
// enable the color swatch, disable the spinner
ShowWindow( GetDlgItem(hwndDlg, IDC_SI_EDIT), SW_HIDE );
ShowWindow( GetDlgItem(hwndDlg, IDC_SI_SPIN), SW_HIDE );
ShowWindow( cs[N_SI_CLR]->GetHwnd(), SW_SHOW );
} else {
// disable the color swatch
ShowWindow( cs[N_SI_CLR]->GetHwnd(), SW_HIDE );
ShowWindow( GetDlgItem(hwndDlg, IDC_SI_EDIT), SW_SHOW );
ShowWindow( GetDlgItem(hwndDlg, IDC_SI_SPIN), SW_SHOW );
}
NotifyChanged();
// UpdateMtlDisplay();
}
break;
}
break;
case CC_COLOR_SEL: {
int id = LOWORD(wParam);
SelectEditColor(ColorIDCToIndex(id));
}
break;
case CC_COLOR_DROP: {
int id = LOWORD(wParam);
SelectEditColor(ColorIDCToIndex(id));
UpdateMtlDisplay();
}
break;
case CC_COLOR_BUTTONDOWN:
theHold.Begin();
break;
case CC_COLOR_BUTTONUP:
if (HIWORD(wParam)) theHold.Accept(GetString(IDS_DS_PARAMCHG));
else theHold.Cancel();
UpdateMtlDisplay();
break;
case CC_COLOR_CHANGE: {
int id = LOWORD(wParam);
int buttonUp = HIWORD(wParam);
int n = ColorIDCToIndex(id);
if (buttonUp) theHold.Begin();
Color curColor(cs[n]->GetColor());
SetMtlColor(n, curColor, pShader, cs, curTime);
if (buttonUp) {
theHold.Accept(GetString(IDS_DS_PARAMCHG));
// DS: 5/11/99- this was commented out. I put it back in, because
// it is necessary for the Reset button in the color picker to
// update the viewport.
UpdateMtlDisplay();
}
} break;
case WM_PAINT:
if (!valid) {
valid = TRUE;
ReloadDialog();
}
return FALSE;
case WM_CLOSE:
case WM_DESTROY:
break;
case CC_SPINNER_CHANGE:
if (!theHold.Holding()) theHold.Begin();
switch (id) {
case IDC_SH_SPIN:
pShader->SetGlossiness(PcToFrac(shSpin->GetIVal()), curTime);
UpdateHilite();
break;
case IDC_SS_SPIN:
pShader->SetSpecularLevel(PcToFrac(ssSpin->GetIVal()),curTime);
UpdateHilite();
break;
case IDC_SOFT_SPIN:
pShader->SetSoftenLevel(softSpin->GetFVal(),curTime);
break;
case IDC_SI_SPIN:
pShader->SetSelfIllum(PcToFrac(siSpin->GetIVal()),curTime);
break;
case IDC_DIFFLEV_SPIN:
pShader->SetDiffuseLevel(PcToFrac(dlevSpin->GetIVal()),curTime);
break;
case IDC_DIFFROUGH_SPIN:
pShader->SetDiffuseRoughness(PcToFrac(roughSpin->GetIVal()),curTime);
break;
//******** >>>><<<< required handling for opacity....must be present in all dialogs
case IDC_TR_SPIN:
pMtl->SetOpacity(PcToFrac( trSpin->GetIVal()),curTime);
break;
}
// UpdateMtlDisplay();
break;
case CC_SPINNER_BUTTONDOWN:
theHold.Begin();
break;
case WM_CUSTEDIT_ENTER:
case CC_SPINNER_BUTTONUP:
if (HIWORD(wParam) || msg==WM_CUSTEDIT_ENTER)
theHold.Accept(GetString(IDS_DS_PARAMCHG));
else
theHold.Cancel();
UpdateMtlDisplay();
break;
}
exit:
return FALSE;
}
bool VDUIJobControlDialog::OnCommand(uint32 id, uint32 extcode) {
OnMenuHit(id);
if (extcode == BN_CLICKED) {
HWND hwndItem = GetDlgItem(mhdlg, IDC_JOBS);
int index = ListView_GetNextItem(hwndItem, -1, LVNI_ALL | LVNI_SELECTED);
VDJob *vdj = NULL;
if (index >= 0)
vdj = g_VDJobQueue.ListGet(index);
switch(id) {
case IDOK:
Destroy();
return true;
case IDC_DELETE:
if (vdj) {
// Do not delete jobs that are in progress!
if (vdj->GetState() != VDJob::kStateInProgress) {
fUpdateDisable = true;
g_VDJobQueue.Delete(vdj, false);
delete vdj;
g_VDJobQueue.SetModified();
fUpdateDisable = false;
if (g_VDJobQueue.ListSize() > 0)
ListView_SetItemState(hwndItem, index==g_VDJobQueue.ListSize() ? index-1 : index, LVIS_SELECTED, LVIS_SELECTED);
}
}
return TRUE;
case IDC_POSTPONE:
if (vdj) {
// Do not postpone jobs in progress
int state = vdj->GetState();
if (state != VDJob::kStateInProgress) {
if (state == VDJob::kStatePostponed)
vdj->SetState(VDJob::kStateWaiting);
else
vdj->SetState(VDJob::kStatePostponed);
vdj->Refresh();
g_VDJobQueue.SetModified();
}
}
return TRUE;
case IDC_MOVE_UP:
if (!vdj || index <= 0)
return TRUE;
g_VDJobQueue.Swap(index-1, index);
ListView_SetItemState(hwndItem, index , 0, LVIS_SELECTED | LVIS_FOCUSED);
ListView_SetItemState(hwndItem, index-1, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
ListView_RedrawItems(hwndItem, index-1, index);
g_VDJobQueue.SetModified();
return TRUE;
case IDC_MOVE_DOWN:
if (!vdj || index >= g_VDJobQueue.ListSize()-1)
return TRUE;
g_VDJobQueue.Swap(index+1, index);
ListView_SetItemState(hwndItem, index , 0, LVIS_SELECTED | LVIS_FOCUSED);
ListView_SetItemState(hwndItem, index+1, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
ListView_RedrawItems(hwndItem, index, index+1);
g_VDJobQueue.SetModified();
return TRUE;
case IDC_START:
if (g_VDJobQueue.IsRunInProgress()) {
g_VDJobQueue.RunAllStop();
EnableControl(IDC_START, FALSE);
} else
g_VDJobQueue.RunAllStart();
return TRUE;
case IDC_ABORT:
if (g_VDJobQueue.IsRunInProgress()) {
g_VDJobQueue.RunAllStop();
EnableControl(IDC_START, false);
EnableControl(IDC_ABORT, false);
if (g_dubber) g_dubber->Abort();
}
return TRUE;
case IDC_RELOAD:
if (!vdj)
return TRUE;
if (!vdj->IsReloadMarkerPresent())
MessageBox(mhdlg, "This job was created with an older version of VirtualDub and cannot be reloaded.", g_szError, MB_ICONERROR|MB_OK);
else
vdj->Reload();
return TRUE;
case IDC_AUTOSTART:
g_VDJobQueue.SetAutoRunEnabled(IsButtonChecked(IDC_AUTOSTART));
return TRUE;
}
}
return false;
}
