#include "stdafx.h" #include "EnBitmap.h" #include #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[] = __FILE__; #define new DEBUG_NEW #endif const int HIMETRIC_INCH = 2540; enum { FT_BMP, FT_ICO, FT_JPG, FT_GIF, FT_UNKNOWN }; CEnBitmap::CEnBitmap() { } CEnBitmap::~CEnBitmap() { } BOOL CEnBitmap::LoadImage(UINT uIDRes, LPCTSTR szResourceType, HMODULE hInst, COLORREF crBack) { ASSERT(m_hObject == NULL); // only attach once, detach on destroy if (m_hObject != NULL) return FALSE; return Attach(LoadImageResource(uIDRes, szResourceType, hInst, crBack)); } BOOL CEnBitmap::LoadImage(LPCTSTR szImagePath, COLORREF crBack) { //如果原先存在就去除 if (m_hObject != NULL) { DeleteObject(); Detach(); } return Attach(LoadImageFile(szImagePath, crBack)); } HBITMAP CEnBitmap::LoadImageFile(LPCTSTR szImagePath, COLORREF crBack) { int nType = GetFileType(szImagePath); switch (nType) { // the reason for this is that i suspect it is more efficient to load // bmps this way since it avoids creating device contexts etc that the // IPicture methods requires. that method however is still valuable // since it handles other image types and transparency case FT_BMP: return (HBITMAP)::LoadImage(NULL, szImagePath, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE); case FT_UNKNOWN: return NULL; default: // all the rest { USES_CONVERSION; IPicture* pPicture = NULL; HBITMAP hbm = NULL; HRESULT hr = OleLoadPicturePath(LPOLESTR(szImagePath), NULL, 0, crBack, IID_IPicture, (LPVOID *)&pPicture); if (pPicture) { hbm = ExtractBitmap(pPicture, crBack); pPicture->Release(); } return hbm; } } return NULL; // can't get here } HBITMAP CEnBitmap::LoadImageResource(UINT uIDRes, LPCTSTR szResourceType, HMODULE hInst, COLORREF crBack) { BYTE* pBuff = NULL; int nSize = 0; HBITMAP hbm = NULL; // first call is to get buffer size if (GetResource(MAKEINTRESOURCE(uIDRes), szResourceType, hInst, 0, nSize)) { if (nSize > 0) { pBuff = new BYTE[nSize]; // this loads it if (GetResource(MAKEINTRESOURCE(uIDRes), szResourceType, hInst, pBuff, nSize)) { IPicture* pPicture = LoadFromBuffer(pBuff, nSize); if (pPicture) { hbm = ExtractBitmap(pPicture, crBack); pPicture->Release(); } } delete[] pBuff; } } return hbm; } IPicture* CEnBitmap::LoadFromBuffer(BYTE* pBuff, int nSize) { bool bResult = false; HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, nSize); void* pData = GlobalLock(hGlobal); memcpy(pData, pBuff, nSize); GlobalUnlock(hGlobal); IStream* pStream = NULL; IPicture* pPicture = NULL; if (CreateStreamOnHGlobal(hGlobal, TRUE, &pStream) == S_OK) { HRESULT hr = OleLoadPicture(pStream, nSize, FALSE, IID_IPicture, (LPVOID *)&pPicture); pStream->Release(); } return pPicture; // caller releases } BOOL CEnBitmap::GetResource(LPCTSTR lpName, LPCTSTR lpType, HMODULE hInst, void* pResource, int& nBufSize) { HRSRC hResInfo; HANDLE hRes; LPSTR lpRes = NULL; int nLen = 0; bool bResult = FALSE; // Find the resource hResInfo = FindResource(hInst, lpName, lpType); if (hResInfo == NULL) return false; // Load the resource hRes = LoadResource(hInst, hResInfo); if (hRes == NULL) return false; // Lock the resource lpRes = (char*)LockResource(hRes); if (lpRes != NULL) { if (pResource == NULL) { nBufSize = SizeofResource(hInst, hResInfo); bResult = true; } else { if (nBufSize >= (int)SizeofResource(hInst, hResInfo)) { memcpy(pResource, lpRes, nBufSize); bResult = true; } } UnlockResource(hRes); } // Free the resource FreeResource(hRes); return bResult; } HBITMAP CEnBitmap::ExtractBitmap(IPicture* pPicture, COLORREF crBack) { ASSERT(pPicture); if (!pPicture) return NULL; CBitmap bmMem; CDC dcMem; CDC* pDC = CWnd::GetDesktopWindow()->GetDC(); if (dcMem.CreateCompatibleDC(pDC)) { long hmWidth; long hmHeight; pPicture->get_Width(&hmWidth); pPicture->get_Height(&hmHeight); int nWidth = MulDiv(hmWidth, pDC->GetDeviceCaps(LOGPIXELSX), HIMETRIC_INCH); int nHeight = MulDiv(hmHeight, pDC->GetDeviceCaps(LOGPIXELSY), HIMETRIC_INCH); if (bmMem.CreateCompatibleBitmap(pDC, nWidth, nHeight)) { CBitmap* pOldBM = dcMem.SelectObject(&bmMem); if (crBack != -1) dcMem.FillSolidRect(0, 0, nWidth, nHeight, crBack); HRESULT hr = pPicture->Render(dcMem, 0, 0, nWidth, nHeight, 0, hmHeight, hmWidth, -hmHeight, NULL); dcMem.SelectObject(pOldBM); } } CWnd::GetDesktopWindow()->ReleaseDC(pDC); return (HBITMAP)bmMem.Detach(); } int CEnBitmap::GetFileType(LPCTSTR szImagePath) { CString sPath(szImagePath); sPath.MakeUpper(); if (sPath.Find(_T(".BMP")) > 0) return FT_BMP; else if (sPath.Find(_T(".ICO")) > 0) return FT_ICO; else if (sPath.Find(_T(".JPG")) > 0 || sPath.Find(_T(".JPEG")) > 0) return FT_JPG; else if (sPath.Find(_T(".GIF")) > 0) return FT_GIF; // else return FT_UNKNOWN; } ///////////////////////////////////////////////////////////////////// // Converts a bitmap to a region // // BitmapToRegion : Create a region from the "non-transparent" pixels of a bitmap // Author : Jean-Edouard Lachand-Robert (http://www.geocities.com/Paris/LeftBank/1160/resume.htm), June 1998. // // hBmp : Source bitmap // cTransparentColor : Color base for the "transparent" pixels (default is black) // cTolerance : Color tolerance for the "transparent" pixels. // // A pixel is assumed to be transparent if the value of each of its 3 components (blue, green and red) is // greater or equal to the corresponding value in cTransparentColor and is lower or equal to the // corresponding value in cTransparentColor + cTolerance. // HRGN CEnBitmap::BitmapToRegion(COLORREF cTransparentColor, COLORREF cTolerance) { HBITMAP hBmp = (HBITMAP)GetSafeHandle(); HRGN hRgn = NULL; if (hBmp) { // Create a memory DC inside which we will scan the bitmap content HDC hMemDC = CreateCompatibleDC(NULL); if (hMemDC) { // Get bitmap size BITMAP bm; ::GetObject(hBmp, sizeof(bm), &bm); // Create a 32 bits depth bitmap and select it into the memory DC BITMAPINFOHEADER RGB32BITSBITMAPINFO = { sizeof(BITMAPINFOHEADER), // biSize bm.bmWidth, // biWidth; bm.bmHeight, // biHeight; 1, // biPlanes; 32, // biBitCount BI_RGB, // biCompression; 0, // biSizeImage; 0, // biXPelsPerMeter; 0, // biYPelsPerMeter; 0, // biClrUsed; 0 // biClrImportant; }; VOID * pbits32; HBITMAP hbm32 = CreateDIBSection(hMemDC, (BITMAPINFO *)&RGB32BITSBITMAPINFO, DIB_RGB_COLORS, &pbits32, NULL, 0); if (hbm32) { HBITMAP holdBmp = (HBITMAP)SelectObject(hMemDC, hbm32); // Create a DC just to copy the bitmap into the memory DC HDC hDC = CreateCompatibleDC(hMemDC); if (hDC) { // Get how many bytes per row we have for the bitmap bits (rounded up to 32 bits) BITMAP bm32; ::GetObject(hbm32, sizeof(bm32), &bm32); while (bm32.bmWidthBytes % 4) bm32.bmWidthBytes++; // Copy the bitmap into the memory DC HBITMAP holdBmp = (HBITMAP)SelectObject(hDC, hBmp); BitBlt(hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY); // For better performances, we will use the ExtCreateRegion() function to create the // region. This function take a RGNDATA structure on entry. We will add rectangles by // amount of ALLOC_UNIT number in this structure. #define ALLOC_UNIT 100 DWORD maxRects = ALLOC_UNIT; HANDLE hData = GlobalAlloc(GMEM_MOVEABLE, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects)); RGNDATA *pData = (RGNDATA *)GlobalLock(hData); pData->rdh.dwSize = sizeof(RGNDATAHEADER); pData->rdh.iType = RDH_RECTANGLES; pData->rdh.nCount = pData->rdh.nRgnSize = 0; SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0); // Keep on hand highest and lowest values for the "transparent" pixels BYTE lr = GetRValue(cTransparentColor); BYTE lg = GetGValue(cTransparentColor); BYTE lb = GetBValue(cTransparentColor); BYTE hr = min(0xff, lr + GetRValue(cTolerance)); BYTE hg = min(0xff, lg + GetGValue(cTolerance)); BYTE hb = min(0xff, lb + GetBValue(cTolerance)); // Scan each bitmap row from bottom to top (the bitmap is inverted vertically) BYTE *p32 = (BYTE *)bm32.bmBits + (bm32.bmHeight - 1) * bm32.bmWidthBytes; for (int y = 0; y < bm.bmHeight; y++) { // Scan each bitmap pixel from left to right for (int x = 0; x < bm.bmWidth; x++) { // Search for a continuous range of "non transparent pixels" int x0 = x; LONG *p = (LONG *)p32 + x; while (x < bm.bmWidth) { BYTE b = GetRValue(*p); if (b >= lr && b <= hr) { b = GetGValue(*p); if (b >= lg && b <= hg) { b = GetBValue(*p); if (b >= lb && b <= hb) // This pixel is "transparent" break; } } p++; x++; } if (x > x0) { // Add the pixels (x0, y) to (x, y+1) as a new rectangle in the region if (pData->rdh.nCount >= maxRects) { GlobalUnlock(hData); maxRects += ALLOC_UNIT; hData = GlobalReAlloc(hData, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), GMEM_MOVEABLE); pData = (RGNDATA *)GlobalLock(hData); } RECT *pr = (RECT *)&pData->Buffer; SetRect(&pr[pData->rdh.nCount], x0, y, x, y + 1); if (x0 < pData->rdh.rcBound.left) pData->rdh.rcBound.left = x0; if (y < pData->rdh.rcBound.top) pData->rdh.rcBound.top = y; if (x > pData->rdh.rcBound.right) pData->rdh.rcBound.right = x; if (y + 1 > pData->rdh.rcBound.bottom) pData->rdh.rcBound.bottom = y + 1; pData->rdh.nCount++; // On Windows98, ExtCreateRegion() may fail if the number of rectangles is too // large (ie: > 4000). Therefore, we have to create the region by multiple steps. if (pData->rdh.nCount == 2000) { HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData); if (hRgn) { CombineRgn(hRgn, hRgn, h, RGN_OR); ::DeleteObject(h); } else hRgn = h; pData->rdh.nCount = 0; SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0); } } } // Go to next row (remember, the bitmap is inverted vertically) p32 -= bm32.bmWidthBytes; } // Create or extend the region with the remaining rectangles HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData); if (hRgn) { CombineRgn(hRgn, hRgn, h, RGN_OR); ::DeleteObject(h); } else hRgn = h; // Clean up GlobalFree(hData); SelectObject(hDC, holdBmp); DeleteDC(hDC); } ::DeleteObject(SelectObject(hMemDC, holdBmp)); } DeleteDC(hMemDC); } } return hRgn; } BOOL CEnBitmap::Draw(CDC *pDC, LPRECT r) { CDC dc; dc.CreateCompatibleDC(pDC); CBitmap * bmp = dc.SelectObject(this); pDC->BitBlt(r->left, r->top, r->right - r->left, r->bottom - r->top, &dc, 0, 0, SRCCOPY); dc.SelectObject(bmp); return TRUE; } // TransparentBlt - Copies a bitmap transparently onto the destination DC // hdcDest - Handle to destination device context // nXDest - x-coordinate of destination rectangle's upper-left corner // nYDest - y-coordinate of destination rectangle's upper-left corner // nWidth - Width of destination rectangle // nHeight - height of destination rectangle // hBitmap - Handle of the source bitmap // nXSrc - x-coordinate of source rectangle's upper-left corner // nYSrc - y-coordinate of source rectangle's upper-left corner // colorTransparent - The transparent color // hPal - Logical palette to be used with bitmap. Can be NULL /************************************************************************/ /* 函数：TransparentBlt[8/23/2016 IT]; /* 描述：将透明位图拷贝到目标; /* 参数：; /* [IN] ：; /* [OUT] ：; /* [IN/OUT] ：; /* 返回：void; /* 注意：; /* 示例：; /* /* 修改：; /* 日期：; /* 内容：; /************************************************************************/ void CEnBitmap::TransparentBlt(IN CDC &dc, IN CRect rc, IN UINT colorTransparent) { CDC pDC; pDC.CreateCompatibleDC(&dc); HBITMAP hOldBmp = (HBITMAP) ::SelectObject(pDC.m_hDC, m_hObject); ::TransparentBlt(dc.GetSafeHdc(), rc.left, rc.top, rc.Width(), rc.Height(), pDC.GetSafeHdc(), 0, 0, GetWidth(), GetHeight(), colorTransparent); ::SelectObject(pDC.m_hDC, hOldBmp); pDC.DeleteDC(); } // DrawGreyScale - Draws a bitmap in Grey scale // pDC - Pointer to target device context // hDIB - Handle of device-independent bitmap // void CEnBitmap::DrawGreyScale(CDC *pDC) { CPalette pal; CPalette *pOldPalette = 0; HBITMAP hBmp = (HBITMAP)this->GetSafeHandle(); // allocate memory for extended image information BITMAPINFO &bmInfo = *(LPBITMAPINFO) new BYTE[sizeof(BITMAPINFO) + 8]; memset(&bmInfo, 0, sizeof(BITMAPINFO) + 8); bmInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); // get extended information about image (length, compression, length of color table if exist, ...) DWORD res = GetDIBits(pDC->GetSafeHdc(), hBmp, 0, GetHeight(), 0, &bmInfo, DIB_RGB_COLORS); // allocate memory for image data (colors) LPBYTE pBits = new BYTE[bmInfo.bmiHeader.biSizeImage + 4]; res = GetDIBits(pDC->GetSafeHdc(), hBmp, 0, bmInfo.bmiHeader.biHeight, pBits, &bmInfo, DIB_RGB_COLORS); int nColors = bmInfo.bmiHeader.biClrUsed ? bmInfo.bmiHeader.biClrUsed : 1 << bmInfo.bmiHeader.biBitCount; int nWidth = bmInfo.bmiHeader.biWidth; int nHeight = bmInfo.bmiHeader.biHeight; // Compute the address of the bitmap bits LPVOID lpDIBBits; if (bmInfo.bmiHeader.biBitCount > 8) lpDIBBits = (LPVOID)((LPDWORD)(pBits + bmInfo.bmiHeader.biClrUsed) + ((bmInfo.bmiHeader.biCompression == BI_BITFIELDS) ? 3 : 0)); else lpDIBBits = (LPVOID)(pBits + nColors); // Create the palette if needed if (pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE && nColors <= 256) { // The device supports a palette and bitmap has color table // Allocate memory for a palette UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors); LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize]; pLP->palVersion = 0x300; pLP->palNumEntries = nColors; for (int i = 0; i < nColors; i++) { int nGrey = Grey(bmInfo.bmiColors[i].rgbRed, bmInfo.bmiColors[i].rgbGreen, bmInfo.bmiColors[i].rgbBlue); pLP->palPalEntry[i].peRed = nGrey; pLP->palPalEntry[i].peGreen = nGrey; pLP->palPalEntry[i].peBlue = nGrey; pLP->palPalEntry[i].peFlags = 0; } pal.CreatePalette(pLP); delete[] pLP; // Select the palette pOldPalette = pDC->SelectPalette(&pal, FALSE); pDC->RealizePalette(); } else { // Modify the bitmaps pixels directly // Note : This ends up changing the DIB. If that is not acceptable then // copy the DIB and then change the copy rather than the original if (bmInfo.bmiHeader.biBitCount == 24 || bmInfo.bmiHeader.biBitCount == 32) { BYTE *dst = (BYTE*)lpDIBBits; int Size = nWidth*nHeight; while (Size--) { int nGrey = Grey(dst[2], dst[1], dst[0]); dst[0] = (BYTE)nGrey; dst[1] = (BYTE)nGrey; dst[2] = (BYTE)nGrey; dst += 4; } } else if (bmInfo.bmiHeader.biBitCount == 16) { WORD *dst = (WORD*)lpDIBBits; int Size = nWidth*nHeight; while (Size--) { BYTE b = (BYTE)((*dst)&(0x1F)); BYTE g = (BYTE)(((*dst) >> 5)&(0x1F)); BYTE r = (BYTE)(((*dst) >> 10)&(0x1F)); int nGrey = Grey(r, g, b); *dst++ = ((WORD)(((BYTE)(nGrey) | ((WORD)((BYTE)(nGrey)) << 5)) | (((DWORD)(BYTE)(nGrey)) << 10))); } } } // Draw the image ::SetDIBitsToDevice(pDC->m_hDC, // hDC 0, // XDest 0, // YDest nWidth, // nDestWidth nHeight, // nDestHeight 0, // XSrc 0, // YSrc 0, // nStartScan nHeight, // nNumScans lpDIBBits, // lpBits &bmInfo, // lpBitsInfo DIB_RGB_COLORS); // wUsage if (pOldPalette) pDC->SelectPalette(pOldPalette, FALSE); } // // DitherBlt : Draw a bitmap dithered (3D grayed effect like disabled buttons in toolbars) into a destination DC // Author : Jean-Edouard Lachand-Robert (iamwired@geocities.com), June 1997. // // hdcDest : destination DC // nXDest : x coordinate of the upper left corner of the destination rectangle into the DC // nYDest : y coordinate of the upper left corner of the destination rectangle into the DC // nWidth : width of the destination rectangle into the DC // nHeight : height of the destination rectangle into the DC // hbm : the bitmap to draw (as a part or as a whole) // nXSrc : x coordinates of the upper left corner of the source rectangle into the bitmap // nYSrc : y coordinates of the upper left corner of the source rectangle into the bitmap // void CEnBitmap::DitherBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HBITMAP hbm, int nXSrc, int nYSrc) { ASSERT(hdcDest && hbm); ASSERT(nWidth > 0 && nHeight > 0); // Create a generic DC for all BitBlts HDC hDC = CreateCompatibleDC(hdcDest); ASSERT(hDC); if (hDC) { // Create a DC for the monochrome DIB section HDC bwDC = CreateCompatibleDC(hDC); ASSERT(bwDC); if (bwDC) { // Create the monochrome DIB section with a black and white palette struct { BITMAPINFOHEADER bmiHeader; RGBQUAD bmiColors[2]; } RGBBWBITMAPINFO = { { // a BITMAPINFOHEADER sizeof(BITMAPINFOHEADER), // biSize nWidth, // biWidth; nHeight, // biHeight; 1, // biPlanes; 1, // biBitCount BI_RGB, // biCompression; 0, // biSizeImage; 0, // biXPelsPerMeter; 0, // biYPelsPerMeter; 0, // biClrUsed; 0 // biClrImportant; }, { { 0x00, 0x00, 0x00, 0x00 }, { 0xFF, 0xFF, 0xFF, 0x00 } } }; VOID *pbitsBW; HBITMAP hbmBW = CreateDIBSection(bwDC, (LPBITMAPINFO)&RGBBWBITMAPINFO, DIB_RGB_COLORS, &pbitsBW, NULL, 0); ASSERT(hbmBW); if (hbmBW) { // Attach the monochrome DIB section and the bitmap to the DCs SelectObject(bwDC, hbmBW); SelectObject(hDC, hbm); // BitBlt the bitmap into the monochrome DIB section BitBlt(bwDC, 0, 0, nWidth, nHeight, hDC, nXSrc, nYSrc, SRCCOPY); // Paint the destination rectangle in gray FillRect(hdcDest, CRect(nXDest, nYDest, nXDest + nWidth, nYDest + nHeight), GetSysColorBrush(COLOR_3DFACE)); // BitBlt the black bits in the monochrome bitmap into COLOR_3DHILIGHT bits in the destination DC // The magic ROP comes from the Charles Petzold's book HBRUSH hb = CreateSolidBrush(GetSysColor(COLOR_3DHILIGHT)); HBRUSH oldBrush = (HBRUSH)SelectObject(hdcDest, hb); BitBlt(hdcDest, nXDest + 1, nYDest + 1, nWidth, nHeight, bwDC, 0, 0, 0xB8074A); // BitBlt the black bits in the monochrome bitmap into COLOR_3DSHADOW bits in the destination DC hb = CreateSolidBrush(GetSysColor(COLOR_3DSHADOW)); ::DeleteObject(SelectObject(hdcDest, hb)); BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, bwDC, 0, 0, 0xB8074A); ::DeleteObject(SelectObject(hdcDest, oldBrush)); } VERIFY(DeleteDC(bwDC)); } VERIFY(DeleteDC(hDC)); } } // CreateReservedPalette - Create a palette using the PC_RESERVED flag // Limit the colors to 236 colors // Returns - Handle to a palette object // hDIB - Handle to a device-independent bitmap // HPALETTE CEnBitmap::CreateReservedPalette(CDC *pDC) { HPALETTE hPal = NULL; // handle to a palette HBITMAP hBmp = (HBITMAP)this->GetSafeHandle(); // get image properties //BITMAP bmp = { 0 }; //::GetObject( hBmp, sizeof(BITMAP), &bmp ); // allocate memory for extended image information BITMAPINFO &bmInfo = *(LPBITMAPINFO) new BYTE[sizeof(BITMAPINFO) + 8]; memset(&bmInfo, 0, sizeof(BITMAPINFO) + 8); bmInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); // get extended information about image (length, compression, length of color table if exist, ...) DWORD res = GetDIBits(pDC->GetSafeHdc(), hBmp, 0, GetHeight(), 0, &bmInfo, DIB_RGB_COLORS); // allocate memory for image data (colors) LPBYTE pBits = new BYTE[bmInfo.bmiHeader.biSizeImage + 4]; res = GetDIBits(pDC->GetSafeHdc(), hBmp, 0, bmInfo.bmiHeader.biHeight, pBits, &bmInfo, DIB_RGB_COLORS); int nWidth = bmInfo.bmiHeader.biWidth; int nHeight = bmInfo.bmiHeader.biHeight; int nColors = bmInfo.bmiHeader.biClrUsed ? bmInfo.bmiHeader.biClrUsed : 1 << bmInfo.bmiHeader.biBitCount; if (nColors > 256) return NULL; // No Palette //allocate memory block for logical palette UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors); LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize]; // Initialize the palette version pLP->palVersion = 0x300; // If it is a 256 color DIB, then let's find the most used 236 colors // and make a palette out of those colors if (nColors > 236) { typedef struct _tagBESTCOLORS { DWORD dwColorCnt; //Count of how many times a color is used BOOL bDontUse; //Should we use this color? } BESTCOLORS; BESTCOLORS bc[256]; BYTE dwLeastUsed[20]; // Least used color indices LPSTR lpBits; // pointer to D.I. bits of a DIB int nWidth, nHeight, nBytesPerLine, cx, cy; ::ZeroMemory(bc, 256 * sizeof(BESTCOLORS)); lpBits = (LPSTR)(pBits + nColors); nWidth = bmInfo.bmiHeader.biWidth; nHeight = bmInfo.bmiHeader.biHeight; nBytesPerLine = ((((bmInfo.bmiHeader.biWidth * bmInfo.bmiHeader.biBitCount) + 31) & ~31) / 8); // Traverse through all of the bits in the bitmap and place the // color count of each color in the BESTCOLORS array for (cy = 0; cy < nHeight; cy++) for (cx = 0; cx < nWidth; cx++) bc[*(LPBYTE)(lpBits + cy*nBytesPerLine + cx)].dwColorCnt++; // Let's arbitrarily place the first few colors in the "Least Used" list. int nReject = nColors - 236; for (cx = 0; cx < nReject; cx++) { bc[cx].bDontUse = TRUE; dwLeastUsed[cx] = cx; } // Now, let's traverse through all of the colors and // sort out the least used for (cx = 0; cx < nColors; cx++) { cy = 0; while ((!(bc[cx].bDontUse)) && cy < nReject) { if (bc[cx].dwColorCnt < bc[dwLeastUsed[cy]].dwColorCnt) { bc[dwLeastUsed[cy]].bDontUse = FALSE; dwLeastUsed[cy] = cx; bc[cx].bDontUse = TRUE; } cy++; } } // We want only 236 colors, so that the 20 system colors // are left untouched pLP->palNumEntries = 236; cx = 0; for (int i = 0; i < nColors; i++) { // Should we use this color? if (!((bc[i].bDontUse))) { pLP->palPalEntry[cx].peRed = bmInfo.bmiColors[i].rgbRed; pLP->palPalEntry[cx].peGreen = bmInfo.bmiColors[i].rgbGreen; pLP->palPalEntry[cx].peBlue = bmInfo.bmiColors[i].rgbBlue; pLP->palPalEntry[cx].peFlags = PC_RESERVED; cx++; } } } else if (nColors) { // We have enough room for all the colors pLP->palNumEntries = nColors; // Copy the colors for (int i = 0; i < nColors; i++) { pLP->palPalEntry[i].peRed = bmInfo.bmiColors[i].rgbRed; pLP->palPalEntry[i].peGreen = bmInfo.bmiColors[i].rgbGreen; pLP->palPalEntry[i].peBlue = bmInfo.bmiColors[i].rgbBlue; pLP->palPalEntry[i].peFlags = PC_RESERVED; } } hPal = CreatePalette(pLP); delete[] pLP; // return handle to DIB's palette return hPal; } // FadeColorToGrayScale - Draws a bitmap in color slowly turns it to grayscale // pDC - Pointer to target device context // hDIB - Handle of device-independent bitmap // xDest - x-coordinate of upper-left corner of dest. rect. // yDest - y-coordinate of upper-left corner of dest. rect. // nLoops - How many loops to fade the image into color // nDelay - Delay in milli-seconds between each loop // void CEnBitmap::FadeColorToGrayScale(CDC *pDC, int xDest, int yDest, int nLoops, int nDelay) { CPalette pal; CPalette *pOldPalette; PALETTEENTRY peAnimate[256]; PALETTEENTRY peGray[256]; PALETTEENTRY peOriginal[256]; HBITMAP hBmp = (HBITMAP)this->GetSafeHandle(); // get image properties //BITMAP bmp = { 0 }; //::GetObject( hBmp, sizeof(BITMAP), &bmp ); // allocate memory for extended image information BITMAPINFO &bmInfo = *(LPBITMAPINFO) new BYTE[sizeof(BITMAPINFO) + 8]; memset(&bmInfo, 0, sizeof(BITMAPINFO) + 8); bmInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); // get extended information about image (length, compression, length of color table if exist, ...) DWORD res = GetDIBits(pDC->GetSafeHdc(), hBmp, 0, GetHeight(), 0, &bmInfo, DIB_RGB_COLORS); // allocate memory for image data (colors) LPBYTE pBits = new BYTE[bmInfo.bmiHeader.biSizeImage + 4]; res = GetDIBits(pDC->GetSafeHdc(), hBmp, 0, bmInfo.bmiHeader.biHeight, pBits, &bmInfo, DIB_RGB_COLORS); int nColors = bmInfo.bmiHeader.biClrUsed ? bmInfo.bmiHeader.biClrUsed : 1 << bmInfo.bmiHeader.biBitCount; int nWidth = bmInfo.bmiHeader.biWidth; int nHeight = bmInfo.bmiHeader.biHeight; // Compute the address of the bitmap bits LPVOID lpDIBBits; if (bmInfo.bmiHeader.biBitCount > 8) lpDIBBits = (LPVOID)((LPDWORD)(pBits + bmInfo.bmiHeader.biClrUsed) + ((bmInfo.bmiHeader.biCompression == BI_BITFIELDS) ? 3 : 0)); else lpDIBBits = (LPVOID)(pBits + nColors); int nReservedColors = nColors > 236 ? 236 : nColors; // Create the palette if needed if (pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE && nColors <= 256) { // The device supports a palette and bitmap has color table HPALETTE hPal = CreateReservedPalette(pDC); pal.Attach(hPal); // Now save the original colors and get the grayscale colors int i = 0; pal.GetPaletteEntries(0, nReservedColors, (LPPALETTEENTRY)&peOriginal); for (i = 0; i < nReservedColors; i++) { int nGray = Grey(peOriginal[i].peRed, peOriginal[i].peGreen, peOriginal[i].peBlue); peGray[i].peRed = nGray; peGray[i].peGreen = nGray; peGray[i].peBlue = nGray; } // Select the palette pOldPalette = pDC->SelectPalette(&pal, FALSE); pDC->RealizePalette(); ::SetDIBitsToDevice(pDC->m_hDC, xDest, yDest, nWidth, nHeight, 0, 0, 0, nHeight, lpDIBBits, (LPBITMAPINFO)&bmInfo, DIB_RGB_COLORS); // Now animate palette to set the image to grayscale for (i = 1; i <= nLoops; i++) { for (int j = 0; j < nColors; j++) { peAnimate[j].peRed = peOriginal[j].peRed - ((peOriginal[j].peRed - peGray[j].peRed)*i) / nLoops; peAnimate[j].peGreen = peOriginal[j].peGreen - ((peOriginal[j].peGreen - peGray[j].peGreen)*i) / nLoops; peAnimate[j].peBlue = peOriginal[j].peBlue - ((peOriginal[j].peBlue - peGray[j].peBlue)*i) / nLoops; peAnimate[j].peFlags = peOriginal[j].peFlags; } pal.AnimatePalette(0, nColors, (LPPALETTEENTRY)&peAnimate); // Delay... Sleep(nDelay); } // Select the old palette back pDC->SelectPalette(pOldPalette, FALSE); } else if ((pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE) == 0 && nColors <= 256) { // Now change the image to grayscale for (int i = 1; i <= nLoops; i++) { BYTE *dst = (BYTE*)lpDIBBits; int Size = nWidth*nHeight; while (Size--) { int nGrey = Grey(dst[2], dst[1], dst[0]); dst[2] = (BYTE)dst[2] - ((dst[2] - nGrey)*i) / nLoops; dst[1] = (BYTE)dst[1] - ((dst[1] - nGrey)*i) / nLoops; dst[0] = (BYTE)dst[0] - ((dst[0] - nGrey)*i) / nLoops; dst += 4; } // Draw the image again ::SetDIBitsToDevice(pDC->m_hDC, xDest, yDest, nWidth, nHeight, 0, 0, 0, nHeight, lpDIBBits, (LPBITMAPINFO)&bmInfo, DIB_RGB_COLORS); // Delay... Sleep(nDelay); } } else { ::SetDIBitsToDevice(pDC->m_hDC, xDest, yDest, nWidth, nHeight, 0, 0, 0, nHeight, lpDIBBits, (LPBITMAPINFO)&bmInfo, DIB_RGB_COLORS); } } void CEnBitmap::AlphaDisplay(CDC *pDC, BYTE bAlpha) { CDC dc; dc.CreateCompatibleDC(pDC); CBitmap * bmp = dc.SelectObject(this); BLENDFUNCTION rBlendProps; rBlendProps.BlendOp = AC_SRC_OVER; rBlendProps.BlendFlags = 0; rBlendProps.AlphaFormat = 0; rBlendProps.SourceConstantAlpha = bAlpha; BITMAP bmInfo; ::GetObject(m_hObject, sizeof(BITMAP), &bmInfo); INT nWidth, nHeigh; nWidth = bmInfo.bmWidth; nHeigh = bmInfo.bmHeight; AlphaBlend(pDC->m_hDC, 0, 0, nWidth, nHeigh, dc.m_hDC, 0, 0, nWidth, nHeigh, rBlendProps); dc.SelectObject(bmp); } /* ExtCreateRegion replacement */ HRGN CEnBitmap::CreateRegionExt(DWORD nCount, CONST RGNDATA *pRgnData) { HRGN hRgn = CreateRectRgn(0, 0, 0, 0); const DWORD RDHDR = sizeof(RGNDATAHEADER); ASSERT(hRgn != NULL); LPRECT pRects = (LPRECT)((LPBYTE)pRgnData + RDHDR); for (int i = 0; i < (int)nCount; i++) { HRGN hr = CreateRectRgn(pRects[i].left, pRects[i].top, pRects[i].right, pRects[i].bottom); VERIFY(CombineRgn(hRgn, hRgn, hr, RGN_OR) != ERROR); if (hr) ::DeleteObject(hr); } ASSERT(hRgn != NULL); return hRgn; } /////////////////////////////////////////////////////////////////// // InflateRegion - Inflates a region by the x and y values // specified in nXInflate and nYInflate // Creates a new region that represents the inflated region // (retains the contents of the old region) // Returns NULL if unsuccessfull HRGN CEnBitmap::InflateRegion(HRGN hRgn, int nXInflate, int nYInflate) { // Local Variables LPRGNDATA lpData; // The RGNDATA structure LPRECT lpRect; // Pointer to the array of RECT structures DWORD BufSize; // The amount of memory required DWORD i; // General index variable HRGN hRgnNew; // The newly created region // Get the number of rectangles in the region BufSize = GetRegionData(hRgn, 0, NULL); if (BufSize == 0) return NULL; // Allocate memory for the RGNDATA structure lpData = (LPRGNDATA)malloc(BufSize); // Set the location of the RECT structures lpRect = (LPRECT)(lpData->Buffer); // Get the region data if (!GetRegionData(hRgn, BufSize, lpData)) { free(lpData); return NULL; } // Expand (or contract) all the rectangles in the data for (i = 0; i < lpData->rdh.nCount; i++) InflateRect(&lpRect[i], nXInflate, nYInflate); // Create the new region hRgnNew = CreateRegionExt(lpData->rdh.nCount, lpData); free((void*)lpData); return hRgnNew; } BOOL CEnBitmap::StretchDraw(CDC *pDC, LPRECT r, LPRECT sr) { if (!r) return FALSE; CDC dc; dc.CreateCompatibleDC(pDC); CBitmap * bmp = dc.SelectObject(this); //pDC->SetStretchBltMode(COLORONCOLOR); pDC->SetStretchBltMode(STRETCH_HALFTONE); // 使界面拉伸后不模糊; if (!sr) pDC->StretchBlt(r->left, r->top, r->right, r->bottom, &dc, 0, 0, GetWidth(), GetHeight(), SRCCOPY); else pDC->StretchBlt(r->left, r->top, r->right - r->left, r->bottom - r->top, &dc, sr->left, sr->top, sr->right - sr->left, sr->bottom - sr->top, SRCCOPY); dc.SelectObject(bmp); return TRUE; } BOOL CEnBitmap::DrawImage(CEnBitmap &bmp, int nX, int nY, int nCol, int nRow) { nX -= 1; nY -= 1; //单个图片的长和宽; int w = GetWidth() / nCol; int h = GetHeight() / nRow; CBitmap *OldBmp; CDC memDC; CClientDC dc(0); memDC.CreateCompatibleDC(&dc); bmp.CreateCompatibleBitmap(&dc, w, h); OldBmp = memDC.SelectObject(&bmp); StretchDraw(&memDC, CRect(0, 0, w, h), CRect(GetWidth()*nX / nCol, GetHeight()*nY / nRow, GetWidth()*nX / nCol + w, GetHeight()*nY / nRow + h)); memDC.SelectObject(OldBmp); return TRUE; } //BOLL GetBmp() CRect CEnBitmap::GetRect() { return CRect(0, 0, GetWidth(), GetHeight()); } HBITMAP CEnBitmap::SetBitmap(HBITMAP hBitmap) { CEnBitmap *pBmp = (CEnBitmap *)CEnBitmap::FromHandle(hBitmap); HBITMAP hBmp = (HBITMAP)this->Detach(); this->DeleteObject(); pBmp->DrawImage(*this, 1, 1, 1, 1); return hBmp; } /************************************************************************/ /* 函数：[8/23/2016 IT]; /* 描述：; /* 参数：; /* [IN] ：; /* [OUT] ：; /* [IN/OUT] ：; /* 返回：void; /* 注意：; /* 示例：; /* /* 修改：; /* 日期：; /* 内容：; /************************************************************************/ BOOL CEnBitmap::ExtendDraw(IN CDC *pDC, IN CRect rc, IN int nX, IN int nY, IN BOOL bTran, IN UINT colorTransparent) { CEnBitmap bmp; if (ExtendDrawImage(bmp, rc, nX, nY)) { if (bTran) bmp.TransparentBlt(*pDC, &rc, colorTransparent); else bmp.Draw(pDC, &rc); // return TRUE; } return FALSE; } /************************************************************************/ /* 函数：ExtendDrawImage[8/23/2016 IT]; /* 描述：; /* 参数：; /* [OUT] bmp：返回图片对象; /* [IN] rc：画图的目标区域; /* [IN] nX：分割点x坐标(原图坐标); /* [IN] nY：分割点y坐标(原图坐标); /* 返回：BOOL; /* 注意：; /* 示例：; /* (0,0)-------|----------| /* | | | /* | 左上 | 右上 | /* | | | /* ----------(x,y)-------|----x,y分割点坐标; /* | | | /* | 左下 | 右下 | /* | | | /* -----------|---------(r,b)- /* /* 修改：; /* 日期：; /* 内容：; /************************************************************************/ BOOL CEnBitmap::ExtendDrawImage(OUT CEnBitmap &bmp, IN CRect rc, IN int nX, IN int nY) { CBitmap *OldBmp; CDC memDC; CClientDC cdc(0); memDC.CreateCompatibleDC(&cdc); bmp.CreateCompatibleBitmap(&cdc, rc.Width(), rc.Height()); OldBmp = memDC.SelectObject(&bmp); if (nX == 0 && nY == 0) { StretchDraw(&memDC, &rc, GetRect()); return TRUE; } CDC dc; dc.CreateCompatibleDC(&memDC); CBitmap * Bmp = dc.SelectObject(this); //dc.SetStretchBltMode(COLORONCOLOR); if (nX > 0 && nY == 0) {// 左右对半; // 左边; memDC.BitBlt(0, 0, nX, rc.Height(), &dc, 0, 0, SRCCOPY); memDC.StretchBlt(nX, 0, rc.Width() - GetWidth(), rc.Height(), &dc, nX, 0, 1, GetHeight(), SRCCOPY); // 右边; memDC.BitBlt(rc.right - (GetWidth() - nX), 0, GetWidth() - nX, rc.Height(), &dc, nX, 0, SRCCOPY); } else if (nX == 0 && nY > 0) {// 上下对半; // 上边; memDC.BitBlt(0, 0, rc.Width(), nY, &dc, 0, 0, SRCCOPY); memDC.StretchBlt(0, nY, GetWidth(), rc.Height() - GetHeight(), &dc, 0, nY, GetWidth(), 1, SRCCOPY); // 下边; memDC.BitBlt(0, rc.bottom - (GetHeight() - nY), GetWidth(), GetHeight() - nY, &dc, 0, nY, SRCCOPY); } else if (nX > 0 && nY > 0) { //左上角; memDC.StretchBlt(0, 0, nX, nY, &dc, 0, 0, nX, nY, SRCCOPY); //上中; memDC.StretchBlt(nX, 0, rc.Width() - GetWidth(), nY, &dc, nX, 0, 1, nY, SRCCOPY); //右上角; memDC.StretchBlt(rc.Width() - (GetWidth() - nX), 0, GetWidth() - nX, nY, &dc, nX, 0, GetWidth() - nX, nY, SRCCOPY); //左中; memDC.StretchBlt(0, nY, nX, rc.Height() - GetHeight(), &dc, 0, nY, nX, 1, SRCCOPY); //正中; memDC.StretchBlt(nX, nY, rc.Width() - GetWidth(), rc.Height() - GetHeight(), &dc, nX, nY, 1, 1, SRCCOPY); //右中; memDC.StretchBlt(rc.Width() - (GetWidth() - nX), nY, GetWidth() - nX, rc.Height() - GetHeight(), &dc, nX, nY, GetWidth() - nX, 1, SRCCOPY); //左下角; memDC.StretchBlt(0, rc.Height() - (GetHeight() - nY), nX, GetHeight() - nY, &dc, 0, nY, nX, GetHeight() - nY, SRCCOPY); //下中; memDC.StretchBlt(nX, rc.Height() - (GetHeight() - nY), rc.Width() - GetWidth(), GetHeight() - nY, &dc, nX, nY, 1, GetHeight() - nY, SRCCOPY); //右下角; memDC.StretchBlt(rc.Width() - (GetWidth() - nX), rc.Height() - (GetHeight() - nY), GetWidth() - nX, GetHeight() - nY, &dc, nX, nY, GetWidth() - nX, GetHeight() - nY, SRCCOPY); } dc.SelectObject(Bmp); memDC.SelectObject(OldBmp); return TRUE; }