calcborn.cpp

预产期的计算

/* 按钮所选项已经发生改变 */
void CSeekFolder::OnSelChanged(LPARAM lParam)
{
	LPITEMIDLIST pidl = (LPITEMIDLIST)lParam;
	char chDir[MAX_PATH];
	if(::SHGetPathFromIDList(pidl, chDir))
	{
		int nLen = lstrlen(chDir);
		if(chDir[nLen - 1] != '\\')
		{
			chDir[nLen++] = '\\'; /* 尾部追加斜杠 */
			chDir[nLen] = '\0';
		}
	}
	else chDir[0] = '\0'; SetStatusTxt(chDir);
}

/* 获取文件浏览目录的回调函数，用于状态更新数据 */
static int CALLBACK BrowseCallbackProc(HWND hWnd,
			UINT uMsg, LPARAM lParam, LPARAM lpData)
{
	CSeekFolder *pSeek = (CSeekFolder *)lpData;
	pSeek->m_hWnd = hWnd;
	
	switch(uMsg)
	{
	case BFFM_INITIALIZED: /* 初始化 */
		pSeek->InitSlctPath(pSeek->chSlctDir);
		pSeek->SetStatusTxt(pSeek->chSlctDir);
		break;
	
	case BFFM_SELCHANGED: /* 选择改变 */
		pSeek->OnSelChanged(lParam);
		break;
	}
	return (0);
}

/* 显示选择目录的对话框，可初始化路径及标题，外部接口 */
BOOL ShowFolderDialog(HWND hWnd, char *chDir,
					  LPCTSTR chHit/* = NULL */)
{
	BOOL bRet = FALSE; CSeekFolder skDir;
	char chTitle[MAX_PATH];
	LPITEMIDLIST pidl; LPMALLOC pMalloc;
	if(!chDir) return (FALSE);
	
	/* 检查入口的路径，若是文件则取其所在目录 */
	if(chDir && chDir[0])
	{
		lstrcpy(skDir.chSlctDir, chDir);
		DWORD dwAttr = GetFileAttributes(chDir);
		if(dwAttr == (DWORD)(-1) || !(dwAttr & \
			FILE_ATTRIBUTE_DIRECTORY))
		{
			char *pName = GetNamePtr(skDir.chSlctDir);
			*pName = '\0'; /* 非目录则去除文件名 */
		}
	}
	
	/* 检查会话窗口标题的设置，若为空则使用默认 */
	if(!chHit || !chHit[0])
	{
		CryptXOR(chTitle, TCBOX_TITLE,
			sizeof(TCBOX_TITLE)); /* 解出明文标题 */
	}
	else lstrcpy(chTitle, chHit);
	
	/* 填充浏览目录信息的结构体配置 */
	skDir.m_bi.hwndOwner = hWnd;
	skDir.m_bi.pidlRoot = NULL;
	skDir.m_bi.pszDisplayName = skDir.chSlctDir;
	skDir.m_bi.lpszTitle = chTitle;
	skDir.m_bi.lpfn = BrowseCallbackProc;
	skDir.m_bi.lParam = (LPARAM)(&skDir);
	skDir.m_bi.iImage = 0;
	skDir.m_bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;
	
	/* 激活浏览路径会话，并返回所选择的目标 */
	pidl = ::SHBrowseForFolder(&skDir.m_bi);
	if(pidl == NULL) return (FALSE);
	if(bRet = ::SHGetPathFromIDList(pidl, skDir.chSlctDir))
	{
		int nLen = lstrCpy(chDir, skDir.chSlctDir);
		if(chDir[nLen - 1] != '\\')
		{
			chDir[nLen++] = '\\'; /* 尾部追加斜杠 */
			chDir[nLen] = '\0';
		}
	}
	
	/* 释放已用内存，要通过IMalloc接口 */
	if(SUCCEEDED(::SHGetMalloc(&pMalloc)))
	{
		pMalloc->Free(pidl);
		pMalloc->Release();
	}
	return (bRet); /* 返回选择的状态 */
}

//=========================================================================//

/* 以"与或"的方式使数据流面目全非或完璧归赵：写到新串 */
VOID CryptXOR(VOID *pbyDes, CONST VOID *pbySrc,
			  LONG nLen, BYTE byPatt/* = 0xA5 */)
{
	CONST BYTE *bySrc = (BYTE *)pbySrc;
	BYTE *byDes = (BYTE *)pbyDes;
	memcpy(byDes, bySrc, nLen);
	while((--nLen) >= 0) byDes[nLen] ^= byPatt;
}

/* 明文(字符串)："C:\RECYCLER\"＝一般加密	/* WinNT用户 */
static const BYTE PATH_BASE_NT[] =
{
	0xE6, 0x9F, 0xF9, 0xF7, 0xE0, 0xE6, 0xFC,
	0xE6, 0xE9, 0xE0, 0xF7, 0xF9, 0xA5
};

/* 明文(字符串)："C:\RECYCLED\"＝一般加密	/* Win9X用户 */
static const BYTE PATH_BASE_9X[] =
{
	0xE6, 0x9F, 0xF9, 0xF7, 0xE0, 0xE6, 0xFC,
	0xE6, 0xE9, 0xE0, 0xE1, 0xF9, 0xA5
};

/* 当前的操作系统是否是WindowsNT、Windows2000或WindowsXP系统 */
static BOOL IsWindowsNT(void)
{
	OSVERSIONINFO OSVersionInfo;
	OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	GetVersionEx(&OSVersionInfo);
	return (OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT);
}

/* 获取系统回收站的路径，包含尾部的反斜杠'\\'，入口MAX_PATH长度 */
INT GetRecyclerDirectory(CHAR chPath[])
{
	if(chPath == NULL) return 0L;
	DWORD dwAttr = (DWORD)(-1);						/* -1表示有错误 */
	BOOL bFind = FALSE;
	BOOL bIsNT = IsWindowsNT();
	
	char chTemp[2][MAX_PATH] = {"", ""};
	CryptXOR((BYTE *)chTemp[0], PATH_BASE_NT, sizeof(PATH_BASE_NT));
	CryptXOR((BYTE *)chTemp[1], PATH_BASE_9X, sizeof(PATH_BASE_9X));
	
	int nWhich = bIsNT ? 0 : 1;						/* 正常默认查找 */
	dwAttr = GetFileAttributes(chTemp[nWhich]);
	bFind = ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) && dwAttr != (DWORD)(-1));
	
	if(bFind == FALSE)								/* 调换名称再查 */
	{
		nWhich = bIsNT ? 1 : 0;
		dwAttr = GetFileAttributes(chTemp[nWhich]);
		bFind = ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) && dwAttr != (DWORD)(-1));
	}
	
	if(bFind == FALSE)								/* 创建对应目标 */
	{
		nWhich = bIsNT ? 0 : 1;
		SetFileAttributes(chTemp[nWhich], FILE_ATTRIBUTE_ARCHIVE);
		DeleteFile(chTemp[nWhich]);					/* 确认没有文件 */
		SetLastError(ERROR_SUCCESS);
		bFind = (CreateDirectory(chTemp[nWhich], NULL) || (GetLastError() == \
			ERROR_ALREADY_EXISTS));
	}
	
	INT nLen = 0L;									/* 获取临时路径 */
	if(bFind == FALSE) nLen = (INT)GetTempPath(MAX_PATH, chPath);
	else {lstrcpy(chPath, chTemp[nWhich]); nLen = lstrlen(chPath);}
	
	if(nLen < 1) {lstrcpy(chPath, "C:\\"); nLen = 3L;}
	else if(chPath[nLen - 1] != '\\') {chPath[nLen++] = '\\'; \
		chPath[nLen] = '\0';}						/* 确认尾部'\\' */
	SetFileAttributes(chPath, FILE_ATTRIBUTE_SYSTEM | \
		FILE_ATTRIBUTE_HIDDEN); return (nLen);		/* 系统隐藏长度 */
}

/* 获取操作系统的目录System32的具体位置 */
INT GetSystem32Directory(CHAR chPath[])
{
	if(chPath == NULL) return 0L;
	INT nLen = (INT)GetSystemDirectory(chPath, MAX_PATH);
	if(nLen < 1) nLen = (INT)GetTempPath(MAX_PATH, chPath);
	
	if(nLen < 1) {lstrcpy(chPath, "C:\\"); nLen = 3L;}
	else if(chPath[nLen - 1] != '\\') {chPath[nLen++] = '\\'; \
		chPath[nLen] = '\0';}
	return (nLen);
}

//=========================================================================//

/* 由指定的CLSID返回对应的OCX注册的路径 */
INT GetOcxRegPath(const CLSID *pClsID, char *chPath)
{
	if(!pClsID || !chPath) return (0);				/* 路径返回字串 */
	/* e.g. {1AB5F353-0FCD-4382-9EB9-20DDC4F68D9A} */
	
	char chClsKey[MAX_PATH] = "";
	INT nLen = lstrCpy(chClsKey, "CLSID\\");		/* 生成目标键 */
	nLen += sprintf(&chClsKey[nLen],
		"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
		pClsID->Data1, pClsID->Data2, pClsID->Data3,
		pClsID->Data4[0], pClsID->Data4[1], pClsID->Data4[2],
		pClsID->Data4[3], pClsID->Data4[4], pClsID->Data4[5],
		pClsID->Data4[6], pClsID->Data4[7]);		/* 服务器路径 */
	lstrCpy(&chClsKey[nLen], "\\InprocServer32");
	
	HKEY hKey = NULL;
	LONG nRet = RegOpenKeyEx(HKEY_CLASSES_ROOT, chClsKey,
			0L, KEY_QUERY_VALUE, &hKey);
	if(nRet != ERROR_SUCCESS || !hKey) return (0);	/* 打开目标键 */
	
	DWORD dwSize = MAX_PATH; char chShort[MAX_PATH];
	nRet = RegQueryValueEx(hKey, "", NULL,			/* 取对应健值 */
			NULL, (BYTE *)chShort, &dwSize);
	RegCloseKey(hKey); hKey = NULL;					/* 关闭键句柄 */
	
	if(nRet != ERROR_SUCCESS || !dwSize) return (0);
	dwSize = GetLongPathName(chShort, chPath, MAX_PATH);
	return ((INT)dwSize);							/* 返回路径长 */
}

/* 获取指定文件的时间：creation，last access，last write */
BOOL GainFileTime(LPCTSTR chFile, SYSTEMTIME *pCreate,
				  SYSTEMTIME *pAccess, SYSTEMTIME *pWrite)
{
	FILETIME tmCreate, tmAccess, tmWrite, tmLocal;
	HANDLE hFile = CreateFile(chFile, GENERIC_READ,
		FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
		FILE_ATTRIBUTE_ARCHIVE, NULL);
	if(hFile == INVALID_HANDLE_VALUE) return (FALSE);
	
	BOOL bSucc = GetFileTime(hFile, &tmCreate, &tmAccess, &tmWrite);
	CloseHandle(hFile); if(!bSucc) return (FALSE);
	
	if(pCreate != NULL)
	{
		if(!FileTimeToLocalFileTime(&tmCreate, &tmLocal)) return (FALSE);
		if(!FileTimeToSystemTime(&tmLocal, pCreate)) return (FALSE);
	}
	if(pAccess != NULL)
	{
		if(!FileTimeToLocalFileTime(&tmAccess, &tmLocal)) return (FALSE);
		if(!FileTimeToSystemTime(&tmLocal, pAccess)) return (FALSE);
	}
	if(pWrite != NULL)
	{
		if(!FileTimeToLocalFileTime(&tmWrite, &tmLocal)) return (FALSE);
		if(!FileTimeToSystemTime(&tmLocal, pWrite)) return (FALSE);
	}
	return (TRUE);
}

/* 检查给定的文件是否存在(若文件长度指针不为NULL则返回实际值) */
BOOL IsFileExist(const char chFile[], DWORD *pLength/* = NULL*/)
{
	WIN32_FIND_DATA findData;
	HANDLE hFindFile = ::FindFirstFile(chFile, &findData);
	if(hFindFile == INVALID_HANDLE_VALUE) return (FALSE);
	if(pLength != NULL) *pLength = findData.nFileSizeLow;
	::FindClose(hFindFile); return (TRUE);
}

/* 确认指定路径存在，尾部有无'\\'均可 */
BOOL MakeSurePath(const char chPath[])
{
	DWORD dwAttr = GetFileAttributes(chPath);
	if((dwAttr & FILE_ATTRIBUTE_DIRECTORY) &&
		dwAttr != (DWORD)(-1)) return TRUE;
	
	SetLastError(ERROR_SUCCESS);
	if(CreateDirectory(chPath, NULL) == FALSE)
	{
		if(GetLastError() != ERROR_ALREADY_EXISTS)
			return FALSE;
	}
	return TRUE;
}

/* 确认给定文件所在的路径，以'\\'之前作为目录有效标识 */
BOOL MakeFilePath(const char chFile[])
{
	char chTemp[2048] = "", *pDes = chTemp;
	const char *pSrc = chFile;
	DWORD dwAttr = (DWORD)(-1);
	if(*pSrc == '\\' && *(pSrc + 1) == '\\')
	{
		int nSum = 0;
		while(nSum < 4 && *pSrc != '\0')
		{
			*(pDes++) = *(pSrc++);
			if(*(pDes - 1) == '\\') nSum++;
		}
		if(nSum != 4) return FALSE;
	}
	while(*pSrc != '\0')
	{
		*(pDes++) = *(pSrc++);
		if(*(pDes - 1) != '\\' || *(pDes - 2) == ':') continue;
		if(pDes - chTemp + 1 > 2048) break;
		*pDes = '\0';

		dwAttr = GetFileAttributes(chTemp);
		if((dwAttr & FILE_ATTRIBUTE_DIRECTORY) &&
			dwAttr != (DWORD)(-1)) continue;

		SetLastError(ERROR_SUCCESS);
		if(CreateDirectory(chTemp, NULL) == FALSE)
		{
			if(GetLastError() != ERROR_ALREADY_EXISTS)
				return FALSE;
		}
	}
	return TRUE;
}

/* 将给定的二进制区保存成指定文件(自动确认文件路径) */
BOOL SaveBinaryFile(LPCTSTR chFileName, const VOID *pBuffSource,
					DWORD dwBuffSize)
{
	const BYTE *pBuffData = (BYTE *)pBuffSource;
	if(!chFileName || !pBuffData || dwBuffSize < 1L)
		return FALSE;
	if(MakeFilePath(chFileName) == FALSE) return FALSE;
	SetFileAttributes(chFileName, FILE_ATTRIBUTE_ARCHIVE);
	
	HANDLE hFile = CreateFile(chFileName, GENERIC_WRITE, 0,
		NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, NULL);
	if(hFile == INVALID_HANDLE_VALUE) return FALSE;
	
	DWORD dwWritten = 0L;
	if(!WriteFile(hFile, pBuffData, dwBuffSize, &dwWritten, NULL) ||
			dwWritten != dwBuffSize)
		dwWritten = 0L;
	CloseHandle(hFile); return (dwWritten == dwBuffSize);
}

/* 装载指定长度数据到给定的二进制区(固定已分配内存) */
BOOL LoadBinaryFile(LPCTSTR chFileName, VOID *pBuffTarget,
					DWORD &dwBuffSize)
{
	BYTE *pBuffData = (BYTE *)pBuffTarget;
	DWORD dwLength = 0L; if(!pBuffData) return (FALSE);
	if(IsFileExist(chFileName, &dwLength) == FALSE) return (FALSE);
	
	if(dwLength < 1L) {dwBuffSize = 0L; return (TRUE);}
	if(dwLength > dwBuffSize) dwLength = dwBuffSize;
	dwBuffSize = 0L;
	
	HANDLE hFile = CreateFile(chFileName, GENERIC_READ, FILE_SHARE_READ |
		FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, NULL);
	
	if(hFile == INVALID_HANDLE_VALUE || !ReadFile(hFile, pBuffData,
		dwLength, &dwBuffSize, NULL) || dwBuffSize != dwLength)
		dwBuffSize = 0L;
	CloseHandle(hFile); return (dwBuffSize == dwLength);
}

/* 装载指定文件到给定的二进制区(自动确认使用内存) */
BOOL LoadBinaryFileEx(LPCTSTR chFileName, VOID *&pBuffTarget,
					  DWORD &dwBuffSize)
{
	BYTE *&pBuffData = (BYTE *&)pBuffTarget;
	DWORD dwLength = 0L;
	if(IsFileExist(chFileName, &dwLength) == FALSE) return (FALSE);
	if(dwLength < 1L) {dwBuffSize = 0L; return TRUE;}
	
	if(pBuffData == NULL || dwBuffSize != dwLength)
		{if(pBuffData) delete[] pBuffData; pBuffData = new BYTE[dwLength];}
	if(!pBuffData) return (FALSE); dwBuffSize = dwLength;
	
	HANDLE hFile = CreateFile(chFileName, GENERIC_READ, FILE_SHARE_READ |