atlwinmisc.h

这是一本学习 window编程的很好的参考教材

#else // __ATLMISC_H__ _WTL_NO_WTYPES

class CClientRect : public tagRECT
{
public:
   CClientRect(HWND hWnd)
   {
      ATLASSERT(::IsWindow(hWnd));
      ::GetClientRect(hWnd, this);
   }
};

class CWindowRect : public tagRECT
{
public:
   CWindowRect(HWND hWnd)
   {
      ATLASSERT(::IsWindow(hWnd));
      ::GetWindowRect(hWnd, this);
   }
};

#endif // _WTL_NO_WTYPES


/////////////////////////////////////////////////////////////////////////////
// CWindowPlacement

#ifndef _WTL_NO_WTYPES

class CWindowPlacement : public WINDOWPLACEMENT
{
public:
   CWindowPlacement()
   {
      ::ZeroMemory( (WINDOWPLACEMENT*) this, sizeof(WINDOWPLACEMENT) );
      length = sizeof(WINDOWPLACEMENT);
      showCmd = SW_NORMAL;
   }
   CWindowPlacement(HWND hWnd)
   {
      length = sizeof(WINDOWPLACEMENT);
      GetPosData(hWnd);
   }
   BOOL GetPosData(HWND hWnd)
   {
      ATLASSERT(::IsWindow(hWnd));
      return ::GetWindowPlacement(hWnd, this);
   }
   BOOL GetPosData(LPCTSTR pstr)
   {
      ATLASSERT(!::IsBadStringPtr(pstr, -1));
      if( ::lstrlen(pstr) == 0 ) return FALSE;
      flags = _GetInt(pstr);
      showCmd = _GetInt(pstr);
      ptMinPosition.x = _GetInt(pstr);
      ptMinPosition.y = _GetInt(pstr);
      ptMaxPosition.x = _GetInt(pstr);
      ptMaxPosition.y = _GetInt(pstr);
      rcNormalPosition.left = _GetInt(pstr);
      rcNormalPosition.top = _GetInt(pstr);
      rcNormalPosition.right = _GetInt(pstr);
      rcNormalPosition.bottom = _GetInt(pstr);
      return TRUE;
   }
   BOOL GetPosData(HKEY hReg, LPCTSTR pstrKeyName)
   {
      ATLASSERT(hReg);
      ATLASSERT(!::IsBadStringPtr(pstrKeyName,-1));
      TCHAR szData[80];
      DWORD dwCount = sizeof(szData)/sizeof(TCHAR);
      DWORD dwType = NULL;
      LONG lRes = ::RegQueryValueEx(hReg, pstrKeyName, NULL, &dwType, (LPBYTE)szData, &dwCount);
      if( lRes != ERROR_SUCCESS ) return FALSE;
      return GetPosData(szData);
   }
   BOOL SetPosData(HWND hWnd)
   {
      // NOTE: Do not place this call in the window's own WM_CREATE handler.
      //       Remember to call ShowWindow() if this method fails!
      ATLASSERT(::IsWindow(hWnd));
      ATLASSERT(!::IsRectEmpty(&rcNormalPosition)); // Initialize structures first
      // Make sure it is not out-of-bounds
      RECT rcTemp;
      RECT rcScreen = { 0, 0, ::GetSystemMetrics(SM_CXSCREEN), ::GetSystemMetrics(SM_CYSCREEN) };
      if( ::IsRectEmpty(&rcNormalPosition) ) return FALSE;
      if( !::IntersectRect(&rcTemp, &rcNormalPosition, &rcScreen) ) return FALSE;
      // Show it...
      return ::SetWindowPlacement(hWnd, this);
   }
   BOOL SetPosData(LPTSTR pstr, UINT cchMax) const
   {
      ATLASSERT(!::IsBadWritePtr(pstr, cchMax));
      cchMax; // BUG: We don't validate on this
      ::wsprintf(pstr, _T("%ld %ld (%ld,%ld) (%ld,%ld) (%ld,%ld,%ld,%ld)"),
         flags,
         showCmd,
         ptMinPosition.x,
         ptMinPosition.y,
         ptMaxPosition.x,
         ptMaxPosition.y,
         rcNormalPosition.left,
         rcNormalPosition.top,
         rcNormalPosition.right,
         rcNormalPosition.bottom);
      return TRUE;
   }
   BOOL SetPosData(HKEY hReg, LPCTSTR pstrValueName) const
   {
      ATLASSERT(!::IsBadStringPtr(pstrValueName,-1));
      ATLASSERT(hReg);
      TCHAR szData[80];
      if( !SetPosData(szData, (UINT) sizeof(szData)/sizeof(TCHAR)) ) return FALSE;
      return ::RegSetValueEx(hReg, pstrValueName, NULL, REG_SZ, (CONST BYTE*) szData, (::lstrlen(szData)+1)*sizeof(TCHAR)) == ERROR_SUCCESS;
   }
   long _GetInt(LPCTSTR& pstr) const
   {
      // NOTE: 'pstr' argument is "byref"
      bool fNeg = false;
      if( *pstr == _T('-') ) {
         fNeg = true;
         pstr = ::CharNext(pstr);
      }
      long n = 0;
      while( *pstr >= _T('0') && *pstr <= _T('9') ) {
         n = (n* 10L) + (*pstr - _T('0'));
         pstr = ::CharNext(pstr);
      }
      while( *pstr >= _T(' ') && *pstr<_T('0') && *pstr != _T('-') ) pstr = ::CharNext(pstr);
      return fNeg ? -n : n;
   }
};

#endif // _WTL_NO_WTYPES


/////////////////////////////////////////////////////////////////////////////
// CWinProp

class CWinProp
{
public:
   HWND m_hWnd;

   CWinProp(HWND hWnd = NULL) : m_hWnd(hWnd)
   {
   }
   CWinProp& operator=(HWND hWnd)
   {
      m_hWnd = hWnd;
      return *this;
   }
   BOOL SetProperty(LPCTSTR pstrName, long lValue)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      return ::SetProp(m_hWnd, pstrName, (HANDLE) lValue);
   }
   BOOL SetProperty(LPCTSTR pstrName, LPCVOID pValue)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      return ::SetProp(m_hWnd, pstrName, (HANDLE) pValue);
   }
   void GetProperty(LPCTSTR pstrName, long& lValue) const
   {
      ATLASSERT(::IsWindow(m_hWnd));
      lValue = (long) ::GetProp(m_hWnd, pstrName);
   }
   void GetProperty(LPCTSTR pstrName, LPCVOID& pValue) const
   {
      ATLASSERT(::IsWindow(m_hWnd));
      pValue = (LPCVOID) ::GetProp(m_hWnd, pstrName);
   }
   BOOL Enumerate(PROPENUMPROCEX Proc, LPARAM lParam) const
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ATLASSERT(!::IsBadCodePtr((FARPROC)Proc));
      return ::EnumPropsEx(m_hWnd, Proc, lParam) != -1;
   }  
   typedef struct PROPFIND { LPCTSTR pstrName; BOOL bFound; };
   BOOL FindProperty(LPCTSTR pstrName) const
   {
      ATLASSERT(::IsWindow(m_hWnd));
      PROPFIND pf = { pstrName, FALSE };
      ::EnumPropsEx(m_hWnd, _FindProc, (LPARAM) &pf); 
      return pf.bFound;
   }
   void RemoveProperty(LPCTSTR pstrName)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ::RemoveProp(m_hWnd, pstrName);
   }
   void RemoveAll()
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ::EnumPropsEx(m_hWnd, _RemoveAllProc, 0); 
   }
   static BOOL CALLBACK _FindProc(HWND /*hWnd*/, LPTSTR pstrName, HANDLE /*hData*/, ULONG_PTR lParam)
   {
      PROPFIND* pf = (PROPFIND*) lParam;
      if( (HIWORD(pstrName) == 0 && pstrName == pf->pstrName) ||
          (HIWORD(pstrName) != 0 && ::lstrcmp(pstrName, pf->pstrName) == 0) ) 
      {
         pf->bFound = TRUE;
         return FALSE;
      }
      return TRUE;
   }
   static BOOL CALLBACK _RemoveAllProc(HWND hWnd, LPTSTR pstrName, HANDLE /*hData*/, ULONG_PTR /*lParam*/)
   {
      ::RemoveProp(hWnd, pstrName);
      return TRUE;
   }
};


/////////////////////////////////////////////////////////////////////////////
// CIniFile

class CIniFile
{
public:
   TCHAR m_szFilename[MAX_PATH];

   CIniFile()
   {
      m_szFilename[0] = _T('\0');
   }
   void SetFilename(LPCTSTR pstrFilename)
   {
      ATLASSERT(!::IsBadStringPtr(pstrFilename,-1));
      ::lstrcpy(m_szFilename, pstrFilename);
   }
   BOOL GetString(LPCTSTR pstrSection, LPCTSTR pstrKey, LPTSTR pstrValue, UINT cchMax, LPCTSTR pstrDefault = NULL) const
   {
      ATLASSERT(m_szFilename[0]);
      ATLASSERT(!::IsBadStringPtr(pstrSection,-1));
      ATLASSERT(!::IsBadStringPtr(pstrKey,-1));
      ATLASSERT(!::IsBadWritePtr(pstrValue,cchMax));
      return ::GetPrivateProfileString(pstrSection, pstrKey, pstrDefault, pstrValue, cchMax,  m_szFilename) > 0;
   }
#if defined(__ATLSTR_H__) || defined(_WTL_USE_CSTRING)
   BOOL GetString(LPCTSTR pstrSection, LPCTSTR pstrKey, CString& sValue, LPCTSTR pstrDefault = NULL) const
   {      
      enum { MAX_INIVALUE_LEN = 1024 };
      BOOL bRes = GetString(pstrSection, pstrKey, sValue.GetBuffer(MAX_INIVALUE_LEN), MAX_INIVALUE_LEN, pstrDefault);
      sValue.ReleaseBuffer(bRes ? -1 : 0);
      return bRes;
   }
#endif // __ATLSTR_H__ _WTL_USE_CSTRING
   BOOL GetInt(LPCTSTR pstrSection, LPCTSTR pstrKey, int& iValue, int iDefault=0) const
   {
      ATLASSERT(m_szFilename[0]);
      ATLASSERT(!::IsBadStringPtr(pstrSection,-1));
      ATLASSERT(!::IsBadStringPtr(pstrKey,-1));
      iValue = ::GetPrivateProfileInt(pstrSection, pstrKey, iDefault, m_szFilename);
      return TRUE;
   }
   BOOL GetBool(LPCTSTR pstrSection, LPCTSTR pstrKey, bool& bValue, bool bDefault=true) const
   {
      TCHAR szValue[2] = { 0 };
      GetString(pstrSection, pstrKey, szValue, sizeof(szValue)/sizeof(TCHAR), bDefault ? _T("Y") : _T("N"));
      switch( szValue[0] ) {
      case _T('y'): // Yes
      case _T('Y'):
      case _T('t'): // True
      case _T('T'):
      case _T('1'): // 1
         bValue = true;
         break;
      case _T('n'): // No
      case _T('N'):
      case _T('f'): // False
      case _T('F'):
      case _T('0'): // 0
         bValue = false;
         break;
      default:
         bValue = bDefault;
      }
      return TRUE;
   }
   BOOL PutString(LPCTSTR pstrSection, LPCTSTR pstrKey, LPCTSTR pstrValue)
   {
      ATLASSERT(m_szFilename[0]);
      ATLASSERT(!::IsBadStringPtr(pstrSection,-1));
      ATLASSERT(!::IsBadStringPtr(pstrKey,-1));
      return ::WritePrivateProfileString(pstrSection, pstrKey, pstrValue, m_szFilename);
   }
   BOOL PutInt(LPCTSTR pstrSection, LPCTSTR pstrKey, int iValue)
   {
      TCHAR szValue[32];
      ::wsprintf(szValue, _T("%ld"), iValue);
      return PutString(pstrSection, pstrKey, szValue);
   }
   BOOL PutBool(LPCTSTR pstrSection, LPCTSTR pstrKey, bool bValue)
   {
      TCHAR szValue[2] = { 0 };
      szValue[0] = bValue ? _T('Y') : _T('N'); // TODO: What about localization? Use 0/1?
      return PutString(pstrSection, pstrKey, szValue);
   }

   void DeleteKey(LPCTSTR pstrSection, LPCTSTR pstrKey)
   {
      ATLASSERT(m_szFilename[0]);
      ATLASSERT(!::IsBadStringPtr(pstrSection,-1));
      ATLASSERT(!::IsBadStringPtr(pstrKey,-1));
      ::WritePrivateProfileString(pstrSection, pstrKey, NULL, m_szFilename);
   }
   void DeleteSection(LPCTSTR pstrSection)
   {
      ATLASSERT(m_szFilename[0]);
      ATLASSERT(!::IsBadStringPtr(pstrSection,-1));
      ::WritePrivateProfileString(pstrSection, NULL, NULL, m_szFilename);
   }
   void Flush()
   {
      ATLASSERT(m_szFilename[0]);
      ::WritePrivateProfileString(NULL, NULL, NULL, m_szFilename);
   }
};


/////////////////////////////////////////////////////////////////////////////
// Misc helper methods

inline bool AtlIsEditControl(HWND hWnd)
{
   if( !::IsWindow(hWnd) ) return false;
   TCHAR szClassName[64] = { 0 };
   ::GetClassName(hWnd, szClassName, (sizeof(szClassName)/sizeof(TCHAR))-1);
#if defined(__ATLSTR_H__) || defined(_WTL_USE_CSTRING)
   CString s = szClassName;
   s.MakeUpper();
   return s.Find(_T("EDIT")) >= 0;
#else
   ::CharUpperBuff(szClassName, ::lstrlen(szClassName));
   return _tcsstr(szClassName, _T("EDIT")) != NULL;
#endif
}

#if defined(__ATLSTR_H__) || defined(_WTL_USE_CSTRING)

// Load HTML from resource (resource type RT_HTML only).
// Thanks to Anatoly Ivasyuk for fixing a sz-string problem.
inline CString AtlLoadHTML(_U_STRINGorID html)
{
#if (_ATL_VER >= 0x0700)
   HRSRC hrsrc = ::FindResource(ATL::_AtlBaseModule.GetResourceInstance(), html.m_lpstr, RT_HTML);
   if( hrsrc != NULL ) {
      DWORD dwSize = ::SizeofResource(ATL::_AtlBaseModule.GetResourceInstance(), hrsrc);
      HGLOBAL hglb = ::LoadResource(ATL::_AtlBaseModule.GetResourceInstance(), hrsrc);
#else
   HRSRC hrsrc = ::FindResource(_Module.GetResourceInstance(), html.m_lpstr, RT_HTML);
   if( hrsrc != NULL ) {
      DWORD dwSize = ::SizeofResource(_Module.GetResourceInstance(), hrsrc);
      HGLOBAL hglb = ::LoadResource(_Module.GetResourceInstance(), hrsrc);
#endif // _ATL_VER
      if( hglb != NULL ) {
         LPCSTR pData = (LPCSTR) ::LockResource(hglb);
         if( pData != NULL ) {
            // Assumes HTML is in ANSI/UTF-8
            CString s;
#ifndef _UNICODE
            ::CopyMemory(s.GetBufferSetLength(dwSize), pData, dwSize);
#else
            AtlA2WHelper(s.GetBufferSetLength(dwSize), pData, dwSize);
#endif // _UNICODE
            s.ReleaseBuffer(dwSize);
            UnlockResource(hglb);
            ::FreeResource(hglb);
            return s;
         }
      }
   }
   return CString();
}

#endif // __ATLSTR_H__ _WTL_USE_CSTRING

}; // namespace WTL


#endif // __ATLWINMISC_H__