// Windows Template Library - WTL version 8.1

// Copyright (C) Microsoft Corporation. All rights reserved.

//

// This file is a part of the Windows Template Library.

// The use and distribution terms for this software are covered by the

// Common Public License 1.0 (http://opensource.org/licenses/cpl1.0.php)

// which can be found in the file CPL.TXT at the root of this distribution.

// By using this software in any fashion, you are agreeing to be bound by

// the terms of this license. You must not remove this notice, or

// any other, from this software.



#ifndef __ATLTHEME_H__

#define __ATLTHEME_H__



#pragma once



#ifdef _WIN32_WCE

	#error atltheme.h is not supported on Windows CE

#endif



#ifndef __ATLAPP_H__

	#error atltheme.h requires atlapp.h to be included first

#endif



#ifndef __ATLWIN_H__

	#error atltheme.h requires atlwin.h to be included first

#endif



#if (_WIN32_WINNT < 0x0501)

	#error atltheme.h requires _WIN32_WINNT >= 0x0501

#endif // (_WIN32_WINNT < 0x0501)



#if defined(_WTL_USE_VSSYM32) || (defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_LONGHORN))

  #include <vssym32.h>

#else

  #ifndef TMSCHEMA_H

  #include <tmschema.h>

  #endif

#endif



#ifndef _UXTHEME_H_

#include <uxtheme.h>

#endif

#pragma comment(lib, "uxtheme.lib")



// Note: To create an application that also runs on older versions of Windows,

// use delay load of uxtheme.dll and ensure that no calls to the Theme API are

// made if theming is not supported. It is enough to check if m_hTheme is NULL.

// Example:

//	if(m_hTheme != NULL)

//	{

//		DrawThemeBackground(dc, BP_PUSHBUTTON, PBS_NORMAL, &rect, NULL);

//		DrawThemeText(dc, BP_PUSHBUTTON, PBS_NORMAL, L"Button", -1, DT_SINGLELINE | DT_CENTER | DT_VCENTER, 0, &rect);

//	}

//	else

//	{

//		dc.DrawFrameControl(&rect, DFC_BUTTON, DFCS_BUTTONPUSH);

//		dc.DrawText(_T("Button"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);

//	}

//

// Delay load is NOT AUTOMATIC for VC++ 7, you have to link to delayimp.lib, 

// and add uxtheme.dll in the Linker.Input.Delay Loaded DLLs section of the 

// project properties.

#if (_MSC_VER < 1300) && !defined(_WTL_NO_THEME_DELAYLOAD)

  #pragma comment(lib, "delayimp.lib")

  #pragma comment(linker, "/delayload:uxtheme.dll")

#endif // (_MSC_VER < 1300) && !defined(_WTL_NO_THEME_DELAYLOAD)



// Hack: Signatures in uxtheme.h changed - the only way to check which variant of uxtheme.h

// is included is to check for presence of new defines MAX_THEMECOLOR and MAX_THEMESIZE

#ifndef _WTL_NEW_UXTHEME

  #if defined(MAX_THEMECOLOR) && defined(MAX_THEMESIZE)

    #define _WTL_NEW_UXTHEME

  #endif // defined(MAX_THEMECOLOR) && defined(MAX_THEMESIZE)

#endif // _WTL_NEW_UXTHEME





///////////////////////////////////////////////////////////////////////////////

// Classes in this file:

//

// CTheme

// CThemeImpl<T, TBase>

//

// CBufferedPaint

// CBufferedPaintImpl<T>

// CBufferedPaintWindowImpl<T, TBase, TWinTraits>

// CBufferedAnimation

// CBufferedAnimationImpl<T, TState>

// CBufferedAnimationWindowImpl<T, TState, TBase, TWinTraits>

//

// Global functions:

//   AtlDrawThemeClientEdge()





namespace WTL

{



///////////////////////////////////////////////////////////////////////////////

// CTheme - wrapper for theme handle



class CTheme

{

public:

// Data members

	HTHEME m_hTheme;

	static int m_nIsThemingSupported;



// Constructor

	CTheme(HTHEME hTheme = NULL) : m_hTheme(hTheme)

	{

		IsThemingSupported();

	}



// Operators and helpers

	bool IsThemeNull() const

	{

		return (m_hTheme == NULL);

	}



	CTheme& operator =(HTHEME hTheme)

	{

		m_hTheme = hTheme;

		return *this;

	}



	operator HTHEME() const

	{

		return m_hTheme;

	}



	void Attach(HTHEME hTheme)

	{

		m_hTheme = hTheme;

	}



	HTHEME Detach()

	{

		HTHEME hTheme = m_hTheme;

		m_hTheme = NULL;

		return hTheme;

	}



// Theme support helper

	static bool IsThemingSupported()

	{

		if(m_nIsThemingSupported == -1)

		{

			CStaticDataInitCriticalSectionLock lock;

			if(FAILED(lock.Lock()))

			{

				ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CTheme::IsThemingSupported.\n"));

				ATLASSERT(FALSE);

				return false;

			}



			if(m_nIsThemingSupported == -1)

			{

				HMODULE hThemeDLL = ::LoadLibrary(_T("uxtheme.dll"));

				m_nIsThemingSupported = (hThemeDLL != NULL) ? 1 : 0;

				if(hThemeDLL != NULL)

					::FreeLibrary(hThemeDLL);

			}



			lock.Unlock();

		}



		ATLASSERT(m_nIsThemingSupported != -1);

		return (m_nIsThemingSupported == 1);

	}



// Operations and theme properties

	HTHEME OpenThemeData(HWND hWnd, LPCWSTR pszClassList)

	{

		if(!IsThemingSupported())

			return NULL;



		ATLASSERT(m_hTheme == NULL);

		m_hTheme = ::OpenThemeData(hWnd, pszClassList);

		return m_hTheme;

	}



	HRESULT CloseThemeData()

	{

		HRESULT hRet = S_FALSE;

		if(m_hTheme != NULL)

		{

			hRet = ::CloseThemeData(m_hTheme);

			if(SUCCEEDED(hRet))

				m_hTheme = NULL;

		}

		return hRet;

	}



	HRESULT DrawThemeBackground(HDC hDC, int nPartID, int nStateID, LPCRECT pRect, LPCRECT pClipRect = NULL)

	{

		ATLASSERT(m_hTheme != NULL);

		return ::DrawThemeBackground(m_hTheme, hDC, nPartID, nStateID, pRect, pClipRect);

	}



	HRESULT DrawThemeBackgroundEx(HDC hDC, int nPartID, int nStateID, LPCRECT pRect, const DTBGOPTS* pOptions = NULL)

	{

		ATLASSERT(m_hTheme != NULL);

		return ::DrawThemeBackgroundEx(m_hTheme, hDC, nPartID, nStateID, pRect, pOptions);

	}



	HRESULT DrawThemeText(HDC hDC, int nPartID, int nStateID, LPCWSTR pszText, int nCharCount, DWORD dwTextFlags, DWORD dwTextFlags2, LPCRECT pRect)

	{

		ATLASSERT(m_hTheme != NULL);

		return ::DrawThemeText(m_hTheme, hDC, nPartID, nStateID, pszText, nCharCount, dwTextFlags, dwTextFlags2, pRect);

	}



	HRESULT GetThemeBackgroundContentRect(HDC hDC, int nPartID, int nStateID,  LPCRECT pBoundingRect, LPRECT pContentRect) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeBackgroundContentRect(m_hTheme, hDC, nPartID, nStateID,  pBoundingRect, pContentRect);

	}



	HRESULT GetThemeBackgroundExtent(HDC hDC, int nPartID, int nStateID, LPCRECT pContentRect, LPRECT pExtentRect) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeBackgroundExtent(m_hTheme, hDC, nPartID, nStateID, pContentRect, pExtentRect);

	}



	HRESULT GetThemePartSize(HDC hDC, int nPartID, int nStateID, LPRECT pRect, enum THEMESIZE eSize, LPSIZE pSize) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemePartSize(m_hTheme, hDC, nPartID, nStateID, pRect, eSize, pSize);

	}



	HRESULT GetThemeTextExtent(HDC hDC, int nPartID, int nStateID, LPCWSTR pszText, int nCharCount, DWORD dwTextFlags, LPCRECT  pBoundingRect, LPRECT pExtentRect) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeTextExtent(m_hTheme, hDC, nPartID, nStateID, pszText, nCharCount, dwTextFlags, pBoundingRect, pExtentRect);

	}



	HRESULT GetThemeTextMetrics(HDC hDC, int nPartID, int nStateID, PTEXTMETRICW pTextMetric) const

	{

		ATLASSERT(m_hTheme != NULL);

#ifdef _WTL_NEW_UXTHEME

		return ::GetThemeTextMetrics(m_hTheme, hDC, nPartID, nStateID, pTextMetric);

#else // !_WTL_NEW_UXTHEME

		// Note: The cast to PTEXTMETRIC is because uxtheme.h incorrectly uses it instead of PTEXTMETRICW

		return ::GetThemeTextMetrics(m_hTheme, hDC, nPartID, nStateID, (PTEXTMETRIC)pTextMetric);

#endif // !_WTL_NEW_UXTHEME

	}



	HRESULT GetThemeBackgroundRegion(HDC hDC, int nPartID, int nStateID, LPCRECT pRect, HRGN* pRegion) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeBackgroundRegion(m_hTheme, hDC, nPartID, nStateID, pRect, pRegion);

	}



	HRESULT HitTestThemeBackground(HDC hDC, int nPartID, int nStateID, DWORD dwOptions, LPCRECT pRect, HRGN hrgn, POINT ptTest, WORD* pwHitTestCode) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::HitTestThemeBackground(m_hTheme, hDC, nPartID, nStateID, dwOptions, pRect, hrgn, ptTest, pwHitTestCode);

	}



	HRESULT DrawThemeEdge(HDC hDC, int nPartID, int nStateID, LPCRECT pDestRect, UINT uEdge, UINT uFlags, LPRECT pContentRect = NULL)

	{

		ATLASSERT(m_hTheme != NULL);

		return ::DrawThemeEdge(m_hTheme, hDC, nPartID, nStateID, pDestRect, uEdge, uFlags, pContentRect);

	}



	HRESULT DrawThemeIcon(HDC hDC, int nPartID, int nStateID, LPCRECT pRect, HIMAGELIST himl, int nImageIndex)

	{

		ATLASSERT(m_hTheme != NULL);

		return ::DrawThemeIcon(m_hTheme, hDC, nPartID, nStateID, pRect, himl, nImageIndex);

	}



	BOOL IsThemePartDefined(int nPartID, int nStateID) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::IsThemePartDefined(m_hTheme, nPartID, nStateID);

	}



	BOOL IsThemeBackgroundPartiallyTransparent(int nPartID, int nStateID) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::IsThemeBackgroundPartiallyTransparent(m_hTheme, nPartID, nStateID);

	}



	HRESULT GetThemeColor(int nPartID, int nStateID, int nPropID, COLORREF* pColor) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeColor(m_hTheme, nPartID, nStateID, nPropID, pColor);

	}



	HRESULT GetThemeMetric(HDC hDC, int nPartID, int nStateID, int nPropID, int* pnVal) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeMetric(m_hTheme, hDC, nPartID, nStateID, nPropID, pnVal);

	}



	HRESULT GetThemeString(int nPartID, int nStateID, int nPropID, LPWSTR pszBuff, int cchMaxBuffChars) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeString(m_hTheme, nPartID, nStateID, nPropID, pszBuff, cchMaxBuffChars);

	}



	HRESULT GetThemeBool(int nPartID, int nStateID, int nPropID, BOOL* pfVal) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeBool(m_hTheme, nPartID, nStateID, nPropID, pfVal);

	}



	HRESULT GetThemeInt(int nPartID, int nStateID, int nPropID, int* pnVal) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeInt(m_hTheme, nPartID, nStateID, nPropID, pnVal);

	}



	HRESULT GetThemeEnumValue(int nPartID, int nStateID, int nPropID, int* pnVal) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeEnumValue(m_hTheme, nPartID, nStateID, nPropID, pnVal);

	}



	HRESULT GetThemePosition(int nPartID, int nStateID, int nPropID, LPPOINT pPoint) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemePosition(m_hTheme, nPartID, nStateID, nPropID, pPoint);

	}



	// deprecated

	HRESULT GetThemeFont(int nPartID, HDC hDC, int nStateID, int nPropID, LOGFONTW* pFont) const

	{

		ATLASSERT(m_hTheme != NULL);

#ifdef _WTL_NEW_UXTHEME

		return ::GetThemeFont(m_hTheme, hDC, nPartID, nStateID, nPropID, pFont);

#else // !_WTL_NEW_UXTHEME

		// Note: The cast to LOGFONT* is because uxtheme.h incorrectly uses it instead of LOGFONTW*

		return ::GetThemeFont(m_hTheme, hDC, nPartID, nStateID, nPropID, (LOGFONT*)pFont);

#endif // !_WTL_NEW_UXTHEME

	}



	HRESULT GetThemeFont(HDC hDC, int nPartID, int nStateID, int nPropID, LOGFONTW* pFont) const

	{

		ATLASSERT(m_hTheme != NULL);

#ifdef _WTL_NEW_UXTHEME

		return ::GetThemeFont(m_hTheme, hDC, nPartID, nStateID, nPropID, pFont);

#else // !_WTL_NEW_UXTHEME

		// Note: The cast to LOGFONT* is because uxtheme.h incorrectly uses it instead of LOGFONTW*

		return ::GetThemeFont(m_hTheme, hDC, nPartID, nStateID, nPropID, (LOGFONT*)pFont);

#endif // !_WTL_NEW_UXTHEME

	}



	HRESULT GetThemeRect(int nPartID, int nStateID, int nPropID, LPRECT pRect) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeRect(m_hTheme, nPartID, nStateID, nPropID, pRect);

	}



	HRESULT GetThemeMargins(HDC hDC, int nPartID, int nStateID, int nPropID, LPRECT pRect, PMARGINS pMargins) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeMargins(m_hTheme, hDC, nPartID, nStateID, nPropID, pRect, pMargins);

	}



	HRESULT GetThemeIntList(int nPartID, int nStateID, int nPropID, INTLIST* pIntList) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeIntList(m_hTheme, nPartID, nStateID, nPropID, pIntList);

	}



	HRESULT GetThemePropertyOrigin(int nPartID, int nStateID, int nPropID, enum PROPERTYORIGIN* pOrigin) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemePropertyOrigin(m_hTheme, nPartID, nStateID, nPropID, pOrigin);

	}



	HRESULT GetThemeFilename(int nPartID, int nStateID, int nPropID, LPWSTR pszThemeFileName, int cchMaxBuffChars) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeFilename(m_hTheme, nPartID, nStateID, nPropID, pszThemeFileName, cchMaxBuffChars);

	}



	COLORREF GetThemeSysColor(int nColorID) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeSysColor(m_hTheme, nColorID);

	}



	HBRUSH GetThemeSysColorBrush(int nColorID) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeSysColorBrush(m_hTheme, nColorID);

	}



	int GetThemeSysSize(int nSizeID) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeSysSize(m_hTheme, nSizeID);

	}



	BOOL GetThemeSysBool(int nBoolID) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeSysBool(m_hTheme, nBoolID);

	}



	HRESULT GetThemeSysFont(int nFontID, LOGFONTW* plf) const

	{

		ATLASSERT(m_hTheme != NULL);

#ifdef _WTL_NEW_UXTHEME

		return ::GetThemeSysFont(m_hTheme, nFontID, plf);

#else // !_WTL_NEW_UXTHEME

		// Note: The cast to LOGFONT* is because uxtheme.h incorrectly uses it instead of LOGFONTW*

		return ::GetThemeSysFont(m_hTheme, nFontID, (LOGFONT*)plf);

#endif // !_WTL_NEW_UXTHEME

	}



	HRESULT GetThemeSysString(int nStringID, LPWSTR pszStringBuff, int cchMaxStringChars) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeSysString(m_hTheme, nStringID, pszStringBuff, cchMaxStringChars);

	}



	HRESULT GetThemeSysInt(int nIntID, int* pnValue) const

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeSysInt(m_hTheme, nIntID, pnValue);

	}



#ifdef _WTL_NEW_UXTHEME

	HTHEME OpenThemeDataEx(HWND hWnd, LPCWSTR pszClassList, DWORD dwFlags)

	{

		if(!IsThemingSupported())

			return NULL;



		ATLASSERT(m_hTheme == NULL);

		m_hTheme = ::OpenThemeDataEx(hWnd, pszClassList, dwFlags);

		return m_hTheme;

	}



	HRESULT DrawThemeTextEx(HDC hDC, int nPartID, int nStateID, LPCWSTR pszText, int cchText, DWORD dwTextFlags, LPRECT lpRect, const DTTOPTS* pOptions)

	{

		ATLASSERT(m_hTheme != NULL);

		return ::DrawThemeTextEx(m_hTheme, hDC, nPartID, nStateID, pszText, cchText, dwTextFlags, lpRect, pOptions);

	}



	HRESULT GetThemeTransitionDuration(int nPartID, int nFromStateID, int nToStateID, int nPropID, DWORD& dwDuration)

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeTransitionDuration(m_hTheme, nPartID, nFromStateID, nToStateID, nPropID, &dwDuration);

	}

#endif // _WTL_NEW_UXTHEME



#if (_WIN32_WINNT >= 0x0600)

	HRESULT GetThemeBitmap(int nPartID, int nStateID, int nPropID, ULONG uFlags, HBITMAP& hBitmap)

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeBitmap(m_hTheme, nPartID, nStateID, nPropID, uFlags, &hBitmap);

	}



	HRESULT GetThemeStream(int nPartID, int nStateID, int nPropID, VOID** ppvStream, DWORD* pcbStream, HINSTANCE hInstance)

	{

		ATLASSERT(m_hTheme != NULL);

		return ::GetThemeStream(m_hTheme, nPartID, nStateID, nPropID, ppvStream, pcbStream, hInstance);

	}

#endif // (_WIN32_WINNT >= 0x0600)

};



__declspec(selectany) int CTheme::m_nIsThemingSupported = -1;





///////////////////////////////////////////////////////////////////////////////

// CThemeImpl - theme support implementation



// Derive from this class to implement window with theme support.

// Example:

//	class CMyThemeWindow : public CWindowImpl<CMyThemeWindow>, public CThemeImpl<CMyThemeWindow>

//	{

//	...

//		BEGIN_MSG_MAP(CMyThemeWindow)

//			CHAIN_MSG_MAP(CThemeImpl<CMyThemeWindow>)

//			...

//		END_MSG_MAP()

//	...

//	};

//

// If you set theme class list, the class will automaticaly open/close/reopen theme data.





// Helper for drawing theme client edge

inline bool AtlDrawThemeClientEdge(HTHEME hTheme, HWND hWnd, HRGN hRgnUpdate = NULL, HBRUSH hBrush = NULL, int nPartID = 0, int nStateID = 0)

{

	ATLASSERT(hTheme != NULL);

	ATLASSERT(::IsWindow(hWnd));



	CWindowDC dc(hWnd);

	if(dc.IsNull())

		return false;



	// Get border size

	int cxBorder = GetSystemMetrics(SM_CXBORDER);

	int cyBorder = GetSystemMetrics(SM_CYBORDER);

	if(SUCCEEDED(::GetThemeInt(hTheme, nPartID, nStateID, TMT_SIZINGBORDERWIDTH, &cxBorder)))

		cyBorder = cxBorder;



	RECT rect;

	::GetWindowRect(hWnd, &rect);            



	// Remove the client edge from the update region

	int cxEdge = GetSystemMetrics(SM_CXEDGE);

	int cyEdge = GetSystemMetrics(SM_CYEDGE);

	::InflateRect(&rect, -cxEdge, -cyEdge);

	CRgn rgn;

	rgn.CreateRectRgnIndirect(&rect);

	if(rgn.IsNull())

		return false;



	if(hRgnUpdate != NULL)

		rgn.CombineRgn(hRgnUpdate, rgn, RGN_AND);



	::OffsetRect(&rect, -rect.left, -rect.top);



	::OffsetRect(&rect, cxEdge, cyEdge);

	dc.ExcludeClipRect(&rect);

	::InflateRect(&rect, cxEdge, cyEdge);



	::DrawThemeBackground(hTheme, dc, nPartID, nStateID, &rect, NULL);



	// Use background brush too, since theme border might not cover everything

	if(cxBorder < cxEdge && cyBorder < cyEdge)

	{

		if(hBrush == NULL)

// need conditional code because types don't match in winuser.h

#ifdef _WIN64

			hBrush = (HBRUSH)::GetClassLongPtr(hWnd, GCLP_HBRBACKGROUND);

#else

			hBrush = (HBRUSH)UlongToPtr(::GetClassLongPtr(hWnd, GCLP_HBRBACKGROUND));

#endif



		::InflateRect(&rect, cxBorder - cxEdge, cyBorder - cyEdge);

		dc.FillRect(&rect, hBrush);

	}



	::DefWindowProc(hWnd, WM_NCPAINT, (WPARAM)rgn.m_hRgn, 0L);



	return true;

}





// Theme extended styles

#define THEME_EX_3DCLIENTEDGE		0x00000001

#define THEME_EX_THEMECLIENTEDGE	0x00000002



template <class T, class TBase = CTheme>

class CThemeImpl : public TBase

{

public:

// Data members

	LPWSTR m_lpstrThemeClassList;

	DWORD m_dwExtendedStyle;   // theme specific extended styles



// Constructor & destructor

	CThemeImpl() : m_lpstrThemeClassList(NULL), m_dwExtendedStyle(0)

	{ }



	~CThemeImpl()

	{

		delete [] m_lpstrThemeClassList;

	}



// Attributes

	bool SetThemeClassList(LPCWSTR lpstrThemeClassList)

	{

		if(m_lpstrThemeClassList != NULL)

		{

			delete [] m_lpstrThemeClassList;

			m_lpstrThemeClassList = NULL;

		}



		if(lpstrThemeClassList == NULL)

			return true;



		int cchLen = lstrlenW(lpstrThemeClassList) + 1;

		ATLTRY(m_lpstrThemeClassList = new WCHAR[cchLen]);

		if(m_lpstrThemeClassList == NULL)

			return false;



		SecureHelper::strcpyW_x(m_lpstrThemeClassList, cchLen, lpstrThemeClassList);



		return true;

	}



	bool GetThemeClassList(LPWSTR lpstrThemeClassList, int cchListBuffer) const

	{

		int cchLen = lstrlenW(m_lpstrThemeClassList) + 1;

		if(cchListBuffer < cchLen)

			return false;



		SecureHelper::strcpyW_x(lpstrThemeClassList, cchListBuffer, m_lpstrThemeClassList);



		return true;

	}



	LPCWSTR GetThemeClassList() const

	{

		return m_lpstrThemeClassList;

	}



	DWORD SetThemeExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)

	{

		DWORD dwPrevStyle = m_dwExtendedStyle;

		if(dwMask == 0)

			m_dwExtendedStyle = dwExtendedStyle;

		else

			m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);

		return dwPrevStyle;

	}



	DWORD GetThemeExtendedStyle() const

	{

		return m_dwExtendedStyle;

	}



// Operations

	HTHEME OpenThemeData()

	{

		T* pT = static_cast<T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

		ATLASSERT(m_lpstrThemeClassList != NULL);

		if(m_lpstrThemeClassList == NULL)

			return NULL;

		CloseThemeData();

		return TBase::OpenThemeData(pT->m_hWnd, m_lpstrThemeClassList);

	}



	HTHEME OpenThemeData(LPCWSTR pszClassList)

	{

		if(!SetThemeClassList(pszClassList))

			return NULL;

		return OpenThemeData();

	}



	HRESULT SetWindowTheme(LPCWSTR pszSubAppName, LPCWSTR pszSubIDList)

	{

		if(!IsThemingSupported())

			return S_FALSE;



		T* pT = static_cast<T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

		return ::SetWindowTheme(pT->m_hWnd, pszSubAppName, pszSubIDList);

	}



	HTHEME GetWindowTheme() const

	{

		if(!IsThemingSupported())

			return NULL;



		const T* pT = static_cast<const T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

		return ::GetWindowTheme(pT->m_hWnd);

	}



	HRESULT EnableThemeDialogTexture(DWORD dwFlags)

	{

		if(!IsThemingSupported())

			return S_FALSE;



		T* pT = static_cast<T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

		return ::EnableThemeDialogTexture(pT->m_hWnd, dwFlags);

	}



	BOOL IsThemeDialogTextureEnabled() const

	{

		if(!IsThemingSupported())

			return FALSE;



		const T* pT = static_cast<const T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

		return ::IsThemeDialogTextureEnabled(pT->m_hWnd);

	}



	HRESULT DrawThemeParentBackground(HDC hDC, const RECT* pRect = NULL)

	{

		if(!IsThemingSupported())

			return S_FALSE;



		T* pT = static_cast<T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

#ifdef _WTL_NEW_UXTHEME

		return ::DrawThemeParentBackground(pT->m_hWnd, hDC, pRect);

#else

		return ::DrawThemeParentBackground(pT->m_hWnd, hDC, (RECT*)pRect);

#endif

	}



#ifdef _WTL_NEW_UXTHEME

	HRESULT SetWindowThemeAttribute(WINDOWTHEMEATTRIBUTETYPE type, PVOID pvAttribute, DWORD cbAttribute)

	{

		if(!IsThemingSupported())

			return S_FALSE;



		T* pT = static_cast<T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

		return ::SetWindowThemeAttribute(pT->m_hWnd, type, pvAttribute, cbAttribute);

	}



	HRESULT SetWindowThemeNonClientAttributes(DWORD dwAttributes, DWORD dwMask)

	{

		if(!IsThemingSupported())

			return S_FALSE;



		T* pT = static_cast<T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

		WTA_OPTIONS opt = { dwAttributes, dwMask };

		return ::SetWindowThemeAttribute(pT->m_hWnd, WTA_NONCLIENT, (PVOID)&opt, sizeof(opt));

	}



	HRESULT DrawThemeParentBackgroundEx(HDC hDC, DWORD dwFlags, const RECT* lpRect = NULL)

	{

		if(!IsThemingSupported())

			return S_FALSE;



		T* pT = static_cast<T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

		return ::DrawThemeParentBackgroundEx(pT->m_hWnd, hDC, dwFlags, lpRect);

	}

#endif // _WTL_NEW_UXTHEME



// Message map and handlers

	// Note: If you handle any of these messages in your derived class,

	// it is better to put CHAIN_MSG_MAP at the start of your message map.

	BEGIN_MSG_MAP(CThemeImpl)

		MESSAGE_HANDLER(WM_CREATE, OnCreate)

		MESSAGE_HANDLER(WM_DESTROY, OnDestroy)

		MESSAGE_HANDLER(WM_THEMECHANGED, OnThemeChanged)

		MESSAGE_HANDLER(WM_NCPAINT, OnNcPaint)

	END_MSG_MAP()



	LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)

	{

		if(m_lpstrThemeClassList != NULL)

			OpenThemeData();

		bHandled = FALSE;

		return 1;

	}



	LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)

	{

		CloseThemeData();

		bHandled = FALSE;

		return 1;

	}



	LRESULT OnThemeChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)

	{

		CloseThemeData();

		if(m_lpstrThemeClassList != NULL)

			OpenThemeData();

		bHandled = FALSE;

		return 1;

	}



	LRESULT OnNcPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)

	{

		T* pT = static_cast<T*>(this);

		ATLASSERT(::IsWindow(pT->m_hWnd));

		LRESULT lRet = 0;

		bHandled = FALSE;

		if(IsThemingSupported() && ((pT->GetExStyle() & WS_EX_CLIENTEDGE) != 0))

		{

			if((m_dwExtendedStyle & THEME_EX_3DCLIENTEDGE) != 0)

			{

				lRet = ::DefWindowProc(pT->m_hWnd, uMsg, wParam, lParam);

				bHandled = TRUE;

			}

			else if((m_hTheme != NULL) && ((m_dwExtendedStyle & THEME_EX_THEMECLIENTEDGE) != 0))

			{

				HRGN hRgn = (wParam != 1) ? (HRGN)wParam : NULL;

				if(pT->DrawThemeClientEdge(hRgn))

					bHandled = TRUE;

			}

		}

		return lRet;

	}



// Drawing helper

	bool DrawThemeClientEdge(HRGN hRgnUpdate)

	{

		T* pT = static_cast<T*>(this);

		return AtlDrawThemeClientEdge(m_hTheme, pT->m_hWnd, hRgnUpdate, NULL, 0, 0);

	}

};



///////////////////////////////////////////////////////////////////////////////

// Buffered Paint and Animation



#ifdef _WTL_NEW_UXTHEME



///////////////////////////////////////////////////////////////////////////////

// CBufferedPaintBase - Buffered Paint support for othe classes



class CBufferedPaintBase

{

public:

	static int m_nIsBufferedPaintSupported;



	CBufferedPaintBase()

	{

		if(IsBufferedPaintSupported())

			ATLVERIFY(SUCCEEDED(::BufferedPaintInit()));

	}



	~CBufferedPaintBase()

	{

		if(IsBufferedPaintSupported())

			ATLVERIFY(SUCCEEDED(::BufferedPaintUnInit()));

	}



	static bool IsBufferedPaintSupported()

	{

		if(m_nIsBufferedPaintSupported == -1)

		{

			CStaticDataInitCriticalSectionLock lock;

			if(FAILED(lock.Lock()))

			{

				ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CBufferedPaintBase::IsBufferedPaintSupported.\n"));

				ATLASSERT(FALSE);

				return false;

			}



			if(m_nIsBufferedPaintSupported == -1)

				m_nIsBufferedPaintSupported = RunTimeHelper::IsVista() ? 1 : 0;



			lock.Unlock();

		}



		ATLASSERT(m_nIsBufferedPaintSupported != -1);

		return (m_nIsBufferedPaintSupported == 1);

	}

};



__declspec(selectany) int CBufferedPaintBase::m_nIsBufferedPaintSupported = -1;





///////////////////////////////////////////////////////////////////////////////

// CBufferedPaint - support for buffered paint functions



class CBufferedPaint

{

public:

	HPAINTBUFFER m_hPaintBuffer;



	CBufferedPaint() : m_hPaintBuffer(NULL)

	{ }



	~CBufferedPaint()

	{

		ATLVERIFY(SUCCEEDED(End()));

	}



	bool IsNull() const

	{

		return (m_hPaintBuffer == NULL);

	}



	HPAINTBUFFER Begin(HDC hdcTarget, const RECT* prcTarget, BP_BUFFERFORMAT dwFormat, BP_PAINTPARAMS* pPaintParams, HDC* phdcPaint)

	{

		ATLASSERT(m_hPaintBuffer == NULL);

		m_hPaintBuffer = ::BeginBufferedPaint(hdcTarget, prcTarget, dwFormat, pPaintParams, phdcPaint);

		return m_hPaintBuffer;

	}



	HRESULT End(BOOL bUpdate = TRUE)

	{

		HRESULT hRet = S_FALSE;

		if(m_hPaintBuffer != NULL)

		{

			hRet = ::EndBufferedPaint(m_hPaintBuffer, bUpdate);

			m_hPaintBuffer = NULL;

		}

		return hRet;

	}



	HRESULT GetTargetRect(LPRECT pRect) const

	{

		ATLASSERT(m_hPaintBuffer != NULL);

		return ::GetBufferedPaintTargetRect(m_hPaintBuffer, pRect);

	}



	HDC GetTargetDC() const

	{

		ATLASSERT(m_hPaintBuffer != NULL);

		return ::GetBufferedPaintTargetDC(m_hPaintBuffer);

	}



	HDC GetPaintDC() const

	{

		ATLASSERT(m_hPaintBuffer != NULL);

		return ::GetBufferedPaintDC(m_hPaintBuffer);

	}



	HRESULT GetBits(RGBQUAD** ppbBuffer, int* pcxRow) const

	{

		ATLASSERT(m_hPaintBuffer != NULL);

		return ::GetBufferedPaintBits(m_hPaintBuffer, ppbBuffer, pcxRow);

	}



	HRESULT Clear(const RECT* pRect = NULL)

	{

		ATLASSERT(m_hPaintBuffer != NULL);

		return ::BufferedPaintClear(m_hPaintBuffer, pRect);

	}



	HRESULT SetAlpha(BYTE alpha, const RECT* pRect = NULL)

	{

		ATLASSERT(m_hPaintBuffer != NULL);

		return ::BufferedPaintSetAlpha(m_hPaintBuffer, pRect, alpha);

	}



	HRESULT MakeOpaque(const RECT* pRect = NULL)

	{

		ATLASSERT(m_hPaintBuffer != NULL);

		return ::BufferedPaintSetAlpha(m_hPaintBuffer, pRect, 255);

	}

};





///////////////////////////////////////////////////////////////////////////////

// CBufferedPaintImpl - provides buffered paint for any window



template <class T>

class ATL_NO_VTABLE CBufferedPaintImpl : public CBufferedPaintBase

{

public:

	CBufferedPaint m_BufferedPaint;

	BP_BUFFERFORMAT m_dwFormat;

	BP_PAINTPARAMS m_PaintParams;



	CBufferedPaintImpl() : m_dwFormat(BPBF_TOPDOWNDIB)

	{

		memset(&m_PaintParams, 0, sizeof(BP_PAINTPARAMS));

		m_PaintParams.cbSize = sizeof(BP_PAINTPARAMS);

	}



// Message map and handlers

	BEGIN_MSG_MAP(CBufferedPaintImpl)

		MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)

		MESSAGE_HANDLER(WM_PAINT, OnPaint)

		MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)

	END_MSG_MAP()



	LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)

	{

		return 1;   // no background needed

	}



	LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)

	{

		T* pT = static_cast<T*>(this);

		if(wParam != NULL)

		{

			RECT rect = { 0 };

			pT->GetClientRect(&rect);

			pT->DoPaint((HDC)wParam, rect);

		}

		else

		{

			CPaintDC dc(pT->m_hWnd);

			pT->DoBufferedPaint(dc.m_hDC, dc.m_ps.rcPaint);

		}



		return 0;

	}



// Overrideables

	void DoBufferedPaint(CDCHandle dc, RECT& rect)

	{

		HDC hDCPaint = NULL;

		if(IsBufferedPaintSupported())

			m_BufferedPaint.Begin(dc, &rect, m_dwFormat, &m_PaintParams, &hDCPaint);



		T* pT = static_cast<T*>(this);

		if(hDCPaint != NULL)

			pT->DoPaint(hDCPaint, rect);

		else

			pT->DoPaint(dc.m_hDC, rect);



		if(IsBufferedPaintSupported())

			m_BufferedPaint.End();

	}



	void DoPaint(CDCHandle /*dc*/, RECT& /*rect*/)

	{

		// must be implemented in a derived class

		ATLASSERT(FALSE);

	}

};





///////////////////////////////////////////////////////////////////////////////

// CBufferedPaintWindowImpl - implements a window that uses buffered paint



template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>

class ATL_NO_VTABLE CBufferedPaintWindowImpl : 

		public ATL::CWindowImpl<T, TBase, TWinTraits>, 

		public CBufferedPaintImpl< T >

{

public:

	BEGIN_MSG_MAP(CBufferedPaintWindowImpl)

		CHAIN_MSG_MAP(CBufferedPaintImpl< T >)

	END_MSG_MAP()

};





///////////////////////////////////////////////////////////////////////////////

// CBufferedAnimation - support for buffered animation



class CBufferedAnimation

{

public:

	HANIMATIONBUFFER m_hAnimationBuffer;



	CBufferedAnimation() : m_hAnimationBuffer(NULL)

	{ }



	~CBufferedAnimation()

	{

		ATLVERIFY(SUCCEEDED(End()));

	}



	bool IsNull() const

	{

		return (m_hAnimationBuffer == NULL);

	}



	HANIMATIONBUFFER Begin(HWND hWnd, HDC hDCTarget, const RECT* pRectTarget, BP_BUFFERFORMAT dwFormat, BP_PAINTPARAMS* pPaintParams, BP_ANIMATIONPARAMS* pAnimationParams, HDC* phdcFrom, HDC* phdcTo)

	{

		ATLASSERT(m_hAnimationBuffer == NULL);

		m_hAnimationBuffer = ::BeginBufferedAnimation(hWnd, hDCTarget, pRectTarget, dwFormat, pPaintParams, pAnimationParams, phdcFrom, phdcTo);

		return m_hAnimationBuffer;

	}



	HRESULT End(BOOL bUpdate = TRUE)

	{

		HRESULT hRet = S_FALSE;

		if(m_hAnimationBuffer != NULL)

		{

			hRet = ::EndBufferedAnimation(m_hAnimationBuffer, bUpdate);

			m_hAnimationBuffer = NULL;

		}

		return hRet;

	}



	static bool IsRendering(HWND hWnd, HDC hDC)

	{

		return (::BufferedPaintRenderAnimation(hWnd, hDC) != FALSE);

	}

};





///////////////////////////////////////////////////////////////////////////////

// CBufferedAnimationImpl - provides buffered animation support for any window



// Note: You can either use m_State and m_NewState to store the state information

// for the animation change, or map your state to those data members. DoPaint()

// should only rely on the state information that is passed to it.



template <class T, class TState = DWORD_PTR>

class ATL_NO_VTABLE CBufferedAnimationImpl : public CBufferedPaintBase

{

public:

	BP_BUFFERFORMAT m_dwFormat;

	BP_PAINTPARAMS m_PaintParams;

	BP_ANIMATIONPARAMS m_AnimationParams;



	TState m_State;

	TState m_NewState;



	CBufferedAnimationImpl(TState InitialState) : m_dwFormat(BPBF_TOPDOWNDIB)

	{

		memset(&m_PaintParams, 0, sizeof(BP_PAINTPARAMS));

		m_PaintParams.cbSize = sizeof(BP_PAINTPARAMS);



		memset(&m_AnimationParams, 0, sizeof(BP_ANIMATIONPARAMS));

		m_AnimationParams.cbSize = sizeof(BP_ANIMATIONPARAMS);

		m_AnimationParams.style = BPAS_LINEAR;

		m_AnimationParams.dwDuration = 500;



		T* pT = static_cast<T*>(this);

		pT->SetState(InitialState);

		pT->SetNewState(InitialState);

	}



	DWORD GetDuration() const

	{

		return m_AnimationParams.dwDuration;

	}



	void SetDuration(DWORD dwDuration)

	{

		m_AnimationParams.dwDuration = dwDuration;

	}



	void DoAnimation(TState NewState, const RECT* pRect = NULL)

	{

		T* pT = static_cast<T*>(this);

		pT->SetNewState(NewState);



		pT->InvalidateRect(pRect, FALSE);

		pT->UpdateWindow();



		pT->SetState(NewState);

	}



// Message map and handlers

	BEGIN_MSG_MAP(CBufferedAnimationImpl)

		MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)

		MESSAGE_HANDLER(WM_PAINT, OnPaint)

		MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)

	END_MSG_MAP()



	LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)

	{

		return 1;   // no background needed

	}



	LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)

	{

		T* pT = static_cast<T*>(this);

		if(wParam != NULL)

		{

			RECT rect = { 0 };

			pT->GetClientRect(&rect);

			pT->DoPaint((HDC)wParam, rect, m_NewState);

		}

		else

		{

			CPaintDC dc(pT->m_hWnd);

			pT->DoAnimationPaint(dc.m_hDC, dc.m_ps.rcPaint);

		}



		return 0;

	}



// Overrideables

	void SetState(TState State)

	{

		m_State = State;

	}



	void SetNewState(TState State)

	{

		m_NewState = State;

	}



	bool AreStatesEqual() const

	{

		return (m_State == m_NewState);

	}



	void DoAnimationPaint(CDCHandle dc, RECT& rect)

	{

		T* pT = static_cast<T*>(this);

		if(IsBufferedPaintSupported() && CBufferedAnimation::IsRendering(pT->m_hWnd, dc))

			return;



		DWORD dwDurationSave = m_AnimationParams.dwDuration;

		if(pT->AreStatesEqual())

			m_AnimationParams.dwDuration = 0;



		HDC hdcFrom = NULL, hdcTo = NULL;

		CBufferedAnimation ba;

		if(IsBufferedPaintSupported())

			ba.Begin(pT->m_hWnd, dc, &rect, m_dwFormat, &m_PaintParams, &m_AnimationParams, &hdcFrom, &hdcTo);



		if(!ba.IsNull())

		{

			if(hdcFrom != NULL)

				pT->DoPaint(hdcFrom, rect, m_State);



			if (hdcTo != NULL)

				pT->DoPaint(hdcTo, rect, m_NewState);

		}

		else

		{

			pT->DoPaint(dc.m_hDC, rect, m_NewState);

		}



		m_AnimationParams.dwDuration = dwDurationSave;

	}



	void DoPaint(CDCHandle /*dc*/, RECT& /*rect*/, TState /*State*/)

	{

		// must be implemented in a derived class

		ATLASSERT(FALSE);

	}

};





///////////////////////////////////////////////////////////////////////////////

// CBufferedAnimationWindowImpl - implements a window that uses buffered animation



template <class T, class TState = DWORD_PTR, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>

class ATL_NO_VTABLE CBufferedAnimationWindowImpl : 

		public ATL::CWindowImpl<T, TBase, TWinTraits>, 

		public CBufferedAnimationImpl< T, TState >

{

public:

	CBufferedAnimationWindowImpl(TState InitialState) : CBufferedAnimationImpl< T, TState >(InitialState)

	{ }



	typedef CBufferedAnimationImpl< T, TState >   _baseBufferedAnimation;

	BEGIN_MSG_MAP(CBufferedAnimationWindowImpl)

		CHAIN_MSG_MAP(_baseBufferedAnimation)

	END_MSG_MAP()

};



#endif // _WTL_NEW_UXTHEME



}; // namespace WTL



#endif // __ATLTHEME_H__