mirror of
https://github.com/reactos/reactos.git
synced 2024-08-22 11:22:59 +00:00
1234 lines
38 KiB
C++
1234 lines
38 KiB
C++
// PROJECT: ReactOS ATL CImage
|
|
// LICENSE: Public Domain
|
|
// PURPOSE: Provides compatibility to Microsoft ATL
|
|
// PROGRAMMERS: Katayama Hirofumi MZ (katayama.hirofumi.mz@gmail.com)
|
|
|
|
#ifndef __ATLIMAGE_H__
|
|
#define __ATLIMAGE_H__
|
|
|
|
// !!!!
|
|
// TODO: The backend (gdi+) that this class relies on is not yet complete!
|
|
// Before that is finished, this class will not be a perfect replacement.
|
|
// See rostest/apitests/atl/CImage_WIP.txt for test results.
|
|
// !!!!
|
|
|
|
// TODO: CImage::Load, CImage::Save
|
|
// TODO: make CImage thread-safe
|
|
|
|
#pragma once
|
|
|
|
#include <atlcore.h> // for ATL Core
|
|
#include <atlstr.h> // for CAtlStringMgr
|
|
#include <atlsimpstr.h> // for CSimpleString
|
|
#include <atlsimpcoll.h> // for CSimpleArray
|
|
|
|
#include <wingdi.h>
|
|
#include <cguid.h> // for GUID_NULL
|
|
#include <gdiplus.h> // GDI+
|
|
|
|
namespace ATL
|
|
{
|
|
|
|
class CImage
|
|
{
|
|
public:
|
|
// flags for CImage::Create/CreateEx
|
|
enum
|
|
{
|
|
createAlphaChannel = 1 // enable alpha
|
|
};
|
|
|
|
// orientation of DIB
|
|
enum DIBOrientation
|
|
{
|
|
DIBOR_DEFAULT, // default
|
|
DIBOR_BOTTOMUP, // bottom-up DIB
|
|
DIBOR_TOPDOWN // top-down DIB
|
|
};
|
|
|
|
CImage() throw()
|
|
{
|
|
m_hbm = NULL;
|
|
m_hbmOld = NULL;
|
|
m_hDC = NULL;
|
|
|
|
m_eOrientation = DIBOR_DEFAULT;
|
|
m_bHasAlphaCh = false;
|
|
m_bIsDIBSec = false;
|
|
m_rgbTransColor = CLR_INVALID;
|
|
ZeroMemory(&m_ds, sizeof(m_ds));
|
|
|
|
if (GetCommon().AddRef() == 1)
|
|
{
|
|
GetCommon().LoadLib();
|
|
}
|
|
}
|
|
|
|
~CImage()
|
|
{
|
|
Destroy();
|
|
ReleaseGDIPlus();
|
|
}
|
|
|
|
operator HBITMAP()
|
|
{
|
|
return m_hbm;
|
|
}
|
|
|
|
public:
|
|
void Attach(HBITMAP hBitmap, DIBOrientation eOrientation = DIBOR_DEFAULT)
|
|
{
|
|
AttachInternal(hBitmap, eOrientation, -1);
|
|
}
|
|
|
|
HBITMAP Detach() throw()
|
|
{
|
|
m_eOrientation = DIBOR_DEFAULT;
|
|
m_bHasAlphaCh = false;
|
|
m_rgbTransColor = CLR_INVALID;
|
|
ZeroMemory(&m_ds, sizeof(m_ds));
|
|
|
|
HBITMAP hBitmap = m_hbm;
|
|
m_hbm = NULL;
|
|
return hBitmap;
|
|
}
|
|
|
|
HDC GetDC() const throw()
|
|
{
|
|
if (m_hDC)
|
|
return m_hDC;
|
|
|
|
m_hDC = ::CreateCompatibleDC(NULL);
|
|
m_hbmOld = ::SelectObject(m_hDC, m_hbm);
|
|
return m_hDC;
|
|
}
|
|
|
|
void ReleaseDC() const throw()
|
|
{
|
|
ATLASSERT(m_hDC);
|
|
|
|
if (m_hDC == NULL)
|
|
return;
|
|
|
|
if (m_hbmOld)
|
|
{
|
|
::SelectObject(m_hDC, m_hbmOld);
|
|
m_hbmOld = NULL;
|
|
}
|
|
::DeleteDC(m_hDC);
|
|
m_hDC = NULL;
|
|
}
|
|
|
|
public:
|
|
BOOL AlphaBlend(HDC hDestDC,
|
|
int xDest, int yDest, int nDestWidth, int nDestHeight,
|
|
int xSrc, int ySrc, int nSrcWidth, int nSrcHeight,
|
|
BYTE bSrcAlpha = 0xFF, BYTE bBlendOp = AC_SRC_OVER) const
|
|
{
|
|
ATLASSERT(IsTransparencySupported());
|
|
|
|
BLENDFUNCTION bf;
|
|
bf.BlendOp = bBlendOp;
|
|
bf.BlendFlags = 0;
|
|
bf.SourceConstantAlpha = bSrcAlpha;
|
|
bf.AlphaFormat = AC_SRC_ALPHA;
|
|
|
|
GetDC();
|
|
BOOL ret = ::AlphaBlend(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
m_hDC, xSrc, ySrc, nSrcWidth, nSrcHeight, bf);
|
|
ReleaseDC();
|
|
return ret;
|
|
}
|
|
BOOL AlphaBlend(HDC hDestDC, int xDest, int yDest,
|
|
BYTE bSrcAlpha = 0xFF, BYTE bBlendOp = AC_SRC_OVER) const
|
|
{
|
|
int width = GetWidth();
|
|
int height = GetHeight();
|
|
return AlphaBlend(hDestDC, xDest, yDest, width, height, 0, 0,
|
|
width, height, bSrcAlpha, bBlendOp);
|
|
}
|
|
BOOL AlphaBlend(HDC hDestDC, const POINT& pointDest,
|
|
BYTE bSrcAlpha = 0xFF, BYTE bBlendOp = AC_SRC_OVER) const
|
|
{
|
|
return AlphaBlend(hDestDC, pointDest.x, pointDest.y, bSrcAlpha, bBlendOp);
|
|
}
|
|
BOOL AlphaBlend(HDC hDestDC, const RECT& rectDest, const RECT& rectSrc,
|
|
BYTE bSrcAlpha = 0xFF, BYTE bBlendOp = AC_SRC_OVER) const
|
|
{
|
|
return AlphaBlend(hDestDC, rectDest.left, rectDest.top,
|
|
rectDest.right - rectDest.left,
|
|
rectDest.bottom - rectDest.top,
|
|
rectSrc.left, rectSrc.top,
|
|
rectSrc.right - rectSrc.left,
|
|
rectSrc.bottom - rectSrc.top,
|
|
bSrcAlpha, bBlendOp);
|
|
}
|
|
|
|
BOOL BitBlt(HDC hDestDC, int xDest, int yDest,
|
|
int nDestWidth, int nDestHeight,
|
|
int xSrc, int ySrc, DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
GetDC();
|
|
BOOL ret = ::BitBlt(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
m_hDC, xSrc, ySrc, dwROP);
|
|
ReleaseDC();
|
|
return ret;
|
|
}
|
|
BOOL BitBlt(HDC hDestDC, int xDest, int yDest,
|
|
DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
return BitBlt(hDestDC, xDest, yDest,
|
|
GetWidth(), GetHeight(), 0, 0, dwROP);
|
|
}
|
|
BOOL BitBlt(HDC hDestDC, const POINT& pointDest,
|
|
DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
return BitBlt(hDestDC, pointDest.x, pointDest.y, dwROP);
|
|
}
|
|
BOOL BitBlt(HDC hDestDC, const RECT& rectDest, const POINT& pointSrc,
|
|
DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
return BitBlt(hDestDC, rectDest.left, rectDest.top,
|
|
rectDest.right - rectDest.left,
|
|
rectDest.bottom - rectDest.top,
|
|
pointSrc.x, pointSrc.y, dwROP);
|
|
}
|
|
|
|
BOOL Create(int nWidth, int nHeight, int nBPP, DWORD dwFlags = 0) throw()
|
|
{
|
|
return CreateEx(nWidth, nHeight, nBPP, BI_RGB, NULL, dwFlags);
|
|
}
|
|
|
|
BOOL CreateEx(int nWidth, int nHeight, int nBPP, DWORD eCompression,
|
|
const DWORD* pdwBitmasks = NULL, DWORD dwFlags = 0) throw()
|
|
{
|
|
return CreateInternal(nWidth, nHeight, nBPP, eCompression, pdwBitmasks, dwFlags);
|
|
}
|
|
|
|
void Destroy() throw()
|
|
{
|
|
if (m_hbm)
|
|
{
|
|
::DeleteObject(Detach());
|
|
}
|
|
}
|
|
|
|
BOOL Draw(HDC hDestDC, int xDest, int yDest, int nDestWidth, int nDestHeight,
|
|
int xSrc, int ySrc, int nSrcWidth, int nSrcHeight) const throw()
|
|
{
|
|
ATLASSERT(IsTransparencySupported());
|
|
if (m_bHasAlphaCh)
|
|
{
|
|
return AlphaBlend(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
xSrc, ySrc, nSrcWidth, nSrcHeight);
|
|
}
|
|
else if (m_rgbTransColor != CLR_INVALID)
|
|
{
|
|
COLORREF rgb;
|
|
if ((m_rgbTransColor & 0xFF000000) == 0x01000000)
|
|
rgb = RGBFromPaletteIndex(m_rgbTransColor & 0xFF);
|
|
else
|
|
rgb = m_rgbTransColor;
|
|
return TransparentBlt(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
xSrc, ySrc, nSrcWidth, nSrcHeight, rgb);
|
|
}
|
|
else
|
|
{
|
|
return StretchBlt(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
xSrc, ySrc, nSrcWidth, nSrcHeight);
|
|
}
|
|
}
|
|
BOOL Draw(HDC hDestDC, const RECT& rectDest, const RECT& rectSrc) const throw()
|
|
{
|
|
return Draw(hDestDC, rectDest.left, rectDest.top,
|
|
rectDest.right - rectDest.left,
|
|
rectDest.bottom - rectDest.top,
|
|
rectSrc.left, rectSrc.top,
|
|
rectSrc.right - rectSrc.left,
|
|
rectSrc.bottom - rectSrc.top);
|
|
}
|
|
BOOL Draw(HDC hDestDC, int xDest, int yDest) const throw()
|
|
{
|
|
return Draw(hDestDC, xDest, yDest, GetWidth(), GetHeight());
|
|
}
|
|
BOOL Draw(HDC hDestDC, const POINT& pointDest) const throw()
|
|
{
|
|
return Draw(hDestDC, pointDest.x, pointDest.y);
|
|
}
|
|
BOOL Draw(HDC hDestDC, int xDest, int yDest,
|
|
int nDestWidth, int nDestHeight) const throw()
|
|
{
|
|
return Draw(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
0, 0, GetWidth(), GetHeight());
|
|
}
|
|
BOOL Draw(HDC hDestDC, const RECT& rectDest) const throw()
|
|
{
|
|
return Draw(hDestDC, rectDest.left, rectDest.top,
|
|
rectDest.right - rectDest.left,
|
|
rectDest.bottom - rectDest.top);
|
|
}
|
|
|
|
void *GetBits() throw()
|
|
{
|
|
ATLASSERT(IsDIBSection());
|
|
BYTE *pb = (BYTE *)m_bm.bmBits;
|
|
if (m_eOrientation == DIBOR_BOTTOMUP)
|
|
{
|
|
pb += m_bm.bmWidthBytes * (m_bm.bmHeight - 1);
|
|
}
|
|
return pb;
|
|
}
|
|
|
|
int GetBPP() const throw()
|
|
{
|
|
ATLASSERT(m_hbm);
|
|
return m_bm.bmBitsPixel;
|
|
}
|
|
|
|
void GetColorTable(UINT iFirstColor, UINT nColors,
|
|
RGBQUAD* prgbColors) const throw()
|
|
{
|
|
ATLASSERT(IsDIBSection());
|
|
GetDC();
|
|
::GetDIBColorTable(m_hDC, iFirstColor, nColors, prgbColors);
|
|
ReleaseDC();
|
|
}
|
|
|
|
int GetHeight() const throw()
|
|
{
|
|
ATLASSERT(m_hbm);
|
|
return m_bm.bmHeight;
|
|
}
|
|
|
|
int GetMaxColorTableEntries() const throw()
|
|
{
|
|
ATLASSERT(IsDIBSection());
|
|
if (m_ds.dsBmih.biClrUsed && m_ds.dsBmih.biBitCount < 16)
|
|
return m_ds.dsBmih.biClrUsed;
|
|
switch (m_bm.bmBitsPixel)
|
|
{
|
|
case 1: return 2;
|
|
case 4: return 16;
|
|
case 8: return 256;
|
|
case 16: case 32:
|
|
if (m_ds.dsBmih.biCompression == BI_BITFIELDS)
|
|
return 3;
|
|
return 0;
|
|
case 24:
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int GetPitch() const throw()
|
|
{
|
|
ATLASSERT(IsDIBSection());
|
|
if (m_eOrientation == DIBOR_BOTTOMUP)
|
|
return -m_bm.bmWidthBytes;
|
|
else
|
|
return m_bm.bmWidthBytes;
|
|
}
|
|
|
|
COLORREF GetPixel(int x, int y) const throw()
|
|
{
|
|
GetDC();
|
|
COLORREF ret = ::GetPixel(m_hDC, x, y);
|
|
ReleaseDC();
|
|
return ret;
|
|
}
|
|
|
|
void* GetPixelAddress(int x, int y) throw()
|
|
{
|
|
ATLASSERT(IsDIBSection());
|
|
BYTE *pb = (BYTE *)GetBits();
|
|
pb += GetPitch() * y;
|
|
pb += (GetBPP() * x) / 8;
|
|
return pb;
|
|
}
|
|
|
|
COLORREF GetTransparentColor() const throw()
|
|
{
|
|
return m_rgbTransColor;
|
|
}
|
|
|
|
int GetWidth() const throw()
|
|
{
|
|
ATLASSERT(m_hbm);
|
|
return m_bm.bmWidth;
|
|
}
|
|
|
|
bool IsDIBSection() const throw()
|
|
{
|
|
ATLASSERT(m_hbm);
|
|
return m_bIsDIBSec;
|
|
}
|
|
|
|
bool IsIndexed() const throw()
|
|
{
|
|
ATLASSERT(IsDIBSection());
|
|
return GetBPP() <= 8;
|
|
}
|
|
|
|
bool IsNull() const throw()
|
|
{
|
|
return m_hbm == NULL;
|
|
}
|
|
|
|
HRESULT Load(LPCTSTR pszFileName) throw()
|
|
{
|
|
// convert the file name string into Unicode
|
|
// TODO: use a string class
|
|
#ifdef UNICODE
|
|
LPCWSTR pszNameW = pszFileName;
|
|
#else
|
|
WCHAR szPath[MAX_PATH];
|
|
::MultiByteToWideChar(CP_ACP, 0, pszFileName, -1, szPath, MAX_PATH);
|
|
LPCWSTR pszNameW = szPath;
|
|
#endif
|
|
|
|
// create a GpBitmap object from file
|
|
using namespace Gdiplus;
|
|
GpBitmap *pBitmap = NULL;
|
|
GetCommon().CreateBitmapFromFile(pszNameW, &pBitmap);
|
|
ATLASSERT(pBitmap);
|
|
|
|
// TODO & FIXME: get parameters (m_rgbTransColor etc.)
|
|
|
|
// get bitmap handle
|
|
HBITMAP hbm = NULL;
|
|
Color color(0xFF, 0xFF, 0xFF);
|
|
Gdiplus::Status status;
|
|
status = GetCommon().CreateHBITMAPFromBitmap(
|
|
pBitmap, &hbm, color.GetValue());
|
|
|
|
// delete GpBitmap
|
|
GetCommon().DisposeImage(pBitmap);
|
|
|
|
// attach it
|
|
if (status == Ok)
|
|
Attach(hbm);
|
|
return (status == Ok ? S_OK : E_FAIL);
|
|
}
|
|
HRESULT Load(IStream* pStream) throw()
|
|
{
|
|
// create GpBitmap from stream
|
|
using namespace Gdiplus;
|
|
GpBitmap *pBitmap = NULL;
|
|
GetCommon().CreateBitmapFromStream(pStream, &pBitmap);
|
|
ATLASSERT(pBitmap);
|
|
|
|
// TODO & FIXME: get parameters (m_rgbTransColor etc.)
|
|
|
|
// get bitmap handle
|
|
HBITMAP hbm = NULL;
|
|
Color color(0xFF, 0xFF, 0xFF);
|
|
Gdiplus::Status status;
|
|
status = GetCommon().CreateHBITMAPFromBitmap(
|
|
pBitmap, &hbm, color.GetValue());
|
|
|
|
// delete Bitmap
|
|
GetCommon().DisposeImage(pBitmap);
|
|
|
|
// attach it
|
|
if (status == Ok)
|
|
Attach(hbm);
|
|
return (status == Ok ? S_OK : E_FAIL);
|
|
}
|
|
|
|
// NOTE: LoadFromResource loads BITMAP resource only
|
|
void LoadFromResource(HINSTANCE hInstance, LPCTSTR pszResourceName) throw()
|
|
{
|
|
HANDLE hHandle = ::LoadImage(hInstance, pszResourceName,
|
|
IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
|
|
Attach(reinterpret_cast<HBITMAP>(hHandle));
|
|
}
|
|
void LoadFromResource(HINSTANCE hInstance, UINT nIDResource) throw()
|
|
{
|
|
LoadFromResource(hInstance, MAKEINTRESOURCE(nIDResource));
|
|
}
|
|
|
|
BOOL MaskBlt(HDC hDestDC, int xDest, int yDest,
|
|
int nDestWidth, int nDestHeight, int xSrc, int ySrc,
|
|
HBITMAP hbmMask, int xMask, int yMask,
|
|
DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
ATLASSERT(IsTransparencySupported());
|
|
GetDC();
|
|
BOOL ret = ::MaskBlt(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
m_hDC, xSrc, ySrc,
|
|
hbmMask, xMask, yMask, dwROP);
|
|
ReleaseDC();
|
|
return ret;
|
|
}
|
|
BOOL MaskBlt(HDC hDestDC, const RECT& rectDest, const POINT& pointSrc,
|
|
HBITMAP hbmMask, const POINT& pointMask,
|
|
DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
return MaskBlt(hDestDC, rectDest.left, rectDest.top,
|
|
rectDest.right - rectDest.left, rectDest.bottom - rectDest.top,
|
|
pointSrc.x, pointSrc.y, hbmMask, pointMask.x, pointMask.y, dwROP);
|
|
}
|
|
BOOL MaskBlt(HDC hDestDC, int xDest, int yDest,
|
|
HBITMAP hbmMask, DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
return MaskBlt(hDestDC, xDest, yDest, GetWidth(), GetHeight(),
|
|
0, 0, hbmMask, 0, 0, dwROP);
|
|
}
|
|
BOOL MaskBlt(HDC hDestDC, const POINT& pointDest,
|
|
HBITMAP hbmMask, DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
return MaskBlt(hDestDC, pointDest.x, pointDest.y, hbmMask, dwROP);
|
|
}
|
|
|
|
BOOL PlgBlt(HDC hDestDC, const POINT* pPoints,
|
|
int xSrc, int ySrc, int nSrcWidth, int nSrcHeight,
|
|
HBITMAP hbmMask = NULL,
|
|
int xMask = 0, int yMask = 0) const throw()
|
|
{
|
|
ATLASSERT(IsTransparencySupported());
|
|
GetDC();
|
|
BOOL ret = ::PlgBlt(hDestDC, pPoints, m_hDC,
|
|
xSrc, ySrc, nSrcWidth, nSrcHeight,
|
|
hbmMask, xMask, yMask);
|
|
ReleaseDC();
|
|
return ret;
|
|
}
|
|
BOOL PlgBlt(HDC hDestDC, const POINT* pPoints,
|
|
HBITMAP hbmMask = NULL) const throw()
|
|
{
|
|
return PlgBlt(hDestDC, pPoints, 0, 0, GetWidth(), GetHeight(),
|
|
hbmMask);
|
|
}
|
|
BOOL PlgBlt(HDC hDestDC, const POINT* pPoints, const RECT& rectSrc,
|
|
HBITMAP hbmMask, const POINT& pointMask) const throw()
|
|
{
|
|
return PlgBlt(hDestDC, pPoints, rectSrc.left, rectSrc.top,
|
|
rectSrc.right - rectSrc.left, rectSrc.bottom - rectSrc.top,
|
|
hbmMask, pointMask.x, pointMask.y);
|
|
}
|
|
BOOL PlgBlt(HDC hDestDC, const POINT* pPoints, const RECT& rectSrc,
|
|
HBITMAP hbmMask = NULL) const throw()
|
|
{
|
|
POINT pointMask = {0, 0};
|
|
return PlgBlt(hDestDC, pPoints, rectSrc, hbmMask, pointMask);
|
|
}
|
|
|
|
void ReleaseGDIPlus() throw()
|
|
{
|
|
COMMON*& pCommon = GetCommonPtr();
|
|
if (pCommon && pCommon->Release() == 0)
|
|
{
|
|
delete pCommon;
|
|
pCommon = NULL;
|
|
}
|
|
}
|
|
|
|
HRESULT Save(IStream* pStream, GUID *guidFileType) const throw()
|
|
{
|
|
using namespace Gdiplus;
|
|
ATLASSERT(m_hbm);
|
|
|
|
// TODO & FIXME: set parameters (m_rgbTransColor etc.)
|
|
CLSID clsid;
|
|
if (!GetClsidFromFileType(&clsid, guidFileType))
|
|
return E_FAIL;
|
|
|
|
// create a GpBitmap from HBITMAP
|
|
GpBitmap *pBitmap = NULL;
|
|
GetCommon().CreateBitmapFromHBITMAP(m_hbm, NULL, &pBitmap);
|
|
|
|
// save to stream
|
|
Status status;
|
|
status = GetCommon().SaveImageToStream(pBitmap, pStream, &clsid, NULL);
|
|
|
|
// destroy GpBitmap
|
|
GetCommon().DisposeImage(pBitmap);
|
|
|
|
return (status == Ok ? S_OK : E_FAIL);
|
|
}
|
|
HRESULT Save(LPCTSTR pszFileName,
|
|
REFGUID guidFileType = GUID_NULL) const throw()
|
|
{
|
|
using namespace Gdiplus;
|
|
ATLASSERT(m_hbm);
|
|
|
|
// TODO & FIXME: set parameters (m_rgbTransColor etc.)
|
|
|
|
// convert the file name string into Unicode
|
|
// TODO: use a string class
|
|
#ifdef UNICODE
|
|
LPCWSTR pszNameW = pszFileName;
|
|
#else
|
|
WCHAR szPath[MAX_PATH];
|
|
::MultiByteToWideChar(CP_ACP, 0, pszFileName, -1, szPath, MAX_PATH);
|
|
LPCWSTR pszNameW = szPath;
|
|
#endif
|
|
|
|
// if the file type is null, get the file type from extension
|
|
const GUID *FileType = &guidFileType;
|
|
if (IsGuidEqual(guidFileType, GUID_NULL))
|
|
{
|
|
LPCWSTR pszExt = GetFileExtension(pszNameW);
|
|
FileType = FileTypeFromExtension(pszExt);
|
|
}
|
|
|
|
// get CLSID from file type
|
|
CLSID clsid;
|
|
if (!GetClsidFromFileType(&clsid, FileType))
|
|
return E_FAIL;
|
|
|
|
// create a GpBitmap from HBITMAP
|
|
GpBitmap *pBitmap = NULL;
|
|
GetCommon().CreateBitmapFromHBITMAP(m_hbm, NULL, &pBitmap);
|
|
|
|
// save to file
|
|
Status status;
|
|
status = GetCommon().SaveImageToFile(pBitmap, pszNameW, &clsid, NULL);
|
|
|
|
// destroy GpBitmap
|
|
GetCommon().DisposeImage(pBitmap);
|
|
|
|
return (status == Ok ? S_OK : E_FAIL);
|
|
}
|
|
|
|
void SetColorTable(UINT iFirstColor, UINT nColors,
|
|
const RGBQUAD* prgbColors) throw()
|
|
{
|
|
ATLASSERT(IsDIBSection());
|
|
GetDC();
|
|
::SetDIBColorTable(m_hDC, iFirstColor, nColors, prgbColors);
|
|
ReleaseDC();
|
|
}
|
|
|
|
void SetPixel(int x, int y, COLORREF color) throw()
|
|
{
|
|
GetDC();
|
|
::SetPixelV(m_hDC, x, y, color);
|
|
ReleaseDC();
|
|
}
|
|
|
|
void SetPixelIndexed(int x, int y, int iIndex) throw()
|
|
{
|
|
ATLASSERT(IsIndexed());
|
|
GetDC();
|
|
::SetPixelV(m_hDC, x, y, PALETTEINDEX(iIndex));
|
|
ReleaseDC();
|
|
}
|
|
|
|
void SetPixelRGB(int x, int y, BYTE r, BYTE g, BYTE b) throw()
|
|
{
|
|
SetPixel(x, y, RGB(r, g, b));
|
|
}
|
|
|
|
COLORREF SetTransparentColor(COLORREF rgbTransparent) throw()
|
|
{
|
|
ATLASSERT(m_hbm);
|
|
COLORREF rgbOldColor = m_rgbTransColor;
|
|
m_rgbTransColor = rgbTransparent;
|
|
return rgbOldColor;
|
|
}
|
|
|
|
BOOL StretchBlt(HDC hDestDC, int xDest, int yDest,
|
|
int nDestWidth, int nDestHeight,
|
|
int xSrc, int ySrc, int nSrcWidth, int nSrcHeight,
|
|
DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
GetDC();
|
|
BOOL ret = ::StretchBlt(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
m_hDC, xSrc, ySrc, nSrcWidth, nSrcHeight, dwROP);
|
|
ReleaseDC();
|
|
return ret;
|
|
}
|
|
BOOL StretchBlt(HDC hDestDC, int xDest, int yDest,
|
|
int nDestWidth, int nDestHeight,
|
|
DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
return StretchBlt(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
0, 0, GetWidth(), GetHeight(), dwROP);
|
|
}
|
|
BOOL StretchBlt(HDC hDestDC, const RECT& rectDest,
|
|
DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
return StretchBlt(hDestDC, rectDest.left, rectDest.top,
|
|
rectDest.right - rectDest.left,
|
|
rectDest.bottom - rectDest.top, dwROP);
|
|
}
|
|
BOOL StretchBlt(HDC hDestDC, const RECT& rectDest,
|
|
const RECT& rectSrc, DWORD dwROP = SRCCOPY) const throw()
|
|
{
|
|
return StretchBlt(hDestDC, rectDest.left, rectDest.top,
|
|
rectDest.right - rectDest.left,
|
|
rectDest.bottom - rectDest.top,
|
|
rectSrc.left, rectSrc.top,
|
|
rectSrc.right - rectSrc.left,
|
|
rectSrc.bottom - rectSrc.top, dwROP);
|
|
}
|
|
|
|
BOOL TransparentBlt(HDC hDestDC, int xDest, int yDest,
|
|
int nDestWidth, int nDestHeight,
|
|
int xSrc, int ySrc, int nSrcWidth, int nSrcHeight,
|
|
UINT crTransparent = CLR_INVALID) const throw()
|
|
{
|
|
ATLASSERT(IsTransparencySupported());
|
|
GetDC();
|
|
BOOL ret = ::TransparentBlt(hDestDC, xDest, yDest,
|
|
nDestWidth, nDestHeight,
|
|
m_hDC, xSrc, ySrc,
|
|
nSrcWidth, nSrcHeight, crTransparent);
|
|
ReleaseDC();
|
|
return ret;
|
|
}
|
|
BOOL TransparentBlt(HDC hDestDC, int xDest, int yDest,
|
|
int nDestWidth, int nDestHeight,
|
|
UINT crTransparent = CLR_INVALID) const throw()
|
|
{
|
|
return TransparentBlt(hDestDC, xDest, yDest, nDestWidth, nDestHeight,
|
|
0, 0, GetWidth(), GetHeight(), crTransparent);
|
|
}
|
|
BOOL TransparentBlt(HDC hDestDC, const RECT& rectDest,
|
|
UINT crTransparent = CLR_INVALID) const throw()
|
|
{
|
|
return TransparentBlt(hDestDC, rectDest.left, rectDest.top,
|
|
rectDest.right - rectDest.left,
|
|
rectDest.bottom - rectDest.top, crTransparent);
|
|
}
|
|
BOOL TransparentBlt(
|
|
HDC hDestDC, const RECT& rectDest,
|
|
const RECT& rectSrc, UINT crTransparent = CLR_INVALID) const throw()
|
|
{
|
|
return TransparentBlt(hDestDC, rectDest.left, rectDest.top,
|
|
rectDest.right - rectDest.left, rectDest.bottom - rectDest.left,
|
|
rectSrc.left, rectSrc.top, rectSrc.right - rectSrc.left,
|
|
rectSrc.bottom - rectSrc.top, crTransparent);
|
|
}
|
|
|
|
public:
|
|
static BOOL IsTransparencySupported() throw()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
enum ExcludeFlags
|
|
{
|
|
excludeGIF = 0x01,
|
|
excludeBMP = 0x02,
|
|
excludeEMF = 0x04,
|
|
excludeWMF = 0x08,
|
|
excludeJPEG = 0x10,
|
|
excludePNG = 0x20,
|
|
excludeTIFF = 0x40,
|
|
excludeIcon = 0x80,
|
|
excludeOther = 0x80000000,
|
|
excludeDefaultLoad = 0,
|
|
excludeDefaultSave = excludeIcon | excludeEMF | excludeWMF
|
|
};
|
|
|
|
struct FILTER_DATA {
|
|
DWORD dwExclude;
|
|
const TCHAR *title;
|
|
const TCHAR *extensions;
|
|
const GUID *guid;
|
|
};
|
|
|
|
protected:
|
|
static HRESULT GetCommonFilterString(
|
|
CSimpleString& strFilter,
|
|
CSimpleArray<GUID>& aguidFileTypes,
|
|
LPCTSTR pszAllFilesDescription,
|
|
DWORD dwExclude,
|
|
TCHAR chSeparator)
|
|
{
|
|
static const FILTER_DATA table[] =
|
|
{
|
|
{excludeBMP, TEXT("BMP"), TEXT("*.BMP;*.DIB;*.RLE"), &Gdiplus::ImageFormatBMP},
|
|
{excludeJPEG, TEXT("JPEG"), TEXT("*.JPG;*.JPEG;*.JPE;*.JFIF"), &Gdiplus::ImageFormatJPEG},
|
|
{excludeGIF, TEXT("GIF"), TEXT("*.GIF"), &Gdiplus::ImageFormatGIF},
|
|
{excludeEMF, TEXT("EMF"), TEXT("*.EMF"), &Gdiplus::ImageFormatEMF},
|
|
{excludeWMF, TEXT("WMF"), TEXT("*.WMF"), &Gdiplus::ImageFormatWMF},
|
|
{excludeTIFF, TEXT("TIFF"), TEXT("*.TIF;*.TIFF"), &Gdiplus::ImageFormatTIFF},
|
|
{excludePNG, TEXT("PNG"), TEXT("*.PNG"), &Gdiplus::ImageFormatPNG},
|
|
{excludeIcon, TEXT("ICO"), TEXT("*.ICO"), &Gdiplus::ImageFormatIcon}
|
|
};
|
|
|
|
if (pszAllFilesDescription)
|
|
{
|
|
strFilter += pszAllFilesDescription;
|
|
strFilter += chSeparator;
|
|
|
|
BOOL bFirst = TRUE;
|
|
for (size_t i = 0; i < _countof(table); ++i)
|
|
{
|
|
if ((dwExclude & table[i].dwExclude) != 0)
|
|
continue;
|
|
|
|
if (bFirst)
|
|
bFirst = FALSE;
|
|
else
|
|
strFilter += TEXT(';');
|
|
|
|
strFilter += table[i].extensions;
|
|
}
|
|
strFilter += chSeparator;
|
|
|
|
aguidFileTypes.Add(GUID_NULL);
|
|
}
|
|
|
|
for (size_t i = 0; i < _countof(table); ++i)
|
|
{
|
|
if ((dwExclude & table[i].dwExclude) != 0)
|
|
continue;
|
|
strFilter += table[i].title;
|
|
strFilter += TEXT(" (");
|
|
strFilter += table[i].extensions;
|
|
strFilter += TEXT(")");
|
|
strFilter += chSeparator;
|
|
strFilter += table[i].extensions;
|
|
strFilter += chSeparator;
|
|
|
|
aguidFileTypes.Add(*table[i].guid);
|
|
}
|
|
|
|
strFilter += chSeparator;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
public:
|
|
static HRESULT GetImporterFilterString(
|
|
CSimpleString& strImporters,
|
|
CSimpleArray<GUID>& aguidFileTypes,
|
|
LPCTSTR pszAllFilesDescription = NULL,
|
|
DWORD dwExclude = excludeDefaultLoad,
|
|
TCHAR chSeparator = TEXT('|'))
|
|
{
|
|
return GetCommonFilterString(strImporters,
|
|
aguidFileTypes,
|
|
pszAllFilesDescription,
|
|
dwExclude,
|
|
chSeparator);
|
|
}
|
|
|
|
static HRESULT GetExporterFilterString(
|
|
CSimpleString& strExporters,
|
|
CSimpleArray<GUID>& aguidFileTypes,
|
|
LPCTSTR pszAllFilesDescription = NULL,
|
|
DWORD dwExclude = excludeDefaultSave,
|
|
TCHAR chSeparator = TEXT('|'))
|
|
{
|
|
return GetCommonFilterString(strExporters,
|
|
aguidFileTypes,
|
|
pszAllFilesDescription,
|
|
dwExclude,
|
|
chSeparator);
|
|
}
|
|
|
|
protected:
|
|
// an extension of BITMAPINFO
|
|
struct MYBITMAPINFOEX
|
|
{
|
|
BITMAPINFOHEADER bmiHeader;
|
|
RGBQUAD bmiColors[256];
|
|
BITMAPINFO *get()
|
|
{
|
|
return reinterpret_cast<BITMAPINFO *>(this);
|
|
}
|
|
const BITMAPINFO *get() const
|
|
{
|
|
return reinterpret_cast<const BITMAPINFO *>(this);
|
|
}
|
|
};
|
|
|
|
// The common data of atlimage
|
|
struct COMMON
|
|
{
|
|
// abbreviations of GDI+ basic types
|
|
typedef Gdiplus::GpStatus St;
|
|
typedef Gdiplus::ImageCodecInfo ICI;
|
|
typedef Gdiplus::GpBitmap Bm;
|
|
typedef Gdiplus::EncoderParameters EncParams;
|
|
typedef Gdiplus::GpImage Im;
|
|
typedef Gdiplus::ARGB ARGB;
|
|
typedef HBITMAP HBM;
|
|
typedef Gdiplus::GdiplusStartupInput GSI;
|
|
typedef Gdiplus::GdiplusStartupOutput GSO;
|
|
|
|
// GDI+ function types
|
|
#undef API
|
|
#undef CST
|
|
#define API WINGDIPAPI
|
|
#define CST GDIPCONST
|
|
typedef St (WINAPI *STARTUP)(ULONG_PTR *, const GSI *, GSO *);
|
|
typedef void (WINAPI *SHUTDOWN)(ULONG_PTR);
|
|
typedef St (API *GETIMAGEENCODERSSIZE)(UINT *, UINT *);
|
|
typedef St (API *GETIMAGEENCODERS)(UINT, UINT, ICI *);
|
|
typedef St (API *CREATEBITMAPFROMFILE)(CST WCHAR*, Bm **);
|
|
typedef St (API *CREATEHBITMAPFROMBITMAP)(Bm *, HBM *, ARGB);
|
|
typedef St (API *CREATEBITMAPFROMSTREAM)(IStream *, Bm **);
|
|
typedef St (API *CREATEBITMAPFROMHBITMAP)(HBM, HPALETTE, Bm **);
|
|
typedef St (API *SAVEIMAGETOSTREAM)(Im *, IStream *, CST CLSID *,
|
|
CST EncParams *);
|
|
typedef St (API *SAVEIMAGETOFILE)(Im *, CST WCHAR *, CST CLSID *,
|
|
CST EncParams *);
|
|
typedef St (API *DISPOSEIMAGE)(Im*);
|
|
#undef API
|
|
#undef CST
|
|
|
|
// members
|
|
int count;
|
|
HINSTANCE hinstGdiPlus;
|
|
ULONG_PTR gdiplusToken;
|
|
|
|
// GDI+ functions
|
|
STARTUP Startup;
|
|
SHUTDOWN Shutdown;
|
|
GETIMAGEENCODERSSIZE GetImageEncodersSize;
|
|
GETIMAGEENCODERS GetImageEncoders;
|
|
CREATEBITMAPFROMFILE CreateBitmapFromFile;
|
|
CREATEHBITMAPFROMBITMAP CreateHBITMAPFromBitmap;
|
|
CREATEBITMAPFROMSTREAM CreateBitmapFromStream;
|
|
CREATEBITMAPFROMHBITMAP CreateBitmapFromHBITMAP;
|
|
SAVEIMAGETOSTREAM SaveImageToStream;
|
|
SAVEIMAGETOFILE SaveImageToFile;
|
|
DISPOSEIMAGE DisposeImage;
|
|
|
|
COMMON()
|
|
{
|
|
count = 0;
|
|
hinstGdiPlus = NULL;
|
|
Startup = NULL;
|
|
Shutdown = NULL;
|
|
GetImageEncodersSize = NULL;
|
|
GetImageEncoders = NULL;
|
|
CreateBitmapFromFile = NULL;
|
|
CreateHBITMAPFromBitmap = NULL;
|
|
CreateBitmapFromStream = NULL;
|
|
CreateBitmapFromHBITMAP = NULL;
|
|
SaveImageToStream = NULL;
|
|
SaveImageToFile = NULL;
|
|
DisposeImage = NULL;
|
|
}
|
|
~COMMON()
|
|
{
|
|
FreeLib();
|
|
}
|
|
|
|
ULONG AddRef()
|
|
{
|
|
return ++count;
|
|
}
|
|
ULONG Release()
|
|
{
|
|
return --count;
|
|
}
|
|
|
|
// get procedure address of the DLL
|
|
template <typename TYPE>
|
|
TYPE AddrOf(const char *name)
|
|
{
|
|
FARPROC proc = ::GetProcAddress(hinstGdiPlus, name);
|
|
return reinterpret_cast<TYPE>(proc);
|
|
}
|
|
|
|
HINSTANCE LoadLib()
|
|
{
|
|
if (hinstGdiPlus)
|
|
return hinstGdiPlus;
|
|
|
|
hinstGdiPlus = ::LoadLibraryA("gdiplus.dll");
|
|
|
|
// get procedure addresses from the DLL
|
|
Startup = AddrOf<STARTUP>("GdiplusStartup");
|
|
Shutdown = AddrOf<SHUTDOWN>("GdiplusShutdown");
|
|
GetImageEncodersSize =
|
|
AddrOf<GETIMAGEENCODERSSIZE>("GdipGetImageEncodersSize");
|
|
GetImageEncoders = AddrOf<GETIMAGEENCODERS>("GdipGetImageEncoders");
|
|
CreateBitmapFromFile =
|
|
AddrOf<CREATEBITMAPFROMFILE>("GdipCreateBitmapFromFile");
|
|
CreateHBITMAPFromBitmap =
|
|
AddrOf<CREATEHBITMAPFROMBITMAP>("GdipCreateHBITMAPFromBitmap");
|
|
CreateBitmapFromStream =
|
|
AddrOf<CREATEBITMAPFROMSTREAM>("GdipCreateBitmapFromStream");
|
|
CreateBitmapFromHBITMAP =
|
|
AddrOf<CREATEBITMAPFROMHBITMAP>("GdipCreateBitmapFromHBITMAP");
|
|
SaveImageToStream =
|
|
AddrOf<SAVEIMAGETOSTREAM>("GdipSaveImageToStream");
|
|
SaveImageToFile = AddrOf<SAVEIMAGETOFILE>("GdipSaveImageToFile");
|
|
DisposeImage = AddrOf<DISPOSEIMAGE>("GdipDisposeImage");
|
|
|
|
if (hinstGdiPlus && Startup)
|
|
{
|
|
Gdiplus::GdiplusStartupInput gdiplusStartupInput;
|
|
Startup(&gdiplusToken, &gdiplusStartupInput, NULL);
|
|
}
|
|
|
|
return hinstGdiPlus;
|
|
}
|
|
void FreeLib()
|
|
{
|
|
if (hinstGdiPlus)
|
|
{
|
|
Shutdown(gdiplusToken);
|
|
|
|
Startup = NULL;
|
|
Shutdown = NULL;
|
|
GetImageEncodersSize = NULL;
|
|
GetImageEncoders = NULL;
|
|
CreateBitmapFromFile = NULL;
|
|
CreateHBITMAPFromBitmap = NULL;
|
|
CreateBitmapFromStream = NULL;
|
|
CreateBitmapFromHBITMAP = NULL;
|
|
SaveImageToStream = NULL;
|
|
SaveImageToFile = NULL;
|
|
DisposeImage = NULL;
|
|
::FreeLibrary(hinstGdiPlus);
|
|
hinstGdiPlus = NULL;
|
|
}
|
|
}
|
|
}; // struct COMMON
|
|
|
|
static COMMON*& GetCommonPtr()
|
|
{
|
|
static COMMON *s_pCommon = NULL;
|
|
return s_pCommon;
|
|
}
|
|
|
|
static COMMON& GetCommon()
|
|
{
|
|
COMMON*& pCommon = GetCommonPtr();
|
|
if (pCommon == NULL)
|
|
pCommon = new COMMON;
|
|
return *pCommon;
|
|
}
|
|
|
|
protected:
|
|
HBITMAP m_hbm;
|
|
mutable HGDIOBJ m_hbmOld;
|
|
mutable HDC m_hDC;
|
|
DIBOrientation m_eOrientation;
|
|
bool m_bHasAlphaCh;
|
|
bool m_bIsDIBSec;
|
|
COLORREF m_rgbTransColor;
|
|
union
|
|
{
|
|
BITMAP m_bm;
|
|
DIBSECTION m_ds;
|
|
};
|
|
|
|
LPCWSTR GetFileExtension(LPCWSTR pszFileName) const
|
|
{
|
|
LPCWSTR pch = wcsrchr(pszFileName, L'\\');
|
|
if (pch == NULL)
|
|
pch = wcsrchr(pszFileName, L'/');
|
|
pch = (pch ? wcsrchr(pch, L'.') : wcsrchr(pszFileName, L'.'));
|
|
return (pch ? pch : (pszFileName + ::lstrlenW(pszFileName)));
|
|
}
|
|
|
|
COLORREF RGBFromPaletteIndex(int iIndex) const
|
|
{
|
|
RGBQUAD table[256];
|
|
GetColorTable(0, 256, table);
|
|
RGBQUAD& quad = table[iIndex];
|
|
return RGB(quad.rgbRed, quad.rgbGreen, quad.rgbBlue);
|
|
}
|
|
|
|
struct EXTENSION_ENTRY
|
|
{
|
|
LPCWSTR pszExt;
|
|
GUID guid;
|
|
};
|
|
|
|
const GUID *FileTypeFromExtension(LPCWSTR pszExt) const
|
|
{
|
|
static const EXTENSION_ENTRY table[] =
|
|
{
|
|
{L".jpg", Gdiplus::ImageFormatJPEG},
|
|
{L".png", Gdiplus::ImageFormatPNG},
|
|
{L".bmp", Gdiplus::ImageFormatBMP},
|
|
{L".gif", Gdiplus::ImageFormatGIF},
|
|
{L".tif", Gdiplus::ImageFormatTIFF},
|
|
{L".jpeg", Gdiplus::ImageFormatJPEG},
|
|
{L".jpe", Gdiplus::ImageFormatJPEG},
|
|
{L".jfif", Gdiplus::ImageFormatJPEG},
|
|
{L".dib", Gdiplus::ImageFormatBMP},
|
|
{L".rle", Gdiplus::ImageFormatBMP},
|
|
{L".tiff", Gdiplus::ImageFormatTIFF}
|
|
};
|
|
const size_t count = _countof(table);
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
if (::lstrcmpiW(table[i].pszExt, pszExt) == 0)
|
|
return &table[i].guid;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
struct FORMAT_ENTRY
|
|
{
|
|
GUID guid;
|
|
LPCWSTR mime;
|
|
};
|
|
|
|
bool GetClsidFromFileType(CLSID *clsid, const GUID *guid) const
|
|
{
|
|
static const FORMAT_ENTRY table[] =
|
|
{
|
|
{Gdiplus::ImageFormatJPEG, L"image/jpeg"},
|
|
{Gdiplus::ImageFormatPNG, L"image/png"},
|
|
{Gdiplus::ImageFormatBMP, L"image/bmp"},
|
|
{Gdiplus::ImageFormatGIF, L"image/gif"},
|
|
{Gdiplus::ImageFormatTIFF, L"image/tiff"}
|
|
};
|
|
const size_t count = _countof(table);
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
if (IsGuidEqual(table[i].guid, *guid))
|
|
{
|
|
int num = GetEncoderClsid(table[i].mime, clsid);
|
|
if (num >= 0)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int GetEncoderClsid(LPCWSTR mime, CLSID *clsid) const
|
|
{
|
|
UINT count = 0, total_size = 0;
|
|
GetCommon().GetImageEncodersSize(&count, &total_size);
|
|
if (total_size == 0)
|
|
return -1; // failure
|
|
|
|
Gdiplus::ImageCodecInfo *pInfo;
|
|
BYTE *pb = new BYTE[total_size];
|
|
ATLASSERT(pb);
|
|
pInfo = reinterpret_cast<Gdiplus::ImageCodecInfo *>(pb);
|
|
if (pInfo == NULL)
|
|
return -1; // failure
|
|
|
|
GetCommon().GetImageEncoders(count, total_size, pInfo);
|
|
|
|
for (UINT iInfo = 0; iInfo < count; ++iInfo)
|
|
{
|
|
if (::lstrcmpiW(pInfo[iInfo].MimeType, mime) == 0)
|
|
{
|
|
*clsid = pInfo[iInfo].Clsid;
|
|
delete[] pb;
|
|
return iInfo; // success
|
|
}
|
|
}
|
|
|
|
delete[] pb;
|
|
return -1; // failure
|
|
}
|
|
|
|
bool IsGuidEqual(const GUID& guid1, const GUID& guid2) const
|
|
{
|
|
RPC_STATUS status;
|
|
if (::UuidEqual(const_cast<GUID *>(&guid1),
|
|
const_cast<GUID *>(&guid2), &status))
|
|
{
|
|
if (status == RPC_S_OK)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void AttachInternal(HBITMAP hBitmap, DIBOrientation eOrientation,
|
|
LONG iTransColor)
|
|
{
|
|
Destroy();
|
|
|
|
const int size = sizeof(DIBSECTION);
|
|
m_bIsDIBSec = (::GetObject(hBitmap, size, &m_ds) == size);
|
|
|
|
bool bOK = (::GetObject(hBitmap, sizeof(BITMAP), &m_bm) != 0);
|
|
|
|
if (bOK)
|
|
{
|
|
m_hbm = hBitmap;
|
|
m_eOrientation = eOrientation;
|
|
m_bHasAlphaCh = (m_bm.bmBitsPixel == 32);
|
|
m_rgbTransColor = CLR_INVALID;
|
|
}
|
|
}
|
|
|
|
BOOL CreateInternal(int nWidth, int nHeight, int nBPP,
|
|
DWORD eCompression, const DWORD* pdwBitmasks = NULL,
|
|
DWORD dwFlags = 0) throw()
|
|
{
|
|
ATLASSERT(nWidth != 0);
|
|
ATLASSERT(nHeight != 0);
|
|
|
|
// initialize BITMAPINFO extension
|
|
MYBITMAPINFOEX bi;
|
|
ZeroMemory(&bi, sizeof(bi));
|
|
bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
bi.bmiHeader.biWidth = nWidth;
|
|
bi.bmiHeader.biHeight = nHeight;
|
|
bi.bmiHeader.biPlanes = 1;
|
|
bi.bmiHeader.biBitCount = nBPP;
|
|
bi.bmiHeader.biCompression = eCompression;
|
|
|
|
// is there alpha channel?
|
|
bool bHasAlphaCh;
|
|
bHasAlphaCh = (nBPP == 32 && (dwFlags & createAlphaChannel));
|
|
|
|
// get orientation
|
|
DIBOrientation eOrientation;
|
|
eOrientation = ((nHeight > 0) ? DIBOR_BOTTOMUP : DIBOR_TOPDOWN);
|
|
|
|
// does it have bit fields?
|
|
if (eCompression == BI_BITFIELDS)
|
|
{
|
|
if (nBPP == 16 || nBPP == 32)
|
|
{
|
|
// store the mask data
|
|
LPDWORD pdwMask = reinterpret_cast<LPDWORD>(bi.bmiColors);
|
|
pdwMask[0] = pdwBitmasks[0];
|
|
pdwMask[1] = pdwBitmasks[1];
|
|
pdwMask[2] = pdwBitmasks[2];
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ATLASSERT(pdwBitmasks == NULL);
|
|
if (pdwBitmasks)
|
|
return FALSE;
|
|
}
|
|
|
|
// create a DIB section
|
|
HDC hDC = ::CreateCompatibleDC(NULL);
|
|
ATLASSERT(hDC);
|
|
LPVOID pvBits;
|
|
HBITMAP hbm = ::CreateDIBSection(hDC, bi.get(), DIB_RGB_COLORS,
|
|
&pvBits, NULL, 0);
|
|
ATLASSERT(hbm);
|
|
::DeleteDC(hDC);
|
|
|
|
// attach it
|
|
AttachInternal(hbm, eOrientation, -1);
|
|
m_bHasAlphaCh = bHasAlphaCh;
|
|
|
|
return hbm != NULL;
|
|
}
|
|
|
|
private:
|
|
// NOTE: CImage is not copyable
|
|
CImage(const CImage&);
|
|
CImage& operator=(const CImage&);
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifndef _ATL_NO_AUTOMATIC_NAMESPACE
|
|
using namespace ATL;
|
|
#endif //!_ATL_NO_AUTOMATIC_NAMESPACE
|