/****************************************************************************/ /* */ /* WFDIR.C - */ /* */ /* Windows File System Directory Window Proc Routines */ /* */ /****************************************************************************/ #include "winfile.h" #include "winnet.h" #include "lfn.h" #include "wfcopy.h" #define MAXDIGITSINSIZE 8 #define DATEMASK 0x001F #define MONTHMASK 0x01E0 #define MINUTEMASK 0x07E0 #define SECONDSMASK 0x001F #define DATESEPERATOR '-' #define TIMESEPERATOR ':' CHAR szAttr[] = "RHSA"; INT iLastSel = -1; INT_PTR APIENTRY DirWndProc(register HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam); LPSTR DirGetSelection(HWND hwndDir, HWND hwndLB, INT iSelType, BOOL *pfDir); VOID DirGetAnchorFocus(register HWND hwndLB, HANDLE hDTA, LPSTR szAnchor, LPSTR szCaret, LPSTR szTopIndex); VOID FillDirList(HWND hWnd, HANDLE hDirEntries); VOID DrawItemFast(HWND hWnd, LPDRAWITEMSTRUCT lpLBItem, LPMYDTA lpmydta, BOOL bHasFocus); INT GetPict(CHAR ch, LPSTR szStr); INT DirFindIndex(HWND hwndLB, HANDLE hDTA, LPSTR szFile); INT CompareDTA(register LPMYDTA item1, LPMYDTA item2, WORD wSort); VOID CreateLBLine(register WORD wLineFormat, LPMYDTA lpmydta, LPSTR szBuffer); HANDLE CreateDTABlock(HWND hWnd, LPSTR pPath, DWORD dwAttribs, BOOL bAllowAbort, BOOL bDontSteal); BOOL SetSelection(HWND hwndLB, HANDLE hDTA, LPSTR pSel); INT CreateDate(WORD *wValArray, LPSTR szOutStr); INT CreateTime(WORD * wValArray, LPSTR szOutStr); VOID GetDirStatus(HWND hWnd, LPSTR szMsg1, LPSTR szMsg2); INT GetMaxExtent(HWND hwndLB, HANDLE hDTA); BOOL CheckEarlyAbort(VOID); BOOL SetDirFocus(HWND hwndDir); VOID APIENTRY CheckEscapes(LPSTR); VOID SortDirList(HWND, LPMYDTA, WORD ,LPMYDTA *); /*--------------------------------------------------------------------------*/ /* */ /* DrawItemFast() - */ /* */ /*--------------------------------------------------------------------------*/ VOID DrawItemFast( HWND hWnd, LPDRAWITEMSTRUCT lpLBItem, LPMYDTA lpmydta, BOOL bHasFocus ) { INT x, y, i; HDC hDC; BOOL bDrawSelected; HWND hwndLB; RECT rc; DWORD rgbText, rgbBackground; CHAR szBuf[MAXFILENAMELEN+2]; hWnd; ENTER("DrawItemFast"); hDC = lpLBItem->hDC; hwndLB = lpLBItem->hwndItem; bDrawSelected = (lpLBItem->itemState & ODS_SELECTED); if (bHasFocus && bDrawSelected) { rgbText = SetTextColor(hDC, GetSysColor(COLOR_HIGHLIGHTTEXT)); rgbBackground = SetBkColor(hDC, GetSysColor(COLOR_HIGHLIGHT)); } if (lpLBItem->itemAction == ODA_FOCUS) goto FocusOnly; /* Draw the black/white background. */ x = lpLBItem->rcItem.left + 1; y = lpLBItem->rcItem.top + (dyFileName/2); lstrcpy(szBuf, lpmydta->my_cFileName); if ((wTextAttribs & TA_LOWERCASE) && !(lpmydta->my_dwAttrs & ATTR_LFN)) AnsiLower(szBuf); ExtTextOut(hDC, x + dxFolder + dyBorderx2 + dyBorder, y-(dyText/2), ETO_OPAQUE, &lpLBItem->rcItem, szBuf, lstrlen(szBuf), NULL); if (fShowSourceBitmaps || (hwndDragging != hwndLB) || !bDrawSelected) { LONG ySrc; i = lpmydta->iBitmap; if (i & 0x40) { // It's an object type bitmap ySrc = (dyFolder * 2) + dyDriveBitmap; i = i & (~0x40); while (i >= 16) { i -= 16; ySrc += (dyFolder * 2); } } else { ySrc = 0; } ySrc += (bHasFocus && bDrawSelected) ? dyFolder : 0; BitBlt(hDC, x + dyBorderx2, y-(dyFolder/2), dxFolder, dyFolder, hdcMem, i * dxFolder, ySrc, SRCCOPY); } if (lpLBItem->itemState & ODS_FOCUS) FocusOnly: DrawFocusRect(hDC, &lpLBItem->rcItem); // toggles focus (XOR) /* Restore the normal drawing colors. */ if (bDrawSelected) { if (bHasFocus) { SetTextColor(hDC, rgbText); SetBkColor(hDC, rgbBackground); } else { HBRUSH hbr; if (hbr = CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT))) { rc = lpLBItem->rcItem; rc.left += dyBorder; rc.right -= dyBorder; if (lpLBItem->itemID > 0 && (BOOL)SendMessage(hwndLB, LB_GETSEL, lpLBItem->itemID - 1, 0L)) rc.top -= dyBorder; FrameRect(hDC, &rc, hbr); DeleteObject(hbr); } } } LEAVE("DrawItemFast"); } /*--------------------------------------------------------------------------*/ /* */ /* FillDirList() - */ /* */ /* HANDLE hDirEntries; Array of directory entries */ /*--------------------------------------------------------------------------*/ VOID FillDirList( HWND hWnd, HANDLE hDTA ) { register WORD count; LPMYDTA lpmydta; LPMYDTA *alpmydtaSorted; WORD i; lpmydta = (LPMYDTA)LocalLock(hDTA); count = (WORD)lpmydta->my_nFileSizeLow; if (count == 0) { SendMessage(hWnd, LB_ADDSTRING, 0, 0L); // tolken for no items } else { alpmydtaSorted = (LPMYDTA *)LocalAlloc(LMEM_FIXED, sizeof(LPMYDTA) * count); if (alpmydtaSorted != NULL) { SortDirList(hWnd, lpmydta, count, alpmydtaSorted); for (i = 0; i < count; i++) { alpmydtaSorted[i]->nIndex = i; SendMessage(hWnd, LB_INSERTSTRING,(WPARAM)-1, (LPARAM)alpmydtaSorted[i]); } LocalFree((HANDLE)alpmydtaSorted); } } LocalUnlock(hDTA); } BOOL CheckEarlyAbort() { MSG msg; if (PeekMessage(&msg, NULL, WM_KEYDOWN, WM_KEYDOWN, PM_NOREMOVE | PM_NOYIELD)) { if (msg.wParam == VK_UP || msg.wParam == VK_DOWN) { return TRUE; } } return FALSE; } HANDLE CopyDTABlock( HANDLE hDTASrc ) { LPMYDTA lpmydtaSrc, lpmydtaDst; HANDLE hDTADst; SIZE_T dwSize; lpmydtaSrc = (LPMYDTA)LocalLock(hDTASrc); dwSize = LocalSize(hDTASrc); if (hDTADst = LocalAlloc(LPTR, dwSize)) { lpmydtaDst = (LPMYDTA)LocalLock(hDTADst); memcpy(lpmydtaDst, lpmydtaSrc, (size_t)dwSize); LocalUnlock(hDTASrc); LocalUnlock(hDTADst); return hDTADst; } else { LocalUnlock(hDTASrc); return NULL; } } HANDLE StealDTABlock( HWND hWnd, LPSTR pPath, DWORD dwAttribs ) { HWND hwnd; HWND hwndDir; HANDLE hDTA; CHAR szPath[MAXPATHLEN]; ENTER("StealDTABlock"); for (hwnd = GetWindow(hwndMDIClient, GW_CHILD); hwnd; hwnd = GetWindow(hwnd, GW_HWNDNEXT)) { if ((hwndDir = HasDirWindow(hwnd)) && (hwndDir != hWnd)) { GetMDIWindowText(hwnd, szPath, sizeof(szPath)); if ((dwAttribs == (DWORD)GetWindowLong(hwnd, GWL_ATTRIBS)) && !lstrcmpi(pPath, szPath) && (hDTA = (HANDLE)GetWindowLongPtr(hwndDir, GWLP_HDTA))) { LEAVE("StealDTABlock"); return CopyDTABlock(hDTA); } } } LEAVE("StealDTABlock"); return NULL; } /*--------------------------------------------------------------------------*/ /* */ /* CreateDTABlock() - */ /* */ /*--------------------------------------------------------------------------*/ /* Builds a global memory block full of DTAs for the path 'pPath'. */ /* Returns: * An unlocked global memory handle to DTA block with first DTA * my_nFileSizeLow field indicating the number of DTA blocks that follow * * This builds a global memory block that has DTA entries for all * of the files with dwAttributes in pPath. The first DTA entry's * my_nFileSizeLow field indicates the number of actual DTA areas found */ HANDLE CreateDTABlock( HWND hWnd, LPSTR pPath, DWORD dwAttribs, BOOL bAllowAbort, BOOL bDontSteal ) { register LPSTR pName; WORD wPathLen; BOOL bDoc, bProgram; DWORD dwCurrentSize, dwBlockSize; WORD wSize, wLastSize; LFNDTA lfndta; HANDLE hMem; LPMYDTA lpmydta, lpStart; CHAR szPathOEM[MAXPATHLEN]; DWORD iBitmap; WORD wDrive; ENTER("CreateDTABlock"); PRINT(BF_PARMTRACE, "IN: pPath=%s", pPath); PRINT(BF_PARMTRACE, "IN: dwAttribs=0x%lx", UlongToPtr(dwAttribs)); PRINT(BF_PARMTRACE, "IN: bDontSteal=%d", IntToPtr(bDontSteal)); #define BLOCK_SIZE_GRANULARITY 512 // must be larger than MYDTA // get the drive index assuming path is // fully qualified... wDrive = (WORD)((*pPath - 'A') & 31); if (bAllowAbort && CheckEarlyAbort()) { PRINT(BF_PARMTRACE, "OUT: hDTA=-1", 0); LEAVE("CreateDTABlock"); return (HANDLE)-1; } if (!bDontSteal && (hMem = StealDTABlock(hWnd, pPath, dwAttribs))) { PRINT(BF_PARMTRACE, "OUT: hDTA=0x%lx", hMem); LEAVE("CreateDTABlock"); return hMem; } dwBlockSize = BLOCK_SIZE_GRANULARITY; hMem = LocalAlloc(LPTR, (DWORD)dwBlockSize); if (!hMem) { PRINT(BF_PARMTRACE, "OUT: hDTA=NULL", 0); LEAVE("CreateDTABlock"); return NULL; } lpmydta = lpStart = (LPMYDTA)LocalLock(hMem); lpStart->my_nFileSizeLow = 0; wLastSize = sizeof(MYDTA) * sizeof(CHAR); wLastSize = (WORD)DwordAlign(wLastSize); lpStart->wSize = wLastSize; dwCurrentSize = (DWORD)wLastSize; lstrcpy(szPathOEM, pPath); FixAnsiPathForDos(szPathOEM); wPathLen = (WORD)(lstrlen(szPathOEM)-3); /* Ignore '*.*' */ if (!WFFindFirst(&lfndta, szPathOEM, (dwAttribs | ATTR_DIR) & ATTR_ALL)) { // Try again if the disk is available if (!IsTheDiskReallyThere(hWnd, pPath, FUNC_EXPAND) || !WFFindFirst(&lfndta, szPathOEM, (dwAttribs | ATTR_DIR) & ATTR_ALL)) goto CDBDone; } while (TRUE) { pName = lfndta.fd.cFileName; OemToAnsi(pName, pName); // be safe, zero unused DOS dta bits lfndta.fd.dwFileAttributes &= ATTR_USED; // filter unwanted stuff here based on current view settings if (!(lfndta.fd.dwFileAttributes & ATTR_DIR)) { bProgram = IsProgramFile(pName); bDoc = IsDocument(pName); } // figure out the bitmap type here if (lfndta.fd.dwFileAttributes & ATTR_DIR) { // ignore the "." directory if (pName[0] == '.' && pName[1] != '.') goto CDBCont; // parent ".." dir if (pName[0] == '.') { pName = szNULL; iBitmap = BM_IND_DIRUP; lfndta.fd.dwFileAttributes |= ATTR_PARENT; // mark this! } else { // We always include DIRs so that the .. is // included. Now we filter other dirs off. if (!(dwAttribs & ATTR_DIR)) goto CDBCont; iBitmap = BM_IND_CLOSE; } } else if (lfndta.fd.dwFileAttributes & ATTR_TYPES) { iBitmap = ((lfndta.fd.dwFileAttributes & ATTR_TYPES) >> 16) | 0x40; } else { iBitmap = BM_IND_DOC; } // // calc the size of this portion // // pName is assumed to be ANSI re: OemToAnsi() call, // so lstrlen() should be size in bytes. We just need to add one // for the terminating NULL wSize = (WORD)(sizeof(MYDTA) + lstrlen(pName) + sizeof('\0')); wSize = (WORD)DwordAlign(wSize); if ((wSize + dwCurrentSize) > dwBlockSize) { DWORD dwDelta; // grow the block dwBlockSize += BLOCK_SIZE_GRANULARITY; LocalUnlock(hMem); dwDelta = (DWORD)((LPBYTE)lpmydta - (LPBYTE)lpStart); if (!(hMem = LocalReAlloc(hMem, dwBlockSize, LMEM_MOVEABLE))) goto CDBMemoryErr; lpStart = (LPMYDTA)LocalLock(hMem); lpmydta = (LPMYDTA)((LPBYTE)lpStart + dwDelta); } lpStart->my_nFileSizeLow++; dwCurrentSize += wSize; // now it is safe to advance the pointer lpmydta = GETDTAPTR(lpmydta, wLastSize); wLastSize = lpmydta->wSize = wSize; lpmydta->my_dwAttrs = lfndta.fd.dwFileAttributes; lpmydta->my_ftLastWriteTime = lfndta.fd.ftLastWriteTime; lpmydta->my_nFileSizeLow = lfndta.fd.nFileSizeLow; lpmydta->my_nFileSizeHigh = lfndta.fd.nFileSizeHigh; lpmydta->iBitmap = (SHORT)iBitmap; if (IsLFN(pName)) { lpmydta->my_dwAttrs |= ATTR_LFN; } lstrcpy(lpmydta->my_cFileName, pName); CDBCont: if (bAllowAbort && CheckEarlyAbort()) { LocalUnlock(hMem); LocalFree(hMem); WFFindClose(&lfndta); PRINT(BF_PARMTRACE, "OUT: hDTA=-1", 0); LEAVE("CreateDTABlock"); return (HANDLE)-1; } if (!WFFindNext(&lfndta)) { break; } } CDBDone: LocalUnlock(hMem); WFFindClose(&lfndta); PRINT(BF_PARMTRACE, "OUT: hDTA=0x%lx", hMem); LEAVE("CreateDTABlock"); return hMem; CDBMemoryErr: WFFindClose(&lfndta); MyMessageBox(hwndFrame, IDS_OOMTITLE, IDS_OOMREADINGDIRMSG, MB_OK | MB_ICONEXCLAMATION); PRINT(BF_PARMTRACE, "OUT: hDTA=0x%lx", hMem); LEAVE("CreateDTABlock"); return hMem; } /*--------------------------------------------------------------------------*/ /* */ /* DirGetSelection() - */ /* */ /*--------------------------------------------------------------------------*/ /* Takes a Listbox and returns a string containing the names of the selected * files seperated by spaces. * * bSingle == 1 return only the first file * bSingle == 2 test for LFN files in the selection, doesn't return string * bSingle == 3 return fully qualified names * * returns: * if (bSingle == 1) * TRUE/FALSE if LFN is in the selection * else * pointer to the list of names (ANSI strings) * (must be freed by caller!) * *pfDir -> bool indicating directories are * contained in the selection (or that LFN names are present) * * NOTE: The caller must free the returned pointer! */ LPSTR DirGetSelection( HWND hwndDir, HWND hwndLB, INT iSelType, BOOL *pfDir ) { LPSTR p, pT; WORD i; WORD cch; WORD iMac; LPMYDTA lpmydta; CHAR szFile[MAXPATHLEN]; CHAR szPath[MAXPATHLEN]; BOOL bDir, bPropertyDialog; LPINT lpSelItems; BOOL bLFNTest; if (bLFNTest = (iSelType == 2)) { // determine if the directory it self is long... iSelType = FALSE; SendMessage(hwndDir, FS_GETDIRECTORY, sizeof(szPath), (LPARAM)szPath); StripBackslash(szPath); if (IsLFN(szPath)) if (pfDir) { *pfDir = TRUE; } return NULL; } if (bPropertyDialog = (iSelType == 3)) { iSelType = FALSE; } bDir = FALSE; if (!bLFNTest) { cch = 1; p = (LPSTR)LocalAlloc(LPTR, cch); if (!p) return NULL; *p = '\0'; } #ifdef DEBUG else p = (LPSTR)0xFFFF; // force a GP fault with bogus p use below #endif iLastSel = -1; iMac = (WORD)SendMessage(hwndLB, LB_GETSELCOUNT, 0, 0L); lpSelItems = LocalAlloc(LMEM_FIXED, sizeof(INT) * iMac); if (lpSelItems == NULL) return NULL; iMac = (WORD)SendMessage(hwndLB, LB_GETSELITEMS, (WPARAM)iMac, (LPARAM)lpSelItems); for (i=0; i < iMac; i++) { if (iLastSel == -1) // remember the first selection iLastSel = lpSelItems[i]; SendMessage(hwndLB, LB_GETTEXT, lpSelItems[i], (LPARAM)&lpmydta); if (!lpmydta) break; lstrcpy(szFile, (LPSTR)lpmydta->my_cFileName); if (lpmydta->my_dwAttrs & ATTR_DIR) { // is this a dir SendMessage(hwndDir, FS_GETDIRECTORY, sizeof(szPath), (LPARAM)szPath); if (lpmydta->my_dwAttrs & ATTR_PARENT) { // parent dir? // if we are getting a full selection don't // return the parent ".." entry (avoid deleting // and other nasty operations on the parent) if (!iSelType) continue; StripBackslash(szPath); // trim it down StripFilespec(szPath); } else { lstrcat(szPath, szFile); // fully qualified } lstrcpy(szFile, szPath); bDir = TRUE; } if (bPropertyDialog) QualifyPath(szFile); if (bLFNTest && lpmydta->my_dwAttrs & ATTR_LFN) { return (LPSTR)TRUE; } CheckEscapes(szFile); if (!bLFNTest) { cch += lstrlen(szFile) + 1; pT = (LPSTR)LocalReAlloc((HANDLE)p, cch, LMEM_MOVEABLE | LMEM_ZEROINIT); if (!pT) goto GDSExit; p = pT; lstrcat(p, szFile); } if (iSelType) goto GDSExit; if (!bLFNTest) lstrcat(p, szBlank); } GDSExit: LocalFree(lpSelItems); if (bLFNTest) { if (pfDir) { *pfDir = FALSE; } return NULL; } if (pfDir) { *pfDir = bDir; } return p; } // compute the max extent of all the files in this DTA block // and update the case to match (wTextAttribs & TA_LOWERCASE) INT GetMaxExtent( HWND hwndLB, HANDLE hDTA ) { LPMYDTA lpmydta; HDC hdc; INT nItems; INT maxWidth = 0; INT wWidth; HFONT hOld; CHAR szPath[MAXPATHLEN]; lpmydta = (LPMYDTA)LocalLock(hDTA); nItems = (INT)lpmydta->my_nFileSizeLow; hdc = GetDC(hwndLB); hOld = SelectObject(hdc, hFont); while (nItems-- > 0) { lpmydta = GETDTAPTR(lpmydta, lpmydta->wSize); lstrcpy(szPath, lpmydta->my_cFileName); // set the case of the file names here! if (!(lpmydta->my_dwAttrs & ATTR_LFN)) { if (wTextAttribs & TA_LOWERCASE) AnsiLower(szPath); else AnsiUpper(szPath); } MGetTextExtent(hdc, szPath, lstrlen(szPath), &wWidth, NULL); maxWidth = max(wWidth, maxWidth); } if (hOld) SelectObject(hdc, hOld); ReleaseDC(hwndLB, hdc); LocalUnlock(hDTA); return maxWidth + 3; // pad it out } /*--------------------------------------------------------------------------*/ /* */ /* DirFindIndex() - */ /* */ /*--------------------------------------------------------------------------*/ INT DirFindIndex( HWND hwndLB, HANDLE hDTA, LPSTR szFile ) { register INT i; INT nSel; LPMYDTA lpmydta; lpmydta = (LPMYDTA)LocalLock(hDTA); nSel = (INT)lpmydta->my_nFileSizeLow; for (i = 0; i < nSel; i++) { SendMessage(hwndLB, LB_GETTEXT, (WORD)i, (LPARAM)&lpmydta); if (!lstrcmpi(szFile, (LPSTR)lpmydta->my_cFileName)) goto DFIExit; } i = -1; // not found, return this DFIExit: LocalUnlock(hDTA); return i; } /*--------------------------------------------------------------------------*/ /* */ /* DirGetAnchorFocus() - */ /* */ /*--------------------------------------------------------------------------*/ VOID DirGetAnchorFocus( register HWND hwndLB, HANDLE hDTA, LPSTR szAnchor, LPSTR szCaret, LPSTR szTopIndex ) { register INT iSel, iCount; LPMYDTA lpmydta; hDTA; // fix compiler warning iSel = (INT)SendMessage(hwndLB, LB_GETANCHORINDEX, 0, 0L); iCount = (INT)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L); if (iCount == 1) { SendMessage(hwndLB, LB_GETTEXT, (WORD)iSel, (LPARAM)&lpmydta); if (!lpmydta) { *szAnchor = 0L; *szCaret = 0L; *szTopIndex = 0L; return; } } if (iSel >= 0 && iSel < iCount) { SendMessage(hwndLB, LB_GETTEXT, (WORD)iSel, (LPARAM)&lpmydta); lstrcpy(szAnchor, (LPSTR)lpmydta->my_cFileName); } else *szAnchor = 0L; iSel = (INT)SendMessage(hwndLB, LB_GETCARETINDEX, 0, 0L); if (iSel >= 0 && iSel < iCount) { SendMessage(hwndLB, LB_GETTEXT, (WORD)iSel, (LPARAM)&lpmydta); lstrcpy(szCaret, (LPSTR)lpmydta->my_cFileName); } else *szCaret = 0L; iSel = (WORD)SendMessage(hwndLB, LB_GETTOPINDEX, 0, 0L); if (iSel >= 0 && iSel < iCount) { SendMessage(hwndLB, LB_GETTEXT, (WORD)iSel, (LPARAM)&lpmydta); lstrcpy(szTopIndex, (LPSTR)lpmydta->my_cFileName); } else *szTopIndex = 0L; } /*--------------------------------------------------------------------------*/ /* */ /* SetSelection() - */ /* */ /*--------------------------------------------------------------------------*/ BOOL SetSelection( HWND hwndLB, HANDLE hDTA, LPSTR pSel ) { INT i; CHAR szFile[MAXPATHLEN]; BOOL bDidSomething = FALSE; while (pSel = GetNextFile(pSel, szFile, sizeof(szFile))) { i = DirFindIndex(hwndLB, hDTA, (LPSTR)szFile); if (i != -1) { SendMessage(hwndLB, LB_SETSEL, TRUE, (DWORD)i); bDidSomething = TRUE; } } return bDidSomething; } /*** FIX30: Why do we use LONG buffer ptrs here? ***/ /*--------------------------------------------------------------------------*/ /* */ /* GetPict() - */ /* */ /*--------------------------------------------------------------------------*/ /* This gets the number of consecutive chrs of the same kind. This is used * to parse the time picture. Returns 0 on error. */ INT GetPict( CHAR ch, LPSTR szStr ) { register INT count; count = 0; while (ch == *szStr++) count++; return(count); } /*--------------------------------------------------------------------------*/ /* */ /* CreateDate() - */ /* */ /*--------------------------------------------------------------------------*/ /* This picks up the values in wValArray, converts them * in a string containing the formatted date. * wValArray should contain Month-Day-Year (in that order). */ INT CreateDate( WORD *wValArray, LPSTR szOutStr ) { INT i; INT cchPictPart; WORD wDigit; WORD wIndex; WORD wTempVal; register LPSTR pszPict; register LPSTR pszInStr; pszPict = szShortDate; pszInStr = szOutStr; for (i=0; i < 3; i++) { cchPictPart = GetPict(*pszPict, pszPict); switch (*pszPict) { case 'M': wIndex = 0; goto CDDoIt; case 'D': wIndex = 1; goto CDDoIt; case 'Y': wIndex = 2; if (cchPictPart == 4) { *pszInStr++ = '1'; *pszInStr++ = '9'; } CDDoIt: /* This assumes that the values are of two digits only. */ wTempVal = wValArray[wIndex]; wDigit = wTempVal / (WORD)10; if (wDigit) *pszInStr++ = (CHAR)(wDigit + '0'); else if (cchPictPart > 1) *pszInStr++ = '0'; #if 0 else { *pszInStr++ = ' '; *pszInStr++ = ' '; } #endif *pszInStr++ = (CHAR)((wTempVal % 10) + '0'); pszPict += cchPictPart; /* Add the separator. */ if (*pszPict) *pszInStr++ = *pszPict; break; } pszPict++; } *pszInStr = 0L; return(lstrlen(szOutStr)); } /*--------------------------------------------------------------------------*/ /* */ /* CreateTime() - */ /* */ /*--------------------------------------------------------------------------*/ /* This picks up the values in wValArray, converts them * in a string containing the formatted time. * wValArray should contain Hour-Min-Sec (in that order). */ INT CreateTime( WORD * wValArray, LPSTR szOutStr ) { INT i; BOOL bAM; WORD wHourMinSec; register WORD wDigit; register LPSTR pszInStr; pszInStr = szOutStr; wDigit = wValArray[0]; bAM = (wDigit < 12); if (!iTime) { if (wDigit >= 12) wDigit -= 12; if (!wDigit) wDigit = 12; } wValArray[0] = wDigit; for (i=0; i < 3; i++) { wHourMinSec = wValArray[i]; /* This assumes that the values are of two digits only. */ wDigit = wHourMinSec / (WORD)10; if (i > 0) *pszInStr++ = (CHAR)(wDigit + '0'); else if (wDigit || iTLZero) *pszInStr++ = (CHAR)(wDigit + '0'); #if 0 else { /* NOTE: 2 blanks is the same width as one digit. */ // wrong! *pszInStr++ = ' '; *pszInStr++ = ' '; } #endif *pszInStr++ = (CHAR)((wHourMinSec % 10) + '0'); if (i < 2) *pszInStr++ = *szTime; /* Assumes time sep. is 1 char long */ } // *pszInStr++ = ' '; if (bAM) lstrcpy(pszInStr, sz1159); else lstrcpy(pszInStr, sz2359); return lstrlen(szOutStr); } /*--------------------------------------------------------------------------*/ /* */ /* PutSize() - */ /* */ /*--------------------------------------------------------------------------*/ INT APIENTRY PutSize( DWORD dwSize, LPSTR szOutStr ) { // LPSTR szStr; // int cBlanks; // char szTemp[30]; // Convert it into string return wsprintf(szOutStr, "%lu", dwSize); } /*--------------------------------------------------------------------------*/ /* */ /* PutDate() - */ /* */ /*--------------------------------------------------------------------------*/ INT APIENTRY PutDate( LPFILETIME lpftDate, LPSTR szStr ) { WORD wValArray[3]; WORD wDate, wTime; if (FileTimeToDosDateTime(lpftDate, &wDate, &wTime)) { wValArray[0] = (WORD)((wDate & MONTHMASK) >> 5); /* Month */ wValArray[1] = (WORD)((wDate & DATEMASK)); /* Date */ wValArray[2] = (WORD)((wDate >> 9) + 80); /* Year */ return(CreateDate((WORD *)wValArray, szStr)); } else { return 0; } } /*--------------------------------------------------------------------------*/ /* */ /* PutTime() - */ /* */ /*--------------------------------------------------------------------------*/ INT APIENTRY PutTime( LPFILETIME lpftTime, LPSTR szStr ) { WORD wValArray[3]; WORD wDate, wTime; if (FileTimeToDosDateTime(lpftTime, &wDate, &wTime)) { wValArray[0] = (wTime >> 0x0B); wValArray[1] = (WORD)((wTime & MINUTEMASK) >> 5); wValArray[2] = (WORD)((wTime & SECONDSMASK) << 1); return(CreateTime((WORD *)wValArray, szStr)); } else { return 0; } } /*--------------------------------------------------------------------------*/ /* */ /* PutAttributes() - */ /* */ /*--------------------------------------------------------------------------*/ INT APIENTRY PutAttributes( register DWORD dwAttribute, register LPSTR pszStr ) { WORD i; INT cch = 0; for (i=0; i < 4; i++) { if (dwAttribute & 1) { // BUG hardcoded. *pszStr++ = szAttr[i]; cch++; } else { #if 0 *pszStr++ = '-'; *pszStr++ = '-'; cch += 2; #endif } if (i == 2) dwAttribute >>= 3; /* Skip next two bits */ else dwAttribute >>= 1; /* Goto next bit */ } *pszStr = 0; return(cch); } /*--------------------------------------------------------------------------*/ /* */ /* CreateLBLine() - */ /* */ /*--------------------------------------------------------------------------*/ /* This creates a character string that contains all the required * details of a file; (Name, Size, Date, Time, Attr) */ VOID CreateLBLine( register WORD wLineFormat, LPMYDTA lpmydta, LPSTR szBuffer ) { register LPSTR pch; DWORD dwAttr; pch = szBuffer; dwAttr = lpmydta->my_dwAttrs; /* Copy the file name. */ lstrcpy(pch, lpmydta->my_cFileName); pch += lstrlen(pch); *pch = 0L; /* Should we show the size? */ if (wLineFormat & VIEW_SIZE) { *pch++ = TABCHAR; if (!(dwAttr & ATTR_DIR)) pch += PutSize(lpmydta->my_nFileSizeLow, pch); else *pch = 0; } /* Should we show the date? */ if (wLineFormat & VIEW_DATE) { *pch++ = TABCHAR; pch += PutDate(&lpmydta->my_ftLastWriteTime, pch); } /* Should we show the time? */ if (wLineFormat & VIEW_TIME) { *pch++ = TABCHAR; pch += PutTime(&lpmydta->my_ftLastWriteTime, pch); } /* Should we show the attributes? */ if (wLineFormat & VIEW_FLAGS) { *pch++ = TABCHAR; pch += PutAttributes(dwAttr, pch); } // *pch = 0L; } /*--------------------------------------------------------------------------*/ /* */ /* CompareDTA() - */ /* */ /*--------------------------------------------------------------------------*/ INT CompareDTA( register LPMYDTA lpItem1, LPMYDTA lpItem2, WORD wSort ) { register INT ret; if (lpItem1->my_dwAttrs & ATTR_PARENT) { ret = -1; goto CDDone; } if (lpItem2->my_dwAttrs & ATTR_PARENT) { ret = 1; goto CDDone; } if ((lpItem1->my_dwAttrs & ATTR_DIR) > (lpItem2->my_dwAttrs & ATTR_DIR)) { ret = -1; goto CDDone; } else if ((lpItem1->my_dwAttrs & ATTR_DIR) < (lpItem2->my_dwAttrs & ATTR_DIR)) { ret = 1; goto CDDone; } switch (wSort) { case IDD_TYPE: { LPSTR ptr1; LPSTR ptr2; // BUG: should use strrchr for long file names. for (ptr1 = lpItem1->my_cFileName; *ptr1 && *ptr1 != '.'; ptr1++) ; for (ptr2 = lpItem2->my_cFileName; *ptr2 && *ptr2 != '.'; ptr2++) ; ret = lstrcmpi(ptr1, ptr2); if (ret == 0) goto CompareNames; break; } case IDD_SIZE: if (lpItem1->my_nFileSizeLow > lpItem2->my_nFileSizeLow) ret = -1; else if (lpItem1->my_nFileSizeLow < lpItem2->my_nFileSizeLow) ret = 1; else goto CompareNames; break; case IDD_DATE: { DWORD d1High, d1Low; DWORD d2High, d2Low; d1High = lpItem1->my_ftLastWriteTime.dwHighDateTime; d2High = lpItem2->my_ftLastWriteTime.dwHighDateTime; if (d1High > d2High) { ret = -1; } else if (d1High < d2High) { ret = 1; } else { d1Low = lpItem1->my_ftLastWriteTime.dwLowDateTime; d2Low = lpItem2->my_ftLastWriteTime.dwLowDateTime; if (d1Low > d2Low) ret = -1; else if (d1Low < d2Low) ret = 1; else goto CompareNames; } break; } case IDD_NAME: CompareNames: ret = lstrcmpi(lpItem1->my_cFileName, lpItem2->my_cFileName); break; } CDDone: return ret; } // load the status buffers with the appropriate stuff and invalidates // the status area causing it to repaint. VOID APIENTRY UpdateStatus( HWND hWnd ) { CHAR szTemp[128]; WCHAR szNumBuf1[40]; WCHAR szNumBuf2[40]; WORD wDrive; HWND hwndDir; RECT rc; if (!bStatusBar) return; if (hWnd != (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L)) return; hwndDir = HasDirWindow(hWnd); szStatusTree[0] = 0L; if (hwndDir) GetDirStatus(hwndDir, szStatusTree, szStatusDir); else szStatusDir[0] = 0L; // force the status area to update GetClientRect(hwndFrame, &rc); rc.top = rc.bottom - dyStatus; InvalidateRect(hwndFrame, &rc, FALSE); } HWND GetDirSelData( HWND hWnd, DWORD *pdwSelSize, INT *piSelCount, DWORD *pdwTotalSize, INT *piTotalCount ) { INT i; LPMYDTA lpmydta; HWND hwndLB; INT countSel, countTotal; LPINT lpSelItems, lpSelItemsT; HANDLE hDTA; if (!(hwndLB = GetDlgItem(hWnd, IDCW_LISTBOX))) { // fast scroll return NULL; } *pdwSelSize = *pdwTotalSize = 0L; *piSelCount = *piTotalCount = 0; countSel = (INT)SendMessage(hwndLB, LB_GETSELCOUNT, 0, 0L); lpSelItems = LocalAlloc(LMEM_FIXED, sizeof(INT) * countSel); if (lpSelItems == NULL) return NULL; countSel = (INT)SendMessage(hwndLB, LB_GETSELITEMS, (WPARAM)countSel, (LPARAM)lpSelItems); hDTA = (HANDLE)GetWindowLongPtr(hWnd, GWLP_HDTA); if (hDTA == NULL) return NULL; lpmydta = (LPMYDTA)LocalLock(hDTA); countTotal = (INT)lpmydta->my_nFileSizeLow; lpSelItemsT = lpSelItems; for (i = 0; i < countTotal; i++) { lpmydta = GETDTAPTR(lpmydta, lpmydta->wSize); if (lpmydta->my_dwAttrs & ATTR_PARENT) continue; if (countSel && *lpSelItems == lpmydta->nIndex) { (*piSelCount)++; *pdwSelSize += lpmydta->my_nFileSizeLow; countSel--; lpSelItems++; } (*piTotalCount)++; *pdwTotalSize += lpmydta->my_nFileSizeLow; } LocalUnlock(hDTA); LocalFree(lpSelItemsT); return hwndLB; } VOID GetDirStatus( HWND hWnd, LPSTR szMessage1, LPSTR szMessage2 ) { INT iSelCount, iCount; DWORD dwSelSize, dwSize; CHAR szNumBuf[40]; HWND hwndLB; szMessage2[0] = 0; hwndLB = GetDirSelData(hWnd, &dwSelSize, &iSelCount, &dwSize, &iCount); if (LoadString(hAppInstance, IDS_STATUSMSG, szMessage, sizeof(szMessage))) wsprintf(szMessage2, szMessage, iCount); if ((HWND)GetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS) == hwndLB) { if (LoadString(hAppInstance, IDS_STATUSMSG2, szMessage, sizeof(szMessage))) wsprintf(szMessage1, szMessage, iSelCount); } } // given a descendant of an MDI child (or an MDI child) return // the MDI child in the descendant chain. returns NULL if not // found. HWND APIENTRY GetMDIChildFromDecendant( HWND hwnd ) { HWND hwndT; while (hwnd && ((hwndT = GetParent(hwnd)) != hwndMDIClient)) hwnd = hwndT; return hwnd; } // setup the defTabStops[] array for subsequent TabbedTextOut() calls. // // in: // iMaxWidthFileName the largest dx width of files to be // displayed // // returns: // total extent of the "File Details" view. used to // set scroll extents INT APIENTRY FixTabsAndThings( HWND hwndLB, WORD *pwTabs, INT iMaxWidthFileName, WORD wViewOpts ) { INT i; HDC hdc; HFONT hOld; CHAR szBuf[30]; INT ixExtent = 0; i = iMaxWidthFileName; // the widest filename if (pwTabs == NULL) return i; hdc = GetDC(NULL); hOld = SelectObject(hdc, hFont); // max size digits field if (wViewOpts & VIEW_SIZE) { MGetTextExtent(hdc, "99999999", 8, &ixExtent, NULL); i += ixExtent + dxText; *pwTabs++ = (WORD)i; // Size } if (wViewOpts & VIEW_DATE) { FILETIME filetime; DosDateTimeToFileTime((WORD)((19 << 9) | (12 << 5) | 30), (WORD)0xFFFF, &filetime); PutDate(&filetime, szBuf); // max date digits MGetTextExtent(hdc, szBuf, lstrlen(szBuf), &ixExtent, NULL); i += ixExtent + dxText; *pwTabs++ = (WORD)i; // Date } // max time digits if (wViewOpts & VIEW_TIME) { FILETIME filetime; DosDateTimeToFileTime((WORD)((19 << 9) | (12 << 5) | 30), (WORD)0xFFFF, &filetime); PutTime(&filetime, szBuf); MGetTextExtent(hdc, szBuf, lstrlen(szBuf), &ixExtent, NULL); i += ixExtent + dxText; *pwTabs++ = (WORD)i; // Time } // max attris digits if (wViewOpts & VIEW_FLAGS) { PutAttributes(ATTR_ALL, szBuf); MGetTextExtent(hdc, szBuf, lstrlen(szBuf), &ixExtent, NULL); i += ixExtent + dxText; *pwTabs++ = (WORD)i; // Attributes } if (hOld) SelectObject(hdc, hOld); ReleaseDC(NULL, hdc); SendMessage(hwndLB, LB_SETHORIZONTALEXTENT, i + dxFolder + 4 * dyBorderx2, 0L); return i; // total extent } // sets the font and adjusts the dimension parameters for the // new font // // in: // hWnd hwnd of a dir window // hwndLB and it's listbox // hFont the font to set // // uses: // dyFileName GLOBAL; set based on new font height // GWL_VIEW window word of hWnd for either full or name view // GWL_HDTA to compute the max extent given the new font // // sets: // Listbox tabs array // LB_SETCOLUMNWIDTH // or // LB_SETHORIZONTALEXTENT VOID APIENTRY SetLBFont( HWND hWnd, HWND hwndLB, HANDLE hNewFont ) { INT dxMaxExtent; HANDLE hDTA; WORD wViewFlags = (WORD)GetWindowLong(GetParent(hWnd), GWL_VIEW); SendMessage(hwndLB, WM_SETFONT, (WPARAM)hNewFont, 0L); // this is needed when changing the font. when creating // the return from WM_MEASUREITEM will set the cell height SendMessage(hwndLB, LB_SETITEMHEIGHT, 0, (LONG)dyFileName); hDTA = (HANDLE)GetWindowLongPtr(hWnd, GWLP_HDTA); dxMaxExtent = (INT)GetMaxExtent(hwndLB, hDTA); // if we are in name only view we change the width if ((VIEW_EVERYTHING & wViewFlags) == VIEW_NAMEONLY) { SendMessage(hwndLB, LB_SETCOLUMNWIDTH, dxMaxExtent + dxFolder + dyBorderx2, 0L); } else { FixTabsAndThings(hwndLB,(WORD *)GetWindowLongPtr(hWnd, GWLP_TABARRAY), dxMaxExtent, wViewFlags); } } VOID APIENTRY UpdateSelection( HWND hwndLB ) { INT count, i; RECT rc; count = (WORD)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L); for (i=0; i < count; i++) { if ((BOOL)SendMessage(hwndLB, LB_GETSEL, i, 0L)) { SendMessage(hwndLB, LB_GETITEMRECT, i, (LPARAM)&rc); InvalidateRect(hwndLB, &rc, TRUE); } } } LONG CreateFSCChangeDisplayMess( HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam ) { CHAR szCaret[MAXFILENAMELEN+1]; CHAR szAnchor[MAXFILENAMELEN+1]; CHAR szTopIndex[MAXFILENAMELEN+1]; CHAR szPath[256]; HCURSOR hCursor; HWND hwndLB, hwndT; HANDLE hDTA; LPMYDTA lpmydta; DWORD ws; LPSTR pSel; INT iSel, iTop=0; RECT rc; BOOL bResetFocus; WORD *pwTabs; hwndLB = GetDlgItem(hWnd, IDCW_LISTBOX); switch (wMsg) { case WM_FILESYSCHANGE: if (cDisableFSC) { // I need to be updated SetWindowLong(GetParent(hWnd), GWL_FSCFLAG, TRUE); break; } wParam = CD_PATH; lParam = 0L; /*** FALL THRU ***/ case FS_CHANGEDISPLAY: // We dont want to reset the flag, if the operation is not CD_PATH. // This is because, only the operation CD_PATH implies a true // refresh. The operations CD_VEIW and CD_SORT are not refresh // operations. They merely reformat the existing contents of a dir // window. The flag is now reset in 'case CD_PATH:'. //SetWindowLong(GetParent(hWnd), GWL_FSCFLAG, FALSE); hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT)); ShowCursor(TRUE); pSel = NULL; // init this bResetFocus = (GetFocus() == hwndLB); hDTA = (HANDLE)GetWindowLongPtr(hWnd, GWLP_HDTA); switch (wParam) { case CD_SORT: // change the sort order of the listbox // we want to save the current selection and things here // and restore them once the listbox has been rebuilt // But first, save a list of the selected items FIX31 pSel = (LPSTR)DirGetSelection(hWnd, hwndLB, 0, NULL); DirGetAnchorFocus(hwndLB, hDTA, szAnchor, szCaret, szTopIndex); iTop = (INT)SendMessage(hwndLB, LB_GETTOPINDEX, 0, 0L); SetWindowLong(GetParent(hWnd), GWL_SORT, LOWORD(lParam)); SendMessage(hwndLB, LB_RESETCONTENT, 0, 0L); SendMessage(hwndLB, WM_SETREDRAW, FALSE, 0L); FillDirList(hwndLB, hDTA); goto ResetSelection; case CD_VIEW: { WORD wCurView; // change the view type (name only, vs full details) // Warning! Convoluted Code! We want to destroy the // listbox only if we are going between Name Only view // and Details view. wNewView = LOWORD(lParam); wCurView = (WORD)GetWindowLong(GetParent(hWnd), GWL_VIEW); if (wNewView == wCurView) break; // NOP // special case the long and partial view change // this doesn't require us to recreate the listbox if ((VIEW_EVERYTHING & wNewView) && (VIEW_EVERYTHING & wCurView)) { SetWindowLong(GetParent(hWnd), GWL_VIEW, wNewView); FixTabsAndThings(hwndLB,(WORD *)GetWindowLongPtr(hWnd, GWLP_TABARRAY), GetMaxExtent(hwndLB, hDTA), wNewView); InvalidateRect(hwndLB, NULL, TRUE); break; } /* Things are a changing radically. Destroy the listbox. */ // But first, save a list of the selected items pSel = (LPSTR)DirGetSelection(hWnd, hwndLB, 0, NULL); DirGetAnchorFocus(hwndLB, hDTA, szAnchor, szCaret, szTopIndex); iTop = (INT)SendMessage(hwndLB, LB_GETTOPINDEX, 0, 0L); lstrcpy(szTopIndex, szCaret); if ((HWND)GetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS) == hwndLB) SetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS, 0L); DestroyWindow(hwndLB); /* Create a new one (preserving the Sort setting). */ wNewSort = (WORD)GetWindowLong(GetParent(hWnd), GWL_SORT); dwNewAttribs = (DWORD)GetWindowLong(GetParent(hWnd), GWL_ATTRIBS); goto CreateLB; } case CD_PATH | CD_ALLOWABORT: case CD_PATH: case CD_PATH_FORCE: // bad things happens if we change the path // while we are reading the tree. bounch this // in that case. this causes the steal data // code in the tree to barf because we would // free the hDTA while it is being traversed // (very bad thing) // we set the GWL_FSCFLAG to true, if we could not refresh. // else we set it to FALSE. However if the flag was previously // TRUE we set lParam to NULL. lParam = NULL implies 'forced' // refresh. hwndT = HasTreeWindow(GetParent(hWnd)); if (hwndT && GetWindowLong(hwndT, GWL_READLEVEL)) { SetWindowLong(GetParent(hWnd), GWL_FSCFLAG, TRUE); break; } else { if (SetWindowLong(GetParent(hWnd), GWL_FSCFLAG, FALSE)) lParam = 0L; } // change the path of the current directory window (basically // recreate the whole thing) // if lParam == NULL this is a refresh, otherwise // check for short circut case to avoid rereading // the directory GetMDIWindowText(GetParent(hWnd), szPath, sizeof(szPath)); if (lParam) { // get out early if this is a NOP if ((wParam != CD_PATH_FORCE) && !lstrcmpi(szPath, (LPSTR)lParam)) break; lstrcpy(szPath, (LPSTR)lParam); iLastSel = -1; // invalidate the last selection } // if this is a refresh save the current selection, anchor stuff, etc if (!lParam) { pSel = (LPSTR)DirGetSelection(hWnd, hwndLB, 0, NULL); iTop = (INT)SendMessage(hwndLB, LB_GETTOPINDEX, 0, 0L); DirGetAnchorFocus(hwndLB, hDTA, szAnchor, szCaret, szTopIndex); } // Create a new one (preserving the Sort setting) wNewSort = (WORD)GetWindowLong(GetParent(hWnd), GWL_SORT); wNewView = (WORD)GetWindowLong(GetParent(hWnd), GWL_VIEW); dwNewAttribs = GetWindowLong(GetParent(hWnd), GWL_ATTRIBS); if (hDTA) { // fast scroll case LocalFree(hDTA); hDTA = NULL; SendMessage(hwndLB, LB_RESETCONTENT, 0, 0L); } goto CreateNewPath; } SetCursor(hCursor); ShowCursor(FALSE); break; case WM_CREATE: TRACE(BF_WM_CREATE, "CreateFSCChangeDisplayMess - WM_CREATE"); // wNewView, wNewSort and dwNewAddribs define the viewing // parameters of the new window (GLOBALS) // the window text of the parent window defines the // filespec and the directory to open up hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT)); ShowCursor(TRUE); wParam = 0; // don't allow abort in CreateDTABlock() lParam = 1L; // allow DTA steal optimization pSel = NULL; // no selection to restore bResetFocus = FALSE; // no focus to restore // get the dir to open from our parent window text GetMDIWindowText(GetParent(hWnd), szPath, sizeof(szPath)); if ((pwTabs = (WORD *)LocalAlloc(LPTR,sizeof(WORD) * 4)) == NULL) return -1L; SetWindowLongPtr(hWnd, GWLP_TABARRAY, (ULONG_PTR)pwTabs); CreateNewPath: // at this point szPath has the directory to read. this // either came from the WM_CREATE case or the // FS_CHANGEDISPLAY (CD_PATH) directory reset #ifdef DEBUG { char buf[80]; wsprintf(buf, "attribs %4.4X\r\n", dwNewAttribs); OutputDebugString(buf); } #endif if (!dwNewAttribs) dwNewAttribs = ATTR_DEFAULT; hDTA = CreateDTABlock(hWnd, szPath, dwNewAttribs, wParam & CD_ALLOWABORT ? TRUE : FALSE, lParam == 0L); // check for user abort (fast scroll case) if (hDTA == (HANDLE)-1) { SetWindowLongPtr(hWnd, GWLP_HDTA, 0L); goto FastScrollExit; } // for the FS_CHANGEDISPLAY case we set this now, to avoid // multiple title repaints when the user is fast scrolling if (wMsg != WM_CREATE) SetMDIWindowText(GetParent(hWnd), szPath); SetWindowLongPtr(hWnd, GWLP_HDTA, (LONG_PTR)hDTA); if (!hDTA) goto CDAbort; if (wMsg != WM_CREATE) goto SkipWindowCreate; CreateLB: if ((wNewView & VIEW_EVERYTHING) == VIEW_NAMEONLY) ws = WS_DIRSTYLE | LBS_MULTICOLUMN | WS_HSCROLL | WS_VISIBLE | WS_BORDER | LBS_DISABLENOSCROLL; else ws = WS_DIRSTYLE | WS_HSCROLL | WS_VSCROLL | WS_VISIBLE | WS_BORDER | LBS_DISABLENOSCROLL; GetClientRect(hWnd, &rc); // the border stuff is for the non initial create case // I don't know why hwndLB = CreateWindowEx(0L, szListbox, NULL, ws, dyBorder, dyBorder, rc.right - 2*dyBorder, rc.bottom - 2*dyBorder, hWnd, (HMENU)IDCW_LISTBOX, hAppInstance, NULL); if (!hwndLB) { if (hDTA) LocalFree(hDTA); if (wMsg != WM_CREATE) SendMessage(hWnd, WM_SYSCOMMAND, SC_CLOSE, 0L); CDAbort: ShowCursor(FALSE); SetCursor(hCursor); return -1L; } // set all the view/sort/include parameters here SetWindowLong(GetParent(hWnd), GWL_VIEW, wNewView); SetWindowLong(GetParent(hWnd), GWL_SORT, wNewSort); SetWindowLong(GetParent(hWnd), GWL_ATTRIBS, dwNewAttribs); // restore the last focus stuff if we are recreating here if (!GetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS)) SetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS, (LONG_PTR)hwndLB); // set the font and dimensions here SkipWindowCreate: SetLBFont(hWnd, hwndLB, hFont); SendMessage(hwndLB, WM_SETREDRAW, FALSE, 0L); FillDirList(hwndLB, hDTA); if (pSel) { BOOL bDidSomething; ResetSelection: /* Give the selected item the focus rect and anchor pt. */ bDidSomething = SetSelection(hwndLB, hDTA, pSel); LocalFree((HANDLE)pSel); if (!bDidSomething) goto SelectFirst; iSel = DirFindIndex(hwndLB, hDTA, szTopIndex); if (iSel == -1) iSel = 0; SendMessage(hwndLB, LB_SETTOPINDEX, iSel, 0L); iSel = DirFindIndex(hwndLB, hDTA, szAnchor); if (iSel == -1) iSel = 0; SendMessage(hwndLB, LB_SETANCHORINDEX, iSel, 0L); iSel = DirFindIndex(hwndLB, hDTA, szCaret); if (iSel == -1) iSel = 0; /* SETCARETINDEX will scroll item into view */ SendMessage(hwndLB, LB_SETCARETINDEX, iSel, 0L); } else { INT iLBCount; SelectFirst: iLBCount = (INT)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L); if (iLastSel != -1 && (iLastSel <= iLBCount)) { iSel = iLastSel; // check the case of the last item being deleted if (iSel == iLBCount) iSel--; SendMessage(hwndLB, LB_SETSEL, TRUE, (DWORD)iSel); } else { // Select the first non-directory item iSel = 0; while (iSel < iLBCount) { SendMessage(hwndLB, LB_GETTEXT, iSel, (LPARAM)&lpmydta); if (!lpmydta) break; if (!(lpmydta->my_dwAttrs & ATTR_PARENT)) { iTop = iSel; break; } iSel++; } LocalUnlock(hDTA); if (iSel == iLBCount) iSel = 0; } SendMessage(hwndLB, LB_SETTOPINDEX, iTop, 0L); // and select this item if no tree window if (!HasTreeWindow(GetParent(hWnd))) SendMessage(hwndLB, LB_SETSEL, TRUE, (DWORD)iSel); SendMessage(hwndLB, LB_SETANCHORINDEX, iSel, 0L); /* SETCARETINDEX will scroll item into view */ SendMessage(hwndLB, LB_SETCARETINDEX, iSel, 0L); } if (bResetFocus) if (SetDirFocus(hWnd)) SetFocus(hWnd); SendMessage(hwndLB, WM_SETREDRAW, TRUE, 0L); InvalidateRect(hwndLB, NULL, TRUE); lFreeSpace = -1; // force status update UpdateStatus(GetParent(hWnd)); FastScrollExit: ShowCursor(FALSE); SetCursor(hCursor); break; } return 0L; } INT_PTR APIENTRY DirWndProc( HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam ) { INT iSel, i; LPSTR pSel; HWND hwndLB; HANDLE hDTA; LPMYDTA lpmydta; CHAR szTemp[MAXPATHLEN] = {0}; CHAR szSourceFile[MAXPATHLEN]; static HWND hwndOwnerDraw = NULL; STKCHK(); /* Here we generate OWNERDRAWBEGIN and OWNERDRAWEND messages * to speed up the painting operations. We do the expensive stuff * at the beginning instead of on every DRAWITEM message. */ if (hwndOwnerDraw == hWnd && wMsg != WM_DRAWITEM) { hwndOwnerDraw = NULL; SendMessage(hWnd, WM_OWNERDRAWEND, 0, 0L); } else if (wMsg == WM_DRAWITEM && hwndOwnerDraw != hWnd) { SendMessage(hWnd, WM_OWNERDRAWBEGIN, wParam, lParam); hwndOwnerDraw = hWnd; } hwndLB = GetDlgItem(hWnd, IDCW_LISTBOX); switch (wMsg) { // returns in lParam upper case ANSI directory string with // a trailing backslash. if you want to do a SetCurrentDirecotor() // you must first StripBackslash() the thing! case FS_GETDIRECTORY: MSG("DirWndProc", "FS_GETDIRECTORY"); GetMDIWindowText(GetParent(hWnd), (LPSTR)lParam, (INT)wParam); // get the string StripFilespec((LPSTR)lParam); // Remove the trailing extention AddBackslash((LPSTR)lParam); // terminate with a backslash //AnsiUpper((LPSTR)lParam); // and upper case break; case FS_GETDRIVE: MSG("DirWndProc", "FS_GETDRIVE"); // Returns the letter of the corresponding directory GetWindowText(GetParent(hWnd), szTemp, sizeof(szTemp)); AnsiUpper(szTemp); return szTemp[0]; // first character case FS_GETFILESPEC: MSG("DirWndProc", "FS_GETFILESPEC"); // returns the current filespec (from View.Include...). this is // an uppercase ANSI string GetMDIWindowText(GetParent(hWnd), (LPSTR)lParam, (INT)wParam); StripPath((LPSTR)lParam); //AnsiUpper((LPSTR)lParam); // and upper case break; case FS_SETSELECTION: MSG("DirWndProc", "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, FALSE); SendMessage(hwndLB, WM_SETREDRAW, TRUE, 0L); InvalidateRect(hwndLB, NULL, TRUE); break; case FS_GETSELECTION: // return = pszDir #define pfDir (BOOL *)lParam #define fSingleSel (BOOL)wParam MSG("DirWndProc", "FS_GETSELECTION"); return (INT_PTR)DirGetSelection(hWnd, hwndLB, fSingleSel, pfDir); #undef pfDir #undef fSingleSel case WM_CREATE: case WM_FILESYSCHANGE: case FS_CHANGEDISPLAY: TRACE(BF_WM_CREATE, "DirWndProc - WM_CREATE"); return CreateFSCChangeDisplayMess(hWnd, wMsg, wParam, lParam); case WM_DESTROY: MSG("DirWndProc", "WM_DESTROY"); { HANDLE hMem; HWND hwnd; if (hwndLB == GetFocus()) if (hwnd = HasTreeWindow(GetParent(hWnd))) SetFocus(hwnd); if (hMem = (HANDLE)GetWindowLongPtr(hWnd, GWLP_TABARRAY)) LocalFree(hMem); } break; case WM_CHARTOITEM: MSG("DirWndProc", "WM_CHARTOITEM"); { WORD i, j; WORD cItems; CHAR ch[2]; if ((ch[0] = GET_WM_CHARTOITEM_CHAR(wParam, lParam)) <= ' ') return(-1L); i = GET_WM_CHARTOITEM_POS(wParam, lParam); cItems = (WORD)SendMessage(hwndLB, LB_GETCOUNT, 0, 0L); szTemp[1] = 0L; ch[0] &= 255; ch[1] = '\0'; for (j=1; j <= cItems; j++) { SendMessage(hwndLB, LB_GETTEXT, (i + j) % cItems, (LPARAM)&lpmydta); szTemp[0] = lpmydta->my_cFileName[0]; /* Do it this way to be case insensitive. */ if (!lstrcmpi((LPSTR)ch, szTemp)) break; } if (j > cItems) return -2L; return(MAKELONG((i + j) % cItems, 0)); } case WM_COMPAREITEM: MSG("DirWndProc", "WM_COMPAREITEM"); { #define lpci ((LPCOMPAREITEMSTRUCT)lParam) return (LONG)CompareDTA((LPMYDTA)lpci->itemData1, (LPMYDTA)lpci->itemData2, (WORD)GetWindowLong(GetParent(hWnd), GWL_SORT)); } case WM_NCDESTROY: MSG("DirWndProc", "WM_NCDESTROY"); if (hDTA = (HANDLE)GetWindowLongPtr(hWnd, GWLP_HDTA)) { LocalFree(hDTA); } break; case WM_DRAGLOOP: MSG("DirWndProc", "WM_DRAGDROP"); /* 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, FALSE); break; case WM_DRAGSELECT: MSG("DirWndProc", "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, FALSE); break; case WM_DRAGMOVE: MSG("DirWndProc", "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, FALSE); /* Select the new one. */ iSelHilite = iSel; DSRectItem(hwndLB, iSel, TRUE, FALSE); break; case WM_OWNERDRAWBEGIN: #define lpLBItem ((LPDRAWITEMSTRUCT)lParam) MSG("DirWndProc", "WM_OWNERDRAWBEGIN"); /* Set the default bk and text colors. */ SetTextColor(lpLBItem->hDC, GetSysColor(COLOR_WINDOWTEXT)); SetBkColor(lpLBItem->hDC, GetSysColor(COLOR_WINDOW)); #undef lpLBItem break; case WM_OWNERDRAWEND: MSG("DirWndProc", "WM_OWNERDRAWEND"); break; case WM_DRAWITEM: #define lpLBItem ((LPDRAWITEMSTRUCT)lParam) MSG("DirWndProc", "WM_DRAWITEM"); { WORD wViewFlags; LPMYDTA lpmydta; /* Don't do anything to empty listboxes. */ if (lpLBItem->itemID == -1) break; if (lpLBItem->itemData == (DWORD)0) { LoadString(hAppInstance, IDS_NOFILES, szTemp, sizeof(szTemp)); TextOut(lpLBItem->hDC, lpLBItem->rcItem.left, lpLBItem->rcItem.top, szTemp, lstrlen(szTemp)); } else { lpmydta = (LPMYDTA)lpLBItem->itemData; wViewFlags = (WORD)GetWindowLong(GetParent(hWnd), GWL_VIEW); if (wViewFlags & VIEW_EVERYTHING) { // if any of the wViewFlags bits set, we are in slow mode CreateLBLine(wViewFlags, lpmydta, szTemp); DrawItem(lpLBItem, szTemp, lpmydta->my_dwAttrs, (HWND)GetFocus()==lpLBItem->hwndItem, (WORD *)GetWindowLongPtr(hWnd, GWLP_TABARRAY)); } else DrawItemFast(hWnd, lpLBItem, lpmydta, (HWND)GetFocus()==lpLBItem->hwndItem); } } #undef lpLBItem break; case WM_DROPOBJECT: MSG("DirWndProc", "WM_DROPOBJECT"); { WORD ret; LPSTR pFrom; DWORD dwAttrib = 0; // init this to not a dir WORD iSelSink; #define lpds ((LPDROPSTRUCT)lParam) // Do nothing - but remove selection rectangle DSRectItem(hwndLB, iSelHilite, FALSE, FALSE); return(TRUE); /* 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 */ // this is the listbox index of the destination 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; } // set the destination, assume move/copy case below (c:\foo\) SendMessage(hWnd, FS_GETDIRECTORY, sizeof(szTemp), (LPARAM)szTemp); // Are we dropping on a unused portion of some listbox? if (iSelSink == 0xFFFF) goto NormalMoveCopy; // check for drop on a directory SendMessage(hwndLB, LB_GETTEXT, iSelSink, (LPARAM)&lpmydta); lstrcpy(szSourceFile, lpmydta->my_cFileName); dwAttrib = lpmydta->my_dwAttrs; if (dwAttrib & ATTR_DIR) { if (dwAttrib & ATTR_PARENT) { // special case the parent StripBackslash(szTemp); StripFilespec(szTemp); } else { lstrcat(szTemp, szSourceFile); } goto DirMoveCopy; } // dropping on a program? if (!IsProgramFile(szSourceFile)) goto NormalMoveCopy; // no, normal stuff // directory drop on a file? this is a NOP if (lpds->wFmt == DOF_DIRECTORY) { DSRectItem(hwndLB, iSelHilite, FALSE, FALSE); break; } // We're dropping a file onto a program. // Exec the program using the source file as the parameter. // set the directory to that of the program to exec SendMessage(hWnd, FS_GETDIRECTORY, sizeof(szTemp), (LPARAM)szTemp); StripBackslash(szTemp); FixAnsiPathForDos(szTemp); SheChangeDir(szTemp); // get the selected file pSel = (LPSTR)SendMessage(lpds->hwndSource, FS_GETSELECTION, TRUE, 0L); if (lstrlen(pSel) > MAXPATHLEN) // don't blow up below! goto DODone; if (bConfirmMouse) { LoadString(hAppInstance, IDS_MOUSECONFIRM, szTitle, sizeof(szTitle)); LoadString(hAppInstance, IDS_EXECMOUSECONFIRM, szTemp, sizeof(szTemp)); wsprintf(szMessage, szTemp, (LPSTR)szSourceFile, (LPSTR)pSel); if (MessageBox(hwndFrame, szMessage, szTitle, MB_YESNO | MB_ICONEXCLAMATION) != IDYES) goto DODone; } // create an absolute path to the argument (search window alaready // is absolute) if (lpds->hwndSource == hwndSearch) { szTemp[0] = 0L; } else { SendMessage(lpds->hwndSource, FS_GETDIRECTORY, sizeof(szTemp), (LPARAM)szTemp); } lstrcat(szTemp, pSel); // this is the parameter to the exec // put a "." extension on if none found if (*GetExtension(szTemp) == 0) lstrcat(szTemp, "."); FixAnsiPathForDos(szSourceFile); FixAnsiPathForDos(szTemp); ret = ExecProgram(szSourceFile, szTemp, NULL, FALSE); if (ret) MyMessageBox(hwndFrame, IDS_EXECERRTITLE, ret, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL); DODone: DSRectItem(hwndLB, iSelHilite, FALSE, FALSE); LocalFree((HANDLE)pSel); return TRUE; NormalMoveCopy: /* Make sure that we don't move into same dir. */ if (GetParent(hWnd) == (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L)) return TRUE; DirMoveCopy: // the source filename is in the loword pFrom = (LPSTR)(((LPDRAGOBJECTDATA)(lpds->dwData))->pch); // SetSourceDir(lpds); AddBackslash(szTemp); lstrcat(szTemp, szStarDotStar); // put files in this dir CheckEscapes(szTemp); ret = DMMoveCopyHelper(pFrom, szTemp, fShowSourceBitmaps); DSRectItem(hwndLB, iSelHilite, FALSE, FALSE); if (ret) return TRUE; if (!fShowSourceBitmaps) SendMessage(lpds->hwndSource, WM_FILESYSCHANGE, FSC_REFRESH, 0L); // we got dropped on, but if this is a dir we don't need to refresh if (!(dwAttrib & ATTR_DIR)) SendMessage(hWnd, WM_FILESYSCHANGE, FSC_REFRESH, 0L); return TRUE; } #if 0 case WM_GETTEXT: MSG("DirWndProc", "WM_GETTEXT"); { HDC hDC; RECT rc; /* This is where we make sure that the Directory's caption fits * inside the caption bar. */ /* Get the full path name. */ DefWindowProc(hWnd, wMsg, wParam, lParam); GetClientRect(hWnd, (LPRECT)&rc); hDC = GetDC(hWnd); CompactPath(hDC, (LPSTR)lParam, rc.right-rc.left-(dxText * 6)); ReleaseDC(hWnd, hDC); return((LONG)lstrlen((LPSTR)lParam)); /* Don't call DefWindowProc()! */ } #endif case WM_LBTRACKPOINT: MSG("DirWndProc", "WM_LBTRACKPOINT"); return DSTrackPoint(hWnd, hwndLB, wParam, lParam, FALSE); case WM_MEASUREITEM: MSG("DirWndProc", "WM_MEASUREITEM"); #define pLBMItem ((LPMEASUREITEMSTRUCT)lParam) pLBMItem->itemHeight = dyFileName; // the same as in SetLBFont() break; case WM_QUERYDROPOBJECT: MSG("DirWndProc", "WM_QUERYDROPOBJECT"); // lParam LPDROPSTRUCT // // return values: // 0 don't accept (use ghost buster) // 1 accept, use cursor from DragObject() // hCursor accept, change to this cursor // /* 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 = (DWORD)-1L; return (INT_PTR)GetMoveCopyCursor(); } return FALSE; case WM_SETFOCUS: // Fall through case WM_LBUTTONDOWN: MSG("DirWndProc", "WM_SETFOCUS/WM_LBUTTONDOWN"); SetFocus(hwndLB); break; case WM_COMMAND: switch (GET_WM_COMMAND_CMD(wParam, lParam)) { case LBN_DBLCLK: MSG("DirWndProc", "LBN_DBLCLK"); /* Double-click... Open the blasted thing. */ SendMessage(hwndFrame, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_OPEN, 0, 0)); break; case LBN_SELCHANGE: MSG("DirWndProc", "LBN_SELCHANGE"); for (i = 0; i < iNumExtensions; i++) { (extensions[i].ExtProc)(hwndFrame, FMEVENT_SELCHANGE, 0L); } UpdateStatus(GetParent(hWnd)); break; case LBN_SETFOCUS: MSG("DirWndProc", "LBN_SETFOCUS"); // Make sure there are files in this window. If not, set // the focus to the tree or drives window. Note: This // message was caused by a mouse click and not an // accelerator, because these were handled in the window // routine that was losing the focus. if (SetDirFocus(hWnd)) { SetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS, (LPARAM)GET_WM_COMMAND_HWND(wParam, lParam)); UpdateSelection(GET_WM_COMMAND_HWND(wParam, lParam)); } break; case LBN_KILLFOCUS: MSG("DirWndProc", "LBN_KILLFOCUS"); SetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS, 0L); UpdateSelection(GET_WM_COMMAND_HWND(wParam, lParam)); SetWindowLongPtr(GetParent(hWnd), GWLP_LASTFOCUS, (LPARAM)GET_WM_COMMAND_HWND(wParam, lParam)); break; } break; case WM_VKEYTOITEM: MSG("DirWndProc", "WM_VKEYTOITEM"); switch (GET_WM_VKEYTOITEM_ITEM(wParam, lParam)) { case VK_ESCAPE: bCancelTree = TRUE; return -2L; case 0xBF: /* Ctrl-/ */ SendMessage(hwndFrame, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_SELALL, 0, 0)); return -2; case 0xDC: /* Ctrl-\ */ SendMessage(hwndFrame, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_DESELALL, 0, 0)); return -2; case VK_F6: // like excel case VK_TAB: { HWND hwndTree, hwndDrives; GetTreeWindows(GetParent(hWnd), &hwndTree, NULL, &hwndDrives); if (GetKeyState(VK_SHIFT) < 0) SetFocus(hwndTree ? hwndTree : hwndDrives); else SetFocus(hwndDrives); break; } case VK_BACK: SendMessage(hWnd, FS_GETDIRECTORY, sizeof(szTemp), (LPARAM)szTemp); // are we already at the root? if (lstrlen(szTemp) <= 3) return -1; StripBackslash(szTemp); StripFilespec(szTemp); CreateDirWindow(szTemp, TRUE, GetParent(hWnd)); return -2; default: { HWND hwndDrives; // check for Ctrl-[DRIVE LETTER] and pass on to drives // window if ((GetKeyState(VK_CONTROL) < 0) && (hwndDrives = HasDrivesWindow(GetParent(hWnd)))) { return SendMessage(hwndDrives, wMsg, wParam, lParam); } break; } } return -1; case WM_SIZE: MSG("DirWndProc", "WM_SIZE"); if (!IsIconic(GetParent(hWnd))) { INT iMax; MoveWindow(hwndLB, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE); iMax = (INT)SendMessage(hwndLB, LB_GETCARETINDEX, 0, 0L); if (iMax >= 0) // scroll item into view /* SETCARETINDEX will scroll item into view */ SendMessage(hwndLB, LB_SETCARETINDEX, iMax, 0L); //MakeItemVisible(iMax, hwndLB); } break; default: DEFMSG("DirWndProc", (WORD)wMsg); return DefWindowProc(hWnd, wMsg, wParam, lParam); } return 0L; } VOID SortDirList( HWND hWnd, LPMYDTA lpmydta, WORD count, LPMYDTA *lplpmydta ) { INT i, j; WORD wSort; INT iMax, iMin, iMid; wSort = (WORD)GetWindowLong(GetParent(GetParent(hWnd)), GWL_SORT); for (i = 0; i < (INT)count; i++) { // advance to next lpmydta = GETDTAPTR(lpmydta, lpmydta->wSize); if (i == 0) { lplpmydta[i] = lpmydta; } else { // do a binary insert iMin = 0; iMax = i-1; // last index do { iMid = (iMax + iMin) / 2; if (CompareDTA(lpmydta, lplpmydta[iMid], wSort) > 0) iMin = iMid + 1; else iMax = iMid - 1; } while (iMax > iMin); if (iMax < 0) iMax = 0; if (CompareDTA(lpmydta, lplpmydta[iMax], wSort) > 0) iMax++; // insert after this one if (i != iMax) { for (j = i; j > iMax; j--) lplpmydta[j] = lplpmydta[j-1]; } lplpmydta[iMax] = lpmydta; } } } BOOL SetDirFocus( HWND hwndDir ) /* Set the focus to whoever deserves it if not the directory window. Return whether focus needs to be set to directory window. */ { DWORD dwTemp; HWND hwndLB = GetDlgItem(hwndDir, IDCW_LISTBOX); SendMessage (hwndLB,LB_GETTEXT,0,(LPARAM) &dwTemp); if (!dwTemp) { HWND hwndFocus,hwndTree,hwndDrives,hwndParent = GetParent(hwndDir); GetTreeWindows(hwndParent,&hwndTree,NULL,&hwndDrives); if ((hwndFocus = GetTreeFocus(hwndParent)) == hwndDir) SetFocus(hwndTree ? hwndTree : hwndDrives); else SetFocus(hwndFocus); return FALSE; } else return TRUE; }