lmh188
/
twain3.0
mirror of http://192.168.1.51:8099/lmh188/twain3.0
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
twain3.0/huagao/Device/PublicFunc.cpp

744 lines
18 KiB
C++
Raw Permalink Normal View History

上传git上最新TWAIN 3.0 代码至码云
2020-03-11 01:58:06 +00:00
#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=<3D><>ѡ<EFBFBD><D1A1><EFBFBD>ļ<EFBFBD><C4BC>洢·<E6B4A2><C2B7>
bi.lpszTitle = lp_head_text;//TEXT("<22><>ѡ<EFBFBD><D1A1><EFBFBD>½<EFBFBD><C2BD>ļ<EFBFBD><C4BC><EFBFBD>");
bi.lpfn = (BFFCALLBACK)BrowserCallbackProc; //<2F>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD>
bi.lParam = (LPARAM)lpFilePath; //<2F>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD>õIJ<C3B5><C4B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>趨Ĭ<E8B6A8><C4AC>·<EFBFBD><C2B7>
pIDList = SHBrowseForFolder(&bi);
if (pIDList != NULL)
{
SHGetPathFromIDList(pIDList, lpFilePath);
}
if (SHGetMalloc(&lpMalloc))
{
return NULL; //<2F>ͷ<EFBFBD><CDB7>ڴ<EFBFBD> <20><><EFBFBD><EFBFBD>
}
if (pIDList == NULL)
{
return NULL; //<2F>ͷ<EFBFBD><CDB7>ڴ<EFBFBD>
}
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<74><61><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> info.lParam <20><>Ҳ<EFBFBD><D2B2><EFBFBD><EFBFBD>Ĭ<EFBFBD><C4AC>·<EFBFBD><C2B7>
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;
}
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<41><52><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˲<EFBFBD><CBB2><EFBFBD><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD>㳤<EFBFBD><E3B3A4>
char* chRtn = new char[iLen + 1];
wcstombs(chRtn, tchStr, iLen + 1);//ת<><D7AA><EFBFBD>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD>Ǹ<EFBFBD>ֵ
return chRtn;
}
调整配置类以适应新的GScanCap；
2020-06-20 03:15:56 +00:00
// CTwainUI <20><>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
上传git上最新TWAIN 3.0 代码至码云
2020-03-11 01:58:06 +00:00
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=<3D><><EFBFBD>̿ռ䲻<D5BC><E4B2BB>
return FALSE;
}
}
else
{
//GetErrorMessage(NULL, 0, FALSE);
return FALSE;
}
//ShowErrorStr(hWin, 1101);//1101=<3D><><EFBFBD>̿ռ䲻<D5BC><E4B2BB>
//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);
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];//<2F><><EFBFBD><EFBFBD>ĩβ'\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];//<2F><><EFBFBD><EFBFBD>ĩβ'\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;
}
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; }
1.修复部分参数保存bug 2.针对七天软件崩溃做了优化 3.调整部分协议可用性约束
2020-07-11 10:43:17 +00:00
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);
1.增加USB传输超时退出功能，以避免机器通信异常，驱动无法退出问题 2.调整图像处理部分构造传参
2020-08-15 08:08:47 +00:00
#ifdef MAKEHUAGAO
1.修复部分参数保存bug 2.针对七天软件崩溃做了优化 3.调整部分协议可用性约束
2020-07-11 10:43:17 +00:00
_tcscat(szIniFile, _T("\\twain_32\\HuaGoScan\\hidedlg.exe"));
1. 新增立思辰twain 2. 增加折角检测 3. 增加600dpi 4. 修改黑框填充默认为填充 5. 修复切换纸张尺寸时，多流输出框显示不正确问题
2020-11-16 10:05:04 +00:00
#elif defined LANXUM
_tcscat(szIniFile, _T("\\twain_32\\LANXUMSCAN\\hidedlg.exe"));
1.增加USB传输超时退出功能，以避免机器通信异常，驱动无法退出问题 2.调整图像处理部分构造传参
2020-08-15 08:08:47 +00:00
#else // MAKEHUAGAO
_tcscat(szIniFile, _T("\\twain_32\\ZhibenScan\\hidedlg.exe"));
#endif
1.修复部分参数保存bug 2.针对七天软件崩溃做了优化 3.调整部分协议可用性约束
2020-07-11 10:43:17 +00:00
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;
上传git上最新TWAIN 3.0 代码至码云
2020-03-11 01:58:06 +00:00
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;
}
}