main.cpp

#pragma comment(linker,"\"/manifestdependency:type='win32' \
name='Microsoft.Windows.Common-Controls' \
version='6.0.0.0' \
processorArchitecture='*' \
publicKeyToken='6595b64144ccf1df' \
language='*'\"")
#ifndef UNICODE
#define UNICODE
#endif

#ifndef _UNICODE
#define _UNICODE
#endif

#include <windows.h>
#include <windowsx.h>
#include <tchar.h>
#include <CommCtrl.h>
#include <wincrypt.h>
#include <shobjidl.h>
#include <shlwapi.h>
#include <algorithm>
#include <string>
#include <vector>
#include <map>

namespace std {
	using tstring = std::basic_string<TCHAR>;
}

#ifdef _MSC_VER
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "Advapi32.lib")
#pragma comment(lib, "Shlwapi.lib")
#endif

const TCHAR* CLASSNAME = _T("WinCalcFileHash");
const TCHAR* WIN_TITLE = _T("WinCalcFileHash");
const TCHAR* VER = _T("V1.0.0.0");
#define COPYRIGHT _T("Copyright(C) 2025 hostzhengwei@gmail.com")

HWND hListView;
#define ID_LISTVIEW 10001
BOOL bTopMost = FALSE;

#define IDM_FILE_OPEN 1001
#define IDM_FILE_EXIT 1002
#define IDM_SETTINGS_TOPMOST 2001
#define IDM_SETTINGS_CLEAR 2002
#define IDM_HELP_ABOUT 3001

#define IDM_CTX_COPY 4000
#define IDM_CTX_FWDOWNLOAD 4001

std::map<LANGID, std::vector<std::tstring>> ctxMenuStrings = {
	{0x0804, {  _T("复制信息")}},
	{0x0409, { _T("CopyInfo")}}
};

std::vector<std::tstring> vecCols{
	_T("FileName"),
	_T("MD5"),
	_T("SHA1"),
	_T("SHA256"),
	_T("FilePath")
	//_T("FileSize"),
	//_T("CreateTime"),
	//_T("LastAccessTime"),
	//_T("LastWriteTime")
};

std::map<int, int> mapColWidths{
	{0, 200},
	{1, 300},
	{2, 500},
	{3, 700},
	{4, 800}
	//{3, 150},
	//{4, 150},
	//{5, 150},
};

LRESULT CALLBACK WinProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
void QuitApp();
void CreateListView(HWND hwnd);
void CreateMainMenu(HWND hwnd);
std::vector<std::tstring> HandleDropFiles(HWND hwnd, WPARAM wParam);
void CalcFiles(const std::vector<std::tstring>& vecfiles);
std::tstring GetFileMD5(const std::tstring& filepath);
std::tstring GetFileSHA1(std::tstring filepath);
std::tstring GetFileSHA256(std::tstring filepath);
void CopySelectItemInfo(HWND hwnd);
void CopyTextToClipboard(HWND hwnd, const std::tstring& text);
void OpenFiles(HWND hwnd);
bool OpenFileDialog(HWND hwnd, std::vector<std::wstring>& paths, bool selectFolder = false, bool multiSelect = false);



#ifndef BUILD_DEFS_H
#define BUILD_DEFS_H
// Example of __DATE__ string: "Jul 27 2012"
// Example of __TIME__ string: "21:06:19"
#define COMPUTE_BUILD_YEAR \
    ( \
        (__DATE__[ 7] - '0') * 1000 + \
        (__DATE__[ 8] - '0') *  100 + \
        (__DATE__[ 9] - '0') *   10 + \
        (__DATE__[10] - '0') \
    )

#define COMPUTE_BUILD_DAY \
    ( \
        ((__DATE__[4] >= '0') ? (__DATE__[4] - '0') * 10 : 0) + \
        (__DATE__[5] - '0') \
    )

#define BUILD_MONTH_IS_JAN (__DATE__[0] == 'J' && __DATE__[1] == 'a' && __DATE__[2] == 'n')
#define BUILD_MONTH_IS_FEB (__DATE__[0] == 'F')
#define BUILD_MONTH_IS_MAR (__DATE__[0] == 'M' && __DATE__[1] == 'a' && __DATE__[2] == 'r')
#define BUILD_MONTH_IS_APR (__DATE__[0] == 'A' && __DATE__[1] == 'p')
#define BUILD_MONTH_IS_MAY (__DATE__[0] == 'M' && __DATE__[1] == 'a' && __DATE__[2] == 'y')
#define BUILD_MONTH_IS_JUN (__DATE__[0] == 'J' && __DATE__[1] == 'u' && __DATE__[2] == 'n')
#define BUILD_MONTH_IS_JUL (__DATE__[0] == 'J' && __DATE__[1] == 'u' && __DATE__[2] == 'l')
#define BUILD_MONTH_IS_AUG (__DATE__[0] == 'A' && __DATE__[1] == 'u')
#define BUILD_MONTH_IS_SEP (__DATE__[0] == 'S')
#define BUILD_MONTH_IS_OCT (__DATE__[0] == 'O')
#define BUILD_MONTH_IS_NOV (__DATE__[0] == 'N')
#define BUILD_MONTH_IS_DEC (__DATE__[0] == 'D')

#define COMPUTE_BUILD_MONTH \
    ( \
        (BUILD_MONTH_IS_JAN) ?  1 : \
        (BUILD_MONTH_IS_FEB) ?  2 : \
        (BUILD_MONTH_IS_MAR) ?  3 : \
        (BUILD_MONTH_IS_APR) ?  4 : \
        (BUILD_MONTH_IS_MAY) ?  5 : \
        (BUILD_MONTH_IS_JUN) ?  6 : \
        (BUILD_MONTH_IS_JUL) ?  7 : \
        (BUILD_MONTH_IS_AUG) ?  8 : \
        (BUILD_MONTH_IS_SEP) ?  9 : \
        (BUILD_MONTH_IS_OCT) ? 10 : \
        (BUILD_MONTH_IS_NOV) ? 11 : \
        (BUILD_MONTH_IS_DEC) ? 12 : \
        /* error default */  99 \
    )

#define COMPUTE_BUILD_HOUR ((__TIME__[0] - '0') * 10 + __TIME__[1] - '0')
#define COMPUTE_BUILD_MIN  ((__TIME__[3] - '0') * 10 + __TIME__[4] - '0')
#define COMPUTE_BUILD_SEC  ((__TIME__[6] - '0') * 10 + __TIME__[7] - '0')

#define BUILD_DATE_IS_BAD (__DATE__[0] == '?')

#define BUILD_YEAR  ((BUILD_DATE_IS_BAD) ? 99 : COMPUTE_BUILD_YEAR)
#define BUILD_MONTH ((BUILD_DATE_IS_BAD) ? 99 : COMPUTE_BUILD_MONTH)
#define BUILD_DAY   ((BUILD_DATE_IS_BAD) ? 99 : COMPUTE_BUILD_DAY)

#define BUILD_TIME_IS_BAD (__TIME__[0] == '?')

#define BUILD_HOUR  ((BUILD_TIME_IS_BAD) ? 99 :  COMPUTE_BUILD_HOUR)
#define BUILD_MIN   ((BUILD_TIME_IS_BAD) ? 99 :  COMPUTE_BUILD_MIN)
#define BUILD_SEC   ((BUILD_TIME_IS_BAD) ? 99 :  COMPUTE_BUILD_SEC)

#endif // BUILD_DEFS_H


int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPreInstance, LPTSTR lpCmdLine, int nCmdShow)
{
	INITCOMMONCONTROLSEX iccex;
	iccex.dwICC = ICC_LISTVIEW_CLASSES;
	InitCommonControlsEx(&iccex);
	HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);

	WNDCLASS wc;
	ZeroMemory(&wc, sizeof(wc));
	wc.style = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc = WinProc;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
	wc.lpszClassName = CLASSNAME;
	if (0 == RegisterClass(&wc))
	{
		return 1;
	}

	TCHAR szTitle[MAX_PATH] = {};
	LANGID langID = GetUserDefaultUILanguage();
	if (langID == 0x0804)
	{
		_stprintf_s(szTitle, MAX_PATH, _T("%s [可以直接拖动文件到窗口中来计算]"), WIN_TITLE);
	}
	else
	{
		_stprintf_s(szTitle, MAX_PATH, _T("%s [Drag File To Window]"), WIN_TITLE);
	}
	
	HWND hwnd = CreateWindowEx(WS_EX_APPWINDOW | WS_EX_ACCEPTFILES,
		CLASSNAME,
		szTitle,
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		NULL,
		NULL,
		hInstance,
		NULL);

	CreateListView(hwnd);
	CreateMainMenu(hwnd);
	ShowWindow(hwnd, SW_SHOWDEFAULT);
	UpdateWindow(hwnd);

	MSG msg;
	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	return (int)msg.wParam;
}


LRESULT CALLBACK WinProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_COMMAND:
	{
		if (LOWORD(wParam) == IDM_FILE_OPEN)
		{
			//OpenFiles(hwnd);
			std::vector<std::tstring> vecFiles;
			OpenFileDialog(hwnd, vecFiles, false, true);
			CalcFiles(vecFiles);
		}
		else if (LOWORD(wParam) == IDM_FILE_EXIT)
		{
			QuitApp();
		}
		else if (LOWORD(wParam) == IDM_SETTINGS_TOPMOST)
		{
			if (bTopMost)
			{
				::SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
				bTopMost = FALSE;
			}

			else
			{
				::SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
				bTopMost = TRUE;
			}
			HMENU hMenu = GetMenu(hwnd);
			HMENU hSubMenu = GetSubMenu(hMenu, 1);
			CheckMenuItem(hSubMenu, IDM_SETTINGS_TOPMOST, bTopMost ? MF_CHECKED : MF_UNCHECKED);
		}
		else if (LOWORD(wParam) == IDM_SETTINGS_CLEAR)
		{
			ListView_DeleteAllItems(hListView);
			UpdateWindow(hListView);
		}
		else if (LOWORD(wParam) == IDM_HELP_ABOUT)
		{
			TCHAR szTitle[256] = { 0 };
			_stprintf_s(szTitle,
				ARRAYSIZE(szTitle),
				_T("%s %s\n\n%s\n\nBuild Time At %04d-%02d-%02d %02d:%02d:%02d"),
				WIN_TITLE,
				VER,
				COPYRIGHT,
				BUILD_YEAR, BUILD_MONTH, BUILD_DAY, BUILD_HOUR, BUILD_MIN, BUILD_SEC);
			//printf("%04d-%02d-%02dT%02d:%02d:%02d\n", BUILD_YEAR, BUILD_MONTH, BUILD_DAY, BUILD_HOUR, BUILD_MIN, BUILD_SEC);

			MessageBox(hwnd, szTitle, WIN_TITLE, MB_OK);
		}
		else if (LOWORD(wParam) == IDM_CTX_COPY)
		{
			CopySelectItemInfo(hwnd);
		}

		break;
	}
	case WM_CONTEXTMENU:
	{
		POINT pt;
		pt.x = GET_X_LPARAM(lParam);
		pt.y = GET_Y_LPARAM(lParam);
		ScreenToClient(hListView, &pt);
		LVHITTESTINFO hitTestInfo;
		hitTestInfo.pt = pt;
		ListView_HitTest(hListView, &hitTestInfo);
		if (hitTestInfo.iItem != -1) {
			UINT uCount = ListView_GetSelectedCount(hListView);
			LANGID langID = GetUserDefaultUILanguage();
			if (langID != 0x0804 && langID != 0x0409)
			{
				langID = 0x0409;
			}
			HMENU hMenu = CreatePopupMenu();
			if (uCount == 1)
			{
				AppendMenu(hMenu, MF_STRING, IDM_CTX_COPY, ctxMenuStrings[langID].at(0).c_str());
				//AppendMenu(hMenu, MF_SEPARATOR, 0, L"");
				//AppendMenu(hMenu, MF_STRING, IDM_CTX_PROP, L"属性");
				//AppendMenu(hMenu, MF_STRING, IDM_CTX_FWDOWNLOAD, ctxMenuStrings[langID].at(1).c_str());
			}
			else
			{
				AppendMenu(hMenu, MF_STRING, IDM_CTX_COPY, ctxMenuStrings[langID].at(0).c_str());
			}


			// Determine the menu position
			pt.x = GET_X_LPARAM(lParam);
			pt.y = GET_Y_LPARAM(lParam);
			UINT uFlags = TPM_RIGHTBUTTON; // Use this flag to handle right clicks
			TrackPopupMenuEx(hMenu, uFlags, pt.x, pt.y, hwnd, NULL);
			DestroyMenu(hMenu);
		}
		break;
	}
	case WM_DROPFILES:
	{
		std::vector<std::tstring> vecFiles = HandleDropFiles(hwnd, wParam);
		CalcFiles(vecFiles);
		break;
	}
	case WM_SIZE:
	{
		RECT rcClient;
		GetClientRect(hwnd, &rcClient);
		InflateRect(&rcClient, -15, -15);
		SetWindowPos(hListView,
			NULL,
			rcClient.left,
			rcClient.top,
			rcClient.right - rcClient.left,
			rcClient.bottom - rcClient.top,
			SWP_NOACTIVATE | SWP_NOZORDER
		);
		break;
	}
	case WM_DESTROY:
	{
		QuitApp();
		break;
	}
	default:
		return DefWindowProc(hwnd, msg, wParam, lParam);
	}
	return 0;
}

void QuitApp()
{
	PostQuitMessage(0);
}

void CreateListView(HWND hwnd)
{
	RECT rc;
	GetClientRect(hwnd, &rc);
	InflateRect(&rc, -15, -15);
	hListView = CreateWindowEx(WS_EX_CLIENTEDGE,
		WC_LISTVIEW,
		NULL,
		WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | LVS_REPORT | LVS_NOSORTHEADER,
		rc.left,
		rc.top,
		rc.right - rc.left,
		rc.bottom - rc.top,
		hwnd,
		(HMENU)ID_LISTVIEW,
		GetModuleHandle(NULL),
		NULL);

	ListView_SetTextColor(hListView, RGB(10, 10, 160));
	ListView_SetExtendedListViewStyle(hListView, LVS_EX_FULLROWSELECT);

	TCHAR szText[MAX_PATH] = {};
	LVCOLUMN lvCol;
	lvCol.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
	lvCol.fmt = LVCFMT_LEFT;
	lvCol.cx = 15;
	lvCol.pszText = szText;

	for (int iCol = 0; iCol < vecCols.size(); iCol++)
	{
		lvCol.cx = mapColWidths.at(iCol);
		_stprintf_s(szText, MAX_PATH, _T("%s"), vecCols[iCol].c_str());
		ListView_InsertColumn(hListView, iCol, &lvCol);
	}
}

void CreateMainMenu(HWND hwnd)
{
	HMENU hMainMenu = CreateMenu();
	HMENU hFileSubMenu = CreatePopupMenu();
	AppendMenu(hFileSubMenu, MF_STRING, IDM_FILE_OPEN, _T("Open"));
	AppendMenu(hFileSubMenu, MF_SEPARATOR, 0, _T(""));
	AppendMenu(hFileSubMenu, MF_STRING, IDM_FILE_EXIT, _T("Exit"));

	HMENU hHelpSettingsMenu = CreatePopupMenu();
	AppendMenu(hHelpSettingsMenu, MF_STRING | MF_STRING | bTopMost ? MF_CHECKED : MF_UNCHECKED, IDM_SETTINGS_TOPMOST, _T("Topmost"));
	AppendMenu(hHelpSettingsMenu, MF_SEPARATOR, 0, _T(""));
	AppendMenu(hHelpSettingsMenu, MF_STRING, IDM_SETTINGS_CLEAR, _T("Clear"));

	HMENU hHelpSubMenu = CreatePopupMenu();
	AppendMenu(hHelpSubMenu, MF_STRING, IDM_HELP_ABOUT, _T("About"));

	AppendMenu(hMainMenu, MF_POPUP, (UINT_PTR)hFileSubMenu, _T("File"));
	AppendMenu(hMainMenu, MF_POPUP, (UINT_PTR)hHelpSettingsMenu, _T("Settings"));
	AppendMenu(hMainMenu, MF_POPUP, (UINT_PTR)hHelpSubMenu, _T("Help"));
	SetMenu(hwnd, hMainMenu);
}

std::vector<std::tstring> HandleDropFiles(HWND hwnd, WPARAM wParam)
{
	TCHAR szFileName[MAX_PATH] = {};
	HDROP hDrop = (HDROP)wParam;
	std::vector<std::tstring> vecFiles;

	UINT count = DragQueryFile(hDrop, 0xFFFFFFFF, szFileName, MAX_PATH);
	for (UINT i = 0; i < count; i++)
	{
		DragQueryFile(hDrop, i, szFileName, MAX_PATH);
		if (!PathIsDirectory(szFileName))
		{
			vecFiles.push_back(szFileName);
		}
	}
	DragFinish(hDrop);
	return vecFiles;
}

void CalcFiles(const std::vector<std::tstring>& vecfiles)
{
	int iCount = ListView_GetItemCount(hListView);
	for (auto item : vecfiles)
	{
		std::tstring strMD5 = GetFileMD5(item);
		std::tstring strSHA1 = GetFileSHA1(item);
		std::tstring strSHA256 = GetFileSHA256(item);
		LVITEM lvItem = {};
		TCHAR szText[MAX_PATH] = {};

		lvItem.iItem = iCount;

		//TCHAR drive[_MAX_DIR] = {};
		//TCHAR dir[_MAX_DIR] = {};
		//TCHAR fname[_MAX_FNAME] = {};
		//TCHAR ext[_MAX_EXT] = {};
		//_tsplitpath_s(item.c_str(), drive, _MAX_DIR, dir, _MAX_DIR, fname, _MAX_FNAME,ext, _MAX_EXT);

		
		std::tstring fname = item.substr(item.find_last_of(L"/\\") + 1);
		std::tstring dir = item.substr(0, item.find_last_of(L"/\\"));

		lvItem.iSubItem = 0;
		_stprintf_s(szText, MAX_PATH, _T("%s"), fname.c_str());
		lvItem.mask = LVIF_TEXT;
		lvItem.pszText = szText;
		ListView_InsertItem(hListView, &lvItem);

		lvItem.iSubItem = 1;
		_stprintf_s(szText, MAX_PATH, _T("%s"), strMD5.c_str());
		lvItem.mask = LVIF_TEXT;
		lvItem.pszText = szText;
		ListView_SetItem(hListView, &lvItem);

		//std::transform(strMD5.begin(), strMD5.end(), strMD5.begin(), ::tolower);
		lvItem.iSubItem = 2;
		_stprintf_s(szText, MAX_PATH, _T("%s"), strSHA1.c_str());
		lvItem.mask = LVIF_TEXT;
		lvItem.pszText = szText;
		ListView_SetItem(hListView, &lvItem);

		lvItem.iSubItem = 3;
		_stprintf_s(szText, MAX_PATH, _T("%s"), strSHA256.c_str());
		lvItem.mask = LVIF_TEXT;
		lvItem.pszText = szText;
		ListView_SetItem(hListView, &lvItem);

		lvItem.iSubItem = 4;
		_stprintf_s(szText, MAX_PATH, _T("%s"), dir.c_str());
		lvItem.mask = LVIF_TEXT;
		lvItem.pszText = szText;
		ListView_SetItem(hListView, &lvItem);
	}
}

std::tstring GetFileMD5(const std::tstring& filepath) 
{
	// 初始化 MD5 句柄
	HCRYPTPROV hProv = NULL;
	HCRYPTHASH hHash = NULL;
	BYTE hash[16]; // MD5 产生 16 字节的哈希值
	DWORD hashLen = sizeof(hash);

	// 打开文件
	HANDLE hFile = CreateFile(filepath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hFile == INVALID_HANDLE_VALUE) {
		return _T(""); // 返回空字符串
	}

	// 获取加密提供程序
	if (!CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
		CloseHandle(hFile);
		return _T("");
	}

	// 创建哈希对象
	if (!CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash)) {
		CryptReleaseContext(hProv, 0);
		CloseHandle(hFile);
		return _T("");
	}

	// 读取文件并更新哈希
	const DWORD bufferSize = 4096;
	BYTE buffer[bufferSize];
	DWORD bytesRead;

	while (ReadFile(hFile, buffer, bufferSize, &bytesRead, NULL) && bytesRead > 0) {
		CryptHashData(hHash, buffer, bytesRead, 0);
	}

	// 获取哈希值
	if (!CryptGetHashParam(hHash, HP_HASHVAL, hash, &hashLen, 0)) {
		CryptDestroyHash(hHash);
		CryptReleaseContext(hProv, 0);
		CloseHandle(hFile);
		return _T("");
	}

	// 关闭句柄
	CryptDestroyHash(hHash);
	CryptReleaseContext(hProv, 0);
	CloseHandle(hFile);

	// 转换哈希值为十六进制字符串
	std::tstring md5String;
	for (DWORD i = 0; i < hashLen; i++) {
		TCHAR buf[3];
		_stprintf_s(buf, sizeof(buf) / sizeof(TCHAR), _T("%02X"), hash[i]);
		md5String += buf;
	}

	return md5String;
}

std::tstring GetFileSHA1(std::tstring filepath) {
	HCRYPTPROV hProv = NULL;
	HCRYPTHASH hHash = NULL;
	BYTE hash[20]; // SHA1 产生 20 字节的哈希值
	DWORD hashLen = sizeof(hash);

	HANDLE hFile = CreateFile(filepath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hFile == INVALID_HANDLE_VALUE) {
		return _T("");
	}

	if (!CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
		CloseHandle(hFile);
		return _T("");
	}

	if (!CryptCreateHash(hProv, CALG_SHA1, 0, 0, &hHash)) {
		CryptReleaseContext(hProv, 0);
		CloseHandle(hFile);
		return _T("");
	}

	const DWORD bufferSize = 4096;
	BYTE buffer[bufferSize];
	DWORD bytesRead;

	while (ReadFile(hFile, buffer, bufferSize, &bytesRead, NULL) && bytesRead > 0) {
		CryptHashData(hHash, buffer, bytesRead, 0);
	}

	if (!CryptGetHashParam(hHash, HP_HASHVAL, hash, &hashLen, 0)) {
		CryptDestroyHash(hHash);
		CryptReleaseContext(hProv, 0);
		CloseHandle(hFile);
		return _T("");
	}

	CryptDestroyHash(hHash);
	CryptReleaseContext(hProv, 0);
	CloseHandle(hFile);

	std::tstring sha1String;
	for (DWORD i = 0; i < hashLen; i++) {
		TCHAR buf[3];
		_stprintf_s(buf, sizeof(buf) / sizeof(TCHAR), _T("%02X"), hash[i]);
		sha1String += buf;
	}

	return sha1String;
}

std::tstring GetFileSHA256(std::tstring filepath) {
	HCRYPTPROV hProv = NULL;
	HCRYPTHASH hHash = NULL;
	BYTE hash[32]; // SHA256 产生 32 字节的哈希值
	DWORD hashLen = sizeof(hash);

	HANDLE hFile = CreateFile(filepath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hFile == INVALID_HANDLE_VALUE) {
		return _T("");
	}

	if (!CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
		CloseHandle(hFile);
		return _T("");
	}

	if (!CryptCreateHash(hProv, CALG_SHA_256, 0, 0, &hHash)) {
		CryptReleaseContext(hProv, 0);
		CloseHandle(hFile);
		return _T("");
	}

	const DWORD bufferSize = 4096;
	BYTE buffer[bufferSize];
	DWORD bytesRead;

	while (ReadFile(hFile, buffer, bufferSize, &bytesRead, NULL) && bytesRead > 0) {
		CryptHashData(hHash, buffer, bytesRead, 0);
	}

	if (!CryptGetHashParam(hHash, HP_HASHVAL, hash, &hashLen, 0)) {
		CryptDestroyHash(hHash);
		CryptReleaseContext(hProv, 0);
		CloseHandle(hFile);
		return _T("");
	}

	CryptDestroyHash(hHash);
	CryptReleaseContext(hProv, 0);
	CloseHandle(hFile);

	std::tstring sha256String;
	for (DWORD i = 0; i < hashLen; i++) {
		TCHAR buf[3];
		_stprintf_s(buf, sizeof(buf) / sizeof(TCHAR), _T("%02X"), hash[i]);
		sha256String += buf;
	}

	return sha256String;
}


void CopySelectItemInfo(HWND hwnd)
{
	UINT itemid = -1;
	itemid = ListView_GetNextItem(hListView, itemid, LVNI_SELECTED);
	std::tstring strInfo;
	while (itemid != -1)
	{
		for (int i = 0; i < vecCols.size(); i++)
		{
			TCHAR szText[128] = {};
			ListView_GetItemText(hListView, itemid, i, szText, ARRAYSIZE(szText));
			strInfo += vecCols[i];
			strInfo += _T(" : ");
			strInfo += szText;
			strInfo += _T("\n");
		}
		strInfo += _T("\n");
		itemid = ListView_GetNextItem(hListView, itemid, LVNI_SELECTED);
	}
	CopyTextToClipboard(hwnd, strInfo);
}

void CopyTextToClipboard(HWND hwnd, const std::tstring& text)
{
	BOOL bCopied = FALSE;
	if (OpenClipboard(NULL))
	{
		if (EmptyClipboard())
		{
			size_t len = text.length();
			HGLOBAL hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (len + 1) * sizeof(TCHAR));
			if (hData != NULL)
			{
				TCHAR* pszData = static_cast<TCHAR*>(GlobalLock(hData));
				if (pszData != NULL)
				{
					//CopyMemory(pszData, text.c_str(), len*sizeof(TCHAR));
					_tcscpy_s(pszData, len + 1, text.c_str());
					GlobalUnlock(hData);
					if (SetClipboardData(CF_UNICODETEXT, hData) != NULL)
					{
						bCopied = TRUE;;
					}
				}
			}
		}
		CloseClipboard();
	}
}

void OpenFiles(HWND hwnd)
{
	TCHAR szFile[MAX_PATH] = { 0 };
	OPENFILENAME ofn;
	ZeroMemory(&ofn, sizeof(ofn)); // Initialize the structure to all zeros

	ofn.lStructSize = sizeof(ofn);
	ofn.hwndOwner = hwnd; // Handle to the owner window (can be NULL for a console app)
	ofn.lpstrFile = szFile;
	ofn.nMaxFile = sizeof(szFile);
	ofn.lpstrFilter = L"Exe Files\0*.exe\0All Files\0*.*\0"; // Filter for file types
	ofn.nFilterIndex = 1;
	ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST; // Flags for behavior


	if (GetOpenFileName(&ofn) == TRUE) {
		// User selected a file, szFile now contains the full path
		// You can now open and process the file
		// Example: MessageBox(NULL, szFile, L"Selected File", MB_OK);
		int a = 200;
	}
	else {
		// User cancelled the dialog or an error occurred
		int b = 100;
	}
}

bool OpenFileDialog(HWND hwnd, std::vector<std::wstring>& paths, bool selectFolder, bool multiSelect)
{
	IFileOpenDialog* p_file_open = nullptr;
	bool are_all_operation_success = false;
	while (!are_all_operation_success)
	{
		HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_ALL,
			IID_IFileOpenDialog, reinterpret_cast<void**>(&p_file_open));
		if (FAILED(hr))
			break;

		if (selectFolder || multiSelect)
		{
			FILEOPENDIALOGOPTIONS options = 0;
			hr = p_file_open->GetOptions(&options);
			if (FAILED(hr))
				break;

			if (selectFolder)
				options |= FOS_PICKFOLDERS;
			if (multiSelect)
				options |= FOS_ALLOWMULTISELECT;

			hr = p_file_open->SetOptions(options);
			if (FAILED(hr))
				break;
		}

		hr = p_file_open->Show(hwnd);
		if (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED)) // No items were selected.
		{
			are_all_operation_success = true;
			break;
		}
		else if (FAILED(hr))
			break;

		IShellItemArray* p_items;
		hr = p_file_open->GetResults(&p_items);
		if (FAILED(hr))
			break;
		DWORD total_items = 0;
		hr = p_items->GetCount(&total_items);
		if (FAILED(hr))
			break;

		for (int i = 0; i < static_cast<int>(total_items); ++i)
		{
			IShellItem* p_item;
			p_items->GetItemAt(i, &p_item);
			if (SUCCEEDED(hr))
			{
				PWSTR path;
				hr = p_item->GetDisplayName(SIGDN_FILESYSPATH, &path);
				if (SUCCEEDED(hr))
				{
					paths.push_back(path);
					CoTaskMemFree(path);
				}
				p_item->Release();
			}
		}

		p_items->Release();
		are_all_operation_success = true;
	}

	if (p_file_open)
		p_file_open->Release();
	return are_all_operation_success;
}