mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2004 lines
53 KiB
2004 lines
53 KiB
/********************************************************************
|
|
|
|
wfdlgs2.c
|
|
|
|
More Windows File System Dialog procedures
|
|
|
|
Copyright (C) 1992-1993 Microsoft Corp.
|
|
All rights reserved
|
|
|
|
********************************************************************/
|
|
|
|
#include "winfile.h"
|
|
#include "lfn.h"
|
|
#include "wfcopy.h"
|
|
#include "wnetcaps.h" // WNetGetCaps()
|
|
#include "commdlg.h"
|
|
|
|
|
|
|
|
BOOL (*lpfnGetFileVersionInfoW)(LPWSTR, DWORD, DWORD, LPVOID);
|
|
DWORD (*lpfnGetFileVersionInfoSizeW)(LPWSTR, LPDWORD);
|
|
BOOL (*lpfnVerQueryValueW)(const LPVOID, LPWSTR, LPVOID*, LPDWORD);
|
|
BOOL (*lpfnVerQueryValueIndexW)(const LPVOID, LPWSTR, INT, LPVOID*, LPVOID*, LPDWORD);
|
|
|
|
#define VERSION_DLL TEXT("version.dll")
|
|
|
|
// LATER: replace these with ordinal numbers
|
|
|
|
#define VERSION_GetFileVersionInfoW "GetFileVersionInfoW"
|
|
#define VERSION_GetFileVersionInfoSizeW "GetFileVersionInfoSizeW"
|
|
#define VERSION_VerQueryValueW "VerQueryValueW"
|
|
#define VERSION_VerQueryValueIndexW "VerQueryValueIndexW"
|
|
|
|
#define GetFileVersionInfoW (*lpfnGetFileVersionInfoW)
|
|
#define GetFileVersionInfoSizeW (*lpfnGetFileVersionInfoSizeW)
|
|
#define VerQueryValueW (*lpfnVerQueryValueW)
|
|
#define VerQueryValueIndexW (*lpfnVerQueryValueIndexW)
|
|
|
|
VOID CheckAttribsDlgButton(HWND hDlg, INT id, DWORD dwAttribs, DWORD dwAttribs3State, DWORD dwAttribsOn);
|
|
BOOL NoQuotes(LPTSTR szT);
|
|
|
|
|
|
// Return pointers to various bits of a path.
|
|
// ie where the dir name starts, where the filename starts and where the
|
|
// params are.
|
|
VOID
|
|
GetPathInfo(LPTSTR szTemp, LPTSTR *ppDir, LPTSTR *ppFile, LPTSTR *ppPar)
|
|
{
|
|
// handle quoted things
|
|
BOOL bInQuotes=FALSE;
|
|
|
|
// strip leading spaces
|
|
|
|
for (*ppDir = szTemp; **ppDir == CHAR_SPACE; (*ppDir)++)
|
|
;
|
|
|
|
// locate the parameters
|
|
|
|
// Use bInQuotes and add if clause
|
|
for (*ppPar = *ppDir; **ppPar && (**ppPar != CHAR_SPACE || bInQuotes) ; (*ppPar)++)
|
|
if ( CHAR_DQUOTE == **ppPar ) bInQuotes = !bInQuotes;
|
|
|
|
// locate the start of the filename and the extension.
|
|
|
|
for (*ppFile = *ppPar; *ppFile > *ppDir; --(*ppFile)) {
|
|
if (((*ppFile)[-1] == CHAR_COLON) || ((*ppFile)[-1] == CHAR_BACKSLASH))
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Strips off the path portion and replaces the first part of an 8-dot-3
|
|
// filename with an asterisk.
|
|
//
|
|
|
|
VOID
|
|
StarFilename(LPTSTR pszPath)
|
|
{
|
|
LPTSTR p;
|
|
TCHAR szTemp[MAXPATHLEN];
|
|
|
|
// Remove any leading path information.
|
|
StripPath(pszPath);
|
|
|
|
lstrcpy(szTemp, pszPath);
|
|
|
|
p=GetExtension(szTemp);
|
|
|
|
if (*p) {
|
|
pszPath[0] = CHAR_STAR;
|
|
lstrcpy(pszPath+1, p-1);
|
|
} else {
|
|
lstrcpy(pszPath, szStarDotStar);
|
|
}
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* SearchDlgProc() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
INT
|
|
SearchDlgProc(register HWND hDlg, UINT wMsg, WPARAM wParam, LONG lParam)
|
|
{
|
|
LPTSTR p;
|
|
MDICREATESTRUCT MDICS;
|
|
TCHAR szStart[MAXFILENAMELEN];
|
|
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
switch (wMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
|
|
SendDlgItemMessage(hDlg, IDD_DIR, EM_LIMITTEXT, COUNTOF(SearchInfo.szSearch)-1, 0L);
|
|
SendDlgItemMessage(hDlg, IDD_NAME, EM_LIMITTEXT, COUNTOF(szStart)-1, 0L);
|
|
|
|
GetSelectedDirectory(0, SearchInfo.szSearch);
|
|
SetDlgItemText(hDlg, IDD_DIR, SearchInfo.szSearch);
|
|
|
|
p = GetSelection(1, NULL);
|
|
|
|
if (p) {
|
|
GetNextFile(p, szStart, COUNTOF(szStart));
|
|
StarFilename(szStart);
|
|
SetDlgItemText(hDlg, IDD_NAME, szStart);
|
|
LocalFree((HANDLE)p);
|
|
}
|
|
|
|
CheckDlgButton(hDlg, IDD_SEARCHALL, !SearchInfo.bDontSearchSubs);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam)) {
|
|
|
|
case IDD_HELP:
|
|
goto DoHelp;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, FALSE);
|
|
break;
|
|
|
|
case IDOK:
|
|
|
|
GetDlgItemText(hDlg, IDD_DIR, SearchInfo.szSearch, COUNTOF(SearchInfo.szSearch));
|
|
QualifyPath(SearchInfo.szSearch);
|
|
|
|
GetDlgItemText(hDlg, IDD_NAME, szStart, COUNTOF(szStart));
|
|
|
|
KillQuoteTrailSpace( szStart );
|
|
|
|
AppendToPath(SearchInfo.szSearch, szStart);
|
|
|
|
SearchInfo.bDontSearchSubs = !IsDlgButtonChecked(hDlg, IDD_SEARCHALL);
|
|
|
|
EndDialog(hDlg, TRUE);
|
|
|
|
SearchInfo.iDirsRead = 0;
|
|
SearchInfo.iFileCount = 0;
|
|
SearchInfo.eStatus = SEARCH_NULL;
|
|
SearchInfo.bCancel = FALSE;
|
|
|
|
/* Is the search window already up? */
|
|
if (hwndSearch) {
|
|
|
|
// used to check ret val of change display then
|
|
// activate and non-iconize search window.
|
|
// now instead pass a flag
|
|
|
|
SendMessage(hwndSearch, FS_CHANGEDISPLAY, CD_PATH, (LPARAM)SearchInfo.szSearch);
|
|
|
|
} else {
|
|
|
|
//
|
|
// !! BUGBUG !!
|
|
//
|
|
// This is safe since szMessage = MAXPATHLEN*2+MAXSUGGESTLEN
|
|
// but it's not portable
|
|
//
|
|
LoadString(hAppInstance, IDS_SEARCHTITLE, szMessage,
|
|
COUNTOF(szMessage));
|
|
|
|
lstrcat(szMessage, SearchInfo.szSearch);
|
|
|
|
|
|
// Have the MDIClient create the MDI directory window.
|
|
|
|
MDICS.szClass = szSearchClass;
|
|
MDICS.hOwner = hAppInstance;
|
|
MDICS.szTitle = szMessage;
|
|
|
|
// Minimize
|
|
|
|
MDICS.style = WS_MINIMIZE;
|
|
MDICS.x = CW_USEDEFAULT;
|
|
MDICS.y = 0;
|
|
MDICS.cx = CW_USEDEFAULT;
|
|
MDICS.cy = 0;
|
|
|
|
SendMessage(hwndMDIClient, WM_MDICREATE, 0L, (DWORD)(LPMDICREATESTRUCT)&MDICS);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return(FALSE);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (wMsg == wHelpMessage) {
|
|
DoHelp:
|
|
WFHelp(hDlg);
|
|
|
|
return TRUE;
|
|
} else
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
#define RUN_LENGTH MAXPATHLEN
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* RunDlgProc() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
INT
|
|
RunDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LONG lParam)
|
|
{
|
|
LPTSTR p,pDir,pFile,pPar;
|
|
register DWORD ret;
|
|
LPTSTR pDir2;
|
|
TCHAR szTemp[MAXPATHLEN];
|
|
TCHAR szTemp2[MAXPATHLEN];
|
|
TCHAR sz3[RUN_LENGTH];
|
|
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
switch (wMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
SetDlgDirectory(hDlg, NULL);
|
|
SetWindowDirectory(); // and really set the DOS current directory
|
|
|
|
SendDlgItemMessage(hDlg, IDD_NAME, EM_LIMITTEXT, COUNTOF(szTemp)-1, 0L);
|
|
|
|
p = GetSelection(1, NULL);
|
|
|
|
if (p) {
|
|
SetDlgItemText(hDlg, IDD_NAME, p);
|
|
LocalFree((HANDLE)p);
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
|
{
|
|
case IDD_HELP:
|
|
goto DoHelp;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, FALSE);
|
|
break;
|
|
|
|
case IDOK:
|
|
{
|
|
BOOL bLoadIt;
|
|
|
|
GetDlgItemText(hDlg, IDD_NAME, szTemp, COUNTOF(szTemp));
|
|
GetPathInfo(szTemp, &pDir, &pFile, &pPar);
|
|
|
|
// copy away parameters
|
|
lstrcpy(sz3,pPar);
|
|
*pPar = CHAR_NULL; // strip the params from the program
|
|
|
|
// REVIEW HACK Hard code UNC style paths.
|
|
if (*pDir == CHAR_BACKSLASH && *(pDir+1) == CHAR_BACKSLASH) {
|
|
// This is a UNC style filename so NULLify directory.
|
|
pDir2 = NULL;
|
|
} else {
|
|
GetSelectedDirectory(0, szTemp2);
|
|
pDir2 = szTemp2;
|
|
}
|
|
|
|
bLoadIt = IsDlgButtonChecked(hDlg, IDD_LOAD);
|
|
|
|
// Stop SaveBits flickering by invalidating the SaveBitsStuff.
|
|
// You can't just hide the window because it messes up the
|
|
// the activation.
|
|
|
|
SetWindowPos(hDlg, 0, 0, 0, 0, 0, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER);
|
|
|
|
ret = ExecProgram(pDir, sz3, pDir2, bLoadIt);
|
|
if (ret) {
|
|
MyMessageBox(hDlg, IDS_EXECERRTITLE, ret, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
|
|
SetWindowPos(hDlg, 0, 0, 0, 0, 0, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER);
|
|
} else
|
|
EndDialog(hDlg, TRUE);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return(FALSE);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (wMsg == wHelpMessage || wMsg == wBrowseMessage) {
|
|
DoHelp:
|
|
WFHelp(hDlg);
|
|
|
|
return TRUE;
|
|
} else
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
#ifdef LFNCLIPBOARD
|
|
VOID
|
|
CopyToClipboard(LPTSTR pszFrom)
|
|
{
|
|
TCHAR szPath[MAXPATHLEN];
|
|
TCHAR szPathLong[MAXPATHLEN];
|
|
|
|
UINT uFormatA, uFormatW;
|
|
UINT uFormatLongA, uFormatLongW;
|
|
|
|
HANDLE hMemW, hMemA;
|
|
HANDLE hMemLongW, hMemLongA;
|
|
|
|
LPSTR lpszMemA, lpszMemLongA;
|
|
BOOL fDefUsed;
|
|
UINT cbMem;
|
|
UINT cbMemLong;
|
|
|
|
GetNextFile(pszFrom, szPath, COUNTOF(szPath));
|
|
|
|
QualifyPath(szPath);
|
|
lstrcpy(szPathLong, szPath);
|
|
|
|
SheShortenPath(szPath, TRUE);
|
|
|
|
uFormatW = RegisterClipboardFormat(TEXT("FileNameW"));
|
|
uFormatLongW = RegisterClipboardFormat(TEXT("LongFileNameW"));
|
|
uFormatA = RegisterClipboardFormat(TEXT("FileName"));
|
|
uFormatLongA = RegisterClipboardFormat(TEXT("LongFileName"));
|
|
|
|
if (!uFormatW || !uFormatLongW ||
|
|
!uFormatA || !uFormatLongA)
|
|
return;
|
|
|
|
cbMem = ByteCountOf(lstrlen(szPath)+1);
|
|
cbMemLong = ByteCountOf(lstrlen(szPathLong)+1);
|
|
|
|
hMemW = GlobalAlloc(GPTR|GMEM_DDESHARE, cbMem);
|
|
hMemLongW = GlobalAlloc(GPTR|GMEM_DDESHARE, cbMemLong);
|
|
hMemA = GlobalAlloc(GPTR|GMEM_DDESHARE, cbMem);
|
|
hMemLongA = GlobalAlloc(GPTR|GMEM_DDESHARE, cbMemLong);
|
|
|
|
if (!hMemW || !hMemLongW || !hMemA || !hMemLongA) {
|
|
if (!hMemW)
|
|
GlobalFree(hMemW);
|
|
if (!hMemLongW)
|
|
GlobalFree(hMemLongW);
|
|
if (!hMemA)
|
|
GlobalFree(hMemA);
|
|
if (!hMemLongA)
|
|
GlobalFree(hMemLongA);
|
|
return;
|
|
}
|
|
|
|
lstrcpy(GlobalLock(hMemW), szPath);
|
|
lstrcpy(GlobalLock(hMemLongW), szPathLong);
|
|
|
|
/*
|
|
* Need to deal with the problem of non-roundtrip conversion when
|
|
* best fit has been applied to long filename.
|
|
*/
|
|
|
|
lpszMemA = (LPSTR) GlobalLock(hMemA);
|
|
WideCharToMultiByte(CP_ACP, 0, szPath, -1, lpszMemA, lstrlen(szPath), NULL, NULL);
|
|
|
|
lpszMemLongA = (LPSTR) GlobalLock(hMemLongA);
|
|
WideCharToMultiByte(CP_ACP, 0, szPathLong, -1, lpszMemLongA, lstrlen(szPathLong), NULL, &fDefUsed);
|
|
|
|
if (fDefUsed)
|
|
lstrcpyA(lpszMemLongA, lpszMemA);
|
|
|
|
GlobalUnlock(hMemW);
|
|
GlobalUnlock(hMemLongW);
|
|
GlobalUnlock(hMemA);
|
|
GlobalUnlock(hMemLongA);
|
|
|
|
if (OpenClipboard(hwndFrame)) {
|
|
EmptyClipboard();
|
|
|
|
SetClipboardData(uFormatW, hMemW);
|
|
SetClipboardData(uFormatLongW, hMemLongW);
|
|
|
|
SetClipboardData(uFormatA, hMemA);
|
|
SetClipboardData(uFormatLongA, hMemLongA);
|
|
|
|
CloseClipboard();
|
|
} else {
|
|
GlobalFree(hMemW);
|
|
GlobalFree(hMemLongW);
|
|
GlobalFree(hMemA);
|
|
GlobalFree(hMemLongA);
|
|
}
|
|
}
|
|
#else
|
|
VOID
|
|
CopyToClipboard(LPTSTR pszFrom)
|
|
{
|
|
TCHAR szPath[MAXPATHLEN];
|
|
UINT wFormat;
|
|
HANDLE hMem;
|
|
|
|
GetNextFile(pszFrom, szPath, COUNTOF(szPath));
|
|
|
|
QualifyPath(szPath);
|
|
SheShortenPath(szPath, TRUE);
|
|
|
|
wFormat = RegisterClipboardFormat(TEXT("FileName"));
|
|
|
|
if (!wFormat)
|
|
return;
|
|
|
|
hMem = GlobalAlloc(GPTR|GMEM_DDESHARE, ByteCountOf(lstrlen(szPath)+1));
|
|
|
|
if (!hMem)
|
|
return;
|
|
|
|
lstrcpy(GlobalLock(hMem), szPath);
|
|
GlobalUnlock(hMem);
|
|
|
|
if (OpenClipboard(hwndFrame)) {
|
|
EmptyClipboard();
|
|
SetClipboardData(wFormat, hMem);
|
|
#if 0
|
|
// write, excel and winword will not past the package
|
|
// if we put text in the clipboard.
|
|
|
|
hMem = GlobalAlloc(GPTR | GMEM_DDESHARE, ByteCountOf(lstrlen(szPath)+1));
|
|
if (hMem) {
|
|
lstrcpy(GlobalLock(hMem), szPath);
|
|
GlobalUnlock(hMem);
|
|
SetClipboardData(CF_OEMTEXT, hMem);
|
|
}
|
|
#endif
|
|
CloseClipboard();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
VOID
|
|
EnableCopy(HWND hDlg, BOOL bCopy)
|
|
{
|
|
HWND hwnd;
|
|
|
|
// turn these off
|
|
|
|
hwnd = GetDlgItem(hDlg, IDD_STATUS);
|
|
if (hwnd) {
|
|
EnableWindow(hwnd, !bCopy);
|
|
ShowWindow(hwnd, !bCopy ? SW_SHOWNA : SW_HIDE);
|
|
}
|
|
|
|
hwnd = GetDlgItem(hDlg, IDD_NAME);
|
|
if (hwnd) {
|
|
EnableWindow(hwnd, !bCopy);
|
|
ShowWindow(hwnd, !bCopy ? SW_SHOWNA : SW_HIDE);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
MessWithRenameDirPath(LPTSTR pszPath)
|
|
{
|
|
TCHAR szPath[MAXPATHLEN];
|
|
LPTSTR lpsz;
|
|
|
|
// absolute path? don't tamper with it!
|
|
|
|
// Also allow "\"f:\joe\me\"" ( -> "f:\joe\me )
|
|
|
|
//
|
|
// !! LATER !!
|
|
//
|
|
// Should we allow backslashes here also ?
|
|
// CheckSlashies(pszPath); or add || clause.
|
|
//
|
|
|
|
lpsz = (CHAR_DQUOTE == pszPath[0]) ?
|
|
pszPath+1 :
|
|
pszPath;
|
|
|
|
if (CHAR_COLON == lpsz[1] && CHAR_BACKSLASH == lpsz[2] ||
|
|
lstrlen(pszPath) > (COUNTOF(szPath) - 4) )
|
|
|
|
return;
|
|
|
|
//
|
|
// prepend "..\" to this non absolute path
|
|
//
|
|
lstrcpy(szPath, TEXT("..\\"));
|
|
lstrcat(szPath, pszPath);
|
|
lstrcpy(pszPath, szPath);
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------*/
|
|
// */
|
|
// SuperDlgProc() - */
|
|
// */
|
|
//--------------------------------------------------------------------------*/
|
|
|
|
// This proc handles the Print, Move, Copy, Delete, and Rename functions.
|
|
// The calling routine (AppCommandProc()) sets 'dwSuperDlgMode' before
|
|
// calling DialogBox() to indicate which function is being used.
|
|
|
|
INT
|
|
SuperDlgProc(register HWND hDlg, UINT wMsg, WPARAM wParam, LONG lParam)
|
|
{
|
|
UINT len;
|
|
LPTSTR pszFrom;
|
|
//
|
|
// WFMoveCopyDrive tries to append \*.* to directories and
|
|
// probably other nasty stuff. 2* for safety.
|
|
//
|
|
TCHAR szTo[2*MAXPATHLEN];
|
|
static BOOL bTreeHasFocus;
|
|
|
|
JAPANBEGIN
|
|
TCHAR szStr[256];
|
|
JAPANEND
|
|
|
|
static PCOPYINFO pCopyInfo;
|
|
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
switch (wMsg) {
|
|
case WM_INITDIALOG:
|
|
{
|
|
LPTSTR p;
|
|
HWND hwndActive;
|
|
|
|
pCopyInfo = NULL;
|
|
|
|
SetDlgDirectory(hDlg, NULL);
|
|
|
|
EnableCopy(hDlg, dwSuperDlgMode == IDM_COPY);
|
|
|
|
hwndActive = (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L);
|
|
bTreeHasFocus = (hwndActive != hwndSearch) &&
|
|
(GetTreeFocus(hwndActive) == HasTreeWindow(hwndActive));
|
|
|
|
switch (dwSuperDlgMode) {
|
|
|
|
case IDM_COPY:
|
|
|
|
p = GetSelection(0, NULL);
|
|
|
|
LoadString(hAppInstance, IDS_COPY, szTitle, COUNTOF(szTitle));
|
|
SetWindowText(hDlg, szTitle);
|
|
|
|
if (bJAPAN) {
|
|
|
|
//by yutakas 1992/10/29
|
|
LoadString(hAppInstance, IDS_KK_COPYFROMSTR, szStr, COUNTOF(szStr));
|
|
SetDlgItemText(hDlg, IDD_KK_TEXTFROM, szStr);
|
|
LoadString(hAppInstance, IDS_KK_COPYTOSTR, szStr, COUNTOF(szStr));
|
|
SetDlgItemText(hDlg, IDD_KK_TEXTTO, szStr);
|
|
}
|
|
|
|
break;
|
|
case IDM_RENAME:
|
|
|
|
LoadString(hAppInstance, IDS_RENAME, szTitle, COUNTOF(szTitle));
|
|
SetWindowText(hDlg, szTitle);
|
|
|
|
if (bJAPAN) {
|
|
//by yutakas 1992/10/29
|
|
LoadString(hAppInstance, IDS_KK_RENAMEFROMSTR, szStr, COUNTOF(szStr));
|
|
SetDlgItemText(hDlg, IDD_KK_TEXTFROM, szStr);
|
|
LoadString(hAppInstance, IDS_KK_RENAMETOSTR, szStr, COUNTOF(szStr));
|
|
SetDlgItemText(hDlg, IDD_KK_TEXTTO, szStr);
|
|
}
|
|
|
|
// when renaming the current directory we cd up a level
|
|
// (not really) and apply the appropriate hacks
|
|
|
|
if (bTreeHasFocus) {
|
|
|
|
p = GetSelection(16, NULL);
|
|
lstrcpy(szTo, p);
|
|
StripFilespec(szTo);
|
|
|
|
SetDlgDirectory(hDlg, szTo); // make the user think this!
|
|
StripPath(p); // name part of dir
|
|
|
|
CheckEsc(p);
|
|
} else {
|
|
p = GetSelection(0, NULL);
|
|
}
|
|
|
|
break;
|
|
|
|
case IDM_COPYTOCLIPBOARD:
|
|
|
|
p=GetSelection(1, NULL);
|
|
break;
|
|
|
|
default:
|
|
|
|
p=GetSelection(0, NULL);
|
|
}
|
|
|
|
SetDlgItemText(hDlg, IDD_FROM, p);
|
|
LocalFree((HANDLE)p);
|
|
|
|
if ((dwSuperDlgMode == IDM_PRINT) || (dwSuperDlgMode == IDM_DELETE) ||
|
|
(dwSuperDlgMode == IDM_COPYTOCLIPBOARD))
|
|
|
|
wParam = IDD_FROM;
|
|
else
|
|
wParam = IDD_TO;
|
|
SendDlgItemMessage(hDlg, wParam, EM_LIMITTEXT, COUNTOF(szTo) - 1, 0L);
|
|
|
|
break;
|
|
}
|
|
|
|
case FS_COPYDONE:
|
|
|
|
//
|
|
// Only cancel out if pCopyInfo == lParam
|
|
// This indicates that the proper thread quit.
|
|
//
|
|
// wParam holds return value
|
|
//
|
|
|
|
if (lParam == (LPARAM)pCopyInfo) {
|
|
SPC_SET_HITDISK(qFreeSpace); // force status info refresh
|
|
|
|
EndDialog(hDlg, wParam);
|
|
}
|
|
break;
|
|
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam)) {
|
|
|
|
case IDD_HELP:
|
|
goto DoHelp;
|
|
|
|
case IDCANCEL:
|
|
|
|
if (pCopyInfo)
|
|
pCopyInfo->bUserAbort = TRUE;
|
|
|
|
SuperDlgExit:
|
|
|
|
EndDialog(hDlg, 0);
|
|
break;
|
|
|
|
case IDOK:
|
|
|
|
len = (UINT)(SendDlgItemMessage(hDlg, IDD_FROM, EM_LINELENGTH,
|
|
(WPARAM)-1, 0L) + 1);
|
|
|
|
//
|
|
// make sure the pszFrom buffer is big enough to
|
|
// add the "..\" stuff in MessWithRenameDirPath()
|
|
//
|
|
len += 4;
|
|
|
|
pszFrom = (LPTSTR)LocalAlloc(LPTR, ByteCountOf(len));
|
|
if (!pszFrom)
|
|
goto SuperDlgExit;
|
|
|
|
GetDlgItemText(hDlg, IDD_FROM, pszFrom, len);
|
|
GetDlgItemText(hDlg, IDD_TO, szTo, COUNTOF(szTo));
|
|
|
|
//
|
|
// if dwSuperDlgMode is copy, rename, or move, do checkesc.
|
|
// Only if no quotes in string!
|
|
//
|
|
if ( IDM_COPY == dwSuperDlgMode || IDM_MOVE == dwSuperDlgMode ||
|
|
IDM_RENAME == dwSuperDlgMode) {
|
|
|
|
if (NoQuotes(szTo))
|
|
CheckEsc(szTo);
|
|
}
|
|
|
|
if (dwSuperDlgMode == IDM_COPYTOCLIPBOARD) {
|
|
if (CheckMultiple(pszFrom)) {
|
|
LoadString(hAppInstance, IDS_NOCOPYTOCLIP, szMessage, COUNTOF(szMessage));
|
|
GetWindowText(hDlg, szTitle, COUNTOF(szTitle));
|
|
MessageBox(hDlg, szMessage, szTitle, MB_OK | MB_ICONSTOP);
|
|
} else
|
|
CopyToClipboard(pszFrom);
|
|
|
|
SuperDlgFreeExit:
|
|
|
|
LocalFree(pszFrom);
|
|
goto SuperDlgExit;
|
|
}
|
|
|
|
if (!szTo[0])
|
|
{
|
|
switch (dwSuperDlgMode)
|
|
{
|
|
case IDM_RENAME:
|
|
case IDM_MOVE:
|
|
case IDM_COPY:
|
|
{
|
|
szTo[0] = CHAR_DOT;
|
|
szTo[1] = CHAR_NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
EnableCopy(hDlg, FALSE);
|
|
|
|
hdlgProgress = hDlg;
|
|
if (dwSuperDlgMode == IDM_PRINT) {
|
|
WFPrint(pszFrom);
|
|
|
|
goto SuperDlgFreeExit;
|
|
|
|
} else {
|
|
|
|
if (dwSuperDlgMode == IDM_RENAME && bTreeHasFocus) {
|
|
MessWithRenameDirPath(pszFrom);
|
|
MessWithRenameDirPath(szTo);
|
|
}
|
|
|
|
//
|
|
// Setup pCopyInfo structure
|
|
//
|
|
// Note that everything must be malloc'd!!
|
|
// (Freed by thread)
|
|
//
|
|
|
|
pCopyInfo = (PCOPYINFO) LocalAlloc(LPTR, sizeof(COPYINFO));
|
|
|
|
if (!pCopyInfo) {
|
|
|
|
Error:
|
|
FormatError(TRUE, szMessage, COUNTOF(szMessage), GetLastError());
|
|
LoadString(hAppInstance, IDS_WINFILE, szTitle, COUNTOF(szTitle));
|
|
|
|
MessageBox(hwndFrame, szMessage, szTitle, MB_OK | MB_ICONEXCLAMATION);
|
|
|
|
goto SuperDlgFreeExit;
|
|
}
|
|
|
|
pCopyInfo->pFrom = pszFrom;
|
|
pCopyInfo->pTo = (LPTSTR) LocalAlloc(LMEM_FIXED, sizeof(szTo));
|
|
|
|
if (!pCopyInfo->pTo) {
|
|
|
|
goto Error;
|
|
}
|
|
|
|
pCopyInfo->dwFunc = dwSuperDlgMode-IDM_MOVE+1;
|
|
pCopyInfo->bUserAbort = FALSE;
|
|
|
|
lstrcpy(pCopyInfo->pTo, szTo);
|
|
|
|
//
|
|
// Move/Copy things.
|
|
//
|
|
// HACK: Compute the FUNC_ values from WFCOPY.H
|
|
//
|
|
if (WFMoveCopyDriver(pCopyInfo)) {
|
|
|
|
LoadString(hAppInstance,
|
|
IDS_COPYERROR + pCopyInfo->dwFunc,
|
|
szTitle,
|
|
COUNTOF(szTitle));
|
|
|
|
FormatError(TRUE, szMessage, COUNTOF(szMessage), GetLastError());
|
|
|
|
MessageBox(hDlg, szMessage, szTitle, MB_ICONSTOP|MB_OK);
|
|
|
|
EndDialog(hDlg, GetLastError());
|
|
|
|
} else {
|
|
|
|
//
|
|
// Disable all but the cancel button on the notify dialog
|
|
//
|
|
DialogEnterFileStuff(hdlgProgress);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return(FALSE);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (wMsg == wHelpMessage) {
|
|
DoHelp:
|
|
WFHelp(hDlg);
|
|
|
|
return TRUE;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
CheckAttribsDlgButton(
|
|
HWND hDlg,
|
|
INT id,
|
|
DWORD dwAttribs,
|
|
DWORD dwAttribs3State,
|
|
DWORD dwAttribsOn)
|
|
{
|
|
INT i;
|
|
|
|
if (dwAttribs3State & dwAttribs)
|
|
i = 2;
|
|
else if (dwAttribsOn & dwAttribs)
|
|
i = 1;
|
|
else
|
|
i = 0;
|
|
|
|
CheckDlgButton(hDlg, id, i);
|
|
}
|
|
|
|
// The following data structure associates a version stamp datum
|
|
// name (which is not localized) with a string ID. This is so we
|
|
// can show translations of these names to the user.
|
|
|
|
struct vertbl {
|
|
WCHAR *pszName;
|
|
WORD idString;
|
|
};
|
|
|
|
// Note that version stamp datum names are NEVER internationalized,
|
|
// so the following literal strings are just fine.
|
|
|
|
#define MAX_VERNAMES 10
|
|
struct vertbl vernames[MAX_VERNAMES] = {
|
|
{ L"Comments", IDS_VN_COMMENTS },
|
|
{ L"CompanyName", IDS_VN_COMPANYNAME },
|
|
{ L"FileDescription", IDS_VN_FILEDESCRIPTION },
|
|
{ L"InternalName", IDS_VN_INTERNALNAME },
|
|
{ L"LegalTrademarks", IDS_VN_LEGALTRADEMARKS },
|
|
{ L"OriginalFilename", IDS_VN_ORIGINALFILENAME },
|
|
{ L"PrivateBuild", IDS_VN_PRIVATEBUILD },
|
|
{ L"ProductName", IDS_VN_PRODUCTNAME },
|
|
{ L"ProductVersion", IDS_VN_PRODUCTVERSION },
|
|
{ L"SpecialBuild", IDS_VN_SPECIALBUILD }
|
|
};
|
|
|
|
DWORD dwHandle; // version subsystem handle
|
|
HANDLE hmemVersion=0; // global handle for version data buffer
|
|
LPTSTR lpVersionBuffer; // pointer to version data
|
|
DWORD dwVersionSize; // size of the version data
|
|
TCHAR szVersionKey[60]; // big enough for anything we need
|
|
LPWORD lpXlate; // ptr to translations data
|
|
UINT cXlate; // count of translations
|
|
LPWSTR pszXlate = NULL;
|
|
UINT cchXlateString;
|
|
|
|
#define LANGLEN 45 // characters per language
|
|
|
|
#define VER_KEY_END 25 // length of "\StringFileInfo\xxxx\yyyy" (chars)
|
|
#define VER_BLOCK_OFFSET 24 // to get block size (chars)
|
|
|
|
// (not localized)
|
|
TCHAR szFileVersion[] = TEXT("FileVersion");
|
|
TCHAR szLegalCopyright[] = TEXT("LegalCopyright");
|
|
|
|
WCHAR wszFileVersion[] = L"FileVersion";
|
|
WCHAR wszLegalCopyright[] = L"LegalCopyright";
|
|
|
|
void FreeVersionInfo(void);
|
|
|
|
|
|
// Disables the version controls in a properties dialog. Used for
|
|
// when the selection is a directory and also when a file has no
|
|
// version stamps.
|
|
|
|
VOID
|
|
DisableVersionCtls(HWND hDlg)
|
|
{
|
|
EnableWindow(GetDlgItem(hDlg, IDD_VERSION_FRAME), FALSE);
|
|
EnableWindow(GetDlgItem(hDlg, IDD_VERSION_KEY), FALSE);
|
|
EnableWindow(GetDlgItem(hDlg, IDD_VERSION_VALUE), FALSE);
|
|
}
|
|
|
|
|
|
// Gets a particular datum about a file. The file's version info
|
|
// should have already been loaded by GetVersionInfo. If no datum
|
|
// by the specified name is available, NULL is returned. The name
|
|
// specified should be just the name of the item itself; it will
|
|
// be concatenated onto "\StringFileInfo\xxxxyyyy\" automatically.
|
|
|
|
// Version datum names are not localized, so it's OK to pass literals
|
|
// such as "FileVersion" to this function.
|
|
|
|
LPTSTR
|
|
GetVersionDatum(LPTSTR pszName)
|
|
{
|
|
DWORD cbValue=0;
|
|
LPTSTR lpValue;
|
|
|
|
if (!hmemVersion)
|
|
return NULL;
|
|
|
|
lstrcpy(szVersionKey + VER_KEY_END, pszName);
|
|
|
|
VerQueryValueW(lpVersionBuffer, szVersionKey, (LPVOID*)&lpValue, &cbValue);
|
|
|
|
return (cbValue != 0) ? lpValue : NULL;
|
|
}
|
|
|
|
// Initialize version information for the properties dialog. The
|
|
// above global variables are initialized by this function, and
|
|
// remain valid (for the specified file only) until FreeVersionInfo
|
|
// is called.
|
|
|
|
// Try in the following order
|
|
//
|
|
// 1. Current language winfile is running in.
|
|
// 2. English, 0409 codepage
|
|
// 3. English, 0000 codepage
|
|
// 4. First translation in resource
|
|
// "\VarFileInfo\Translations" section
|
|
|
|
// GetVersionInfo returns LPTSTR if the version info was read OK,
|
|
// otherwise NULL. If the return is NULL, the buffer may still
|
|
// have been allocated; always call FreeVersionInfo to be safe.
|
|
//
|
|
// pszPath is modified by this call (pszName is appended).
|
|
//
|
|
// Note, Codepage is bogus, since everything is really in unicode.
|
|
// Note, Language is bogus, since FindResourceEx takes a langauge already...
|
|
|
|
|
|
LPTSTR
|
|
GetVersionInfo(PTSTR pszPath, PTSTR pszName)
|
|
{
|
|
DWORD cbValue=0;
|
|
DWORD cbValueTranslation=0;
|
|
LPTSTR lpszValue=NULL;
|
|
|
|
static bDLLFail = FALSE;
|
|
|
|
if (!hVersion) {
|
|
|
|
hVersion = LoadLibrary(VERSION_DLL);
|
|
|
|
if (!hVersion) {
|
|
bDLLFail = TRUE;
|
|
return NULL;
|
|
}
|
|
|
|
#define GET_PROC(x) \
|
|
if (!(lpfn##x = (PVOID) GetProcAddress(hVersion,VERSION_##x))) {\
|
|
bDLLFail = TRUE; \
|
|
return NULL; }
|
|
|
|
GET_PROC(GetFileVersionInfoW);
|
|
GET_PROC(GetFileVersionInfoSizeW);
|
|
GET_PROC(VerQueryValueW);
|
|
GET_PROC(VerQueryValueIndexW);
|
|
}
|
|
|
|
if (bDLLFail)
|
|
return NULL;
|
|
|
|
#undef GET_PROC
|
|
|
|
//
|
|
// Just in case, free old version buffer.
|
|
//
|
|
if (hmemVersion)
|
|
FreeVersionInfo();
|
|
|
|
AddBackslash(pszPath);
|
|
|
|
// pszPath = fully qualified name
|
|
lstrcat(pszPath, pszName);
|
|
|
|
dwVersionSize = GetFileVersionInfoSizeW(pszPath, &dwHandle);
|
|
|
|
if (dwVersionSize == 0L)
|
|
// no version info
|
|
return NULL;
|
|
|
|
//
|
|
// The value returned from GetFileVersionInfoSize is actually
|
|
// a byte count.
|
|
//
|
|
hmemVersion = GlobalAlloc(GPTR, dwVersionSize);
|
|
if (hmemVersion == NULL)
|
|
// can't get memory for version info, blow out
|
|
return NULL;
|
|
|
|
lpVersionBuffer = GlobalLock(hmemVersion);
|
|
|
|
//
|
|
// If we fail, just return NULL. hmemVersion will be freed the next
|
|
// time we do a version call.
|
|
//
|
|
if (!GetFileVersionInfoW(pszPath, dwHandle, dwVersionSize, lpVersionBuffer))
|
|
return NULL;
|
|
|
|
//
|
|
// We must always get the translation since we want to display
|
|
// all the languages anyway.
|
|
//
|
|
VerQueryValue(lpVersionBuffer, TEXT("\\VarFileInfo\\Translation"),
|
|
(LPVOID*)&lpXlate, &cbValueTranslation);
|
|
|
|
if (cbValueTranslation != 0) {
|
|
|
|
//
|
|
// We found some translations above; use the first one.
|
|
//
|
|
cXlate = cbValueTranslation / sizeof(DWORD);
|
|
|
|
//
|
|
// figure 45 LANGLEN chars per lang name
|
|
//
|
|
cchXlateString = cXlate * LANGLEN;
|
|
pszXlate = (LPWSTR)LocalAlloc(LPTR, ByteCountOf(cchXlateString));
|
|
|
|
} else {
|
|
lpXlate = NULL;
|
|
}
|
|
|
|
//
|
|
// First try the language we are currently in.
|
|
//
|
|
wsprintf(szVersionKey, TEXT("\\StringFileInfo\\%04X04B0\\"),
|
|
LANGIDFROMLCID(lcid));
|
|
|
|
lpszValue = GetVersionDatum(szFileVersion);
|
|
|
|
if (lpszValue != NULL)
|
|
return lpszValue;
|
|
|
|
//
|
|
// Now try the first translation
|
|
//
|
|
if (cbValueTranslation != 0) {
|
|
|
|
wsprintf(szVersionKey, TEXT("\\StringFileInfo\\%04X%04X\\"),
|
|
*lpXlate, *(lpXlate+1));
|
|
|
|
//
|
|
// a required field
|
|
//
|
|
lpszValue = GetVersionDatum(szFileVersion);
|
|
|
|
if (lpszValue != NULL) {
|
|
|
|
//
|
|
// localized key found version data
|
|
//
|
|
return lpszValue;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Now try the english, unicode
|
|
//
|
|
lstrcpy(szVersionKey, TEXT("\\StringFileInfo\\040904B0\\"));
|
|
lpszValue = GetVersionDatum(szFileVersion);
|
|
|
|
if (lpszValue != NULL)
|
|
return lpszValue;
|
|
|
|
|
|
//
|
|
// Try english with various code pages
|
|
// (04E4) here
|
|
//
|
|
lstrcpy(szVersionKey, TEXT("\\StringFileInfo\\040904E4\\"));
|
|
lpszValue = GetVersionDatum(szFileVersion);
|
|
|
|
if (lpszValue != NULL)
|
|
return lpszValue; // localized key found version data
|
|
|
|
|
|
//
|
|
// Try english with various code pages
|
|
// (0000) here
|
|
//
|
|
lstrcpy(szVersionKey, TEXT("\\StringFileInfo\\04090000\\"));
|
|
lpszValue = GetVersionDatum(szFileVersion);
|
|
|
|
return lpszValue;
|
|
}
|
|
|
|
// Frees global version data about a file. After this call, all
|
|
// GetVersionDatum calls will return NULL. To avoid memory leaks,
|
|
// always call this before the main properties dialog exits.
|
|
|
|
VOID
|
|
FreeVersionInfo(VOID)
|
|
{
|
|
lpVersionBuffer = NULL;
|
|
dwHandle = 0L;
|
|
if (hmemVersion) {
|
|
GlobalUnlock(hmemVersion);
|
|
GlobalFree(hmemVersion);
|
|
hmemVersion = 0;
|
|
}
|
|
if (pszXlate) {
|
|
LocalFree((HANDLE)pszXlate);
|
|
pszXlate = NULL;
|
|
}
|
|
}
|
|
|
|
// Looks for version information on the file. If none is found,
|
|
// leaves the version number label as-is ("Not marked"). The
|
|
// specific datum displayed is "FileVersion" from the "StringFileInfo"
|
|
// block.
|
|
|
|
// Returns TRUE if the file has version stamp information.
|
|
|
|
BOOL
|
|
FillSimpleVersion(HWND hDlg, LPTSTR lpszValue)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
if (lpszValue != NULL)
|
|
SetDlgItemText(hDlg, IDD_VERSION, lpszValue);
|
|
else {
|
|
DisableVersionCtls(hDlg);
|
|
bRet = FALSE;
|
|
}
|
|
|
|
lpszValue = GetVersionDatum(szLegalCopyright);
|
|
|
|
if (lpszValue != NULL)
|
|
SetDlgItemText(hDlg, IDD_COPYRIGHT, lpszValue);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
// Fills the version key listbox with all available keys in the
|
|
// StringFileInfo block, and sets the version value text to the
|
|
// value of the first item.
|
|
|
|
|
|
VOID
|
|
FillVersionList(HWND hDlg)
|
|
{
|
|
LPTSTR lpszKey, lpszValue;
|
|
|
|
DWORD cbValue;
|
|
UINT i, j, cchOffset;
|
|
INT idx;
|
|
HWND hwndLB;
|
|
|
|
hwndLB = GetDlgItem(hDlg, IDD_VERSION_KEY);
|
|
|
|
szVersionKey[VER_KEY_END - 1] = CHAR_NULL; // strip the backslash
|
|
|
|
for (j=0; VerQueryValueIndexW(lpVersionBuffer,
|
|
szVersionKey,
|
|
j,
|
|
&lpszKey,
|
|
&lpszValue,
|
|
&cbValue); j++) {
|
|
|
|
if (!lstrcmp(lpszKey, szFileVersion) ||
|
|
!lstrcmp(lpszKey, szLegalCopyright)) {
|
|
|
|
continue;
|
|
}
|
|
|
|
for (i=0; i<MAX_VERNAMES; i++)
|
|
if (!lstrcmp(vernames[i].pszName, lpszKey))
|
|
break;
|
|
|
|
if (i != MAX_VERNAMES && LoadString(hAppInstance, vernames[i].idString, szMessage, COUNTOF(szMessage)))
|
|
lpszKey=szMessage;
|
|
|
|
idx = (INT)SendMessage(hwndLB, LB_ADDSTRING, 0, (LPARAM)lpszKey);
|
|
|
|
//
|
|
// Only add if the value len isn't zero.
|
|
// This is checked in the SendMessage 4th parm.
|
|
//
|
|
if (idx != LB_ERR)
|
|
SendMessage(hwndLB, LB_SETITEMDATA, idx, (LPARAM)lpszValue);
|
|
}
|
|
|
|
//
|
|
// Now look at the \VarFileInfo\Translations section and add an
|
|
// item for the language(s) this file supports.
|
|
//
|
|
|
|
if (lpXlate == NULL || pszXlate == NULL)
|
|
goto Done;
|
|
|
|
if (!LoadString(hAppInstance, (cXlate == 1) ? IDS_VN_LANGUAGE : IDS_VN_LANGUAGES,
|
|
szMessage, COUNTOF(szMessage)))
|
|
|
|
goto Done;
|
|
|
|
idx = SendMessage(hwndLB, LB_ADDSTRING, 0, (LPARAM)szMessage);
|
|
if (idx == LB_ERR)
|
|
goto Done;
|
|
|
|
pszXlate[0] = CHAR_NULL;
|
|
cchOffset = 0;
|
|
for (i=0; i<cXlate; i++) {
|
|
if (cchOffset + 2 > cchXlateString)
|
|
break;
|
|
if (i != 0) {
|
|
lstrcat(pszXlate, TEXT(", "));
|
|
cchOffset += 2;
|
|
}
|
|
|
|
if (VerLanguageName(lpXlate[i*2],
|
|
pszXlate+cchOffset,
|
|
cchXlateString-cchOffset
|
|
) > cchXlateString - cchOffset)
|
|
|
|
break;
|
|
|
|
cchOffset += lstrlen(pszXlate+cchOffset);
|
|
}
|
|
pszXlate[cchXlateString-1] = CHAR_NULL;
|
|
|
|
SendMessage(hwndLB, LB_SETITEMDATA, idx, (LPARAM)pszXlate);
|
|
|
|
Done:
|
|
|
|
SendMessage(hwndLB, LB_SETCURSEL, 0, 0L);
|
|
PostMessage(hDlg, WM_COMMAND, GET_WM_COMMAND_MPS(IDD_VERSION_KEY, NULL, LBN_SELCHANGE));
|
|
}
|
|
|
|
|
|
INT
|
|
InitPropertiesDialog(
|
|
HWND hDlg)
|
|
{
|
|
HWND hwndLB, hwndActive, hwndTree;
|
|
LPXDTA lpxdta;
|
|
DWORD dwAttribsOn, dwAttribs3State, dwAttribsLast;
|
|
HWND hwndDir, hwnd, hwndView;
|
|
WCHAR szName[MAXPATHLEN];
|
|
WCHAR szPath[MAXPATHLEN];
|
|
WCHAR szTemp[MAXPATHLEN + 20];
|
|
WCHAR szBuf[MAXPATHLEN];
|
|
WCHAR szNum[MAXPATHLEN];
|
|
INT i, iMac, iCount, dyButton;
|
|
RECT rc, rcT;
|
|
DWORD dwAttrib;
|
|
FILETIME ftLastWrite;
|
|
LFNDTA lfndta;
|
|
LPTSTR p;
|
|
HFONT hFont;
|
|
INT nType = 0;
|
|
DWORD dwFlags;
|
|
BOOL bFileCompression = FALSE;
|
|
|
|
LPTSTR lpszBuf;
|
|
LARGE_INTEGER qSize, qCSize;
|
|
|
|
LARGE_INTEGER_NULL(qSize);
|
|
LARGE_INTEGER_NULL(qCSize);
|
|
|
|
//
|
|
// this is needed for relative findfirst calls below
|
|
//
|
|
SetWindowDirectory();
|
|
|
|
hwndActive = (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L);
|
|
hwndDir = HasDirWindow(hwndActive);
|
|
hwndTree = HasTreeWindow(hwndActive);
|
|
|
|
if (GetVolumeInformation(NULL, NULL, 0L, NULL, NULL, &dwFlags, NULL, 0L))
|
|
{
|
|
bFileCompression = ((dwFlags & FS_FILE_COMPRESSION) == FS_FILE_COMPRESSION);
|
|
}
|
|
|
|
iCount = 0;
|
|
dwAttribsOn = 0; // all bits to check
|
|
dwAttribs3State = 0; // all bits to 3 state
|
|
dwAttribsLast = 0xFFFF; // previous bits
|
|
|
|
if (hwndTree && hwndTree == GetTreeFocus(hwndActive)) {
|
|
|
|
SendMessage(hwndActive, FS_GETDIRECTORY, COUNTOF(szPath), (LPARAM)szPath);
|
|
StripBackslash(szPath);
|
|
|
|
if (!WFFindFirst(&lfndta, szPath, ATTR_ALL | ATTR_DIR)) {
|
|
LoadString(hAppInstance, IDS_ATTRIBERR, szMessage, COUNTOF(szMessage));
|
|
FormatError(FALSE, szMessage, COUNTOF(szMessage), ERROR_FILE_NOT_FOUND);
|
|
|
|
//
|
|
// BUGBUG: szPath should be set to "Properties for %s"!
|
|
//
|
|
MessageBox(hwndFrame, szMessage, szPath, MB_OK | MB_ICONSTOP);
|
|
EndDialog(hDlg, FALSE);
|
|
return 0;
|
|
}
|
|
WFFindClose(&lfndta);
|
|
|
|
dwAttribsOn = lfndta.fd.dwFileAttributes;
|
|
ftLastWrite = lfndta.fd.ftLastWriteTime;
|
|
|
|
lstrcpy(szName, szPath);
|
|
|
|
goto FullPath;
|
|
}
|
|
|
|
if (hwndDir) {
|
|
hwndLB = GetDlgItem(hwndDir, IDCW_LISTBOX);
|
|
hwndView = hwndDir;
|
|
} else {
|
|
hwndLB = GetDlgItem(hwndActive, IDCW_LISTBOX);
|
|
hwndView = hwndActive;
|
|
}
|
|
|
|
iMac = SendMessage(hwndLB, LB_GETCOUNT, 0, 0L);
|
|
|
|
szPath[0] = CHAR_NULL;
|
|
szName[0] = CHAR_NULL;
|
|
|
|
for (i = 0; i < iMac; i++) {
|
|
|
|
if (SendMessage(hwndLB, LB_GETSEL, i, 0L)) {
|
|
|
|
//
|
|
// get info from either dir or search window
|
|
//
|
|
SendMessage(hwndLB, LB_GETTEXT, i, (LPARAM)&lpxdta);
|
|
dwAttrib = lpxdta->dwAttrs;
|
|
|
|
//
|
|
// Check that this is not the .. entry
|
|
//
|
|
if (dwAttrib & ATTR_DIR && dwAttrib & ATTR_PARENT)
|
|
continue;
|
|
|
|
qSize.QuadPart = qSize.QuadPart + (lpxdta->qFileSize).QuadPart;
|
|
|
|
if (!szName[0]) {
|
|
|
|
ftLastWrite = lpxdta->ftLastWriteTime;
|
|
lstrcpy(szName, MemGetFileName(lpxdta));
|
|
}
|
|
|
|
dwAttribsOn |= dwAttrib;
|
|
|
|
if (dwAttribsLast == 0xFFFF) {
|
|
|
|
//
|
|
// save the previous bits for future compares
|
|
//
|
|
dwAttribsLast = dwAttrib;
|
|
|
|
} else {
|
|
|
|
//
|
|
// remember all bits that don't compare to last bits
|
|
//
|
|
dwAttribs3State |= (dwAttrib ^ dwAttribsLast);
|
|
}
|
|
|
|
iCount++;
|
|
}
|
|
}
|
|
|
|
GetDlgItemText(hDlg, IDD_TEXT1, szTemp, COUNTOF(szTemp));
|
|
wsprintf(szBuf, szTemp, iCount);
|
|
SetDlgItemText(hDlg, IDD_TEXT1, szBuf);
|
|
|
|
GetDlgItemText(hDlg, IDD_TEXT2, szTemp, COUNTOF(szTemp));
|
|
PutSize(&qSize, szNum);
|
|
wsprintf(szBuf, szTemp, szNum);
|
|
SetDlgItemText(hDlg, IDD_TEXT2, szBuf);
|
|
|
|
if (iCount == 1)
|
|
{
|
|
if (hwndDir)
|
|
{
|
|
SendMessage(hwndDir, FS_GETDIRECTORY, COUNTOF(szPath), (LPARAM)szPath);
|
|
}
|
|
else
|
|
{
|
|
lstrcpy(szPath, szName);
|
|
FullPath:
|
|
StripPath(szName);
|
|
StripFilespec(szPath);
|
|
}
|
|
|
|
StripBackslash(szPath);
|
|
|
|
GetWindowText(hDlg, szTitle, COUNTOF(szTitle));
|
|
wsprintf(szTemp, szTitle, szName);
|
|
SetWindowText(hDlg, szTemp);
|
|
|
|
SetDlgItemText(hDlg, IDD_NAME, szName);
|
|
SetDlgItemText(hDlg, IDD_DIR, szPath);
|
|
|
|
if (dwAttribsOn & ATTR_DIR)
|
|
{
|
|
//
|
|
// Hide size, ratio, and version info.
|
|
//
|
|
if (LoadString(hAppInstance, IDS_DIRNAMELABEL, szTemp, COUNTOF(szTemp)))
|
|
SetDlgItemText(hDlg, IDD_NAMELABEL, szTemp);
|
|
|
|
ShowWindow(GetDlgItem(hDlg, IDD_SIZELABEL), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hDlg, IDD_SIZE), SW_HIDE);
|
|
|
|
ShowWindow(GetDlgItem(hDlg, IDD_CSIZELABEL), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hDlg, IDD_CSIZE), SW_HIDE);
|
|
|
|
ShowWindow(GetDlgItem(hDlg, IDD_CRATIOLABEL), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hDlg, IDD_CRATIO), SW_HIDE);
|
|
}
|
|
else
|
|
{
|
|
if ((bFileCompression) && (dwAttribsOn & ATTR_COMPRESSED))
|
|
{
|
|
qCSize.LowPart = GetCompressedFileSize(szName, &(qCSize.HighPart));
|
|
PutSize(&qCSize, szNum);
|
|
wsprintf(szTemp, szSBytes, szNum);
|
|
SetDlgItemText(hDlg, IDD_CSIZE, szTemp);
|
|
|
|
if (qSize.QuadPart != 0)
|
|
{
|
|
//
|
|
// Ratio = 100 - ((CompressSize * 100) / FileSize)
|
|
//
|
|
qCSize.QuadPart =
|
|
RtlExtendedIntegerMultiply(qCSize, 100).QuadPart /
|
|
qSize.QuadPart;
|
|
|
|
if (qCSize.HighPart || (qCSize.LowPart > 100))
|
|
{
|
|
//
|
|
// Ratio = 100%
|
|
//
|
|
qCSize.LowPart = 100;
|
|
qCSize.HighPart = 0;
|
|
}
|
|
else
|
|
{
|
|
qCSize.LowPart = 100 - qCSize.LowPart;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Ratio = 0%
|
|
//
|
|
qCSize.LowPart = 0;
|
|
qCSize.HighPart = 0;
|
|
}
|
|
PutSize(&qCSize, szNum);
|
|
wsprintf(szTemp, TEXT("%s%%"), szNum);
|
|
SetDlgItemText(hDlg, IDD_CRATIO, szTemp);
|
|
}
|
|
else
|
|
{
|
|
ShowWindow(GetDlgItem(hDlg, IDD_CSIZELABEL), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hDlg, IDD_CSIZE), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hDlg, IDD_CRATIOLABEL), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hDlg, IDD_CRATIO), SW_HIDE);
|
|
}
|
|
|
|
PostMessage(hDlg, FS_CHANGEDISPLAY, 0, 0L);
|
|
|
|
// changes szPath
|
|
lpszBuf = GetVersionInfo(szPath, szName);
|
|
|
|
if (FillSimpleVersion(hDlg, lpszBuf))
|
|
FillVersionList(hDlg);
|
|
}
|
|
|
|
if (!bFileCompression)
|
|
{
|
|
ShowWindow(GetDlgItem(hDlg, IDD_COMPRESSED), SW_HIDE);
|
|
}
|
|
|
|
PutSize(&qSize, szNum);
|
|
wsprintf(szTemp, szSBytes, szNum);
|
|
SetDlgItemText(hDlg, IDD_SIZE, szTemp);
|
|
|
|
PutDate(&ftLastWrite, szTemp);
|
|
lstrcat(szTemp, TEXT(" "));
|
|
PutTime(&ftLastWrite, szTemp + lstrlen(szTemp));
|
|
|
|
SetDlgItemText(hDlg, IDD_DATE, szTemp);
|
|
}
|
|
else
|
|
{
|
|
dwContext = IDH_GROUP_ATTRIBS;
|
|
|
|
if (!bFileCompression)
|
|
{
|
|
ShowWindow(GetDlgItem(hDlg, IDD_COMPRESSED), SW_HIDE);
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// add the network specific property buttons
|
|
//
|
|
if (WNetStat(NS_PROPERTYDLG)) {
|
|
GetWindowRect(GetDlgItem(hDlg,IDOK), &rcT);
|
|
GetWindowRect(GetDlgItem(hDlg,IDCANCEL), &rc);
|
|
dyButton = rc.top - rcT.top;
|
|
|
|
GetWindowRect(GetDlgItem(hDlg,IDD_HELP), &rc);
|
|
ScreenToClient(hDlg,(LPPOINT)&rc.left);
|
|
ScreenToClient(hDlg,(LPPOINT)&rc.right);
|
|
|
|
p = GetSelection(4, NULL);
|
|
if (p) {
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
|
|
if (iCount > 1)
|
|
nType = WNPS_MULT;
|
|
else if (dwAttribsOn & ATTR_DIR)
|
|
nType = WNPS_DIR;
|
|
else
|
|
nType = WNPS_FILE;
|
|
|
|
if (WNetGetPropertyText((WORD)i, (WORD)nType, p, szTemp, 30, WNTYPE_FILE) != WN_SUCCESS)
|
|
break;
|
|
|
|
if (!szTemp[0])
|
|
break;
|
|
|
|
OffsetRect(&rc,0,dyButton);
|
|
hwnd = CreateWindowEx(0L, TEXT("button"), szTemp,
|
|
WS_VISIBLE|WS_CHILD|WS_TABSTOP|BS_PUSHBUTTON,
|
|
rc.left, rc.top,
|
|
rc.right - rc.left, rc.bottom-rc.top,
|
|
hDlg, (HMENU)(i + IDD_NETWORKFIRST), hAppInstance, NULL);
|
|
|
|
if (hwnd) {
|
|
hFont = (HFONT)SendDlgItemMessage(hDlg, IDOK, WM_GETFONT, 0, 0L);
|
|
SendMessage(hwnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
|
|
}
|
|
}
|
|
|
|
LocalFree((HANDLE)p);
|
|
|
|
ClientToScreen(hDlg,(LPPOINT)&rc.left);
|
|
ClientToScreen(hDlg,(LPPOINT)&rc.right);
|
|
GetWindowRect(hDlg,&rcT);
|
|
rc.bottom += dyButton;
|
|
if (rcT.bottom <= rc.bottom) {
|
|
SetWindowPos(hDlg,NULL,0,0,rcT.right-rcT.left,
|
|
rc.bottom - rcT.top, SWP_NOMOVE|SWP_NOZORDER);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// change those that don't need to be 3state to regular
|
|
//
|
|
if (ATTR_READONLY & dwAttribs3State)
|
|
{
|
|
SetWindowLong( GetDlgItem(hDlg, IDD_READONLY),
|
|
GWL_STYLE,
|
|
WS_VISIBLE | WS_GROUP | WS_TABSTOP | BS_AUTO3STATE | WS_CHILD );
|
|
}
|
|
if (ATTR_HIDDEN & dwAttribs3State)
|
|
{
|
|
SetWindowLong( GetDlgItem(hDlg, IDD_HIDDEN),
|
|
GWL_STYLE,
|
|
WS_VISIBLE | BS_AUTO3STATE | WS_CHILD);
|
|
}
|
|
if (ATTR_ARCHIVE & dwAttribs3State)
|
|
{
|
|
SetWindowLong( GetDlgItem(hDlg, IDD_ARCHIVE),
|
|
GWL_STYLE,
|
|
WS_VISIBLE | BS_AUTO3STATE | WS_CHILD);
|
|
}
|
|
if (ATTR_SYSTEM & dwAttribs3State)
|
|
{
|
|
SetWindowLong( GetDlgItem(hDlg, IDD_SYSTEM),
|
|
GWL_STYLE,
|
|
WS_VISIBLE | BS_AUTO3STATE | WS_CHILD);
|
|
}
|
|
if (ATTR_COMPRESSED & dwAttribs3State)
|
|
{
|
|
SetWindowLong( GetDlgItem(hDlg, IDD_COMPRESSED),
|
|
GWL_STYLE,
|
|
WS_VISIBLE | BS_AUTO3STATE | WS_CHILD);
|
|
}
|
|
|
|
CheckAttribsDlgButton(hDlg, IDD_READONLY, ATTR_READONLY, dwAttribs3State, dwAttribsOn);
|
|
CheckAttribsDlgButton(hDlg, IDD_HIDDEN, ATTR_HIDDEN, dwAttribs3State, dwAttribsOn);
|
|
CheckAttribsDlgButton(hDlg, IDD_ARCHIVE, ATTR_ARCHIVE, dwAttribs3State, dwAttribsOn);
|
|
CheckAttribsDlgButton(hDlg, IDD_SYSTEM, ATTR_SYSTEM, dwAttribs3State, dwAttribsOn);
|
|
CheckAttribsDlgButton(hDlg, IDD_COMPRESSED, ATTR_COMPRESSED, dwAttribs3State, dwAttribsOn);
|
|
|
|
return nType;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* AttribsDlgProc() - */
|
|
/* */
|
|
// assumes the active MDI child has a directory window
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
INT
|
|
AttribsDlgProc(register HWND hDlg, UINT wMsg, WPARAM wParam, LONG lParam)
|
|
{
|
|
LPTSTR p, pSel;
|
|
BOOL bRet;
|
|
HCURSOR hCursor;
|
|
DWORD dwAttribsNew, dwAttribs, dwChangeMask;
|
|
UINT state;
|
|
TCHAR szName[MAXPATHLEN];
|
|
TCHAR szTemp[MAXPATHLEN];
|
|
static INT nType;
|
|
LPWSTR lpszValue;
|
|
INT idx;
|
|
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
switch (wMsg) {
|
|
|
|
case WM_INITDIALOG:
|
|
|
|
WAITNET();
|
|
|
|
nType = InitPropertiesDialog(hDlg);
|
|
break;
|
|
|
|
case FS_CHANGEDISPLAY:
|
|
{
|
|
// Private message to make the version edit control and
|
|
// listbox line up properly. Yes, a pain, but this is the
|
|
// easiest way to do it...
|
|
|
|
RECT rcVersionKey;
|
|
RECT rcVersionValue;
|
|
|
|
GetWindowRect(GetDlgItem(hDlg, IDD_VERSION_KEY), &rcVersionKey);
|
|
ScreenToClient(hDlg, (POINT FAR *) &rcVersionKey.left);
|
|
ScreenToClient(hDlg, (POINT FAR *) &rcVersionKey.right);
|
|
|
|
GetWindowRect(GetDlgItem(hDlg, IDD_VERSION_VALUE), &rcVersionValue);
|
|
ScreenToClient(hDlg, (POINT FAR *) &rcVersionValue.left);
|
|
ScreenToClient(hDlg, (POINT FAR *) &rcVersionValue.right);
|
|
|
|
SetWindowPos(GetDlgItem(hDlg, IDD_VERSION_VALUE),
|
|
0,
|
|
rcVersionValue.left, rcVersionKey.top,
|
|
rcVersionValue.right - rcVersionValue.left,
|
|
rcVersionKey.bottom-rcVersionKey.top,
|
|
SWP_NOACTIVATE | SWP_NOZORDER);
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam)) {
|
|
case IDD_HELP:
|
|
goto DoHelp;
|
|
|
|
case IDD_NETWORKFIRST+0:
|
|
case IDD_NETWORKFIRST+1:
|
|
case IDD_NETWORKFIRST+2:
|
|
case IDD_NETWORKFIRST+3:
|
|
case IDD_NETWORKFIRST+4:
|
|
case IDD_NETWORKFIRST+5:
|
|
|
|
p = GetSelection(4|1|16, NULL);
|
|
if (p) {
|
|
|
|
WAITNET();
|
|
|
|
if (WAITNET_LOADED) {
|
|
WNetPropertyDialog(hDlg,
|
|
(WORD)(GET_WM_COMMAND_ID(wParam, lParam)-IDD_NETWORKFIRST),
|
|
(WORD)nType, p, WNTYPE_FILE);
|
|
}
|
|
|
|
LocalFree((HANDLE)p);
|
|
}
|
|
break;
|
|
|
|
case IDD_VERSION_KEY:
|
|
|
|
if (GET_WM_COMMAND_CMD(wParam,lParam) != LBN_SELCHANGE)
|
|
break;
|
|
idx = (INT)SendDlgItemMessage(hDlg, IDD_VERSION_KEY, LB_GETCURSEL, 0, 0L);
|
|
lpszValue = (LPTSTR)SendDlgItemMessage(hDlg, IDD_VERSION_KEY, LB_GETITEMDATA, idx, 0L);
|
|
|
|
SetDlgItemText(hDlg, IDD_VERSION_VALUE, lpszValue);
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
|
|
FreeVersionInfo();
|
|
EndDialog(hDlg, FALSE);
|
|
break;
|
|
|
|
case IDOK:
|
|
{
|
|
BOOL bIgnoreAll = FALSE;
|
|
|
|
bRet = TRUE;
|
|
dwChangeMask = ATTR_READWRITE;
|
|
dwAttribsNew = ATTR_READWRITE;
|
|
|
|
if ((state = IsDlgButtonChecked(hDlg, IDD_READONLY)) < 2)
|
|
{
|
|
dwChangeMask |= ATTR_READONLY;
|
|
if (state == 1)
|
|
{
|
|
dwAttribsNew |= ATTR_READONLY;
|
|
}
|
|
}
|
|
|
|
if ((state = IsDlgButtonChecked(hDlg, IDD_HIDDEN)) < 2)
|
|
{
|
|
dwChangeMask |= ATTR_HIDDEN;
|
|
if (state == 1)
|
|
{
|
|
dwAttribsNew |= ATTR_HIDDEN;
|
|
}
|
|
}
|
|
|
|
if ((state = IsDlgButtonChecked(hDlg, IDD_ARCHIVE)) < 2)
|
|
{
|
|
dwChangeMask |= ATTR_ARCHIVE;
|
|
if (state == 1)
|
|
{
|
|
dwAttribsNew |= ATTR_ARCHIVE;
|
|
}
|
|
}
|
|
|
|
if ((state = IsDlgButtonChecked(hDlg, IDD_SYSTEM)) < 2)
|
|
{
|
|
dwChangeMask |= ATTR_SYSTEM;
|
|
if (state == 1)
|
|
{
|
|
dwAttribsNew |= ATTR_SYSTEM;
|
|
}
|
|
}
|
|
|
|
if ((state = IsDlgButtonChecked(hDlg, IDD_COMPRESSED)) < 2)
|
|
{
|
|
dwChangeMask |= ATTR_COMPRESSED;
|
|
if (state == 1)
|
|
{
|
|
dwAttribsNew |= ATTR_COMPRESSED;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Free old version buffer
|
|
// (Ok to call even if no version info present.)
|
|
//
|
|
FreeVersionInfo();
|
|
EndDialog(hDlg, bRet);
|
|
|
|
pSel = GetSelection(0, NULL);
|
|
|
|
if (!pSel)
|
|
break;
|
|
|
|
hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
ShowCursor(TRUE);
|
|
|
|
SendMessage(hwndFrame, FS_DISABLEFSC, 0, 0L);
|
|
|
|
p = pSel;
|
|
|
|
while (p = GetNextFile(p, szName, COUNTOF(szName))) {
|
|
|
|
QualifyPath(szName);
|
|
|
|
dwAttribs = GetFileAttributes(szName);
|
|
|
|
if (dwAttribs & 0x8000) // BUG hardcoded!
|
|
goto AttributeError;
|
|
else
|
|
dwAttribs &= ~ATTR_DIR;
|
|
|
|
//
|
|
// Only try and change the attributes if we need to change
|
|
// attributes.
|
|
//
|
|
if ((dwAttribs ^ dwAttribsNew) & dwChangeMask)
|
|
{
|
|
dwAttribs = (dwChangeMask & dwAttribsNew) | (~dwChangeMask & dwAttribs);
|
|
|
|
//
|
|
// Process the IDD_COMPRESSED attribute setting and then
|
|
// set the attributes on the file or directory.
|
|
//
|
|
lstrcpy(szTemp, szName);
|
|
if (!WFCheckCompress(hDlg, szTemp, dwAttribs, TRUE, &bIgnoreAll))
|
|
{
|
|
//
|
|
// WFCheckCompress will only be FALSE if the user
|
|
// chooses to Abort the compression.
|
|
//
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
if (WFSetAttr(szName, dwAttribs))
|
|
{
|
|
AttributeError:
|
|
GetWindowText(hDlg, szTitle, COUNTOF(szTitle));
|
|
LoadString(hAppInstance, IDS_ATTRIBERR, szMessage, COUNTOF(szMessage));
|
|
|
|
FormatError(FALSE, szMessage, COUNTOF(szMessage), GetLastError());
|
|
MessageBox(hwndFrame, szMessage, szTitle, MB_OK | MB_ICONSTOP);
|
|
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Clear all the FSC messages from the message queue.
|
|
//
|
|
wfYield();
|
|
}
|
|
|
|
SendMessage(hwndFrame, FS_ENABLEFSC, 0, 0L);
|
|
|
|
ShowCursor(FALSE);
|
|
SetCursor(hCursor);
|
|
|
|
LocalFree((HANDLE)pSel);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
if (wMsg == wHelpMessage) {
|
|
DoHelp:
|
|
WFHelp(hDlg);
|
|
|
|
return TRUE;
|
|
} else
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* MakeDirDlgProc() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
INT
|
|
MakeDirDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LONG lParam)
|
|
{
|
|
//
|
|
// Must be at least MAXPATHLEN
|
|
//
|
|
TCHAR szPath[MAXPATHLEN*2];
|
|
INT ret;
|
|
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
switch (wMsg) {
|
|
case WM_INITDIALOG:
|
|
SetDlgDirectory(hDlg, NULL);
|
|
SendDlgItemMessage(hDlg, IDD_NAME, EM_LIMITTEXT, MAXPATHLEN-1, 0L);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam)){
|
|
case IDD_HELP:
|
|
goto DoHelp;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, FALSE);
|
|
break;
|
|
|
|
case IDOK:
|
|
|
|
GetDlgItemText(hDlg, IDD_NAME, szPath, MAXPATHLEN);
|
|
EndDialog(hDlg, TRUE);
|
|
|
|
//
|
|
// If "a b" typed in (no quotes, just a b) do we create two
|
|
// directors, "a" and "b," or create just one: "a b."
|
|
// For now, create just one. (No need to call checkesc!)
|
|
//
|
|
// put it back in to handle quoted things.
|
|
// Now, it _ignores_ extra files on the line. We may wish to return
|
|
// an error; that would be smart...
|
|
//
|
|
if (NoQuotes(szPath)) {
|
|
CheckEsc(szPath);
|
|
}
|
|
|
|
GetNextFile(szPath, szPath, COUNTOF(szPath));
|
|
|
|
QualifyPath(szPath);
|
|
|
|
hdlgProgress = hDlg;
|
|
|
|
#ifdef NETCHECK
|
|
if (NetCheck(szPath,WNDN_MKDIR) == WN_SUCCESS) {
|
|
#endif
|
|
SendMessage(hwndFrame, FS_DISABLEFSC, 0, 0L);
|
|
|
|
ret = WF_CreateDirectory(hDlg, szPath, NULL);
|
|
|
|
if (ret && ret!=DE_OPCANCELLED) {
|
|
// Handle error messages cleanly.
|
|
// Special case ERROR_ALREADY_EXISTS
|
|
|
|
if ( ERROR_ALREADY_EXISTS == ret ) {
|
|
ret = WFIsDir(szPath) ?
|
|
DE_MAKEDIREXISTS :
|
|
DE_DIREXISTSASFILE;
|
|
}
|
|
|
|
LoadString(hAppInstance, IDS_MAKEDIRERR, szMessage, COUNTOF(szMessage));
|
|
FormatError(FALSE, szMessage, COUNTOF(szMessage), ret);
|
|
|
|
GetWindowText(hDlg, szTitle, COUNTOF(szTitle));
|
|
MessageBox(hwndFrame, szMessage, szTitle, MB_OK | MB_ICONSTOP);
|
|
}
|
|
|
|
SendMessage(hwndFrame, FS_ENABLEFSC, 0, 0L);
|
|
#ifdef NETCHECK
|
|
}
|
|
#endif
|
|
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
if (wMsg == wHelpMessage) {
|
|
DoHelp:
|
|
WFHelp(hDlg);
|
|
|
|
return TRUE;
|
|
} else
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Check if szT has quote in it.
|
|
// could use strchr...
|
|
|
|
BOOL
|
|
NoQuotes(LPTSTR szT)
|
|
{
|
|
while (*szT) {
|
|
if (CHAR_DQUOTE == *szT ) return FALSE;
|
|
|
|
szT++;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|