开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
Dib.cpp
资源名称：ViewDIB.rar　[点击查看]
上传用户：elida16851
上传日期：2022-08-05
资源大小：2048k
文件大小：18k
源码类别：

图形图象

开发平台：

Visual C++

Dib.cpp：源码内容
  1. // Dib.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include <stdlib.h>
  6. #include <time.h>
  7. #include <math.h>
  8. #include <windowsx.h> // especially for GlobalAllocPtr
  10. #include "Dib.h"
  12. #ifdef _DEBUG
  13. #define new DEBUG_NEW
  14. #undef THIS_FILE
  15. static char THIS_FILE[] = __FILE__;
  16. #endif
  19. IMPLEMENT_SERIAL(CDib, CObject, 0)
  21. ////////////////////////////////////////////////////////////////////////////
  22. CDib::CDib()
  23. {
  24. m_hDib = NULL;
  25. m_hBitmap   = NULL;
  26. m_pPalette  = NULL;
  27. m_pBitmap   = NULL;
  28. }           
  29.                                       
  30. CDib::~CDib()
  31. {
  32. Destroy();
  33. if (m_pBitmap != NULL)
  34. {
  35. delete m_pBitmap;
  36. m_pBitmap = NULL;
  37. }
  38. if (m_pPalette != NULL)
  39. {
  40. delete m_pPalette;
  41. m_pPalette = NULL;
  42. }
  43. }
  45. void CDib::Destroy()
  46. {
  47. if (m_hDib != NULL)
  48. {
  49. DestroyDIB(m_hDib);
  50. m_hDib = NULL;
  51. }
  52. }
  54. BOOL CDib::Create(DWORD dwWidth, DWORD dwHeight)
  55. {
  56. HDIB hDib = CreateDefaultDIB(dwWidth, dwHeight);
  57. if (! hDib)
  58. return FALSE;
  60. Destroy();
  61. m_hDib = hDib;
  62. return UpdateInternal();
  63. }
  65. BOOL CDib::Create(DWORD dwWidth, DWORD dwHeight, WORD wBitCount)
  66. {
  67. HDIB hDib = CreateDIB(dwWidth, dwHeight, wBitCount);
  68. if (! hDib)
  69. return FALSE;
  71. Destroy();
  72. m_hDib = hDib;
  73. return UpdateInternal();
  74. }
  76. BOOL CDib::Create(LPBYTE lpDIB)
  77. {
  78. if (lpDIB == NULL)
  79. return FALSE;
  81. DWORD dwSize = DIBlockSize(lpDIB);
  83.     HDIB hDib  = GlobalAlloc(GHND, dwSize); 
  84.     // Check that DIB handle is valid 
  85.     if (! hDib) 
  86.         return FALSE; 
  87.  
  88.     LPBYTE lpbi  = (LPBYTE)GlobalLock(hDib); 
  89. if (! lpbi)
  90.         return FALSE; 
  92. CopyMemory(lpbi, lpDIB, dwSize);
  93. GlobalUnlock(hDib);
  95. Destroy();
  96. m_hDib = hDib;
  97. return UpdateInternal();
  98. }
  100. BOOL CDib::Create(LPBYTE lpDIB,
  101.   WORD  wBitCount) // bits/pixel 
  102. {
  103. if (lpDIB == NULL)
  104. return FALSE;
  105. if (! Create(lpDIB))
  106. return FALSE;
  108. WORD wBits = ((LPBITMAPINFOHEADER)lpDIB)->biBitCount;
  109. if (wBitCount == wBits)
  110. return TRUE;
  112. HDIB hNewDib = ConvertDIBFormat(m_hDib, wBitCount, NULL); 
  113. if (! hNewDib)
  114. return FALSE;
  116. Destroy();
  117. m_hDib = hNewDib;
  118. return UpdateInternal();
  119. }
  121. BOOL CDib::Create(HBITMAP hBitmap) // DIB Section
  122. {
  123. if (! hBitmap)
  124.         return FALSE; 
  126. HDIB hDib = DIBSectionToDIB(hBitmap); 
  127.     if (! hDib) 
  128.         return FALSE; 
  130. Destroy();
  131. m_hDib = hDib;
  132. return UpdateInternal();
  133. }
  135. BOOL CDib::Create(HBITMAP hBitmap, // DIB Section
  136.   WORD  wBitCount) // bits/pixel 
  137. {
  138. HDIB hNewDib;
  140. if (! hBitmap)
  141.         return FALSE; 
  143. HDIB hDib = DIBSectionToDIB(hBitmap); 
  144.     if (! hDib) 
  145.         return FALSE; 
  147. DIBSECTION ds;
  148. GetObject(hBitmap, sizeof(DIBSECTION), &ds);
  150. if (wBitCount == ds.dsBmih.biBitCount)
  151. hNewDib = hDib;
  152. else
  153. {
  154. hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL); 
  155. // cleanup hDib
  156. GlobalFree(hDib);
  157. }
  158. if (! hNewDib)
  159. return FALSE;
  161. Destroy();
  162. m_hDib = hNewDib;
  163. return UpdateInternal();
  164. }
  166. BOOL CDib::Create(HBITMAP hBitmap, // DDB bitmap
  167.       HPALETTE hPalette) // DDB palette
  168. {
  169. if (! hBitmap)
  170.         return FALSE; 
  172. HDIB hDib = BitmapToDIB(hBitmap, hPalette); 
  173.     if (! hDib) 
  174.         return FALSE; 
  176. Destroy();
  177. m_hDib = hDib;
  178. return UpdateInternal();
  179. }
  181. BOOL CDib::Create(HBITMAP hBitmap, // DDB bitmap
  182.       HPALETTE hPalette, // DDB palette
  183.   WORD  wBitCount) // bits/pixel 
  184. {
  185. if (! hBitmap)
  186.         return FALSE; 
  188. HDIB hDib = BitmapToDIB(hBitmap, hPalette, wBitCount); 
  189.     if (! hDib) 
  190.         return FALSE; 
  192. Destroy();
  193. m_hDib = hDib;
  194. return UpdateInternal();
  195. }
  197. BOOL CDib::Create(CRect rcScreen)
  198. {
  199. HDIB hDib = CopyScreenToDIB(rcScreen); 
  200.     if (! hDib) 
  201.         return FALSE; 
  203. Destroy();
  204. m_hDib = hDib;
  205. return UpdateInternal();
  206. }
  208. BOOL CDib::Create(HWND hWnd, WORD fPrintArea)
  209. {
  210. HDIB hDib = CopyWindowToDIB(hWnd, fPrintArea); 
  211.     if (! hDib) 
  212.         return FALSE; 
  214. Destroy();
  215. m_hDib = hDib;
  216. return UpdateInternal();
  217. }
  219. BOOL CDib::Create(HWND hWnd, CRect rcClientArea)
  220. {
  221. HDIB hDib = CopyClientRectToDIB(hWnd, rcClientArea); 
  222.     if (! hDib) 
  223.         return FALSE; 
  225. Destroy();
  226. m_hDib = hDib;
  227. return UpdateInternal();
  228. }
  230. void CDib::Serialize(CArchive& ar)
  231. {
  232. CObject::Serialize(ar);
  233. ar.Flush();
  234. if (ar.IsStoring())
  235. {
  236. Write(ar.GetFile());
  237. }
  238.     else
  239.     {
  240.     Read(ar.GetFile());
  241.     }
  242. }
  244. BOOL CDib::Load(UINT uIDS, LPCTSTR lpszDibType)
  245. {                                
  246. LPCTSTR lpszDibRes = MAKEINTRESOURCE(uIDS);
  248. return Load(lpszDibRes, lpszDibType);
  249. }
  251. BOOL CDib::Load(LPCTSTR lpszDibRes, LPCTSTR lpszDibType)
  252. {                                
  253. HINSTANCE hInst = AfxGetInstanceHandle();
  254. HRSRC   hRes    = ::FindResource(hInst, lpszDibRes, lpszDibType);
  255. HGLOBAL hData   = ::LoadResource(hInst, hRes);
  257. // if resource ok?
  258. if (hRes == NULL || hData == NULL)
  259. return FALSE;
  261. // get resource buffer
  262. LPBYTE lpBuf = (LPBYTE)::LockResource(hData);
  263. // is DIB ?
  264. if (((LPBITMAPFILEHEADER)lpBuf)->bfType != DIB_HEADER_MARKER/*"BM"*/)
  265. return FALSE;
  267. // use this buffer to create CDib
  268. LPBYTE lpDIB = lpBuf + sizeof(BITMAPFILEHEADER);
  269. return Create(lpDIB);
  270. }
  272. BOOL CDib::Load(LPCTSTR lpszDibFile)
  273. {                                
  274. TRY
  275. {
  276. CFile file(lpszDibFile, CFile::modeRead|CFile::shareDenyNone);
  278. if (! Read(&file))
  279. return FALSE;
  280. }
  281. CATCH (CException, e)
  282. {
  283. return FALSE;
  284. }
  285. END_CATCH
  287. return TRUE;
  288. }               
  290. BOOL CDib::Save(LPCSTR lpszDibFile)
  291. {
  292. TRY
  293. {
  294. CFile file(lpszDibFile, CFile::modeCreate|CFile::modeWrite);
  296. if (! Write(&file))
  297. return FALSE;
  298. }
  299. CATCH (CException, e)
  300. {
  301. return FALSE;
  302. }
  303. END_CATCH
  305. return TRUE;
  306. }
  308. BOOL CDib::Read(CFile *pFile)
  309. {
  310. WaitCursorBegin();
  312. LPBITMAPINFOHEADER lpbi;
  313. DWORD dwSize;
  314. TRY
  315. {
  316. // read DIB file header
  317. BITMAPFILEHEADER bmfHdr;
  318. pFile->Read(&bmfHdr, sizeof(BITMAPFILEHEADER));
  319. // is DIB file?
  320. if (bmfHdr.bfType != DIB_HEADER_MARKER/*"BM"*/)
  321. {
  322. WaitCursorEnd();
  323. return FALSE;
  324. }
  325. DWORD dwLength = pFile->GetLength();
  326. if (bmfHdr.bfSize != dwLength)
  327. bmfHdr.bfSize = dwLength;
  329. // read DIB buffer
  330. dwSize = bmfHdr.bfSize - sizeof(BITMAPFILEHEADER);
  331. lpbi = (LPBITMAPINFOHEADER)GlobalAllocPtr(GHND, dwSize);
  332. DWORD dwCount = pFile->Read(lpbi, dwSize);
  333. // read ok?
  334. if (dwCount != dwSize)
  335. {
  336. GlobalFreePtr(lpbi);
  337. WaitCursorEnd();
  338. return FALSE;
  339. }
  341. // Check to see that it's a Windows DIB -- an OS/2 DIB would cause 
  342. // strange problems with the rest of the DIB API since the fields 
  343. // in the header are different and the color table entries are 
  344. // smaller. 
  345. // 
  346. // If it's not a Windows DIB (e.g. if biSize is wrong), return NULL. 
  347.     if (lpbi->biSize != sizeof(BITMAPINFOHEADER)) 
  348. {
  349. GlobalFreePtr(lpbi);
  350. WaitCursorEnd();
  351. return FALSE;
  352. }
  354. // fill color num item
  355. int nNumColors = (UINT)lpbi->biClrUsed;
  356. if (nNumColors == 0) 
  357. { 
  358. // no color table for 24-bit, default size otherwise 
  359.         if (lpbi->biBitCount != 24) 
  360.         nNumColors = 1 << lpbi->biBitCount; // standard size table 
  361. } 
  362.  
  363. // fill in some default values if they are zero 
  364.     if (lpbi->biClrUsed == 0) 
  365.     lpbi->biClrUsed = nNumColors; 
  366. if (lpbi->biSizeImage == 0) 
  367. lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3) * lpbi->biHeight; 
  368.   }
  369. CATCH (CException, e)
  370. {
  371. GlobalFreePtr(lpbi);
  372. WaitCursorEnd();
  373. return FALSE;
  374. }
  375. END_CATCH
  377. // create CDib with DIB buffer
  378. BOOL bSuccess = Create((LPBYTE)lpbi);
  379. GlobalFreePtr(lpbi);
  380. WaitCursorEnd();
  382. return bSuccess;
  383. }
  385. BOOL CDib::Write(CFile *pFile)
  386. {
  387. WaitCursorBegin();
  389.     BITMAPFILEHEADER    bmfHdr;     // Header for Bitmap file 
  390.     LPBITMAPINFOHEADER  lpBI;       // Pointer to DIB info structure 
  391.     DWORD               dwDIBSize; 
  393. // Get a pointer to the DIB memory, the first of which contains 
  394.     // a BITMAPINFO structure 
  395.     lpBI = (LPBITMAPINFOHEADER)GlobalLock(m_hDib); 
  396.     if (!lpBI) 
  397. {
  398. GlobalUnlock(m_hDib);
  399. WaitCursorEnd();
  400.         return FALSE; 
  401. }
  402.  
  403.     // Check to see if we're dealing with an OS/2 DIB.  If so, don't 
  404.     // save it because our functions aren't written to deal with these 
  405.     // DIBs. 
  406.     if (lpBI->biSize != sizeof(BITMAPINFOHEADER)) 
  407.     { 
  408.         GlobalUnlock(m_hDib); 
  409. WaitCursorEnd();
  410.         return FALSE; 
  411.     } 
  412.  
  413.     // Fill in the fields of the file header 
  414.  
  415.     // Fill in file type (first 2 bytes must be "BM" for a bitmap) 
  416.  
  417.     bmfHdr.bfType = DIB_HEADER_MARKER;  // "BM" 
  418.  
  419.     // Calculating the size of the DIB is a bit tricky (if we want to 
  420.     // do it right).  The easiest way to do this is to call GlobalSize() 
  421.     // on our global handle, but since the size of our global memory may have 
  422.     // been padded a few bytes, we may end up writing out a few too 
  423.     // many bytes to the file (which may cause problems with some apps, 
  424.     // like HC 3.0). 
  425.     // 
  426.     // So, instead let's calculate the size manually. 
  427.     // 
  428.     // To do this, find size of header plus size of color table.  Since the 
  429.     // first DWORD in both BITMAPINFOHEADER and BITMAPCOREHEADER conains 
  430.     // the size of the structure, let's use this. 
  431.  
  432.     // Partial Calculation 
  433.  
  434.     dwDIBSize = *(LPDWORD)lpBI + PaletteSize((LPBYTE)lpBI);   
  435.  
  436.     // Now calculate the size of the image 
  437.  
  438.     // It's an RLE bitmap, we can't calculate size, so trust the biSizeImage 
  439.     // field 
  440.  
  441.     if ((lpBI->biCompression == BI_RLE8) || (lpBI->biCompression == BI_RLE4)) 
  442.         dwDIBSize += lpBI->biSizeImage; 
  443.     else 
  444.     { 
  445.         DWORD dwBmBitsSize;  // Size of Bitmap Bits only 
  446.  
  447.         // It's not RLE, so size is Width (DWORD aligned) * Height 
  448.  
  449.         dwBmBitsSize = WIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount)) * 
  450.                 lpBI->biHeight; 
  451.  
  452.         dwDIBSize += dwBmBitsSize; 
  453.  
  454.         // Now, since we have calculated the correct size, why don't we 
  455.         // fill in the biSizeImage field (this will fix any .BMP files which  
  456.         // have this field incorrect). 
  457.  
  458.         lpBI->biSizeImage = dwBmBitsSize; 
  459.     } 
  460.  
  461.  
  462.     // Calculate the file size by adding the DIB size to sizeof(BITMAPFILEHEADER) 
  463.                     
  464.     bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER); 
  465.     bmfHdr.bfReserved1 = 0; 
  466.     bmfHdr.bfReserved2 = 0; 
  467.  
  468.     // Now, calculate the offset the actual bitmap bits will be in 
  469.     // the file -- It's the Bitmap file header plus the DIB header, 
  470.     // plus the size of the color table. 
  471.      
  472.     bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpBI->biSize + 
  473.             PaletteSize((LPBYTE)lpBI); 
  474.  
  475.   TRY
  476. {
  477.     // Write the file header 
  478. pFile->Write(&bmfHdr, sizeof(BITMAPFILEHEADER));
  479. // write DIB buffer
  480. pFile->Write(lpBI, dwDIBSize);
  481. }
  482. CATCH (CException, e)
  483. {
  484.         GlobalUnlock(m_hDib); 
  485. WaitCursorEnd();
  486. return FALSE;
  487. }
  488. END_CATCH
  490. GlobalUnlock(m_hDib); 
  491. WaitCursorEnd();
  493. return TRUE;
  494. }
  496. BOOL CDib::Display(CDC* pDC, int xDest, int yDest, int nWidthDest, int nHeightDest, 
  497.      int xSrc, int ySrc, DWORD dwRop)
  498. {
  499. CDC MemDC;
  500. MemDC.CreateCompatibleDC(pDC);
  502. CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);
  504. CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
  505.     pDC->RealizePalette();
  507. BOOL bSuccess = pDC->BitBlt( xDest, yDest, 
  508. nWidthDest, nHeightDest,
  509.     &MemDC, 
  510. xSrc, ySrc, 
  511. dwRop);
  513. MemDC.SelectObject(pOldBmp);
  514. pDC->SelectPalette(pOldPal, TRUE);
  516. return bSuccess;
  517. }
  519. BOOL CDib::Display(CDC * pDC, int xDest, int yDest, int nWidthDest, int nHeightDest, 
  520.    int xSrc, int ySrc, int nWidthSrc, int nHeightSrc, DWORD dwRop)
  521. {
  522. CDC MemDC;
  523. MemDC.CreateCompatibleDC(pDC);
  525. CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);
  527. CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
  528.     pDC->RealizePalette();
  530. BOOL bSuccess = pDC->StretchBlt( xDest, yDest, 
  531. nWidthDest, nHeightDest,
  532.         &MemDC, 
  533. xSrc, ySrc, 
  534. nWidthSrc, nHeightSrc, 
  535. dwRop);
  537. MemDC.SelectObject(pOldBmp);
  538. pDC->SelectPalette(pOldPal, TRUE);
  540. return bSuccess;
  541. }
  543. BOOL CDib::Display(CDC * pDC, int x, int y, DWORD dwRop)
  544. {
  545. CDC MemDC;
  546. MemDC.CreateCompatibleDC(pDC);
  548. CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);
  550. CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
  551.     pDC->RealizePalette();
  553. BOOL bSuccess = pDC->BitBlt(x, y, 
  554. GetWidth(), GetHeight(),
  555. &MemDC, 
  556. 0, 0, 
  557. dwRop);
  559. MemDC.SelectObject(pOldBmp);
  560. pDC->SelectPalette(pOldPal, TRUE);
  562. return bSuccess;
  563. }
  565. BOOL CDib::Display(CDC* pDC, CRect rcDest, CRect rcSrc, DWORD dwRop)
  566. {
  567. CDC MemDC;
  568. MemDC.CreateCompatibleDC(pDC);
  570. CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);
  572. CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
  573.     pDC->RealizePalette();
  575. BOOL bSuccess = pDC->StretchBlt( rcDest.left, rcDest.top, 
  576. rcDest.Width(), rcDest.Height(),
  577.         &MemDC, 
  578. rcSrc.left, rcSrc.top, 
  579. rcSrc.Width(), rcSrc.Height(),
  580. dwRop);
  582. MemDC.SelectObject(pOldBmp);
  583. pDC->SelectPalette(pOldPal, TRUE);
  585. return bSuccess;
  586. }
  588. BOOL CDib::BuildBitmap()
  589. {
  590. if (m_pBitmap != NULL)
  591. {
  592. delete m_pBitmap;
  593. m_pBitmap = NULL;
  594. m_hBitmap = NULL;
  595. }
  596. m_hBitmap = DIBToDIBSection(m_hDib);
  597. if (m_hBitmap == NULL)
  598. return FALSE;
  599. m_pBitmap = new CBitmap;
  600. m_pBitmap->Attach(m_hBitmap);
  602. return TRUE;
  603. }
  605. BOOL CDib::BuildPalette()
  606. {
  607. if (m_pPalette != NULL)
  608. {
  609. delete m_pPalette;
  610. m_pPalette = NULL;
  611. }
  612. HPALETTE hPalette = CreateDIBPalette(m_hDib);
  613. if (hPalette == NULL)
  614. return FALSE;
  615. m_pPalette = new CPalette;
  616. m_pPalette->Attach(hPalette);
  618. return TRUE;
  619. }
  621. BOOL CDib::UpdateInternal()
  622. {
  623. BuildPalette();
  624. return BuildBitmap();
  625. }
  627. CPalette* CDib::GetPalette()
  628. {
  629. return m_pPalette;
  630. }
  632. CBitmap* CDib::GetBitmap()
  633. {
  634. return m_pBitmap;
  635. }
  637. BOOL CDib::IsEmpty()
  638. {
  639. if (m_hDib == NULL)
  640. return TRUE;
  642. if (! GlobalLock(m_hDib))
  643. return TRUE;
  645. GlobalUnlock(m_hDib);
  646. return FALSE;
  647. }
  649. DWORD CDib::GetCompression()
  650. {
  651.     LPBITMAPINFOHEADER lpBI = (LPBITMAPINFOHEADER)GlobalLock(m_hDib); 
  652.     if (!lpBI) 
  653. {
  654. GlobalUnlock(m_hDib);
  655.         return 0; 
  656. }
  657.  
  658. DWORD dwCompression = lpBI->biCompression;
  659. GlobalUnlock(m_hDib);
  661. return dwCompression;
  662. }
  664. WORD CDib::GetBitCount()
  665. {
  666.     LPBITMAPINFOHEADER lpBI = (LPBITMAPINFOHEADER)GlobalLock(m_hDib); 
  667.     if (!lpBI) 
  668. {
  669. GlobalUnlock(m_hDib);
  670.         return 0; 
  671. }
  672.  
  673. WORD wBitCount = lpBI->biBitCount;
  674. GlobalUnlock(m_hDib);
  676. return wBitCount;
  677. }
  679. LONG CDib::GetWidth()
  680. {
  681. // get DIB buffer pointer
  682.     LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib); 
  683. if (! lpDIB)
  684. {
  685. GlobalUnlock(m_hDib);
  686. return 0;
  687. }
  689. LONG lWidth = (LONG)DIBWidth(lpDIB);
  690. GlobalUnlock(m_hDib);
  692. return lWidth; 
  693. }
  695. LONG CDib::GetHeight()
  696. {
  697. // get DIB buffer pointer
  698.     LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib); 
  699. if (! lpDIB)
  700. {
  701. GlobalUnlock(m_hDib);
  702. return 0;
  703. }
  705. LONG lHeight = (LONG)DIBHeight(lpDIB);
  706. GlobalUnlock(m_hDib);
  708. return lHeight; 
  709. }
  711. LONG CDib::GetWidthBytes()
  712. {
  713. return WIDTHBYTES((GetWidth())*((DWORD)GetBitCount()));
  714. }
  716. COLORREF CDib::GetPixel(LONG x, LONG y)
  717. {
  718. COLORREF cColor;
  719. switch (GetBitCount())
  720. {
  721. case 1 : if (1<<(7-x%8) & 
  722. *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)))
  723. cColor = RGB(255,255,255);
  724. else
  725. cColor = RGB(0,0,0);
  726. break;
  727. case 4 :
  728. {
  729. PALETTEENTRY PaletteColors[16];
  730. m_pPalette->GetPaletteEntries(0, 16, PaletteColors);
  731. int nIndex = (*(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)) & 
  732.    (x%2 ? 0x0f : 0xf0)) >> (x%2 ? 0 : 4);
  733. cColor = RGB(PaletteColors[nIndex].peRed,
  734.  PaletteColors[nIndex].peGreen,
  735.  PaletteColors[nIndex].peBlue);
  736. }
  737. break;
  738. case 8 :
  739. {
  740. PALETTEENTRY PaletteColors[256];
  741. m_pPalette->GetPaletteEntries(0, 256, PaletteColors);
  742. int nIndex = *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y));
  743. cColor = RGB(PaletteColors[nIndex].peRed,
  744.  PaletteColors[nIndex].peGreen,
  745.  PaletteColors[nIndex].peBlue);
  746. }
  747. break;
  748. default: cColor = RGB(*(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)),
  749.  *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)+1),
  750.  *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)+2));
  751. break;
  752. }
  753. return cColor;
  754. }
  756. LONG CDib::GetPixelOffset(LONG x, LONG y)
  757. {
  758. return (GetHeight()-y-1)*GetWidthBytes()+(x*GetBitCount())/8;
  759. }
  761. LPBYTE CDib::GetBitsPtr()
  762. {
  763.     LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib); 
  764.     if (! lpDIB) 
  765. {
  766. GlobalUnlock(m_hDib);
  767. return NULL;
  768. }
  770. LPBYTE lpData = FindDIBBits(lpDIB);
  771. GlobalUnlock(m_hDib);
  773. return lpData;
  774. }
  776. HANDLE CDib::GetHandle()
  777. {
  778. return m_hDib;
  779. }
  781. WORD CDib::GetColorNumber()
  782. {
  783.     LPBYTE lpBI = (LPBYTE)GlobalLock(m_hDib); 
  784.     if (! lpBI) 
  785. {
  786. GlobalUnlock(m_hDib);
  787. return 0;
  788. }
  789.  
  790. WORD wColors = DIBNumColors(lpBI);
  791. GlobalUnlock(m_hDib);
  793. return wColors;
  794. }
  796. WORD CDib::GetPaletteSize()
  797. {
  798.     LPBYTE lpBI = (LPBYTE)GlobalLock(m_hDib); 
  799.     if (! lpBI) 
  800. {
  801. GlobalUnlock(m_hDib);
  802. return 0;
  803. }
  804.  
  805. WORD wPalSize = PaletteSize(lpBI);
  806. GlobalUnlock(m_hDib);
  808. return wPalSize;
  809. }
  811. CDC* CDib::BeginPaint(CDC *pDC)
  812. {
  813. m_pMemDC = new CDC;
  814. m_pMemDC->CreateCompatibleDC(pDC);
  815. m_pPaletteTmp = m_pMemDC->SelectPalette(m_pPalette, TRUE);
  816. m_pMemDC->RealizePalette();
  817. m_pBitmapTmp = (CBitmap *)m_pMemDC->SelectObject(m_pBitmap);
  818. return m_pMemDC;
  819. }
  821. void CDib::EndPaint()
  822. {
  823. m_pMemDC->SelectObject(m_pBitmapTmp);
  824. m_pMemDC->SelectPalette(m_pPaletteTmp, TRUE);
  825. delete m_pMemDC;
  827. Create(m_hBitmap);
  828. }
  830. BOOL CDib::DisplayPalette(CDC* pDC, CRect rc)
  831. {
  832. return ::DisplayPalette(pDC->GetSafeHdc(), &rc, (HPALETTE)m_pPalette->GetSafeHandle());
  833. }
  835. CDib * CDib::Clone()
  836. {
  837. if (m_hDib == NULL)
  838. return NULL;
  840. HDIB hDIB = CopyHandle(m_hDib);
  841. if (hDIB == NULL)
  842. return NULL;
  844. CDib *pDib = new CDib;
  845. pDib->m_hDib = hDIB;
  846. pDib->BuildPalette();
  847. pDib->BuildBitmap();
  849. return pDib;
  850. }