#include "stdafx.h"
#include "PublicFunc.h"
#include "CTwainMutex.h"
#include <io.h>

TCHAR* GetUserCustomFilePath(HWND hWin, TCHAR* lpFilePath, TCHAR* lp_head_text)
{
	if (lpFilePath == NULL)
	{
		return NULL;
	}

	BROWSEINFO bi = { 0 };
	TCHAR szBuffer[MAX_PATH] = { 0 };

	memset(&bi, 0, sizeof(BROWSEINFO));


	bi.hwndOwner = hWin;
	bi.pszDisplayName = GetExistFileDir(lpFilePath);
	bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_SHAREABLE | BIF_USENEWUI | BIF_RETURNFSANCESTORS;

	LPITEMIDLIST pIDList = NULL;
	LPMALLOC lpMalloc = NULL;
	//m_pUI_INI->GetMessageBoxStr(szBuffer, sizeof(szBuffer), 1041);
	//bi.lpszTitle = szBuffer;//1041=请选择文件存储路径
	bi.lpszTitle = lp_head_text;//TEXT("请选择新建文件夹");
	bi.lpfn = (BFFCALLBACK)BrowserCallbackProc; //回调函数
	bi.lParam = (LPARAM)lpFilePath; //回调函数的使用的参数，用来设定默认路径

	pIDList = SHBrowseForFolder(&bi);
	if (pIDList != NULL)
	{
		SHGetPathFromIDList(pIDList, lpFilePath);
	}
	if (SHGetMalloc(&lpMalloc))
	{
		return NULL;	//释放内存 　　
	}
	if (pIDList == NULL)
	{
		return NULL;	//释放内存 
	}
	lpMalloc->Free(pIDList);
	lpMalloc->Release();
	pIDList = NULL;
	lpMalloc = NULL;
	//_tcscpy(lpFilePath, szBuffer2);
	return lpFilePath;
}

TCHAR* GetCurExeFilePath(HINSTANCE hInstance, TCHAR* lpPath, DWORD dwSize)
{
	INT nRet = 0x0L;
	TCHAR* p = NULL;
	if (lpPath == NULL || dwSize == 0)
	{
		return NULL;
	}
	nRet = GetModuleFileName(hInstance, lpPath, dwSize);
	if (nRet > 0)
	{
		p = _tcsrchr(lpPath, TEXT('\\'));
		if (p != NULL)
		{
			*(p + 1) = TEXT('\0');
		}
		else
		{
			return NULL;
		}
	}
	else
	{
		return NULL;
	}
	return lpPath;
}

TCHAR* GetExistFileDir(TCHAR* p_file_path)
{
	WIN32_FIND_DATA wfd = { 0 };
	LPSTR p_test = NULL;
	HANDLE hFindFile = INVALID_HANDLE_VALUE;

	if (p_file_path == NULL)
		return NULL;

	hFindFile = FindFirstFile(p_file_path, &wfd);
	if (hFindFile != NULL)
	{
		FindClose(hFindFile);
		hFindFile = INVALID_HANDLE_VALUE;
	}
	if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
	{
		return p_file_path;
	}

	p_test = (LPSTR)(_tcsrchr(p_file_path, '\\'));
	if (p_test != NULL)
	{
		*p_test = 0;
		return GetExistFileDir(p_file_path);
	}
	else
	{
		return NULL;
	}
}

DWORD CALLBACK BrowserCallbackProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
	case BFFM_INITIALIZED:    //LPARAM(TEXT("D:\\test_adf_project"))
		SendMessage(hWnd, BFFM_SETSELECTION, TRUE, lParam); //lpData就是上一个函数的 info.lParam ，也就是默认路径
		break;
	default:
		break;
	}
	return 0;
}

BOOL isFolderExist(char* folder)
{
	int ret = 0;

	ret = _access(folder, 0);
	if (ret == 0)
		ret = TRUE;
	else
		ret = FALSE;

	return ret;
}

BOOL isFileExist(std::string folder)
{
	return _access(folder.c_str(), 4) == 0 ? TRUE : FALSE;
}


int32_t createDirectory(char* directoryPath)
{
	uint32_t dirPathLen = 0;
	if (directoryPath != NULL) {
		dirPathLen = strlen(directoryPath);
	}
	if (dirPathLen > FILENAME_MAX)
	{
		return -1;
	}
	char tmpDirPath[FILENAME_MAX] = { 0 };
	for (uint32_t i = 0; i < dirPathLen; ++i)
	{
		tmpDirPath[i] = directoryPath[i];
		if (tmpDirPath[i] == '\\' || tmpDirPath[i] == '/')
		{
			if (!isFolderExist(tmpDirPath))
			{
				int ret = _mkdir(tmpDirPath);
				if (ret != 0)
					return -1;
			}
		}
	}
	return 0;
}

float GetContrast(int level)
{
	float ret = 0.0;
	switch (level)
	{
	case -3:
		ret = -1000.0;
		break;
	case -2:
		ret = -666.0;
		break;
	case -1:
		ret = -333.0;
		break;
	case 1:
		ret = 333.0;
		break;
	case 2:
		ret = 666.0;
		break;
	case 3:
		ret = 1000.0;
		break;
	}
	return ret;
}

char* THCAR2char(TCHAR* tchStr)
{
	int iLen = 2 * wcslen(tchStr);//CString,TCHAR汉字算一个字符，因此不用普通计算长度 
	char* chRtn = new char[iLen + 1];
	wcstombs(chRtn, tchStr, iLen + 1);//转换成功返回为非负值 
	return chRtn;
}

// CTwainUI 消息处理程序

BOOL CheckAndCreateFileDir(TCHAR* p_file_path, BOOL flg)
{
	TCHAR szTmp[MAX_PATH] = { 0 };
	WIN32_FIND_DATA wfd = { 0 };
	INT len = 0;
	INT pos = 0;
	BOOL bFlg = FALSE;
	HANDLE hFindFile = INVALID_HANDLE_VALUE;

	if (p_file_path == NULL)
		return FALSE;

	if (*p_file_path >= 'a' && *p_file_path <= 'z' || *p_file_path >= 'A' && *p_file_path <= 'Z')
	{
		if (*(p_file_path + 1) != ':' && *(p_file_path + 2) != '\\')
		{
			return FALSE;
		}
	}
	if (_access(THCAR2char(p_file_path), 0) == 0)
	{
		return TRUE;
	}

	if (!flg)
		return FALSE;

	if (CreateDirectory(p_file_path, NULL))
		return TRUE;

	_tcscpy(szTmp, p_file_path);

	len = (INT)_tcslen(szTmp);

	bFlg = FALSE;
	while (len)
	{
		if (*(szTmp + len - 1) == '\\')
		{
			bFlg = TRUE;
			break;
		}
		len--;
	}
	if (bFlg)
	{
		*(szTmp + len - 1) = 0;
		CheckAndCreateFileDir(szTmp, flg);
		return CreateDirectory(p_file_path, NULL);
	}
	else
		return FALSE;
}

BOOL CheckDiskFreeBitM(HWND hWin, TCHAR* p_disk_name, DWORD dw_min_bit_m)
{
	TCHAR* p = NULL;
	TCHAR sz_root_path_name[MAX_PATH + 1] = { 0 };
	INT len = 0;

	DWORD   dwTotalDiskSpace = 0;
	DWORD	dwFreeDiskSpace = 0;
	DWORD	dwUsedDiskSpace = 0;

	ULARGE_INTEGER   uiFreeBytesAvailableToCaller;
	ULARGE_INTEGER   uiTotalNumberOfBytes;
	ULARGE_INTEGER   uiTotalNumberOfFreeBytes;

	UINT un_ret = 0;
	if (p_disk_name == NULL)
		return FALSE;

	len = _tcslen(p_disk_name);
	if (len > MAX_PATH)
	{
		len = MAX_PATH;
	}

	memcpy(sz_root_path_name, p_disk_name, (size_t)len);

	p = sz_root_path_name;
	//p = _tcsstr(sz_root_path_name, "\\");
	if (p == NULL)
	{
		if (len == 2)
		{
			if (!((sz_root_path_name[0] >= 'A' && sz_root_path_name[0] <= 'Z' || sz_root_path_name[0] >= 'a' && sz_root_path_name[0] <= 'z') && sz_root_path_name[1] == ':'))
				return FALSE;
		}
		else
			return FALSE;
	}
	if (p != NULL)
		*(p + 1) = 0;
	un_ret = GetDriveType(sz_root_path_name);
	if (un_ret == 0 || un_ret == 1)
	{
		return FALSE;
	}

	if (GetDiskFreeSpaceEx(sz_root_path_name, &uiFreeBytesAvailableToCaller, &uiTotalNumberOfBytes, &uiTotalNumberOfFreeBytes))
	{
		//dwTotalDiskSpace  =   (DWORD)(uiTotalNumberOfBytes.QuadPart   /   1024   /   1024); 
		dwFreeDiskSpace = (DWORD)(uiFreeBytesAvailableToCaller.QuadPart >> 20);
		//dwUsedDiskSpace   =   dwTotalDiskSpace   -   dwFreeDiskSpace;
		if (dwFreeDiskSpace < dw_min_bit_m)
		{
			//ShowErrorStr(hWin, 1101);//1101=磁盘空间不足
			return FALSE;
		}
	}
	else
	{
		//GetErrorMessage(NULL, 0, FALSE);
		return FALSE;
	}
	//ShowErrorStr(hWin, 1101);//1101=磁盘空间不足
	//return FALSE;
	return TRUE;
}

HBITMAP SetButtonStaticBkBmp(HINSTANCE hInst, HWND hWin, UINT id, UINT iamge_id)
{

	UINT ctr_msg = 0;
	UINT str_iamge_type = 0;
	HBITMAP hBitmap = NULL;
	HBITMAP hOldBitmap = NULL;
	//BS_ICON BS_BITMAP
	//SS_BITMAP|SS_CENTERIMAGE SS_ICON

	LONG ctr_s = 0;
	ctr_s = GetWindowLong(GetDlgItem(hWin, id), GWL_STYLE);

	ctr_msg = STM_SETIMAGE;
	ctr_s |= SS_BITMAP | SS_CENTERIMAGE | SS_RIGHT;

	hBitmap = LoadBitmap(hInst, MAKEINTRESOURCE(iamge_id));

	if (hBitmap == NULL)
	{
		return NULL;
	}

	SetWindowLong(GetDlgItem(hWin, id), GWL_STYLE, ctr_s);
	hOldBitmap = (HBITMAP)SendDlgItemMessage(hWin, id, ctr_msg, IMAGE_BITMAP, (LPARAM)hBitmap);
	if (hOldBitmap != NULL)
	{
		DeleteObject(hOldBitmap);
		hOldBitmap = NULL;
	}
	DeleteObject(hBitmap);
	hBitmap = NULL;
	return hBitmap;
}

void writelog(std::string msg)
{
	TCHAR cfFilePath[MAX_PATH] = { 0 };
	SHGetSpecialFolderPath(NULL, cfFilePath, CSIDL_LOCAL_APPDATA, TRUE);
	_tcscat(cfFilePath, HUAGAO_SCAN);
	_tcscat(cfFilePath, TWAIN_ERROR_PATH);
	std::string tmpstr = TCHAR2STRING(cfFilePath);
	if (!isFolderExist((char*)tmpstr.c_str())) {
		createDirectory((char*)tmpstr.c_str());
	}
	CString filePath(cfFilePath);
	filePath += TWAIN_ERROR_LOG_NAME;
	std::string savepath = TCHAR2STRING(filePath.GetBuffer());

	std::ofstream ofs(savepath, std::ios::app);
	SYSTEMTIME sys;
	GetLocalTime(&sys);
	ofs << sys.wYear << "/" << sys.wMonth << "/" << sys.wDay << " " << sys.wHour << ":" << sys.wMinute << ":" << sys.wSecond << ":" << sys.wMilliseconds << "  " << msg << std::endl;
	ofs.close();
}

std::string TCHAR2STRING(TCHAR* STR)
{
	int iLen = WideCharToMultiByte(CP_ACP, 0, STR, -1, NULL, 0, NULL, NULL);
	char* chRtn = new char[iLen * sizeof(char)];
	WideCharToMultiByte(CP_ACP, 0, STR, -1, chRtn, iLen, NULL, NULL);
	std::string str(chRtn);
	delete[]chRtn;
	return str;
}

std::string UtfToString(std::string strValue)
{
	int nwLen = ::MultiByteToWideChar(CP_ACP, 0, strValue.c_str(), -1, NULL, 0);
	wchar_t* pwBuf = new wchar_t[nwLen + 1];//加上末尾'\0'
	ZeroMemory(pwBuf, nwLen * 2 + 2);
	::MultiByteToWideChar(CP_ACP, 0, strValue.c_str(), strValue.length(), pwBuf, nwLen);
	int nLen = ::WideCharToMultiByte(CP_UTF8, 0, pwBuf, -1, NULL, NULL, NULL, NULL);
	char* pBuf = new char[nLen + 1];
	ZeroMemory(pBuf, nLen + 1);
	::WideCharToMultiByte(CP_UTF8, 0, pwBuf, nwLen, pBuf, nLen, NULL, NULL);
	std::string retStr(pBuf);
	delete[]pwBuf;
	delete[]pBuf;
	pwBuf = NULL;
	pBuf = NULL;
	return retStr;
}


std::string StringToUtf(std::string strValue)
{
	int nwLen = MultiByteToWideChar(CP_UTF8, 0, strValue.c_str(), -1, NULL, 0);
	wchar_t* pwBuf = new wchar_t[nwLen + 1];//加上末尾'\0'
	memset(pwBuf, 0, nwLen * 2 + 2);
	MultiByteToWideChar(CP_UTF8, 0, strValue.c_str(), strValue.length(), pwBuf, nwLen);
	int nLen = WideCharToMultiByte(CP_ACP, 0, pwBuf, -1, NULL, NULL, NULL, NULL);
	char* pBuf = new char[nLen + 1];
	memset(pBuf, 0, nLen + 1);
	WideCharToMultiByte(CP_ACP, 0, pwBuf, nwLen, pBuf, nLen, NULL, NULL);
	std::string retStr = pBuf;
	delete[]pBuf;
	delete[]pwBuf;
	return retStr;
}

char* GBKToUTF8(const char* chGBK)
{
	DWORD dWideBufSize = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)chGBK, -1, NULL, 0);
	wchar_t* pWideBuf = new wchar_t[dWideBufSize];
	wmemset(pWideBuf, 0, dWideBufSize);
	MultiByteToWideChar(CP_ACP, 0, (LPCSTR)chGBK, -1, pWideBuf, dWideBufSize);

	DWORD dUTF8BufSize = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)pWideBuf, -1, NULL, 0, NULL, NULL);

	char* pUTF8Buf = new char[dUTF8BufSize];
	memset(pUTF8Buf, 0, dUTF8BufSize);
	WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)pWideBuf, -1, pUTF8Buf, dUTF8BufSize, NULL, NULL);

	delete[]pWideBuf;
	return pUTF8Buf;
}

int GetContrastLevel(float contrast) {
	int ret = 4;
	if (contrast >= -1000.0f && contrast < -666.0f) { ret = 1; }
	else if (contrast >= -666.0f && contrast < -333.0f) { ret = 2; }
	else if (contrast >= -333.0f && contrast < 0.0f) { ret = 3; }
	else if (contrast > 0.0f && contrast <= 333.0f) { ret = 5; }
	else if (contrast > 333.0f && contrast <= 666.0f) { ret = 6; }
	else if (contrast > 666.0f && contrast <= 1000.0f) { ret = 7; }
	return ret;
}

CString GetHidedlgPath()
{
	TCHAR szIniFile[MAX_PATH] = { 0 };
	SHGetSpecialFolderPath(NULL, szIniFile, CSIDL_WINDOWS, TRUE);
#ifdef MAKEHUAGAO
	_tcscat(szIniFile, _T("\\twain_32\\HuaGoScan\\hidedlg.exe"));
#elif defined AUGE
	_tcscat(szIniFile, _T("\\twain_32\\AuGeScan\\hidedlg.exe"));
#elif defined HANVON 
	_tcscat(szIniFile, _T("\\twain_32\\HanvonScan\\hidedlg.exe"));
#elif defined LANXUM
	_tcscat(szIniFile, _T("\\twain_32\\LANXUMSCAN\\hidedlg.exe"));
#elif defined CUMTENN
	_tcscat(szIniFile, _T("\\twain_32\\CumTennScan\\hidedlg.exe"));
#elif defined MAKERIGHTWAY
	_tcscat(szIniFile, _T("\\twain_32\\RIGHTWAYSCAN\\hidedlg.exe"));
#elif defined NOLOGO
	_tcscat(szIniFile, _T("\\twain_32\\Scan\\hidedlg.exe"));
#else // MAKEHUAGAO
	_tcscat(szIniFile, _T("\\twain_32\\ZhibenScan\\hidedlg.exe"));
#endif
	int iLen = WideCharToMultiByte(CP_ACP, 0, szIniFile, -1, NULL, 0, NULL, NULL);
	char* chRtn = new char[iLen * sizeof(char)];
	WideCharToMultiByte(CP_ACP, 0, szIniFile, -1, chRtn, iLen, NULL, NULL);
	CString ret(chRtn);
	delete[] chRtn;
	return ret;
}

int GetMappingBrightnessValue(float in)
{
	float ratio = 254 / 2000.0f;
	int ret = 0;
	ret = (int)(ratio * in) + 128;
	return ret;
}

int GetMappingContrastValue(float in) {
	int ret = 0;
	float ratio = 72 / 2000.0f;
	ret = (int)(in * ratio);
	return ret;
}

string getOSInfo() {
	string iosinfo;
	OSVERSIONINFOEX osver = { sizeof(OSVERSIONINFOEX) };
	osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
	GetVersionEx((OSVERSIONINFO*)(&osver));
	if (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 0)
		iosinfo = "Windows 2000";
	else if (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 1)
		iosinfo = "Windows XP";
	else if (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 2) {
		if (GetSystemMetrics(SM_SERVERR2) != 0) { iosinfo = "Windows Server 2003 R2"; }
		else { iosinfo = "Windows Server 2003"; }
	}
	else if (osver.dwMajorVersion == 6 && osver.dwMinorVersion == 0) {
		if (osver.wProductType == VER_NT_WORKSTATION) { iosinfo = "Windows Vista"; }
		else { iosinfo = "Windows Server 2008"; }
	}
	else if (osver.dwMajorVersion == 6 && osver.dwMinorVersion == 1) {
		if (osver.wProductType == VER_NT_WORKSTATION) { iosinfo = "Windows 7"; }
		else { iosinfo = "Windows Server 2008 R2"; }
	}
	else if (osver.dwMajorVersion == 6 && osver.dwMinorVersion == 2) {
		if (osver.wProductType == VER_NT_WORKSTATION) { iosinfo = "Windows 8"; }
		else { iosinfo = "Windows Server 2012"; }
	}
	else if (osver.dwMajorVersion == 6 && osver.dwMinorVersion == 3) {
		if (osver.wProductType == VER_NT_WORKSTATION) { iosinfo = "Windows 8.1"; }
		else { iosinfo = "Windows Server 2012 R2"; }
	}
	else if (osver.dwMajorVersion == 10 && osver.dwMinorVersion == 0) {
		if (osver.wProductType == VER_NT_WORKSTATION) { iosinfo = "Windows 10"; }
		else { iosinfo = "Windows Server 2016"; }
	}
	else 
	   iosinfo = "unkown system";
	return iosinfo;
}

#ifdef _WIN64

// method 2: usde winapi, works for x86 and x64
#include <intrin.h>
string getCpuInfo()
{
	string retinfo;
	int cpuInfo[4] = { -1 };
	char cpu_manufacture[32] = { 0 };
	char cpu_type[32] = { 0 };
	char cpu_freq[32] = { 0 };

	__cpuid(cpuInfo, 0x80000002);
	memcpy(cpu_manufacture, cpuInfo, sizeof(cpuInfo));

	__cpuid(cpuInfo, 0x80000003);
	memcpy(cpu_type, cpuInfo, sizeof(cpuInfo));

	__cpuid(cpuInfo, 0x80000004);
	memcpy(cpu_freq, cpuInfo, sizeof(cpuInfo));

	string mfc(cpu_manufacture);
	string cputype(cpu_type);
	string cpufreq(cpu_freq);
	retinfo = mfc + cputype + cpufreq;
	return  retinfo;
}

#else

// mothed 1: this kind asm embedded in code only works in x86 build
// save 4 register variables
DWORD deax;
DWORD debx;
DWORD decx;
DWORD dedx;

// init cpu in assembly language
void initCpu(DWORD veax)
{
	__asm
	{
		mov eax, veax
		cpuid
		mov deax, eax
		mov debx, ebx
		mov decx, ecx
		mov dedx, edx
	}
}

long getCpuFreq()
{
	int start, over;
	_asm
	{
		RDTSC
		mov start, eax
	}
	Sleep(50);
	_asm
	{
		RDTSC
		mov over, eax
	}
	return (over - start) / 50000;
}

std::string getManufactureID()
{
	char manuID[25];
	memset(manuID, 0, sizeof(manuID));

	initCpu(0);
	memcpy(manuID + 0, &debx, 4); // copy to array
	memcpy(manuID + 4, &dedx, 4);
	memcpy(manuID + 8, &decx, 4);

	return  string(manuID);
}

std::string getCpuType()
{
	const DWORD id = 0x80000002; // start 0x80000002 end to 0x80000004
	char cpuType[49];
	memset(cpuType, 0, sizeof(cpuType));

	for (DWORD t = 0; t < 3; t++)
	{
		initCpu(id + t);

		memcpy(cpuType + 16 * t + 0, &deax, 4);
		memcpy(cpuType + 16 * t + 4, &debx, 4);
		memcpy(cpuType + 16 * t + 8, &decx, 4);
		memcpy(cpuType + 16 * t + 12, &dedx, 4);
	}

	return string(cpuType);
}

#endif


// ---- get memory info ---- //
string getMemoryInfo()
{
	std::string memory_info;
	MEMORYSTATUSEX statusex;
	statusex.dwLength = sizeof(statusex);
	if (GlobalMemoryStatusEx(&statusex))
	{
		unsigned long long total = 0, remain_total = 0, avl = 0, remain_avl = 0;
		double decimal_total = 0, decimal_avl = 0;
		remain_total = statusex.ullTotalPhys % GBYTES;
		total = statusex.ullTotalPhys / GBYTES;
		avl = statusex.ullAvailPhys / GBYTES;
		remain_avl = statusex.ullAvailPhys % GBYTES;
		if (remain_total > 0)
			decimal_total = (remain_total / MBYTES) / DKBYTES;
		if (remain_avl > 0)
			decimal_avl = (remain_avl / MBYTES) / DKBYTES;

		decimal_total += (double)total;
		decimal_avl += (double)avl;
		char  buffer[kMaxInfoBuffer];
		sprintf_s(buffer, kMaxInfoBuffer, "total %.2f GB (%.2f GB available)", decimal_total, decimal_avl);
		memory_info.append(buffer);
	}
	return memory_info;
}

void GetDiskInfo(DWORD& dwNum, CString chDriveInfo[])
{
	DWORD DiskCount = 0;

	//The number of logical drivers in the system can be obtained by using the GetLogicalDrives() function, which returns a 32-bit unsigned integer data.  
	DWORD DiskInfo = GetLogicalDrives();

	//Cyclic operations are used to see if each bit of data is 1, if 1, the disk is true, and if 0, the disk does not exist.  
	while (DiskInfo)
	{
		//Through the logic and operation of bit operation, we can judge whether it is 1 or not.  
		Sleep(10);
		if (DiskInfo & 1)
		{
			DiskCount++;
		}
		DiskInfo = DiskInfo >> 1;//The right-shift operation of bit operation ensures that the checked position moves one bit to the right once per cycle. * /  
	}

	if (dwNum < DiskCount)
	{
		return;//The actual number of disks is greater than dwNum  
	}
	dwNum = DiskCount;//Save the number of disk partitions  


	//-------------------------------------------------------------------//  
	//Get the length of all drive string information through the GetLogicalDriveStrings() function  
	int DSLength = GetLogicalDriveStrings(0, NULL);

	WCHAR* DStr = new WCHAR[DSLength];
	memset(DStr, 0, DSLength);

	//The string information is copied into the heap area array by GetLogical Drive Strings, which stores the information of all drives.  
	GetLogicalDriveStrings(DSLength, DStr);

	int DType;
	int si = 0;
	BOOL fResult;
	unsigned _int64 i64FreeBytesToCaller;
	unsigned _int64 i64TotalBytes;
	unsigned _int64 i64FreeBytes;

	//Read the driver information, because the DStr internal data format is A: NULLB: NULLC: NULL, so DSLength/4 can get specific large cycle range.  
	for (int i = 0; i < DSLength / 4; ++i)
	{
		Sleep(10);
		CString strdriver = DStr + i * 4;
		CString strTmp, strTotalBytes, strFreeBytes;
		DType = GetDriveType(strdriver);//GetDriveType function, you can get the driver type, parameter is the root directory of the driver  
		switch (DType)
		{
		case DRIVE_FIXED:
		{
			strTmp.Format(_T("Local disk"));
		}
		break;
		case DRIVE_CDROM:
		{
			strTmp.Format(_T("DVD Driver"));
		}
		break;
		case DRIVE_REMOVABLE:
		{
			strTmp.Format(_T("Removable disk"));
		}
		break;
		case DRIVE_REMOTE:
		{
			strTmp.Format(_T("Network disk"));
		}
		break;
		case DRIVE_RAMDISK:
		{
			strTmp.Format(_T("fictitious RAM disk"));
		}
		break;
		case DRIVE_UNKNOWN:
		{
			strTmp.Format(_T("fictitious RAM unknown device"));
		}
		break;
		default:
			strTmp.Format(_T("unknown device"));
			break;
		}

		//GetDiskFreeSpaceEx function, which can get the space state of the drive disk, returns a BOOL-type data  
		fResult = GetDiskFreeSpaceEx(strdriver,
			(PULARGE_INTEGER)&i64FreeBytesToCaller,
			(PULARGE_INTEGER)&i64TotalBytes,
			(PULARGE_INTEGER)&i64FreeBytes);

		if (fResult)
		{
			strTotalBytes.Format(_T("Total disk capacity%fMB"), (float)i64TotalBytes / 1024 / 1024);
			strFreeBytes.Format(_T("Disk Remaining Space%fMB"), (float)i64FreeBytesToCaller / 1024 / 1024);
		}
		else
		{
			strTotalBytes.Format(_T(""));
			strFreeBytes.Format(_T(""));
		}
		chDriveInfo[i] = strTmp + _T("(") + strdriver + _T("):") + strTotalBytes + strFreeBytes;
		si += 4;
	}
}