自己比较喜欢的CCommon类

//========================================================================
//TITLE:
// 自己比较喜欢的CCommon类
//AUTHOR:
// norains
//DATE:
// Monday 4-June-2007
//Environment:
// EVC4.0 + Standard SDK 4.2
// EVC4.0 + Standard SDK 5.0
//========================================================================

CCommon包含了一小部分编程时所需的操作,小巧精悍,主要是自己比较喜欢.CCommon类的完整源代码附录于本文之后,之前先让我们看看该类的函数具体用法.

1. DeleteDirectory(const TCHAR *pszPath)

和系统函数RemoveDirectory不同,该函数可以删除非空文件夹.

例:
CCommon::DeleteDirectory(TEXT("My Documents//Photo"));

2.BroadcastMessage(BroadcastType bcType, UINT wMsg, WPARAM wParam,LPARAM lParam)

广播消息.当bcType为BC_ALL时,向所有的窗口发送消息;BC_VISIBLE是发送给所有的可见窗口;BC_VISIBLE_NOBASEEXPLORER则是除了explorer以外的其它可视窗口.

例,关闭所有的除了explorer以外的所有可视窗口:
CCommon::BroadMessage(BC_VISIBLE_NOBASEEXPLORER,WM_CLOSE,NULL,NULL);



3.CreateDirectorySerial(TCHAR *pszPath)

创建文件夹序列.

例:
CCommon::CreateDirectorySerial(TEXT("Document//abc//d"));
该代码将依次建立如下文件夹:document,abc,d.



4.CompareSystime(const LPSYSTEMTIME lpTimeA,const LPSYSTEMTIME lpTimeB,LPSYSTEMTIME lpTimeResult)

比较系统时间,时间的差值存储在lpTimeResult结构体中.返回值 == 1 则两者相等;返回值 > 1, 则lpTimeA时间比lpTimeB在后;返回值 < 1, 则lpTimeB时间比lpTimeA在后.

例:
SYSTEMTIME ta,tb,tr;
GetSystemTime(&ta);
Sleep(1000);
GetSystemTime(&tb);
CompareSystime(&ta,&tb,&tr);

5.WCharToMByte(LPCWSTR lpcwszStr, LPSTR lpszStr, DWORD dwSize),MByteToWChar(LPCSTR lpcszStr, LPWSTR lpwszStr, DWORD dwSize)

多字节字符和宽字节字符的相互转换,具体原理和细节请参考:《MultiByteToWideChar和WideCharToMultiByte用法详解 》http://blog.csdn.net/norains/archive/2006/12/25/1461174.aspx

6.CenterWindow(HWND hWnd)

移动窗口到居中位置.

例:
CCommon::CenterWindow(hWnd);

7.GetScreenHeight(),GetScreenWidth()

获取屏幕的高度和宽度,以像素点为单位

例:
int iHeight = CCommon::GetScreenHeight();
int iWidth = CCommon::GetScreenWidth();



8.GetCurrentDirectory(TCHAR *pszPath, ULONG ulSize)

获取当前程序运行的路径,其后附带'/'.

例:
TCHAR szCurPath[MAX_PATH];
CCommon::GetCurrentPath(szCurPath,MAX_PATH);

9.FindString(const TCHAR *szSource, const TCHAR *szFind,const int iBeginPos)

查找某段字符串.

例:
int iPos1 = CCommon(TEXT("ABCEF"),TEXT("BC")); //iPos1 == 1
int iPos2 = CCommon(TEXT("ABCEF"),TEXT("BC"),1); //iPos1 == 0



10.Execute(TCHAR *pszPath,TCHAR *pParameters = NULL)

运行指定程序.

例:
CCommon::Execute(TEXT("windows//pmail.exe"))



11.ShowTaskBar(BOOL bShow)

隐藏或显示任务栏.

例:
CCommon::ShowTaskBar(TRUE);//显示任务栏



至此,CCommon的函数用法已经基本介绍完毕,更详细的用法请参加其后的完整代码.

/**//
// Common.h: interface for the CCommon class.
//
//Version:
// 2.2.1
//Date:
// 2007.06.02
/**///

#ifndef COMMON_H
#define COMMON_H

//--------------------------------------------------------------------
enum BroadcastType
...{
BC_VISIBLE, //Broadcast the visible window
BC_ALL, //Broadcast all the window
BC_VISIBLE_NOBASEEXPLORER //Broadcast all the visible window, but no base explorer window as "DesktopExplorerWnd" and "HHTaskBar"
};
//--------------------------------------------------------------------
class CCommon
...{
public:
static void DeleteDirectory(const TCHAR *pszPath);
static void BroadcastMessage(BroadcastType bcType, UINT wMsg, WPARAM wParam,LPARAM lParam);
static void CreateDirectorySerial(TCHAR *pszPath);
static int CompareSystime(const LPSYSTEMTIME lpTimeA,const LPSYSTEMTIME lpTimeB,LPSYSTEMTIME lpTimeResult);
static BOOL WCharToMByte(LPCWSTR lpcwszStr, LPSTR lpszStr, DWORD dwSize);
static BOOL MByteToWChar(LPCSTR lpcszStr, LPWSTR lpwszStr, DWORD dwSize);
static BOOL CenterWindow(HWND hWnd);
static int GetScreenHeight();
static int GetScreenWidth();
static TCHAR *GetCurrentDirectory(TCHAR *pszPath, ULONG ulSize);
static int FindString(const TCHAR *szSource, const TCHAR *szFind,const int iBeginPos);
static BOOL Execute(TCHAR *pszPath,TCHAR *pParameters = NULL);
static BOOL ShowTaskBar(BOOL bShow);
virtual ~CCommon();

protected:
static BOOL EnumWindowsProcForBroadcast(HWND hWnd, LPARAM lParam );
CCommon();

//It's for the BroadcastMessage function
static HWND m_hWndBc;
static UINT m_wMsgBc;
static WPARAM m_wParamBc;
static LPARAM m_lParamBc;
static BroadcastType m_BcType;
};

#endif // !defined(AFX_COMMON_H__BCB17199_0561_47B0_943C_8921D6CC42D7__INCLUDED_)

/**///
// Common.cpp: implementation of the CCommon class.
//
/**///

#include "stdafx.h"
#include "Common.h"

//--------------------------------------------------------------------
//static member initialize
HWND CCommon::m_hWndBc = NULL;
UINT CCommon::m_wMsgBc = NULL;
WPARAM CCommon::m_wParamBc = NULL;
LPARAM CCommon::m_lParamBc = NULL;
BroadcastType CCommon::m_BcType = BC_VISIBLE;
//--------------------------------------------------------------------
/**///
// Construction/Destruction
/**///

CCommon::CCommon()
...{

}

CCommon::~CCommon()
...{

}

//---------------------------------------------------------------------
//Description:
// Show or hide the task bar
//
//Parameters:
// bShow:[in]
// TRUE -- Show the task bar
// FALSE -- Hide the task bar
//---------------------------------------------------------------------
BOOL CCommon::ShowTaskBar(BOOL bShow)
...{
HWND hWndTask = FindWindow(TEXT("HHTaskBar"),NULL);
if(hWndTask == NULL)
...{
return FALSE;
}

if(bShow == TRUE)
...{
ShowWindow(hWndTask,SW_SHOW);
}
else
...{
ShowWindow(hWndTask,SW_HIDE);
}

return TRUE;
}

//---------------------------------------------------------------------
//Description:
// Execute the application
//
//Parameters:
// pszPath:[in] Long pointer to a null-terminated string that specifies the absolute name of the file to run
// pParameters:[in] Long pointer to a null-terminated string that contains the application parameters.
// The parameters must be separated by spaces. To include double quotation marks,
// you must enclose the marks in double quotation marks, as in the following example.
// TCHAR *pParameters = "An example: """quoted text"""";
// In this case, the application receives three parameters: An, example:, and "quoted text".
// If the pszPath specifies a document file, this member should be NULL.
//
//---------------------------------------------------------------------
BOOL CCommon::Execute(TCHAR *pszPath,TCHAR *pParameters)
...{
SHELLEXECUTEINFO info;
memset(&info,0,sizeof(info));
info.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI;
info.lpVerb = NULL;
info.lpFile = pszPath;
info.lpParameters = pParameters;
info.lpDirectory = NULL;
info.nShow = SW_SHOW;
info.hInstApp = NULL;
info.cbSize = sizeof( info );

BOOL bResult = ShellExecuteEx( &info );

return bResult;
}

//---------------------------------------------------------------------------
//Description:
// Find the string in the source string ,and return the position.
//
//Parameter:
// szSource:[in]
// The source string
// szFind:[in]
// The find string
// iBeginPos:[in]
// The begin finding position
//
//Return Values:
// If it -1 , couldn't find the string.
// Others , it's the position of the first character of szFind in the source string
//
//---------------------------------------------------------------------------
int CCommon::FindString(const TCHAR *szSource, const TCHAR *szFind, const int iBeginPos)
...{
int iLenSource = _tcslen(szSource);
int iLenFind = _tcslen(szFind);

if(iLenSource - 1 < iBeginPos)
...{
return -1;
}

int iCount = 0;
int iFindCount = 0;
BOOL bPair = FALSE;
for(iCount = 0; iCount < iLenSource - iBeginPos; iCount++)
...{
if(szSource[iCount + iBeginPos] == szFind[iFindCount])
...{
if(iFindCount == iLenFind - 1)
...{
bPair = TRUE;
break;
}
iFindCount++;
}
else
...{
iFindCount = 0;
}
}

int iFindPos ;

if(bPair == FALSE)
...{
iFindPos = -1;
}
else
...{
iFindPos = iCount + iBeginPos - iLenFind + 1;
}
return iFindPos;
}

//-------------------------------------------------------------------------------------
//Description:
// Get the current runing path including '' in last
//
//Parameters:
// pszPath: [out] Get the current path
// ulSize: [in] The size of the buffer. For example: szPath[MAX_NUMBER],the size if MAX_NUMBER.
//
//-------------------------------------------------------------------------------------
TCHAR *CCommon::GetCurrentDirectory(TCHAR *pszPath, ULONG ulSize)
...{
memset(pszPath, 0, sizeof(TCHAR) * ulSize);

TCHAR szBuf[MAX_PATH] = ...{0};
GetModuleFileName(NULL,szBuf,sizeof(szBuf)/sizeof(TCHAR));

ULONG ulCount = _tcslen(szBuf);
while(--ulCount >= 0)
...{
if(szBuf[ulCount] == '/')
...{
break;
}
else
...{
continue;
}
}

if(ulSize > (DWORD)ulCount)
...{
_tcsncpy(pszPath,szBuf,(ulCount + 1));
}

return pszPath;
}

//-------------------------------------------------------------------------------------
//Description:
// Get screen width in pixels
//------------------------------------------------------------------------------------
int CCommon::GetScreenWidth()
...{
return GetSystemMetrics(SM_CXSCREEN);
}

//-------------------------------------------------------------------------------------
//Description:
// Get screen height in pixels
//------------------------------------------------------------------------------------
int CCommon::GetScreenHeight()
...{
return GetSystemMetrics(SM_CYSCREEN);
}

//-------------------------------------------------------------------------------------
//Description:
// Center the window.
//
//Parameters:
// hWnd:[in] The window to be moved
//------------------------------------------------------------------------------------
BOOL CCommon::CenterWindow(HWND hWnd)
...{
if(hWnd == NULL)
...{
return FALSE;
}

RECT rcWnd = ...{0};
if(GetWindowRect(hWnd,&rcWnd) == FALSE)
...{
return FALSE;
}

int iWidth = rcWnd.right - rcWnd.left;
int iHeight = rcWnd.bottom - rcWnd.top;
int iX = (GetScreenWidth() - iWidth) / 2;
int iY = (GetScreenHeight() - iHeight) / 2;

return MoveWindow(hWnd,iX,iY,iWidth,iHeight,TRUE);

}

//-------------------------------------------------------------------------------------
//Description:
// This function maps a character string to a wide-character (Unicode) string
//
//Parameters:
// lpcszStr: [in] Pointer to the character string to be converted
// lpwszStr: [out] Pointer to a buffer that receives the translated string.
// dwSize: [in] Size of the buffer
//
//Return Values:
// TRUE: Succeed
// FALSE: Failed
//
//Example:
// MByteToWChar(szA,szW,sizeof(szW)/sizeof(szW[0]));
//---------------------------------------------------------------------------------------
BOOL CCommon::MByteToWChar(LPCSTR lpcszStr, LPWSTR lpwszStr, DWORD dwSize)
...{
// Get the required size of the buffer that receives the Unicode
// string.
DWORD dwMinSize;
dwMinSize = MultiByteToWideChar (CP_ACP, 0, lpcszStr, -1, NULL, 0);

if(dwSize < dwMinSize)
...{
return FALSE;
}


// Convert headers from ASCII to Unicode.
MultiByteToWideChar (CP_ACP, 0, lpcszStr, -1, lpwszStr, dwMinSize);
return TRUE;
}

//-------------------------------------------------------------------------------------
//Description:
// This function maps a wide-character string to a new character string
//
//Parameters:
// lpcwszStr: [in] Pointer to the character string to be converted
// lpszStr: [out] Pointer to a buffer that receives the translated string.
// dwSize: [in] Size of the buffer
//
//Return Values:
// TRUE: Succeed
// FALSE: Failed
//
//Example:
// MByteToWChar(szW,szA,sizeof(szA)/sizeof(szA[0]));
//---------------------------------------------------------------------------------------
BOOL CCommon::WCharToMByte(LPCWSTR lpcwszStr, LPSTR lpszStr, DWORD dwSize)
...{
DWORD dwMinSize;
dwMinSize = WideCharToMultiByte(CP_OEMCP,NULL,lpcwszStr,-1,NULL,0,NULL,FALSE);
if(dwSize < dwMinSize)
...{
return FALSE;
}
WideCharToMultiByte(CP_OEMCP,NULL,lpcwszStr,-1,lpszStr,dwSize,NULL,FALSE);
return TRUE;
}

//-------------------------------------------------------------------------------------------
//Description:
// Compare the two system time. The return value is the differ time.
//
//Parameters:
// lpTimeA: [in] System time to compare
// lpTimeB: [in] System time to compare
// lpTimeResult: [out] Different time
//
//Return values:
// 0: Equal
// 1: lpTimeA is greater than lpTimeB
// -1: lpTimeA is less than lpTimeB
//------------------------------------------------------------------------------------------
int CCommon::CompareSystime(const LPSYSTEMTIME lpTimeA, const LPSYSTEMTIME lpTimeB, LPSYSTEMTIME lpTimeResult)
...{

BYTE bBorrow = FALSE;

int iReturn = 0;

iReturn = lpTimeA->wYear - lpTimeB->wYear;
if(iReturn == 0)
...{
iReturn = lpTimeA->wMonth - lpTimeB->wMonth;
if(iReturn == 0)
...{
iReturn = lpTimeA->wDay - lpTimeB->wDay;
if(iReturn == 0)
...{
iReturn = lpTimeA->wHour - lpTimeB->wHour;
if(iReturn == 0)
...{
iReturn = lpTimeA->wMinute - lpTimeB->wMinute;
if(iReturn == 0)
...{
iReturn = lpTimeA->wSecond - lpTimeB->wSecond;
if(iReturn == 0)
...{
iReturn = lpTimeA->wMilliseconds - lpTimeB->wMilliseconds;
}
}
}
}
}
}

SYSTEMTIME sysTimeMinuend = ...{0};
SYSTEMTIME sysTimeSub = ...{0};
if(iReturn != 0)
...{
if(iReturn > 0)
...{
iReturn = 1;
sysTimeMinuend = *lpTimeA;
sysTimeSub = *lpTimeB;
}
else
...{
iReturn = -1;
sysTimeMinuend = *lpTimeB;
sysTimeSub = *lpTimeA;
}
}
else
...{
memset(lpTimeResult,0,sizeof(SYSTEMTIME));
goto END;
}

//Milliseconds
if(sysTimeMinuend.wMilliseconds >= sysTimeSub.wMilliseconds)
...{
bBorrow = FALSE;
lpTimeResult->wMilliseconds = sysTimeMinuend.wMilliseconds - sysTimeSub.wMilliseconds;
}
else
...{
bBorrow = TRUE;
lpTimeResult->wMilliseconds = 1000 + sysTimeMinuend.wMilliseconds - sysTimeSub.wMilliseconds;
}

//Second
if(bBorrow == TRUE)
...{
sysTimeMinuend.wSecond --;
}
if(sysTimeMinuend.wSecond >= sysTimeSub.wSecond)
...{
bBorrow = FALSE;
lpTimeResult->wSecond = sysTimeMinuend.wSecond - sysTimeSub.wSecond;
}
else
...{
bBorrow = TRUE;
lpTimeResult->wSecond = 60 + sysTimeMinuend.wSecond - sysTimeSub.wSecond;
}

//Minute
if(bBorrow == TRUE)
...{
sysTimeMinuend.wMinute --;
}
if(sysTimeMinuend.wMinute >= sysTimeSub.wMinute)
...{
bBorrow = FALSE;
lpTimeResult->wMinute = sysTimeMinuend.wMinute - sysTimeSub.wMinute;
}
else
...{
bBorrow = TRUE;
lpTimeResult->wMinute = 60 + sysTimeMinuend.wMinute - sysTimeSub.wMinute;
}

//Hour
if(bBorrow == TRUE)
...{
sysTimeMinuend.wHour --;
}
if(sysTimeMinuend.wHour >= sysTimeSub.wHour)
...{
bBorrow = FALSE;
lpTimeResult->wHour = sysTimeMinuend.wHour - sysTimeSub.wHour;
}
else
...{
bBorrow = TRUE;
lpTimeResult->wHour = 60 + sysTimeMinuend.wHour - sysTimeSub.wHour;
}

//Day
if(bBorrow == TRUE)
...{
sysTimeMinuend.wDay --;
}
if(sysTimeMinuend.wDay >= sysTimeSub.wDay)
...{
bBorrow = FALSE;
lpTimeResult->wDay = sysTimeMinuend.wDay - sysTimeSub.wDay;
}
else
...{
bBorrow = TRUE;
lpTimeResult->wDay = 60 + sysTimeMinuend.wDay - sysTimeSub.wDay;
}

//Month
if(bBorrow == TRUE)
...{
sysTimeMinuend.wMonth --;
}
if(sysTimeMinuend.wMonth >= sysTimeSub.wMonth)
...{
bBorrow = FALSE;
lpTimeResult->wMonth = sysTimeMinuend.wMonth - sysTimeSub.wMonth;
}
else
...{
bBorrow = TRUE;
lpTimeResult->wMonth = 60 + sysTimeMinuend.wMonth - sysTimeSub.wMonth;
}

//Year
if(bBorrow == TRUE)
...{
sysTimeMinuend.wYear --;
}
lpTimeResult->wYear = sysTimeMinuend.wYear - sysTimeSub.wYear;

END:
return iReturn;

}

//-------------------------------------------------------------------------------------
//Description:
// Create the directory serial as to the path. For explame: If the path is "harddisk/test/temp",
//it will create the directory: "harddisk","test",and "temp".
//
//Parameters:
// pszPath[in]: Pointer to the path for creating
//------------------------------------------------------------------------------------
void CCommon::CreateDirectorySerial(TCHAR *pszPath)
...{

int iBeginCpy = 0;
int iEndCpy = 0;
TCHAR szCpy[MAX_PATH] = ...{0};
TCHAR szSource[MAX_PATH] = ...{0};

_tcscpy(szSource,pszPath);

int iLen = _tcslen(szSource);
if(szSource[iLen - 1] == '/')
...{
szSource[iLen - 1] = '';
}

while(TRUE)
...{
iEndCpy = FindString(szSource,TEXT("/"),iBeginCpy);
if(iEndCpy == -1)
...{
break;
}

memset(szCpy,0,sizeof(szCpy));
_tcsncpy(szCpy, pszPath, iEndCpy + 1);
CreateDirectory(szCpy,NULL);

iBeginCpy = iEndCpy + 1;

}

if(iEndCpy == -1 && iBeginCpy != 0)
...{
CreateDirectory(szSource,NULL);
}
}

//-------------------------------------------------------------------------------------
//Description:
// Broad the message to the specifies window
//
//Parameters:
// bctype: [in] Specifies which type of window to receive the message
// wMsg: [in] Specifies the message to be sent.
// wParam: [in] Specifies additional message-specific information.
// lParam: [in] Specifies additional message-specific information.
//---------------------------------------------------------------------------------------
void CCommon::BroadcastMessage(BroadcastType bcType, UINT wMsg, WPARAM wParam, LPARAM lParam)
...{
m_hWndBc = NULL;
m_wMsgBc = wMsg;
m_wParamBc = wParam;
m_lParamBc = lParam;
m_BcType = bcType;
EnumWindows(EnumWindowsProcForBroadcast,NULL);
}

//--------------------------------------------------------------------------------------
//Description:
// This function is an application-defined callback function that receives top-level window
//handles as a result of a call to the EnumWindows function. And the function is only be called
//in the BroadcastMessage() function
//--------------------------------------------------------------------------------------
BOOL CCommon::EnumWindowsProcForBroadcast(HWND hWnd, LPARAM lParam)
...{
if(m_hWndBc == hWnd)
...{
return FALSE;
}

if(m_hWndBc == NULL)
...{
m_hWndBc = hWnd;
}

if(m_BcType == BC_VISIBLE || m_BcType == BC_VISIBLE_NOBASEEXPLORER)
...{
if(GetWindowLong(hWnd,GWL_STYLE) & WS_VISIBLE)
...{
if(m_BcType == BC_VISIBLE_NOBASEEXPLORER)
...{
TCHAR szClsName[MAX_PATH] = ...{0};
GetClassName(hWnd,szClsName,MAX_PATH);
if(_tcscmp(TEXT("HHTaskBar"),szClsName) == 0 ||
_tcscmp(TEXT("DesktopExplorerWindow"),szClsName) == 0
)
...{
return TRUE;
}
}

SendMessage(hWnd,m_wMsgBc,m_wParamBc,m_lParamBc);
}
}
else if(m_BcType == BC_ALL)
...{
SendMessage(hWnd,m_wMsgBc,m_wParamBc,m_lParamBc);
}

return TRUE;
}

//-------------------------------------------------------------------------------------
//Description:
// Delete the no empty directory
//
//Parameters:
// pszPath: [in] The path of directory
//---------------------------------------------------------------------------------------
void CCommon::DeleteDirectory(const TCHAR *pszPath)
...{

ULONG ulLen = _tcslen(pszPath);
TCHAR szPathBuf[MAX_PATH] = ...{0};
_tcscpy(szPathBuf,pszPath);

ulLen = _tcslen(szPathBuf);
if(szPathBuf[ulLen - 1] != '/')
...{
szPathBuf[ulLen] = '/';
szPathBuf[ulLen + 1] = '';
}
_tcscat(szPathBuf,TEXT("*.*"));

WIN32_FIND_DATA fd;
HANDLE hFind = FindFirstFile(szPathBuf,&fd);
if(hFind != INVALID_HANDLE_VALUE)
...{
do...{
TCHAR szNextPath[MAX_PATH] = ...{0};
_tcscpy(szNextPath,pszPath);

ULONG uLenNext = _tcslen(szNextPath);
if(szNextPath[uLenNext - 1] != '/')
...{
szNextPath[uLenNext] = '/';
szNextPath[uLenNext + 1] = '';
}
_tcscat(szNextPath,fd.cFileName);

if(fd.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY)
...{
//it must be directory
DeleteDirectory(szNextPath);
RemoveDirectory(szNextPath);
}
else
...{
//it is file
DeleteFile(szNextPath);
}
}while(FindNextFile(hFind,&fd));
}

FindClose(hFind);

RemoveDirectory(pszPath);

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/norains/archive/2007/06/09/1646061.aspx