d:\qicon.cpp( 547 ) : error C2512: 'CQIcon::BitmapCache' : no appropriate default constructor available
d:\qicon.cpp( 552 ) : error C2512: 'CQIcon::BitmapCache' : no appropriate default constructor available

#pragma once
#include "qbitmap.h"

#define QICON_PER_ALPHA  1 . 4 
#define QICON_CLR_ALPHA COLORREF(-1L)
/////////////////////////////////////////////////////////////////////////////////////////////
// CQBMPCache
class AFX_EXT_CLASS CQBMPCache : public CQBitmap
{
private:
	HBITMAP m_hBitmapCache;
	void _InitCache(const CQBitmap& _bmp);

public:
	CQBMPCache();
	CQBMPCache(const CQBitmap& other);
	virtual ~CQBMPCache();

	virtual bool AssignFromOther(const CQBitmap& other,	bool bEnableTrowException = false);
	virtual void Empty();
	virtual bool IsEmpty() const;
	virtual int AlphaBlend(HDC hDC, int nDstX, int nDstY, int nDstWidth, int nDstHeight,
						   int nSrcX, int nSrcY, int nSrcWidth, int nSrcHeight,
						   BYTE nSCA = 0xFF) const;
	virtual void OnLoad();
}; // class CQBMPCache

//CQIcon -------------- класс иконки для кнопок, панели управления, меню и др. эл. управления
/////////////////////////////////////////////////////////////////////////////////////////////
class AFX_EXT_CLASS CQIcon
{
//КОНСТРУКТОРЫ И ДЕСТРУКТОРЫ=================================================================
public:
	CQIcon(HICON& hIcon, bool bCreateCopy);
	CQIcon(const CQIcon& other);
	CQIcon(HBITMAP hBitmap = NULL, COLORREF clrTransparent = RGB( 0 ,  0 ,  0 ), LPCRECT pRectBitmapSrc = NULL, bool bCloneBitmap = true);
	virtual ~CQIcon();

//ПЕРЕМЕННЫЕ=================================================================================
	COLORREF m_clrAlpha;
	double	 m_lfAlphaAdjustPercent;

//ОПЕРАТОРЫ==================================================================================
	operator HICON() {return GetIcon();}
	operator CSize() const {return GetSize();}
	
	CQIcon& operator = (const CQIcon& other)
	{
		AssignFromOther(other);
		return (*this);
	}

//ПЕРЕЧИСЛЕНИЯ===============================================================================
	enum draw_type {DRAW_NORMAL  =  0 , DRAW_DISABLED =  1 , DRAW_MONO =  2 , DRAW_ALPHA =  3 ,
					DRAW_VAL_MIN =  0 , DRAW_VAL_MAX  =  3 };

//ФУНКЦИИ====================================================================================
	virtual void  Empty();
	virtual bool  IsEmpty() const;
	virtual void  AssignFromOther(const CQIcon& other);
	virtual void  AssignFromHICON(HICON hIcon, bool bCreateCopy);
	virtual	CSize GetSize() const;
	virtual HICON GetIcon(bool bReplaceSysColors = true) const;
	virtual HICON DetachAsHICON(bool bReplaceSysColors = true);
	static  CSize stGetIconSize(HICON hIcon);
	virtual bool  CreateEmptyIcon(COLORREF clrTransparent = COLORREF(-1L), CSize sizeIcon = CSize( 16 ,  16 ),
								  COLORREF** ppOutSurface = NULL);

/////////////////////////////////////////////////////////////////////////////////////////////
//ВНУТРЕННИЕ КЛАССЫ
/////////////////////////////////////////////////////////////////////////////////////////////
private:
	class AFX_EXT_CLASS BitmapCache
	{
	public:
		BitmapCache(HBITMAP hBitmap, COLORREF clrTransparent = RGB( 0 ,  0 ,  0 ), LPCRECT pRectBitmapSrc = NULL, bool bCloneBitmap = true);
		BitmapCache(const BitmapCache& other);
		~BitmapCache();

		BitmapCache& operator = (const BitmapCache& other);

		HBITMAP	 m_hBitmap;
		CSize    m_sizeBitmap;
		COLORREF m_clrTransparent;

		HICON	 CreateHICON(bool bReplaceSysColors = true) const;
		CSize	 GetSize() const;
		COLORREF GetTransparentColor() const;
		HBITMAP  GetBitmap() const;
		INT		 GetColorMap(CMap<COLORREF, COLORREF, DWORD, DWORD>& _map) const;
		INT		 GetBitsPerPixel() const;
	
		bool	 IsEmpty() const;
		void	 Empty();
		void	 AssignIndirect(HBITMAP hBitmap, COLORREF clrTransparent, 
								LPCRECT pRectBitmapSrc = NULL, bool bCloneBitmap = true);
		void	 Serialize(CArchive& ar);
		void	 AssignFromOther(const BitmapCache& other);
	}; // class BitmapCache====================================================================

	class AFX_EXT_CLASS CIconCache
	{
		HICON m_hIcon;
		CSize m_sizeIcon;

	public:
		CIconCache();
		CIconCache(const CIconCache& other);
		~CIconCache();
		bool	IsEmpty() const;
		void	Empty();
		void	Serialize(CArchive& ar);
		void	RecalcIconOriginalSize();
		void	AssignFromOther(const CIconCache& other);
		void	AssignFromHICON(HICON& hIcon, bool bCreateCopy);
		void	Paint(HDC hDC, const POINT& pt, draw_type eDT, HBRUSH hBrush) const;
		HICON	Detach();
		HICON	GetIcon() const;
		CSize	GetSize() const;
		INT		GetColorMap(CMap<COLORREF, COLORREF, DWORD, DWORD>& _map) const;
		INT		GetBitsPerPixel() const;
		CIconCache& operator = (const CIconCache& other);
	}; // class IconCache====================================================================

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

	CIconCache			m_IconCache;
	mutable CIconCache	m_IconAlpha;
	BitmapCache			m_BitmapCache;
}; // class CQIcon

#include "stdafx.h"
#include "qicon.h"
#include "qbitmap.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////////////////////
//CQBMPCache**********************************************************************************
CQBMPCache::CQBMPCache() : m_hBitmapCache(NULL){}
CQBMPCache::CQBMPCache(const CQBitmap& other) : m_hBitmapCache(NULL), CQBitmap(other)
{
	_InitCache(*this);
}

CQBMPCache::~CQBMPCache(){Empty();}

bool CQBMPCache::AssignFromOther(const CQBitmap& other, bool bEnableTrowException)
{
	Empty();
	bool bRetVal = CQBitmap::AssignFromOther(other, bEnableTrowException);
	_InitCache(other);
	return bRetVal;
}

void CQBMPCache::_InitCache(const CQBitmap& _bmp)
{
	if(m_hBitmapCache != NULL)
	{
		::DeleteObject(m_hBitmapCache);
		m_hBitmapCache = NULL;
	}
	if(g_Painter.m_qMsImgAlphaBlend == NULL || _bmp.IsEmpty() || _bmp.GetBPP() !=  32 	|| _bmp.MaskAlpha() ==  0 )
		return;
	CQBitmap _bmpCrt = _bmp;
	if(_bmpCrt.IsEmpty())
		return;
	_bmpCrt.PreMultiplyRGBChannels();
	m_hBitmapCache = _bmpCrt.CreateBitmap();
}

void CQBMPCache::Empty()
{
	CQBitmap::Empty();
	if(m_hBitmapCache != NULL)
	{
		::DeleteObject(m_hBitmapCache);
		m_hBitmapCache = NULL;
	}
}

bool CQBMPCache::IsEmpty() const
{
	bool bRetVal = CQBitmap::IsEmpty();
	return bRetVal;
}

int CQBMPCache::AlphaBlend(HDC hDC,   int nDstX, int nDstY,     int nDstWidth, int nDstHeight, 
						  int nSrcX, int nSrcY,	int nSrcWidth, int nSrcHeight, BYTE nSCA /*0xFF*/) const
{
	ASSERT(hDC != NULL);
	if(IsEmpty() || hDC == NULL)
		return GDI_ERROR;
	if(g_Painter.m_qMsImgAlphaBlend != NULL && m_hBitmapCache != NULL)
	{
		int nRetVal = GDI_ERROR;
		HDC hSrcDC  = ::CreateCompatibleDC(NULL);
		if(hSrcDC != NULL)
		{
			HGDIOBJ hOld = ::SelectObject(hSrcDC, m_hBitmapCache);
			CQPainter::CQPainterAutoPtr::BLENDFUNCTION
				_bf = {AC_SRC_OVER,  0 , nSCA, LAC_SRC_ALPHA};
			if(g_Painter.m_qMsImgAlphaBlend(hDC, nDstX, nDstY, nDstWidth, nDstHeight,
										hSrcDC, nSrcX, nSrcY, nSrcWidth, nSrcHeight, _bf))
				nRetVal =  0 ;
			::SelectObject(hSrcDC, hOld);
			::DeleteDC(hSrcDC);
		}
		return nRetVal;
	}
	return CQBitmap::AlphaBlend(hDC, nDstX, nDstY,	nDstWidth, nDstHeight, nSrcX, nSrcY,
								nSrcWidth, nSrcHeight, nSCA);
}

void CQBMPCache::OnLoad()
{
	CQBitmap::OnLoad();
	_InitCache(*this);
}

/////////////////////////////////////////////////////////////////////////////////////////////
// CQIcon::BitmapCache
CQIcon::BitmapCache::BitmapCache(HBITMAP hBitmap, COLORREF clrTransparent, LPCRECT pRectBitmapSrc, bool bCloneBitmap)
	: m_hBitmap(NULL), m_clrTransparent(RGB( 0 ,  0 ,  0 )), m_sizeBitmap( 0 ,  0 )
{
	AssignIndirect(hBitmap,	clrTransparent,	pRectBitmapSrc,	bCloneBitmap);
}

CQIcon::BitmapCache::BitmapCache(const BitmapCache& other) : m_hBitmap(NULL), m_clrTransparent(RGB( 0 ,  0 ,  0 )), m_sizeBitmap( 0 ,  0 )
{
	AssignFromOther(other);
}

CQIcon::BitmapCache::~BitmapCache()
{
	Empty();
}