PWSTR pszCmdLine, INT nCmdShow )

{

SIZE_T cchPath = SSLenW(pszCmdLine) + 1;

PTSTR pszPath;

// HashVerifyThread will try to free the path passed to it, as it expects

// it to be allocated by malloc; it also expects g_cRefThisDll to be

// incremented by the caller.

if (pszPath = (PTSTR)malloc(cchPath * sizeof(TCHAR)))

{

if (WStrToTStr(pszCmdLine, pszPath, (UINT)cchPath))

{

++g_cRefThisDll;

HashVerifyThread(pszPath);

}

else

{

free(pszPath);

}

}

{

// We will need to free the memory allocated for the data when done

PBYTE pbRawData;

// First, activate our manifest and AddRef our host

ULONG_PTR uActCtxCookie = ActivateManifest(TRUE);

ULONG_PTR uHostCookie = HostAddRef();

// Allocate the context data that will persist across this session

HASHVERIFYCONTEXT hvctx;

// It's important that we zero the memory since an initial value of zero is

// assumed for many of the elements

ZeroMemory(&hvctx, sizeof(hvctx));

// Prep the path

HCNormalizeString(pszPath);

StrTrim(pszPath, TEXT(" "));

hvctx.pszPath = pszPath;

// Load the raw data

pbRawData = HashVerifyLoadData(&hvctx);

if (hvctx.pszFileData && (hvctx.hList = SLCreateEx(TRUE)))

{

HashVerifyParseData(&hvctx);

DialogBoxParam(

g_hModThisDll,

MAKEINTRESOURCE(IDD_HASHVERF),

NULL,

HashVerifyDlgProc,

(LPARAM)&hvctx

);

SLRelease(hvctx.hList);

}

else if (*pszPath)

{

// Technically, we could reach this point by either having a file read

// error or a memory allocation error, but I really don't feel like

// doing separate messages for what are supposed to be rare edge cases.

TCHAR szFormat[MAX_STRINGRES], szMessage[0x100];

LoadString(g_hModThisDll, IDS_HV_LOADERROR_FMT, szFormat, countof(szFormat));

StringCchPrintf(szMessage, countof(szMessage), szFormat, pszPath);

MessageBox(NULL, szMessage, NULL, MB_OK | MB_ICONERROR);

}

free(pbRawData);

free(pszPath);

// Clean up the manifest activation and release our host

DeactivateManifest(uActCtxCookie);

HostRelease(uHostCookie);

InterlockedDecrement(&g_cRefThisDll);

return(0);

{

PBYTE pbRawData = NULL;

HANDLE hFile;

if ((hFile = OpenFileForReading(phvctx->pszPath)) != INVALID_HANDLE_VALUE)

{

LARGE_INTEGER cbRawData;

DWORD cbBytesRead;

if ( (GetFileSizeEx(hFile, &cbRawData)) &&

(pbRawData = (PBYTE)malloc(cbRawData.LowPart + sizeof(DWORD))) &&

(ReadFile(hFile, pbRawData, cbRawData.LowPart, &cbBytesRead, NULL)) &&

(cbRawData.LowPart == cbBytesRead) )

{

// When we allocated a block of memory for the file data, we

// reserved a DWORD at the end for NULL termination and to serve as

// the extra buffer needed by IsTextUTF8...

*((UPDWORD)(pbRawData + cbRawData.LowPart)) = 0;

// Prepare the data for the parser...

phvctx->pszFileData = BufferToWStr(&pbRawData, cbRawData.LowPart);

HCNormalizeString(phvctx->pszFileData);

}

CloseHandle(hFile);

}

return(pbRawData);

{

PTSTR pszData = phvctx->pszFileData; // Points to the next line to process

UINT cchChecksum; // Expected length of the checksum in TCHARs

BOOL bReverseFormat = FALSE; // TRUE if using SFV's format of putting the checksum last

BOOL bLinesRemaining = TRUE; // TRUE if we have not reached the end of the data

// Try to determine the file type from the extension

{

PTSTR pszExt = StrRChr(phvctx->pszPath, NULL, TEXT('.'));

if (pszExt)

{

do // loops once; only here so there's something to break out of

{

#define HASH_VERIFY_EXT_TYPE(alg) \

if (StrCmpI(pszExt, HASH_EXT_##alg) == 0) \

{ \

phvctx->whctxFlags = WHEX_CHECK##alg; \

cchChecksum = alg##_DIGEST_LENGTH * 2; \

break; \

}

FOR_EACH_HASH(HASH_VERIFY_EXT_TYPE)

} while (FALSE);

// Special case for CRC-32

if (phvctx->whctxFlags == WHEX_CHECKCRC32)

bReverseFormat = TRUE;

}

}

while (bLinesRemaining)

{

PTSTR pszStartOfLine; // First non-whitespace character of the line

PTSTR pszEndOfLine; // Last non-whitespace character of the line

PTSTR pszChecksum = NULL, pszFileName = NULL;

INT16 cchPath; // This INCLUDES the NULL terminator!

// Step 1: Isolate the current line as a NULL-terminated string

{

pszStartOfLine = pszData;

// Find the end of the line

while (*pszData && *pszData != TEXT('\n'))

++pszData;

// Terminate it if necessary, otherwise flag the end of the data

if (*pszData)

*pszData = 0;

else

bLinesRemaining = FALSE;

pszEndOfLine = pszData;

// Strip spaces from the end of the line...

while (--pszEndOfLine >= pszStartOfLine && *pszEndOfLine == TEXT(' '))

*pszEndOfLine = 0;

// ...and from the start of the line

while (*pszStartOfLine == TEXT(' '))

++pszStartOfLine;

// Skip past this line's terminator; point at the remaining data

++pszData;

}

// Step 2a: Parse the line as SFV

if (bReverseFormat)

{

pszEndOfLine -= 7;

if (pszEndOfLine > pszStartOfLine && ValidateHexSequence(pszEndOfLine, 8))

{

pszChecksum = pszEndOfLine;

// Trim spaces between the checksum and the file name

while (--pszEndOfLine >= pszStartOfLine && *pszEndOfLine == TEXT(' '))

*pszEndOfLine = 0;

// Lines that begin with ';' are comments in SFV

if (*pszStartOfLine && *pszStartOfLine != TEXT(';'))

pszFileName = pszStartOfLine;

}

}

// Step 2b: All other file formats

else

{

// If we do not know the type yet, make a stab at detecting it

if (phvctx->whctxFlags == 0)

{

// 32-bit algorithms (8-byte)

if (ValidateHexSequence(pszStartOfLine, 8))

{

cchChecksum = 8;

phvctx->whctxFlags = WHEX_ALL32; // WHEX_CHECKCRC32

}

// 128-bit algorithms (32-byte)

else if (ValidateHexSequence(pszStartOfLine, 32))

{

cchChecksum = 32;

phvctx->whctxFlags = WHEX_ALL128; // WHEX_CHECKMD5

}

// 160-bit algorithms (40-byte)

else if (ValidateHexSequence(pszStartOfLine, 40))

{

cchChecksum = 40;

phvctx->whctxFlags = WHEX_ALL160; // WHEX_CHECKSHA1

}

// 256-bit algorithms (64-byte)

else if (ValidateHexSequence(pszStartOfLine, 64))

{

cchChecksum = 64;

phvctx->whctxFlags = WHEX_ALL256; // WHEX_CHECKSHA256 | WHEX_CHECKSHA3_256

}

// 512-bit algorithms (128-byte)

else if (ValidateHexSequence(pszStartOfLine, 128))

{

cchChecksum = 128;

phvctx->whctxFlags = WHEX_ALL512; // WHEX_CHECKSHA512 | WHEX_CHECKSHA3_512

}

}

// Parse the line

if ( phvctx->whctxFlags && pszEndOfLine > pszStartOfLine + cchChecksum &&

ValidateHexSequence(pszStartOfLine, cchChecksum) )

{

pszChecksum = pszStartOfLine;

pszStartOfLine += cchChecksum + 1;

// Skip over spaces between the checksum and filename

while (*pszStartOfLine == TEXT(' '))

++pszStartOfLine;

if (*pszStartOfLine)

pszFileName = pszStartOfLine;

}

}

// Step 3: Do something useful with the results

if (pszFileName && (cchPath = (INT16)(pszEndOfLine + 2 - pszFileName)) > 1)

{

// Since pszEndOfLine points to the character BEFORE the terminator,

// cchLine == 1 + pszEnd - pszStart, and then +1 for the NULL

// terminator means that we need to add 2 TCHARs to the length

// By treating cchPath as INT16 and checking the sign, we ensure

// that the path does not exceed 32K.

// Create the new data block

PHASHVERIFYITEM pItem = (PHASHVERIFYITEM)SLAddItem(phvctx->hList, NULL, sizeof(HASHVERIFYITEM));

// Abort if we are out of memory

if (!pItem) break;

pItem->filesize.ui64 = -1;

pItem->filesize.sz[0] = 0;

pItem->pszDisplayName = pszFileName;

pItem->pszExpected = pszChecksum;

pItem->cchDisplayName = cchPath;

pItem->nListviewIndex = phvctx->cTotal;

pItem->bBeenSeen = FALSE;

pItem->uStatusID = HV_STATUS_NULL;

pItem->szActual[0] = 0;

++phvctx->cTotal;

} // If the current line was found to be valid

} // Loop until there are no lines left

// Build the index

if ( phvctx->cTotal && (phvctx->index =

(PPHVITEM)SLSetContextSize(phvctx->hList, phvctx->cTotal * sizeof(PHVITEM))) )

{

SLBuildIndex(phvctx->hList, (PVOID*)phvctx->index);

}

else

{

phvctx->cTotal = 0;

}

{

// Check that the given hex string matches /[0-9A-Fa-f]{cch}\b/, and if it

// does, convert to lower-case and NULL-terminate it.

while (cch)

{

TCHAR ch = *psz;

if (ch < TEXT('0'))

{

return(FALSE);

}

else if (ch > TEXT('9'))

{

ch |= 0x20; // Convert to lower-case

if (ch < TEXT('a') || ch > TEXT('f'))

return(FALSE);

*psz = ch;

}

++psz;

--cch;

}

if (*psz == 0 || *psz == TEXT('\n') || *psz == TEXT(' '))

{

*psz = 0;

return(TRUE);

}

return(FALSE);

{

// Note that ALL message communication to and from the main window MUST

// be asynchronous, or else there may be a deadlock

// Initialize the path prefix length; used for building the full path

PTSTR pszPathTail = StrRChr(phvctx->pszPath, NULL, TEXT('\\'));

SIZE_T cchPathPrefix = (pszPathTail) ? pszPathTail + 1 - phvctx->pszPath : 0;

#ifdef USE_PPL

// If the first file has an absolute path, use it for IsSSD(),

// otherwise use the checksum file itself

const bool bMultithreaded = phvctx->cTotal > 1 && IsSSD(

phvctx->index[0]->pszDisplayName[0] == TEXT('\\') ||

phvctx->index[0]->pszDisplayName[1] == TEXT(':') ?

phvctx->index[0]->pszDisplayName :

phvctx->pszPath);

concurrency::concurrent_vector<void*> vecBuffers; // a vector of all allocated read buffers (one per thread)

DWORD dwBufferTlsIndex = TlsAlloc(); // TLS index of the current thread's read buffer

if (dwBufferTlsIndex == TLS_OUT_OF_INDEXES)

return;

#else

constexpr bool bMultithreaded = false;

#endif

PBYTE pbTheBuffer; // filename/read buffer, used iff not multithreaded

if (! bMultithreaded)

{

pbTheBuffer = (PBYTE)VirtualAlloc(NULL, READ_BUFFER_SIZE, MEM_COMMIT, PAGE_READWRITE);

if (pbTheBuffer == NULL)

return;

}

// Initialize the progress bar update synchronization vars

CRITICAL_SECTION updateCritSec;

volatile ULONGLONG cbCurrentMaxSize = 0;

if (bMultithreaded)

InitializeCriticalSection(&updateCritSec);

// We need to keep track of the thread's execution time so that we can do a

// sound notification of completion when appropriate

phvctx->dwStarted = GetTickCount();

class CanceledException {};

// concurrency::parallel_for_each(phvctx->index, phvctx->index + phvctx->cTotal, ...

auto per_file_worker = [&](PHASHVERIFYITEM pItem)

{

PBYTE pbBuffer;

#ifdef USE_PPL

if (bMultithreaded)

{

// Allocate or retrieve the already-allocated read buffer for the current thread

pbBuffer = (PBYTE)TlsGetValue(dwBufferTlsIndex);

if (pbBuffer == NULL)

{

pbBuffer = (PBYTE)VirtualAlloc(NULL, READ_BUFFER_SIZE, MEM_COMMIT, PAGE_READWRITE);

if (pbBuffer == NULL)

throw CanceledException();

// Cache the read buffer for the current thread

vecBuffers.push_back(pbBuffer);

TlsSetValue(dwBufferTlsIndex, pbBuffer);

}

}

else

#endif

pbBuffer = pbTheBuffer;

// Part 1: Build the path

{

SIZE_T cchPrefix = cchPathPrefix;

// Do not use the prefix if pszDisplayName is an absolute path

if ( pItem->pszDisplayName[0] == TEXT('\\') ||

pItem->pszDisplayName[1] == TEXT(':') )

{

cchPrefix = 0;

}

SSChainNCpy2(

(PTSTR)pbBuffer,

phvctx->pszPath, cchPrefix,

pItem->pszDisplayName, pItem->cchDisplayName

);

}

// Part 2: Calculate the checksum(s)

WHCTXEX whctx;

WHRESULTEX whres;

whctx.dwFlags = phvctx->whctxFlags;

whres.dwFlags = 0;

WorkerThreadHashFile(

(PCOMMONCONTEXT)phvctx,

(PTSTR)pbBuffer,

&whctx,

&whres,

pbBuffer,

&pItem->filesize,

pItem->nListviewIndex,

bMultithreaded ? &updateCritSec : NULL, &cbCurrentMaxSize

#ifdef _TIMED

, NULL

#endif

);

if (phvctx->status == PAUSED)

WaitForSingleObject(phvctx->hUnpauseEvent, INFINITE);

if (phvctx->status == CANCEL_REQUESTED)

throw CanceledException();

// Part 3: Do something with the results

if (whres.dwFlags)

{

UINT cHashes = 0;

DWORD dwMatched = 0;

PTSTR pszActual = NULL;

#define HASH_VERIFY_ONE_HASH_op(alg) \

if (whres.dwFlags & WHEX_CHECK##alg) \

{ \

cHashes++; \

if (! dwMatched) \

{ \

pszActual = whres.szHex##alg; \

if (StrCmpI(pItem->pszExpected, pszActual) == 0) \

dwMatched = WHEX_CHECK##alg; \

} \

}

FOR_EACH_HASH(HASH_VERIFY_ONE_HASH_op)

assert(cHashes > 0); // should always be true since whres.dwFlags > 0

assert(pszActual);

if (dwMatched)

{

pItem->uStatusID = HV_STATUS_MATCH;

StringCbCopy(pItem->szActual, sizeof(pItem->szActual), pszActual);

if (cHashes > 1 && phvctx->whctxFlags != dwMatched)

phvctx->whctxFlags = dwMatched;

}

else

{

pItem->uStatusID = HV_STATUS_MISMATCH;

if (cHashes == 1)

StringCbCopy(pItem->szActual, sizeof(pItem->szActual), pszActual);

}

}

else

{

pItem->uStatusID = HV_STATUS_UNREADABLE;

}

// Part 4: Update the UI

++phvctx->cSentMsgs;

PostMessage(phvctx->hWnd, HM_WORKERTHREAD_UPDATE, (WPARAM)phvctx, (LPARAM)pItem);

};

try

{

#ifdef USE_PPL

if (bMultithreaded)

concurrency::parallel_for_each(phvctx->index, phvctx->index + phvctx->cTotal, per_file_worker);

else

#endif

std::for_each(phvctx->index, phvctx->index + phvctx->cTotal, per_file_worker);

}

catch (CanceledException) {} // ignore cancellation requests

#ifdef USE_PPL

if (bMultithreaded)

{

for (void* pBuffer : vecBuffers)

VirtualFree(pBuffer, 0, MEM_RELEASE);

DeleteCriticalSection(&updateCritSec);

}

else

#endif

VirtualFree(pbTheBuffer, 0, MEM_RELEASE);

// Play a sound to signal the normal, successful termination of operations,

// but exempt operations that were nearly instantaneous

if (phvctx->cTotal && GetTickCount() - phvctx->dwStarted >= 2000)

MessageBeep(MB_ICONASTERISK);

{

PHASHVERIFYCONTEXT phvctx;

switch (uMsg)

{

case WM_INITDIALOG:

{

phvctx = (PHASHVERIFYCONTEXT)lParam;

// Associate the window with the context and vice-versa

phvctx->hWnd = hWnd;

SetWindowLongPtr(hWnd, DWLP_USER, (LONG_PTR)phvctx);

SetAppIDForWindow(hWnd, TRUE);

HashVerifyDlgInit(phvctx);

phvctx->pfnWorkerMain = (PFNWORKERMAIN)HashVerifyWorkerMain;

phvctx->hThread = CreateThreadCRT(NULL, phvctx);

if (!phvctx->hThread)

WorkerThreadCleanup((PCOMMONCONTEXT)phvctx);

// Initialize the summary

SendMessage(phvctx->hWndPBTotal, PBM_SETRANGE32, 0, phvctx->cTotal);

HashVerifyUpdateSummary(phvctx, NULL);

return(TRUE);

}

case WM_DESTROY:

{

SetAppIDForWindow(hWnd, FALSE);

break;

}

case WM_ENDSESSION:

{

if (wParam == FALSE) // if TRUE, fall through to WM_CLOSE

break;

}

case WM_CLOSE:

{

phvctx = (PHASHVERIFYCONTEXT)GetWindowLongPtr(hWnd, DWLP_USER);

goto cleanup_and_exit;

}

case WM_COMMAND:

{

phvctx = (PHASHVERIFYCONTEXT)GetWindowLongPtr(hWnd, DWLP_USER);

switch (LOWORD(wParam))

{

case IDC_PAUSE:

{

WorkerThreadTogglePause((PCOMMONCONTEXT)phvctx);

return(TRUE);

}

case IDC_STOP:

{

WorkerThreadStop((PCOMMONCONTEXT)phvctx);

return(TRUE);

}

case IDC_EXIT:

{

cleanup_and_exit:

phvctx->dwFlags |= HCF_EXIT_PENDING;

WorkerThreadStop((PCOMMONCONTEXT)phvctx);

WorkerThreadCleanup((PCOMMONCONTEXT)phvctx);

EndDialog(hWnd, 0);

break;

}

}

break;

}

case WM_NOTIFY:

{

LPNMHDR pnm = (LPNMHDR)lParam;

if (pnm && pnm->idFrom == IDC_LIST)

{

phvctx = (PHASHVERIFYCONTEXT)GetWindowLongPtr(hWnd, DWLP_USER);

switch (pnm->code)

{

case LVN_GETDISPINFO:

{

HashVerifyListInfo(phvctx, (LPNMLVDISPINFO)lParam);

return(TRUE);

}

case NM_CUSTOMDRAW:

{

SetWindowLongPtr(hWnd, DWLP_MSGRESULT, HashVerifySetColor(phvctx, (LPNMLVCUSTOMDRAW)lParam));

return(TRUE);

}

case LVN_ODFINDITEM:

{

SetWindowLongPtr(hWnd, DWLP_MSGRESULT, HashVerifyFindItem(phvctx, (LPNMLVFINDITEM)lParam));

return(TRUE);

}

case LVN_COLUMNCLICK:

{

HashVerifySortColumn(phvctx, (LPNMLISTVIEW)lParam);

return(TRUE);

}

case LVN_ITEMCHANGED:

{

if (((LPNMLISTVIEW)lParam)->uChanged & LVIF_STATE)

phvctx->bFreshStates = FALSE;

break;

}

case LVN_ODSTATECHANGED:

{

phvctx->bFreshStates = FALSE;

break;

}

}

}

break;

}

case WM_TIMER:

{

// Vista: Workaround to fix their buggy progress bar

KillTimer(hWnd, TIMER_ID_PAUSE);

phvctx = (PHASHVERIFYCONTEXT)GetWindowLongPtr(hWnd, DWLP_USER);

if (phvctx->status == PAUSED)

SetProgressBarPause((PCOMMONCONTEXT)phvctx, PBST_PAUSED);

return(TRUE);

}

case HM_WORKERTHREAD_DONE:

{

phvctx = (PHASHVERIFYCONTEXT)wParam;

WorkerThreadCleanup((PCOMMONCONTEXT)phvctx);

return(TRUE);

}

case HM_WORKERTHREAD_UPDATE:

{

phvctx = (PHASHVERIFYCONTEXT)wParam;

++phvctx->cHandledMsgs;

HashVerifyUpdateSummary(phvctx, (PHASHVERIFYITEM)lParam);

return(TRUE);

}

case HM_WORKERTHREAD_SETSIZE:

{

phvctx = (PHASHVERIFYCONTEXT)wParam;

assert(lParam >= 0 && (UINT)lParam < phvctx->cTotal);

if (phvctx->index[lParam]->bBeenSeen)

ListView_RedrawItems(phvctx->hWndList, lParam, lParam);

return(TRUE);

}

}

return(FALSE);

{

HWND hWnd = phvctx->hWnd;

UINT i;

// Load strings

{

static const UINT16 arStrMap[][2] =

{

{ IDC_SUMMARY, IDS_HV_SUMMARY },

{ IDC_MATCH_LABEL, IDS_HV_MATCH },

{ IDC_MISMATCH_LABEL, IDS_HV_MISMATCH },

{ IDC_UNREADABLE_LABEL, IDS_HV_UNREADABLE },

{ IDC_PENDING_LABEL, IDS_HV_PENDING },

{ IDC_PAUSE, IDS_HV_PAUSE },

{ IDC_STOP, IDS_HV_STOP },

{ IDC_EXIT, IDS_HV_EXIT }

};

for (i = 0; i < countof(arStrMap); ++i)

SetControlText(hWnd, arStrMap[i][0], arStrMap[i][1]);

}

// Set the window icon and title

{

PTSTR pszFileName = StrRChr(phvctx->pszPath, NULL, TEXT('\\'));

if (!(pszFileName && *++pszFileName))

pszFileName = phvctx->pszPath;

SendMessage(

hWnd,

WM_SETTEXT,

0,

(LPARAM)pszFileName

);

SendMessage(

hWnd,

WM_SETICON,

ICON_BIG, // No need to explicitly set the small icon

(LPARAM)LoadIcon(g_hModThisDll, MAKEINTRESOURCE(IDI_FILETYPE))

);

}

// Initialize the list box

{

typedef struct {

UINT16 iStringID;

UINT16 iAlign;

UINT16 iWidth;

} COLINFO, *PCOLINFO;

static const COLINFO arCols[] =

{

{ IDS_HV_COL_FILENAME, LVCFMT_LEFT, 245 },

{ IDS_HV_COL_SIZE, LVCFMT_RIGHT, 64 },

{ IDS_HV_COL_STATUS, LVCFMT_CENTER, 64 },

{ IDS_HV_COL_EXPECTED, LVCFMT_CENTER, 0 },

{ IDS_HV_COL_ACTUAL, LVCFMT_CENTER, 0 },

};

// We will be using the list window handle a lot throughout HashVerify,

// so we should cache it to reduce the number of lookups

phvctx->hWndList = GetDlgItem(hWnd, IDC_LIST);

for (i = 0; i < countof(arCols); ++i)

{

TCHAR szBuffer[MAX_STRINGRES];

LVCOLUMN lvc;

RECT rc;

LoadString(g_hModThisDll, arCols[i].iStringID, szBuffer, countof(szBuffer));

rc.left = arCols[i].iWidth;

if (rc.left == 0)

{

if (phvctx->whctxFlags & WHEX_ALL512)

rc.left = 512 + 20;

else if (phvctx->whctxFlags & WHEX_ALL256)

rc.left = 256 + 20;

else if (phvctx->whctxFlags & WHEX_ALL160)

rc.left = 160 + 20;

else if (phvctx->whctxFlags & WHEX_ALL128)

rc.left = 128 + 20;

else if (phvctx->whctxFlags & WHEX_ALL32)

rc.left = 32 + 20 + 40; // extra size to accommodate the header labels

}

MapDialogRect(hWnd, &rc);

lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;

lvc.fmt = arCols[i].iAlign;

lvc.cx = rc.left;

lvc.pszText = szBuffer;

ListView_InsertColumn(phvctx->hWndList, i, &lvc);

}

ListView_SetExtendedListViewStyle(phvctx->hWndList, LISTVIEW_EXSTYLES);

ListView_SetItemCount(phvctx->hWndList, phvctx->cTotal);

// Use the new-fangled list view style for Vista

if (g_uWinVer >= 0x0600)

SetWindowTheme(phvctx->hWndList, L"Explorer", NULL);

phvctx->sort.iColumn = -1;

}

// Initialize the status strings

{

UINT i;

for (i = 1; i <= 3; ++i)

{

LoadString(

g_hModThisDll,

i + (IDS_HV_STATUS_MATCH - 1),

phvctx->szStatus[i],

countof(phvctx->szStatus[i])

);

}

}

// Initialize miscellaneous stuff

{

phvctx->uMaxBatch = (phvctx->cTotal < (0x20 << 8)) ? 0x20 : phvctx->cTotal >> 8;

phvctx->dwStarted = 0;

phvctx->hThread = NULL;

phvctx->hUnpauseEvent = NULL;

}

{

HWND hWnd = phvctx->hWnd;

TCHAR szFormat[MAX_STRINGRES], szBuffer[MAX_STRINGMSG];

// If this is not the initial update and we are lagging, and our update