able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/winobj/wfsearch.c

943 lines
30 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/****************************************************************************/
/* */
/* WFSEARCH.C - */
/* */
/* File System Search Routines */
/* */
/****************************************************************************/
#include "winfile.h"
#include "lfn.h"
INT maxExt;
INT iDirsRead;
DWORD LastUpdateTime;
WORD APIENTRY StackAvail(VOID);
INT FillSearchLB(HWND hwndLB, LPSTR szSearchFileSpec, BOOL bSubDirOnly);
INT SearchList(HWND hwndLB, LPSTR szPath, LPSTR szFileSpec, BOOL bRecurse, LPHANDLE lphMem, INT iFileCount);
LPSTR SearchGetSelection(HWND hwndLB, BOOL bMostRecent, BOOL *pfDir);
/*--------------------------------------------------------------------------*/
/* */
/* SearchList() - */
/* */
/* This is a recursive routine. It returns the number of files found. */
// szPath OEM
// szFileSpec OEM
/* */
/*--------------------------------------------------------------------------*/
#define DTA_GRANULARITY 20
INT
SearchList(
HWND hwndLB,
LPSTR szPath,
LPSTR szFileSpec,
BOOL bRecurse,
LPHANDLE lphMem,
INT iFileCount
)
{
INT iRetVal;
INT cxExt;
BOOL bFound;
LPSTR pszNewPath;
LPSTR pszNextFile;
LFNDTA lfndta;
LPDTASEARCH lpdtasch;
HDC hdc;
HANDLE hOld;
HANDLE hMem, hMemT;
DWORD TimeNow;
STKCHK();
hMem = *lphMem;
/* Just return 0 files so parent dirs will still be searched
*/
if (StackAvail() < 1024)
return(iFileCount);
TimeNow = GetTickCount();
if (TimeNow > LastUpdateTime+1000) {
LastUpdateTime = TimeNow;
if (LoadString(hAppInstance, IDS_DIRSREAD, szMessage, sizeof(szMessage)))
wsprintf(szStatusTree, szMessage, iDirsRead);
InvalidateRect(hwndFrame, NULL, FALSE);
UpdateWindow(hwndFrame);
}
iDirsRead++;
if (!hMem) {
hMem = LocalAlloc(LPTR, (DWORD)DTA_GRANULARITY * sizeof(DTASEARCH));
if (!hMem)
return -1;
*lphMem = hMem;
}
lpdtasch = (LPDTASEARCH)LocalLock(hMem);
// allocate the buffer for this level
pszNewPath = (LPSTR)LocalAlloc(LPTR, lstrlen(szPath) + MAXFILENAMELEN + 2);
if (!pszNewPath)
return -1;
lstrcpy(pszNewPath, szPath);
AddBackslash(pszNewPath);
pszNextFile = pszNewPath + lstrlen(pszNewPath);
lstrcpy(pszNextFile, szFileSpec);
bFound = WFFindFirst(&lfndta, pszNewPath, ATTR_ALL);
hdc = GetDC(hwndLB);
hOld = SelectObject(hdc, hFont);
while (bFound) {
// alow escape to exit
if (GetAsyncKeyState(VK_ESCAPE) & 0x8000) {
bRecurse = FALSE;
iFileCount = -1;
break;
}
// Make sure this is not a "." or ".." directory
if (lfndta.fd.cFileName[0] != '.') {
BOOL bLFN;
lstrcpy(pszNextFile, lfndta.fd.cFileName);
OemToAnsi(pszNewPath, szMessage);
bLFN = IsLFN(lfndta.fd.cFileName);
iRetVal = (INT)SendMessage(hwndLB, LB_ADDSTRING, 0, (LPARAM)szMessage);
MGetTextExtent(hdc, szMessage, lstrlen(szMessage), &cxExt, NULL);
maxExt = max(maxExt, cxExt);
if (iRetVal >= 0) {
if (iFileCount && ((iFileCount % DTA_GRANULARITY) == 0)) {
LocalUnlock(hMem);
if (!(hMemT = LocalReAlloc(hMem, (DWORD)((iFileCount + DTA_GRANULARITY) * sizeof(DTASEARCH)), LMEM_MOVEABLE))) {
LocalLock(hMem);
bRecurse = FALSE; // simulate an abort
iFileCount = -1;
break;
} else {
hMem = hMemT;
*lphMem = hMemT;
}
lpdtasch = (LPDTASEARCH)LocalLock(hMem);
}
lpdtasch[iFileCount] = *((LPDTASEARCH)(&lfndta.fd));
if (bLFN)
lpdtasch[iFileCount].sch_dwAttrs |= ATTR_LFN;
SendMessage(hwndLB, LB_SETITEMDATA, iRetVal, (LONG)iFileCount);
iFileCount++;
}
}
/* Search for more files in the current directory */
bFound = WFFindNext(&lfndta);
}
WFFindClose(&lfndta);
if (hOld)
SelectObject(hdc, hOld);
ReleaseDC(hwndLB, hdc);
LocalUnlock(hMem);
SetWindowLongPtr(GetParent(hwndLB), GWLP_HDTASEARCH, (LONG_PTR)hMem);
if (!bRecurse)
goto SearchEnd;
/* Now see if there are any subdirectories here */
lstrcpy(pszNextFile, szStarDotStar);
bFound = WFFindFirst(&lfndta, pszNewPath, ATTR_DIR | ATTR_HS);
while (bFound) {
// alow escape to exit
if (GetAsyncKeyState(VK_ESCAPE) & 0x8000) {
bRecurse = FALSE;
iFileCount = -1;
break;
}
/* Make sure this is not a "." or ".." directory. */
if ((lfndta.fd.cFileName[0] != '.') && (lfndta.fd.dwFileAttributes & ATTR_DIR)) {
/* Yes, search and add files in this directory */
lstrcpy(pszNextFile, lfndta.fd.cFileName);
/* Add all files in this subdirectory. */
if ((iRetVal = SearchList(hwndLB, pszNewPath, szFileSpec, bRecurse, lphMem, iFileCount)) < 0) {
iFileCount = iRetVal;
break;
}
iFileCount = iRetVal;
}
bFound = WFFindNext(&lfndta);
}
WFFindClose(&lfndta);
SearchEnd:
LocalFree((HANDLE)pszNewPath);
return iFileCount;
}
VOID
FixUpFileSpec(
LPSTR szFileSpec
)
{
CHAR szTemp[MAXPATHLEN+1];
register LPSTR p;
if (*szFileSpec == '.') {
lstrcpy(szTemp, "*");
lstrcat(szTemp, szFileSpec);
lstrcpy(szFileSpec, szTemp);
}
/* HACK: If there isn't a dot and the last char is a *, append ".*" */
p = szFileSpec;
while ((*p) && (*p != '.'))
p = AnsiNext(p);
if ((!*p) && (p != szFileSpec)) {
p = AnsiPrev(szFileSpec, p);
if (*p == '*')
lstrcat(p, ".*");
}
}
/*--------------------------------------------------------------------------*/
/* */
/* FillSearchLB() - */
/* */
/*--------------------------------------------------------------------------*/
/* This parses the given string for Drive, PathName, FileSpecs and
* calls SearchList() with proper parameters;
*
* hwndLB : List box where files are to be displayed;
* szSearchFileSpec : ANSI path to search
* bSubDirOnly : TRUE, if only subdirectories are to be searched;
*/
INT
FillSearchLB(
HWND hwndLB,
LPSTR szSearchFileSpec,
BOOL bRecurse
)
{
INT iRet;
HCURSOR hCursor;
CHAR szFileSpec[MAXPATHLEN+1];
CHAR szPathName[MAXPATHLEN+1];
HANDLE hMemIn = NULL;
FixAnsiPathForDos(szSearchFileSpec);
/* Get the file specification part of the string. */
lstrcpy(szFileSpec, szSearchFileSpec);
lstrcpy(szPathName, szSearchFileSpec);
StripPath(szFileSpec);
StripFilespec(szPathName);
FixUpFileSpec(szFileSpec);
hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
ShowCursor(TRUE);
maxExt = 0;
iDirsRead = 1;
LastUpdateTime = 0;
iRet = SearchList(hwndLB, szPathName, szFileSpec, bRecurse, &hMemIn, 0);
ShowCursor(FALSE);
SetCursor(hCursor);
SendMessage(hwndLB, LB_SETSEL, TRUE, 0L);
return(iRet);
}
/*--------------------------------------------------------------------------*/
/* */
/* SearchGetSelection() - */
/* */
/*--------------------------------------------------------------------------*/
/* Returns a string containing the names of the selected
* files seperated by spaces. If bMostRecent is TRUE, it only returns the
* most recently selected file.
*
* The string is returned and a *pfDir is set indicating if it points
* to a directory.
*
* NOTE: The caller must free the returned pointer!
*/
LPSTR
SearchGetSelection(
HWND hwndLB,
BOOL bMostRecent,
BOOL *pfDir
)
{
register LPSTR p;
LPSTR pT;
register WORD i;
WORD iMac;
WORD cch = 1;
BOOL bDir;
HANDLE hMem;
LPDTASEARCH lpdtasch;
CHAR szTemp[MAXPATHLEN];
BOOL bLFNTest;
if (bLFNTest = (bMostRecent == 2)) {
bMostRecent = FALSE;
} else {
p = (LPSTR)LocalAlloc(LPTR, 1);
if (!p)
return NULL;
}
if (bMostRecent == 3)
bMostRecent = 0;
bDir = TRUE;
iMac = (WORD)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L);
hMem = (HANDLE)GetWindowLongPtr(GetParent(hwndLB), GWLP_HDTASEARCH);
lpdtasch = (LPDTASEARCH)LocalLock(hMem);
for (i=0; i < iMac; i++) {
if (!(BOOL)SendMessage(hwndLB, LB_GETSEL, i, 0L))
continue;
cch += (WORD)SendMessage(hwndLB, LB_GETTEXT, i, (LPARAM)szTemp);
cch++;
if (bLFNTest) {
if (IsLFN(szTemp)) {
if (pfDir)
*pfDir = TRUE;
return NULL;
}
} else {
pT = (LPSTR)LocalReAlloc((HANDLE)p, cch, LMEM_MOVEABLE | LMEM_ZEROINIT);
if (!pT)
goto SGSExit;
p = pT;
lstrcat(p, szTemp);
bDir = lpdtasch[(INT)SendMessage(hwndLB, LB_GETITEMDATA, i, 0L)].sch_dwAttrs & ATTR_DIR;
if (bMostRecent)
break;
lstrcat(p, szBlank);
}
}
SGSExit:
LocalUnlock(hMem);
if (bLFNTest) {
if (pfDir)
*pfDir = FALSE;
return NULL;
}
if (pfDir)
*pfDir = bDir;
return(p);
}
VOID
CreateLine(
WORD wLineFormat,
LPSTR szFile,
LPDTASEARCH lpdtasch,
LPSTR szBuffer
)
{
LPSTR pch;
BYTE chAttribute;
pch = szBuffer;
chAttribute = (BYTE)lpdtasch->sch_dwAttrs;
/* Copy the file name. */
lstrcpy(pch, szFile);
pch += lstrlen(pch);
*pch = TEXT('\0');
/* Should we show the size? */
if (wLineFormat & VIEW_SIZE) {
*pch++ = TABCHAR;
if (!(chAttribute & ATTR_DIR))
pch += PutSize(lpdtasch->sch_nFileSizeLow, pch);
}
/* Should we show the date? */
if (wLineFormat & VIEW_DATE) {
*pch++ = TABCHAR;
pch += PutDate(&lpdtasch->sch_ftLastWriteTime, pch);
}
/* Should we show the time? */
if (wLineFormat & VIEW_TIME) {
*pch++ = TABCHAR;
pch += PutTime(&lpdtasch->sch_ftLastWriteTime, pch);
}
/* Should we show the attributes? */
if (wLineFormat & VIEW_FLAGS) {
*pch++ = TABCHAR;
pch += PutAttributes((WORD)chAttribute, pch);
}
}
// the window text looks like "Search Window: C:\FOO\BAR\*.*"
VOID
GetSearchPath(
HWND hWnd,
LPSTR pszPath
)
{
LPSTR p;
CHAR szTemp[MAXPATHLEN+32];
// the search window doesn't have a current directory
GetWindowText(hWnd, szTemp, sizeof(szTemp));
// the window text looks like "Search Window: C:\FOO\BAR\*.*"
p = szTemp;
while (*p && *p != ':') // find the :
p = AnsiNext(p);
p += 2; // skip the ": "
lstrcpy(pszPath, p);
}
/*--------------------------------------------------------------------------*/
/* */
/* UpdateSearchStatus() - */
/* */
/*--------------------------------------------------------------------------*/
VOID
UpdateSearchStatus(
HWND hwndLB
)
{
INT nCount;
nCount = (INT)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L);
if (LoadString(hAppInstance, IDS_SEARCHMSG, szMessage, sizeof(szMessage)))
wsprintf(szStatusTree, szMessage, nCount);
szStatusDir[0] = '\0';
InvalidateRect(hwndFrame, NULL, FALSE);
}
/*--------------------------------------------------------------------------*/
/* */
/* SearchWndProc() - */
/* */
/*--------------------------------------------------------------------------*/
INT_PTR
APIENTRY
SearchWndProc(
register HWND hWnd,
UINT wMsg,
WPARAM wParam,
LPARAM lParam
)
{
INT iRet;
INT iSel;
HWND hwndLB;
CHAR szTemp[MAXPATHLEN + 32];
CHAR szPath[MAXPATHLEN];
STKCHK();
hwndLB = GetDlgItem(hWnd, IDCW_LISTBOX);
switch (wMsg) {
case FS_GETDRIVE:
MSG("SearchWndProc", "FS_GETDRIVE");
// Returns the letter of the corresponding directory
SendMessage(hWnd, FS_GETDIRECTORY, sizeof(szPath), (LPARAM)szPath);
return szPath[0]; // first character
case FS_GETDIRECTORY:
MSG("SearchWndProc", "FS_GETDIRECTORY");
GetSearchPath(hWnd, szPath);
StripFilespec(szPath); // remove the filespec
AddBackslash(szPath); // to be the same as DirWndProc
lstrcpy((LPSTR)lParam, szPath);
break;
case FS_GETFILESPEC:
MSG("SearchWndProc", "FS_GETFILESPEC");
// the search window doesn't have a current directory
GetSearchPath(hWnd, szPath);
StripPath(szPath); // remove the path (leave the filespec)
lstrcpy((LPSTR)lParam, szPath);
break;
case FS_SETSELECTION:
MSG("SearchWndProc", "FS_SETSELECTION");
// wParam is the select(TRUE)/unselect(FALSE) param
// lParam is the filespec to match against
SendMessage(hwndLB, WM_SETREDRAW, FALSE, 0L);
DSSetSelection(hwndLB, wParam ? TRUE : FALSE, (LPSTR)lParam, TRUE);
SendMessage(hwndLB, WM_SETREDRAW, TRUE, 0L);
InvalidateRect(hwndLB, NULL, TRUE);
break;
case FS_GETSELECTION:
MSG("SearchWndProc", "FS_GETSELECTION");
return (INT_PTR)SearchGetSelection(hwndLB, wParam ? TRUE : FALSE, (BOOL *)lParam);
break;
case WM_MDIACTIVATE:
if (wParam) {
UpdateSearchStatus(hwndLB);
// if we are dirty, ask if we should update
if (GetWindowLong(hWnd, GWL_FSCFLAG))
PostMessage(hWnd, FS_CHANGEDISPLAY, CD_SEARCHUPDATE, 0L);
}
break;
case WM_FILESYSCHANGE:
SetWindowLong(hWnd, GWL_FSCFLAG, TRUE); // I need updating
// if the search window is not active or FSCs are disabled
// don't prompt now, wait till we get the end FSC or are
// activated (above in WM_ACTIVATE)
if (cDisableFSC ||
(hWnd != (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L)) &&
(GetActiveWindow() != hwndFrame))
break;
PostMessage(hWnd, FS_CHANGEDISPLAY, CD_SEARCHUPDATE, 0L);
break;
case FS_CHANGEDISPLAY:
MSG("SearchWndProc", "FS_CHANGEDISPLAY");
SetWindowLong(hWnd, GWL_FSCFLAG, FALSE); // I am clean
if (wParam == CD_SEARCHUPDATE) {
LoadString(hAppInstance, IDS_SEARCHTITLE, szTitle, sizeof(szTitle));
LoadString(hAppInstance, IDS_SEARCHREFRESH, szMessage, sizeof(szMessage));
if (MessageBox(hWnd, szMessage, szTitle, MB_YESNO | MB_ICONQUESTION) != IDYES)
break;
}
// is this a refresh?
if (!lParam) {
GetSearchPath(hWnd, szPath);
} else {
lstrcpy(szPath, (LPSTR)lParam); // explicit re-search
}
LoadString(hAppInstance, IDS_SEARCHTITLE, szMessage, 32);
lstrcat(szMessage, szPath);
SetWindowText(hWnd, szMessage);
SendMessage(hwndLB, WM_SETREDRAW, FALSE, 0L);
SendMessage(hwndLB, LB_RESETCONTENT, 0, 0L);
iRet = FillSearchLB(hwndLB, szPath, bSearchSubs);
FixTabsAndThings(hwndLB,(WORD *)GetWindowLongPtr(hWnd, GWLP_TABARRAYSEARCH), maxExt + dxText,wNewView);
SendMessage(hwndLB, WM_SETREDRAW, TRUE, 0L);
InvalidateRect(hwndLB, NULL, TRUE);
if (iRet == 0) {
LoadString(hAppInstance, IDS_SEARCHTITLE, szTitle, sizeof(szTitle));
LoadString(hAppInstance, IDS_SEARCHNOMATCHES, szMessage, sizeof(szMessage));
MessageBox(hwndFrame, szMessage, szTitle, MB_OK | MB_ICONINFORMATION);
ShowWindow(hWnd, SW_HIDE);
PostMessage(hWnd, WM_CLOSE, 0, 0L);
return FALSE;
} else {
UpdateSearchStatus(hwndLB);
}
if (GetFocus() != hwndLB)
return(iRet);
/*** FALL THRU ***/
case WM_SETFOCUS:
MSG("SearchWndProc", "WM_SETFOCUS");
SetFocus(hwndLB);
return (WORD)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L);
case WM_CLOSE:
MSG("SearchWndProc", "WM_CLOSE");
hwndSearch = NULL;
goto DefChildProc;
case WM_COMMAND:
/* Was this a double-click? */
if (GET_WM_COMMAND_CMD(wParam, lParam) == LBN_DBLCLK)
SendMessage(hwndFrame, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_OPEN, 0, 0));
else if (GET_WM_COMMAND_CMD(wParam, lParam) == LBN_SELCHANGE) {
INT i;
for (i = 0; i < iNumExtensions; i++) {
(extensions[i].ExtProc)(hwndFrame, FMEVENT_SELCHANGE, 0L);
}
}
break;
case WM_DESTROY:
MSG("SearchWndProc", "WM_DESTROY");
{
HANDLE hMem;
if (hMem = (HANDLE)GetWindowLongPtr(hWnd, GWLP_HDTASEARCH))
LocalFree(hMem);
if (hMem = (HANDLE)GetWindowLongPtr(hWnd, GWLP_TABARRAYSEARCH))
LocalFree(hMem);
}
break;
case WM_CREATE:
TRACE(BF_WM_CREATE, "SearchWndProc - WM_CREATE");
{
// globals used:
// szSearch path to start search at
// bSearchSubs tells us to do a recursive search
RECT rc;
WORD *pwTabs;
GetClientRect(hWnd, &rc);
hwndLB = CreateWindowEx(0, szListbox, NULL,
WS_CHILD | WS_BORDER | LBS_SORT | LBS_NOTIFY |
LBS_OWNERDRAWFIXED | LBS_EXTENDEDSEL |
LBS_NOINTEGRALHEIGHT | LBS_WANTKEYBOARDINPUT |
LBS_HASSTRINGS | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE,
-1, -1, rc.right+2, rc.bottom+2,
hWnd, (HMENU)IDCW_LISTBOX,
hAppInstance, NULL);
if (!hwndLB)
return -1L;
if ((pwTabs = (WORD *)LocalAlloc(LPTR,sizeof(WORD) * 4)) == NULL)
return -1L;
hwndSearch = hWnd;
SetWindowLong(hWnd, GWL_TYPE, TYPE_SEARCH);
SetWindowLong(hWnd, GWL_VIEW, wNewView);
SetWindowLong(hWnd, GWL_SORT, IDD_NAME);
SetWindowLong(hWnd, GWL_ATTRIBS,ATTR_DEFAULT);
SetWindowLong(hWnd, GWL_FSCFLAG, FALSE);
SetWindowLongPtr(hWnd, GWLP_HDTASEARCH, 0);
SetWindowLongPtr(hWnd, GWLP_TABARRAYSEARCH, (LONG_PTR)pwTabs);
SetWindowLongPtr(hWnd, GWLP_LASTFOCUSSEARCH, (LONG_PTR)hwndLB);
// Fill the listbox
if (!FillSearchLB(hwndLB, szSearch, bSearchSubs)) {
LoadString(hAppInstance, IDS_SEARCHTITLE, szTitle, sizeof(szTitle));
LoadString(hAppInstance, IDS_SEARCHNOMATCHES, szMessage, sizeof(szMessage));
MessageBox(hwndFrame, szMessage, szTitle, MB_OK | MB_ICONINFORMATION);
hwndSearch = NULL;
return -1L;
} else {
FixTabsAndThings(hwndLB,pwTabs, maxExt + dxText,wNewView);
SendMessage(hwndLB, WM_SETFONT, (WPARAM)hFont, 0L);
ShowWindow(hwndSearch, SW_SHOWNORMAL);
}
break;
}
case WM_DRAGLOOP:
MSG("SearchWndProc", "WM_DRAGLOOP");
/* WM_DRAGLOOP is sent to the source window as the object is moved.
*
* wParam: TRUE if the object is currently over a droppable sink
* lParam: LPDROPSTRUCT
*/
/* DRAGLOOP is used to turn the source bitmaps on/off as we drag. */
DSDragLoop(hwndLB, wParam, (LPDROPSTRUCT)lParam, TRUE);
break;
case WM_DRAGSELECT:
MSG("SearchWndProc", "WM_DRAGSELECT");
/* WM_DRAGSELECT is sent to a sink whenever an new object is dragged
* inside of it.
*
* wParam: TRUE if the sink is being entered, FALSE if it's being
* exited.
* lParam: LPDROPSTRUCT
*/
/* DRAGSELECT is used to turn our selection rectangle on or off. */
#define lpds ((LPDROPSTRUCT)lParam)
iSelHilite = LOWORD(lpds->dwControlData);
DSRectItem(hwndLB, iSelHilite, (BOOL)wParam, TRUE);
break;
case WM_DRAGMOVE:
MSG("SearchWndProc", "WM_DRAGMOVE");
/* WM_DRAGMOVE is sent to a sink as the object is being dragged
* within it.
*
* wParam: Unused
* lParam: LPDROPSTRUCT
*/
/* DRAGMOVE is used to move our selection rectangle among sub-items. */
#define lpds ((LPDROPSTRUCT)lParam)
/* Get the subitem we are over. */
iSel = LOWORD(lpds->dwControlData);
/* Is it a new one? */
if (iSel == iSelHilite)
break;
/* Yup, un-select the old item. */
DSRectItem(hwndLB, iSelHilite, FALSE, TRUE);
/* Select the new one. */
iSelHilite = iSel;
DSRectItem(hwndLB, iSel, TRUE, TRUE);
break;
case WM_DRAWITEM:
MSG("SearchWndProc", "WM_DRAWITEM");
{
LPDRAWITEMSTRUCT lpLBItem;
HANDLE hMem;
LPDTASEARCH lpdtasch;
lpLBItem = (LPDRAWITEMSTRUCT)lParam;
iSel = lpLBItem->itemID;
if (iSel < 0)
break;
SendMessage(hwndLB, LB_GETTEXT, iSel, (LPARAM)szPath);
hMem = (HANDLE)GetWindowLongPtr(hWnd, GWLP_HDTASEARCH);
lpdtasch = (LPDTASEARCH)LocalLock(hMem);
iSel = (INT)SendMessage(hwndLB, LB_GETITEMDATA, iSel, 0L);
CreateLine((WORD)GetWindowLong(hWnd, GWL_VIEW), szPath, &(lpdtasch[iSel]), szTemp);
DrawItem(lpLBItem, szTemp, lpdtasch[iSel].sch_dwAttrs, TRUE,
(WORD *)GetWindowLongPtr(hWnd,GWLP_TABARRAYSEARCH));
LocalUnlock(hMem);
break;
}
case WM_DROPOBJECT:
MSG("SearchWndProc", "WM_DROPOBJECT");
{
LPSTR pFrom;
WORD ret;
WORD iSelSink;
HANDLE hMem;
LPDTASEARCH lpdtasch;
DWORD attrib;
/* WM_DROPOBJECT is sent to a sink when the user releases an
* acceptable object over it
*
* wParam: TRUE if over the non-client area, FALSE if over the
* client area.
* lParam: LPDROPSTRUCT
*/
#define lpds ((LPDROPSTRUCT)lParam)
iSelSink = LOWORD(lpds->dwControlData);
/* Are we dropping onto ourselves? (i.e. a selected item in the
* source listbox OR an unused area of the source listbox) If
* so, don't do anything.
*/
if (hWnd == lpds->hwndSource) {
if ((iSelSink == 0xFFFF) || (SendMessage(hwndLB, LB_GETSEL, iSelSink, 0L)))
return TRUE;
}
/* Are we dropping on a unused portion of the listbox? */
if (iSelSink == 0xFFFF)
return TRUE;
/* Get the sink's filename. */
SendMessage(hwndLB, LB_GETTEXT, iSelSink, (LPARAM)szPath);
hMem = (HANDLE)GetWindowLongPtr(hWnd, GWLP_HDTASEARCH);
lpdtasch = (LPDTASEARCH)LocalLock(hMem);
attrib = lpdtasch[(INT)SendMessage(hwndLB, LB_GETITEMDATA, iSelSink, 0L)].sch_dwAttrs;
LocalUnlock(hMem);
/* Are we dropping on a subdirectory? */
if (attrib & ATTR_DIR)
goto DirMoveCopy;
/* Are we not dropping on a Program file? */
if (!IsProgramFile(szPath))
return TRUE;
if (lpds->wFmt == DOF_DIRECTORY) {
goto DODone;
}
/* We're dropping a file onto a program.
* Exec the program using the source file as the parameter.
*/
/* Should we confirm it first? */
if (bConfirmMouse) {
LoadString(hAppInstance, IDS_MOUSECONFIRM, szTitle, MAXTITLELEN);
LoadString(hAppInstance, IDS_EXECMOUSECONFIRM, szTemp, sizeof(szTemp));
wsprintf(szMessage, szTemp, (LPSTR)szPath, (LPSTR)(((LPDRAGOBJECTDATA)(lpds->dwData))->pch));
if (MessageBox(hwndFrame, szMessage, szTitle, MB_YESNO | MB_ICONEXCLAMATION) == IDNO)
goto DODone;
}
/* If we dragged from a Dir Window, add path information. */
if (lpds->hwndSource == hWnd)
szTemp[0] = TEXT('\0');
else
SendMessage(lpds->hwndSource, FS_GETDIRECTORY, sizeof(szTemp), (LPARAM)szTemp);
lstrcat(szTemp, (LPSTR)(((LPDRAGOBJECTDATA)(lpds->dwData))->pch));
// put a "." extension on if none found
if (*GetExtension(szTemp) == 0)
lstrcat(szTemp, ".");
FixAnsiPathForDos(szTemp);
FixAnsiPathForDos(szPath);
ret = ExecProgram(szPath,szTemp,NULL,FALSE);
if (ret)
MyMessageBox(hwndFrame, IDS_EXECERRTITLE, ret, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
DODone:
DSRectItem(hwndLB, iSelHilite, FALSE, TRUE);
return TRUE;
DirMoveCopy:
pFrom = (LPSTR)(((LPDRAGOBJECTDATA)(lpds->dwData))->pch);
AddBackslash(szPath); // add filespec filter
lstrcat(szPath, szStarDotStar);
DMMoveCopyHelper(pFrom, szPath, fShowSourceBitmaps);
DSRectItem(hwndLB, iSelHilite, FALSE, TRUE);
return TRUE;
}
case WM_LBTRACKPOINT:
MSG("SearchWndProc", "WM_LBTRACKPOINT");
return(DSTrackPoint(hWnd, hwndLB, wParam, lParam, TRUE));
case WM_MEASUREITEM:
MSG("SearchWndProc", "WM_MEASUREITEM");
{
#define pLBMItem ((LPMEASUREITEMSTRUCT)lParam)
pLBMItem->itemHeight = dyFileName;
break;
}
case WM_QUERYDROPOBJECT:
MSG("SearchWndProc", "WM_QUERYDROPOBJECT");
/* Ensure that we are dropping on the client area of the listbox. */
#define lpds ((LPDROPSTRUCT)lParam)
/* Ensure that we can accept the format. */
switch (lpds->wFmt) {
case DOF_EXECUTABLE:
case DOF_DIRECTORY:
case DOF_DOCUMENT:
case DOF_MULTIPLE:
if (lpds->hwndSink == hWnd)
lpds->dwControlData = -1L;
return TRUE;
}
return FALSE;
case WM_SIZE:
MSG("SearchWndProc", "WM_SIZE");
if (wParam != SIZEICONIC) {
MoveWindow(GetDlgItem(hWnd, IDCW_LISTBOX),
-1, -1,
LOWORD(lParam)+2,
HIWORD(lParam)+2,
TRUE);
}
/*** FALL THRU ***/
default:
DefChildProc:
DEFMSG("SearchWndProc", (WORD)wMsg);
return(DefMDIChildProc(hWnd, wMsg, wParam, lParam));
}
return(0L);
}
Reference in a new issue Copy permalink