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;
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-22 07:18:41 +00:00
|
|
|
|
BOOL isFileExist(std::string folder)
|
|
|
|
|
{
|
|
|
|
|
return _access(folder.c_str(), 4) == 0 ? TRUE : FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-20 03:15:56 +00:00
|
|
|
|
// CTwainUI <20><>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
|
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);
|
2021-06-21 11:38:36 +00:00
|
|
|
|
delete[]chRtn;
|
2020-03-11 01:58:06 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-21 11:38:36 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
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; }
|
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);
|
2020-08-15 08:08:47 +00:00
|
|
|
|
#ifdef MAKEHUAGAO
|
2020-07-11 10:43:17 +00:00
|
|
|
|
_tcscat(szIniFile, _T("\\twain_32\\HuaGoScan\\hidedlg.exe"));
|
2021-11-20 03:09:04 +00:00
|
|
|
|
#elif defined AUGE
|
|
|
|
|
_tcscat(szIniFile, _T("\\twain_32\\AuGeScan\\hidedlg.exe"));
|
2021-09-23 01:19:47 +00:00
|
|
|
|
#elif defined HANVON
|
|
|
|
|
_tcscat(szIniFile, _T("\\twain_32\\HanvonScan\\hidedlg.exe"));
|
2020-11-16 10:05:04 +00:00
|
|
|
|
#elif defined LANXUM
|
|
|
|
|
_tcscat(szIniFile, _T("\\twain_32\\LANXUMSCAN\\hidedlg.exe"));
|
2022-06-29 12:24:24 +00:00
|
|
|
|
#elif defined CUMTENN
|
|
|
|
|
_tcscat(szIniFile, _T("\\twain_32\\CumTennScan\\hidedlg.exe"));
|
2022-02-14 02:30:19 +00:00
|
|
|
|
#elif defined MAKERIGHTWAY
|
|
|
|
|
_tcscat(szIniFile, _T("\\twain_32\\RIGHTWAYSCAN\\hidedlg.exe"));
|
2022-05-24 12:05:47 +00:00
|
|
|
|
#elif defined NOLOGO
|
|
|
|
|
_tcscat(szIniFile, _T("\\twain_32\\Scan\\hidedlg.exe"));
|
2020-08-15 08:08:47 +00:00
|
|
|
|
#else // MAKEHUAGAO
|
|
|
|
|
_tcscat(szIniFile, _T("\\twain_32\\ZhibenScan\\hidedlg.exe"));
|
|
|
|
|
#endif
|
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;
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|