From 6aa9bd0f77dcb5128167fae62e32aa5252fe85c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20Mr=C3=A1zek?= Date: Mon, 2 Dec 2013 00:55:24 +0100 Subject: Renew the updater branch Now with some actual consensus on what the updater will do! --- mmc_updater/depends/win32cpp/winutils.h | 649 ++++++++++++++++++++++++++++++++ 1 file changed, 649 insertions(+) create mode 100644 mmc_updater/depends/win32cpp/winutils.h (limited to 'mmc_updater/depends/win32cpp/winutils.h') diff --git a/mmc_updater/depends/win32cpp/winutils.h b/mmc_updater/depends/win32cpp/winutils.h new file mode 100644 index 00000000..94ba2d80 --- /dev/null +++ b/mmc_updater/depends/win32cpp/winutils.h @@ -0,0 +1,649 @@ +// Win32++ Version 7.2 +// Released: 5th AUgust 2011 +// +// David Nash +// email: dnash@bigpond.net.au +// url: https://sourceforge.net/projects/win32-framework +// +// +// Copyright (c) 2005-2011 David Nash +// +// Permission is hereby granted, free of charge, to +// any person obtaining a copy of this software and +// associated documentation files (the "Software"), +// to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, +// merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom +// the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice +// shall be included in all copies or substantial portions +// of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR +// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +// OR OTHER DEALINGS IN THE SOFTWARE. +// +//////////////////////////////////////////////////////// + +#ifndef _WIN32XX_WINUTILS_H_ +#define _WIN32XX_WINUTILS_H_ + + +// define useful macros from WindowsX.h +#ifndef GET_X_LPARAM + #define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp)) +#endif +#ifndef GET_Y_LPARAM + #define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp)) +#endif + +// Define our own MIN and MAX macros +// this avoids inconsistencies with Dev-C++ and other compilers, and +// avoids conflicts between typical min/max macros and std::min/std::max +#define MAX(a,b) (((a) > (b)) ? (a) : (b)) +#define MIN(a,b) (((a) < (b)) ? (a) : (b)) + + +namespace Win32xx +{ + // Forward declarations + class CPoint; + class CRect; + CWinApp* GetApp(); + void TRACE(LPCTSTR str); + + + ///////////////////////////////////////// + // Definition of the CSize class + // This class can be used to replace the SIZE structure + class CSize : public SIZE + { + public: + CSize() { cx = 0; cy = 0; } + CSize(int CX, int CY) { cx = CX; cy = CY; } + CSize(SIZE sz) { cx = sz.cx; cy = sz.cy; } + CSize(POINT pt) { cx = pt.x; cy = pt.y; } + CSize(DWORD dw) { cx = (short)LOWORD(dw); cy = (short)HIWORD(dw); } + void SetSize(int CX, int CY) { cx = CX; cy = CY; } + + // Operators + operator LPSIZE() { return this; } + BOOL operator == (SIZE sz) const { return (cx == sz.cx && cy == sz.cy); } + BOOL operator != (SIZE sz) const { return (cx != sz.cx || cy != sz.cy); } + void operator += (SIZE sz) { cx += sz.cx; cy += sz.cy; } + void operator -= (SIZE sz) { cx -= sz.cx; cy -= sz.cy; } + + // Operators returning CSize + CSize operator - () const { return CSize (-cx, -cy); } + CSize operator + (SIZE sz) const { return CSize (cx + sz.cx, cy + sz.cy); } + CSize operator - (SIZE sz) const { return CSize (cx - sz.cx, cy - sz.cy); } + + // Operators returning CPoint + CPoint operator + (POINT point) const; + CPoint operator - (POINT point) const; + + // Operators returning CRect + CRect operator + (RECT rc) const; + CRect operator - (RECT rc) const; + }; + + + ///////////////////////////////////////// + // Definition of the CPoint class + // This class can be used to replace the POINT structure + class CPoint : public POINT + { + public: + CPoint() { x = 0; y = 0; } + CPoint(int X, int Y) { x = X; y = Y; } + CPoint(POINT pt) { x = pt.x ; y = pt.y; } + CPoint(POINTS pts) { x = pts.x; y = pts.y; } + CPoint(SIZE sz) { x = sz.cx; y = sz.cy; } + CPoint(DWORD dw) { x = (short) LOWORD(dw); y = (short) HIWORD(dw); } + + void Offset(int dx, int dy) { x += dx; y += dy; } + void Offset(POINT pt) { x += pt.x; y += pt.y; } + void Offset(SIZE sz) { x += sz.cx; y += sz.cy; } + void SetPoint(int X, int Y) { x = X; y = Y; } + + // Operators + operator LPPOINT() { return this; } + BOOL operator == (POINT pt) const { return ((x == pt.x) && (y == pt.y)); } + BOOL operator != (POINT pt) const { return ((x != pt.x) || (y != pt.y)); } + void operator += (SIZE sz) { x += sz.cx; y += sz.cy; } + void operator -= (SIZE sz) { x -= sz.cx; y -= sz.cy; } + void operator += (POINT pt) { x += pt.x; y += pt.y; } + void operator -= (POINT pt) { x -= pt.x; y -= pt.y; } + + // Operators returning CPoint + CPoint operator - () const { return CPoint(-x, -y); } + CPoint operator + (SIZE sz) const { return CPoint(x + sz.cx, y + sz.cy); } + CPoint operator - (SIZE sz) const { return CPoint(x - sz.cx, y - sz.cy); } + CPoint operator + (POINT pt) const { return CPoint(x + pt.x, y + pt.y); } + CPoint operator - (POINT pt) const { return CPoint(x - pt.x, y - pt.y); } + + // Operators returning CRect + CRect operator + (RECT rc) const; + CRect operator - (RECT rc) const; + }; + + + ///////////////////////////////////////// + // Definition of the CRect class + // This class can be used to replace the RECT structure. + class CRect : public RECT + { + public: + CRect() { left = top = right = bottom = 0; } + CRect(int l, int t, int r, int b) { left = l; top = t; right = r; bottom = b; } + CRect(RECT rc) { left = rc.left; top = rc.top; right = rc.right; bottom = rc.bottom; } + CRect(POINT pt, SIZE sz) { right = (left = pt.x) + sz.cx; bottom = (top = pt.y) + sz.cy; } + CRect(POINT topLeft, POINT bottomRight) { left = topLeft.x; top = topLeft.y; right = bottomRight.x; bottom = bottomRight.y; } + + BOOL CopyRect(RECT rc) { return ::CopyRect(this, &rc); } + BOOL DeflateRect(int x, int y) { return ::InflateRect(this, -x, -y); } + BOOL DeflateRect(SIZE size) { return ::InflateRect(this, -size.cx, -size.cy); } + BOOL DeflateRect(RECT rc) { return ::InflateRect(this, rc.left - rc.right, rc.top - rc.bottom); } + BOOL DeflateRect(int l, int t, int r, int b){ return ::InflateRect(this, l - r, t - b); } + BOOL EqualRect(RECT rc) const { return ::EqualRect(&rc, this); } + BOOL InflateRect(int dx, int dy) { return ::InflateRect(this, dx, dy); } + BOOL InflateRect(SIZE sz) { return ::InflateRect(this, sz.cx, sz.cy); } + BOOL InflateRect(RECT rc) { return ::InflateRect(this, rc.right - rc.left, rc.bottom - rc.top); } + BOOL InflateRect(int l, int t, int r, int b){ return ::InflateRect(this, r - l, b - t); } + BOOL IntersectRect(RECT rc1, RECT rc2) { return ::IntersectRect(this, &rc1, &rc2); } + BOOL IsRectEmpty() const { return ::IsRectEmpty(this);} + BOOL IsRectNull() const { return (left == 0 && right == 0 && top == 0 && bottom == 0); } + CRect MulDiv(int nMult, int nDiv) const { return CRect ((left * nMult) / nDiv, (top * nMult) / nDiv, + (right * nMult) / nDiv, (bottom * nMult) / nDiv); } + void NormalizeRect() { int nTemp; if (left > right) { nTemp = left; left = right; right = nTemp; } + if (top > bottom) { nTemp = top; top = bottom; bottom = nTemp; } } + BOOL OffsetRect(int dx, int dy) { return ::OffsetRect(this, dx, dy); } + BOOL OffsetRect(POINT pt) { return ::OffsetRect(this, pt.x, pt.y); } + BOOL OffsetRect(SIZE size) { return ::OffsetRect(this, size.cx, size.cy); } + BOOL PtInRect(POINT pt) const { return ::PtInRect(this, pt); } + BOOL SetRect(int l, int t, int r, int b) { return ::SetRect(this, l, t, r, b); } + BOOL SetRect(POINT TopLeft, POINT BtmRight) { return ::SetRect(this, TopLeft.x, TopLeft.y, BtmRight.x, BtmRight.y); } + BOOL SetRectEmpty() { return ::SetRectEmpty(this); } + BOOL SubtractRect(RECT rc1, RECT rc2) { return ::SubtractRect(this, &rc1, &rc2); } + BOOL UnionRect(RECT rc1, RECT rc2) { return ::UnionRect(this, &rc1, &rc2); } + + // Reposition rectangle + void MoveToX (int x) { right = Width() + x; left = x; } + void MoveToY (int y) { bottom = Height() + y; top = y; } + void MoveToXY (int x, int y) { MoveToX(x); MoveToY(y); } + void MoveToXY (POINT pt) { MoveToX (pt.x); MoveToY (pt.y); } + + // Attributes + int Height() const { return bottom - top; } + int Width() const { return right - left; } + CSize Size() const { return CSize(Width(), Height()); } + CPoint CenterPoint() const { return CPoint((left + right) / 2, (top + bottom) / 2); } + CPoint TopLeft() const { return CPoint(left, top); } + CPoint BottomRight() const { return CPoint(right, bottom); } + + // operators + operator LPRECT() { return this; } + BOOL operator == (RECT rc) const { return ::EqualRect(this, &rc); } + BOOL operator != (RECT rc) const { return !::EqualRect(this, &rc); } + void operator += (POINT pt) { ::OffsetRect(this, pt.x, pt.y); } + void operator += (SIZE size) { ::OffsetRect(this, size.cx, size.cy); } + void operator += (RECT rc) { ::InflateRect(this, rc.right - rc.left, rc.bottom - rc.top); } + void operator -= (RECT rc) { ::InflateRect(this, rc.left - rc.right, rc.top - rc.bottom); } + void operator -= (POINT pt) { ::OffsetRect(this, -pt.x, -pt.y); } + void operator -= (SIZE sz) { ::OffsetRect(this, -sz.cx, -sz.cy); } + void operator &= (RECT rc) { ::IntersectRect(this, this, &rc); } + void operator |= (RECT rc) { ::UnionRect(this, this, &rc); } + + // Operators returning CRect + CRect operator + (POINT pt) const { CRect rc(*this); ::OffsetRect(&rc, pt.x, pt.y); return rc; } + CRect operator - (POINT pt) const { CRect rc(*this); ::OffsetRect(&rc, -pt.x, -pt.y); return rc; } + CRect operator + (SIZE sz) const { CRect rc(*this); ::OffsetRect(&rc, sz.cx, sz.cy); return rc; } + CRect operator - (SIZE sz) const { CRect rc(*this); ::OffsetRect(&rc, -sz.cx, -sz.cy); return rc; } + CRect operator + (RECT rc) const { CRect rc1(*this); rc1.InflateRect(rc); return rc1; } + CRect operator - (RECT rc) const { CRect rc1(*this); rc1.DeflateRect(rc); return rc1; } + CRect operator & (RECT rc) const { CRect rc1; ::IntersectRect(&rc1, this, &rc); return rc1; } + CRect operator | (RECT rc) const { CRect rc1; ::UnionRect(&rc1, this, &rc); return rc1; } + }; + + // CSize member function definitions + inline CPoint CSize::operator + (POINT pt) const { return CPoint(pt) + *this; } + inline CPoint CSize::operator - (POINT pt) const { return CPoint(pt) - *this; } + inline CRect CSize::operator + (RECT rc) const { return CRect(rc) + *this; } + inline CRect CSize::operator - (RECT rc) const { return CRect(rc) - *this; } + + // CPoint member function definitions + inline CRect CPoint::operator + (RECT rc) const { return CRect(rc) + *this; } + inline CRect CPoint::operator - (RECT rc) const { return CRect(rc) - *this; } + + + //////////////////////////////////////////////////////// + // Classes and functions (typedefs) for text conversions + // + // This section defines the following text conversions: + // A2BSTR ANSI to BSTR + // A2OLE ANSI to OLE + // A2T ANSI to TCHAR + // A2W ANSI to WCHAR + // OLE2A OLE to ANSI + // OLE2T OLE to TCHAR + // OLE2W OLE to WCHAR + // T2A TCHAR to ANSI + // T2BSTR TCHAR to BSTR + // T2OLE TCHAR to OLE + // T2W TCHAR to WCHAR + // W2A WCHAR to ANSI + // W2BSTR WCHAR to BSTR + // W2OLE WCHAR to OLE + // W2T WCHAR to TCHAR + + // About different character and string types: + // ------------------------------------------ + // char (or CHAR) character types are ANSI (8 bits). + // wchar_t (or WCHAR) character types are Unicode (16 bits). + // TCHAR characters are Unicode if the _UNICODE macro is defined, otherwise they are ANSI. + // BSTR (Basic String) is a type of string used in Visual Basic and COM programming. + // OLE is the same as WCHAR. It is used in Visual Basic and COM programming. + + + // Forward declarations of our classes. They are defined later. + class CA2A; + class CA2W; + class CW2A; + class CW2W; + class CA2BSTR; + class CW2BSTR; + + // typedefs for the well known text conversions + typedef CA2W A2W; + typedef CW2A W2A; + typedef CW2BSTR W2BSTR; + typedef CA2BSTR A2BSTR; + typedef CW2A BSTR2A; + typedef CW2W BSTR2W; + +#ifdef _UNICODE + typedef CA2W A2T; + typedef CW2A T2A; + typedef CW2W T2W; + typedef CW2W W2T; + typedef CW2BSTR T2BSTR; + typedef BSTR2W BSTR2T; +#else + typedef CA2A A2T; + typedef CA2A T2A; + typedef CA2W T2W; + typedef CW2A W2T; + typedef CA2BSTR T2BSTR; + typedef BSTR2A BSTR2T; +#endif + + typedef A2W A2OLE; + typedef T2W T2OLE; + typedef CW2W W2OLE; + typedef W2A OLE2A; + typedef W2T OLE2T; + typedef CW2W OLE2W; + + class CA2W + { + public: + CA2W(LPCSTR pStr) : m_pStr(pStr) + { + if (pStr) + { + // Resize the vector and assign null WCHAR to each element + int length = (int)strlen(pStr)+1; + m_vWideArray.assign(length, L'\0'); + + // Fill our vector with the converted WCHAR array + MultiByteToWideChar(CP_ACP, 0, pStr, -1, &m_vWideArray[0], length); + } + } + ~CA2W() {} + operator LPCWSTR() { return m_pStr? &m_vWideArray[0] : NULL; } + operator LPOLESTR() { return m_pStr? (LPOLESTR)&m_vWideArray[0] : (LPOLESTR)NULL; } + operator LPBSTR() { return m_pStr? (LPBSTR)&m_vWideArray[0] : (LPBSTR)NULL; } + + private: + CA2W(const CA2W&); + CA2W& operator= (const CA2W&); + std::vector m_vWideArray; + LPCSTR m_pStr; + }; + + class CW2A + { + public: + CW2A(LPCWSTR pWStr) : m_pWStr(pWStr) + { + // Resize the vector and assign null char to each element + int length = (int)wcslen(pWStr)+1; + m_vAnsiArray.assign(length, '\0'); + + // Fill our vector with the converted char array + WideCharToMultiByte(CP_ACP, 0, pWStr, -1, &m_vAnsiArray[0], length, NULL,NULL); + } + + ~CW2A() {} + operator LPCSTR() { return m_pWStr? &m_vAnsiArray[0] : NULL; } + + private: + CW2A(const CW2A&); + CW2A& operator= (const CW2A&); + std::vector m_vAnsiArray; + LPCWSTR m_pWStr; + }; + + class CW2W + { + public: + CW2W(LPCWSTR pWStr) : m_pWStr(pWStr) {} + operator LPCWSTR() { return (LPWSTR)m_pWStr; } + operator LPOLESTR() { return (LPOLESTR)m_pWStr; } + + private: + CW2W(const CW2W&); + CW2W& operator= (const CW2W&); + + LPCWSTR m_pWStr; + }; + + class CA2A + { + public: + CA2A(LPCSTR pStr) : m_pStr(pStr) {} + operator LPCSTR() { return (LPSTR)m_pStr; } + + private: + CA2A(const CA2A&); + CA2A& operator= (const CA2A&); + + LPCSTR m_pStr; + }; + + class CW2BSTR + { + public: + CW2BSTR(LPCWSTR pWStr) { m_bstrString = ::SysAllocString(pWStr); } + ~CW2BSTR() { ::SysFreeString(m_bstrString); } + operator BSTR() { return m_bstrString;} + + private: + CW2BSTR(const CW2BSTR&); + CW2BSTR& operator= (const CW2BSTR&); + BSTR m_bstrString; + }; + + class CA2BSTR + { + public: + CA2BSTR(LPCSTR pStr) { m_bstrString = ::SysAllocString(A2W(pStr)); } + ~CA2BSTR() { ::SysFreeString(m_bstrString); } + operator BSTR() { return m_bstrString;} + + private: + CA2BSTR(const CA2BSTR&); + CA2BSTR& operator= (const CA2BSTR&); + BSTR m_bstrString; + }; + + + //////////////////////////////////////// + // Global Functions + // + + inline CWnd* FromHandle(HWND hWnd) + // Returns the CWnd object associated with the window handle + { + assert( GetApp() ); + CWnd* pWnd = GetApp()->GetCWndFromMap(hWnd); + if (::IsWindow(hWnd) && pWnd == 0) + { + GetApp()->AddTmpWnd(hWnd); + pWnd = GetApp()->GetCWndFromMap(hWnd); + ::PostMessage(hWnd, UWM_CLEANUPTEMPS, 0, 0); + } + + return pWnd; + } + + + inline CWinApp* GetApp() + // Returns a pointer to the CWinApp derrived class + { + return CWinApp::SetnGetThis(); + } + + inline CPoint GetCursorPos() + { + CPoint pt; + ::GetCursorPos(&pt); + return pt; + } + + inline HBITMAP LoadBitmap (LPCTSTR lpszName) + { + assert(GetApp()); + + HBITMAP hBitmap = (HBITMAP)::LoadImage (GetApp()->GetResourceHandle(), lpszName, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR); + return hBitmap; + } + + inline HBITMAP LoadBitmap (int nID) + { + return LoadBitmap(MAKEINTRESOURCE(nID)); + } + + + inline void TRACE(LPCTSTR str) + // TRACE sends a string to the debug/output pane, or an external debugger + { + #ifdef _DEBUG + OutputDebugString(str); + #else + UNREFERENCED_PARAMETER(str); // no-op + #endif + } + + #ifndef _WIN32_WCE // for Win32/64 operating systems, not WinCE + + inline int GetWinVersion() + { + DWORD dwVersion = GetVersion(); + int Platform = (dwVersion < 0x80000000)? 2:1; + int MajorVer = LOBYTE(LOWORD(dwVersion)); + int MinorVer = HIBYTE(LOWORD(dwVersion)); + + int nVersion = 1000*Platform + 100*MajorVer + MinorVer; + + // Return values and window versions: + // 1400 Windows 95 + // 1410 Windows 98 + // 1490 Windows ME + // 2400 Windows NT + // 2500 Windows 2000 + // 2501 Windows XP + // 2502 Windows Server 2003 + // 2600 Windows Vista and Windows Server 2008 + // 2601 Windows 7 + + return nVersion; + } + + inline int GetComCtlVersion() + { + // Load the Common Controls DLL + HMODULE hComCtl = ::LoadLibraryA("COMCTL32.DLL"); + if (!hComCtl) + return 0; + + int ComCtlVer = 400; + + if (::GetProcAddress(hComCtl, "InitCommonControlsEx")) + { + // InitCommonControlsEx is unique to 4.7 and later + ComCtlVer = 470; + + if (::GetProcAddress(hComCtl, "DllGetVersion")) + { + typedef HRESULT CALLBACK DLLGETVERSION(DLLVERSIONINFO*); + DLLGETVERSION* pfnDLLGetVersion = NULL; + + pfnDLLGetVersion = (DLLGETVERSION*)::GetProcAddress(hComCtl, "DllGetVersion"); + if(pfnDLLGetVersion) + { + DLLVERSIONINFO dvi; + dvi.cbSize = sizeof dvi; + if(NOERROR == pfnDLLGetVersion(&dvi)) + { + DWORD dwVerMajor = dvi.dwMajorVersion; + DWORD dwVerMinor = dvi.dwMinorVersion; + ComCtlVer = 100 * dwVerMajor + dwVerMinor; + } + } + } + else if (::GetProcAddress(hComCtl, "InitializeFlatSB")) + ComCtlVer = 471; // InitializeFlatSB is unique to version 4.71 + } + + ::FreeLibrary(hComCtl); + + // return values and DLL versions + // 400 dll ver 4.00 Windows 95/Windows NT 4.0 + // 470 dll ver 4.70 Internet Explorer 3.x + // 471 dll ver 4.71 Internet Explorer 4.0 + // 472 dll ver 4.72 Internet Explorer 4.01 and Windows 98 + // 580 dll ver 5.80 Internet Explorer 5 + // 581 dll ver 5.81 Windows 2000 and Windows ME + // 582 dll ver 5.82 Windows XP or Vista without XP themes + // 600 dll ver 6.00 Windows XP with XP themes + // 610 dll ver 6.10 Windows Vista with XP themes + // 616 dll ver 6.16 Windows Vista SP1 or Windows 7 with XP themes + + return ComCtlVer; + } + + inline UINT GetSizeofMenuItemInfo() + { + UINT uSize = sizeof(MENUITEMINFO); + // For Win95 and NT, cbSize needs to be 44 + if (1400 == (GetWinVersion()) || (2400 == GetWinVersion())) + uSize = 44; + + return uSize; + } + + inline UINT GetSizeofNonClientMetrics() + { + // This function correctly determines the sizeof NONCLIENTMETRICS + UINT uSize = sizeof (NONCLIENTMETRICS); + + #if (WINVER >= 0x0600) + if (GetWinVersion() < 2600 && (uSize > 500)) // Is OS version less than Vista + uSize -= sizeof(int); // Adjust size back to correct value + #endif + + return uSize; + } + + + + // A global function to report the state of the left mouse button + inline BOOL IsLeftButtonDown() + { + SHORT state; + if (GetSystemMetrics(SM_SWAPBUTTON)) + // Mouse buttons are swapped + state = GetAsyncKeyState(VK_RBUTTON); + else + // Mouse buttons are not swapped + state = GetAsyncKeyState(VK_LBUTTON); + + // returns true if the left mouse button is down + return (state & 0x8000); + } + + inline BOOL IsAeroThemed() + { + BOOL bIsAeroThemed = FALSE; + + // Test if Windows version is XP or greater + if (GetWinVersion() >= 2501) + { + HMODULE hMod = ::LoadLibrary(_T("uxtheme.dll")); + if(hMod) + { + // Declare pointers to IsCompositionActive function + FARPROC pIsCompositionActive = ::GetProcAddress(hMod, "IsCompositionActive"); + + if(pIsCompositionActive) + { + if(pIsCompositionActive()) + { + bIsAeroThemed = TRUE; + } + } + ::FreeLibrary(hMod); + } + } + + return bIsAeroThemed; + } + + inline BOOL IsXPThemed() + { + BOOL bIsXPThemed = FALSE; + + // Test if Windows version is XP or greater + if (GetWinVersion() >= 2501) + { + HMODULE hMod = ::LoadLibrary(_T("uxtheme.dll")); + if(hMod) + { + // Declare pointers to functions + FARPROC pIsAppThemed = ::GetProcAddress(hMod, "IsAppThemed"); + FARPROC pIsThemeActive = ::GetProcAddress(hMod, "IsThemeActive"); + + if(pIsAppThemed && pIsThemeActive) + { + if(pIsAppThemed() && pIsThemeActive()) + { + // Test if ComCtl32 dll used is version 6 or later + bIsXPThemed = (GetComCtlVersion() >= 600); + } + } + ::FreeLibrary(hMod); + } + } + + return bIsXPThemed; + } + + #endif // #ifndef _WIN32_WCE + + // Required for WinCE + #ifndef lstrcpyn + inline LPTSTR lstrcpyn(LPTSTR lpstrDest, LPCTSTR lpstrSrc, int nLength) + { + if(NULL == lpstrDest || NULL == lpstrSrc || nLength <= 0) + return NULL; + int nLen = MIN((int)lstrlen(lpstrSrc), nLength - 1); + LPTSTR lpstrRet = (LPTSTR)memcpy(lpstrDest, lpstrSrc, nLen * sizeof(TCHAR)); + lpstrDest[nLen] = _T('\0'); + return lpstrRet; + } + #endif // !lstrcpyn + +} + + +#endif // _WIN32XX_WINUTILS_H_ -- cgit v1.2.3