CDIB.CPP
上传用户:whhgrj
上传日期:2013-03-18
资源大小:169k
文件大小:16k
源码类别:

波变换

开发平台:

Visual C++

  1. // cdib.cpp
  2. // new version for WIN32
  3. #include "stdafx.h"
  4. #include "cdib.h"
  5. #ifdef _DEBUG
  6. #define new DEBUG_NEW
  7. #undef THIS_FILE
  8. static char THIS_FILE[] = __FILE__;
  9. #endif
  10. IMPLEMENT_SERIAL(CDib, CObject, 0);
  11. CDib::CDib()
  12. {
  13. m_hFile = NULL;
  14. m_hBitmap = NULL;
  15. m_hPalette = NULL;
  16. m_nBmihAlloc = m_nImageAlloc = noAlloc;
  17. Empty();
  18. }
  19. CDib::CDib(CSize size, int nBitCount)
  20. {
  21. m_hFile = NULL;
  22. m_hBitmap = NULL;
  23. m_hPalette = NULL;
  24. m_nBmihAlloc = m_nImageAlloc = noAlloc;
  25. Empty();
  26. ComputePaletteSize(nBitCount);
  27. m_lpBMIH = (LPBITMAPINFOHEADER) new 
  28. char[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries];
  29. m_nBmihAlloc = crtAlloc;
  30. m_lpBMIH->biSize = sizeof(BITMAPINFOHEADER);
  31. m_lpBMIH->biWidth = size.cx;
  32. m_lpBMIH->biHeight = size.cy;
  33. m_lpBMIH->biPlanes = 1;
  34. m_lpBMIH->biBitCount = nBitCount;
  35. m_lpBMIH->biCompression = BI_RGB;
  36. m_lpBMIH->biSizeImage = 0;
  37. m_lpBMIH->biXPelsPerMeter = 0;
  38. m_lpBMIH->biYPelsPerMeter = 0;
  39. m_lpBMIH->biClrUsed = m_nColorTableEntries;
  40. m_lpBMIH->biClrImportant = m_nColorTableEntries;
  41. ComputeMetrics();
  42. memset(m_lpvColorTable, 0, sizeof(RGBQUAD) * m_nColorTableEntries);
  43. m_lpImage = NULL;  // no data yet
  44. }
  45. CDib::~CDib()
  46. {
  47. Empty();
  48. }
  49. CSize CDib::GetDimensions()
  50. {
  51. if(m_lpBMIH == NULL) return CSize(0, 0);
  52. return CSize((int) m_lpBMIH->biWidth, (int) m_lpBMIH->biHeight);
  53. }
  54. BOOL CDib::AttachMapFile(const char* strPathname, BOOL bShare) // for reading
  55. {
  56. // if we open the same file twice, Windows treats it as 2 separate files
  57. // doesn't work with rare BMP files where # palette entries > biClrUsed
  58. HANDLE hFile = ::CreateFile(strPathname, GENERIC_WRITE | GENERIC_READ,
  59. bShare ? FILE_SHARE_READ : 0,
  60. NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  61. ASSERT(hFile != INVALID_HANDLE_VALUE);
  62. DWORD dwFileSize = ::GetFileSize(hFile, NULL);
  63. HANDLE hMap = ::CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, NULL);
  64. DWORD dwErr = ::GetLastError();
  65. if(hMap == NULL)
  66. {
  67. AfxMessageBox("Empty bitmap file");
  68. return FALSE;
  69. }
  70. LPVOID lpvFile = ::MapViewOfFile(hMap, FILE_MAP_WRITE, 0, 0, 0); // map whole file
  71. ASSERT(lpvFile != NULL);
  72. if(((LPBITMAPFILEHEADER) lpvFile)->bfType != 0x4d42)
  73. {
  74. AfxMessageBox("Invalid bitmap file");
  75. DetachMapFile();
  76. return FALSE;
  77. }
  78. AttachMemory((LPBYTE) lpvFile + sizeof(BITMAPFILEHEADER));
  79. m_lpvFile = lpvFile;
  80. m_hFile = hFile;
  81. m_hMap = hMap;
  82. return TRUE;
  83. }
  84. BOOL CDib::CopyToMapFile(const char* strPathname)
  85. {
  86. // copies DIB to a new file, releases prior pointers
  87. // if you previously used CreateSection, the HBITMAP will be NULL (and unusable)
  88. BITMAPFILEHEADER bmfh;
  89. bmfh.bfType = 0x4d42;  // 'BM'
  90. bmfh.bfSize = m_dwSizeImage + sizeof(BITMAPINFOHEADER) +
  91. sizeof(RGBQUAD) * m_nColorTableEntries + sizeof(BITMAPFILEHEADER);
  92. // meaning of bfSize open to interpretation
  93. bmfh.bfReserved1 = bmfh.bfReserved2 = 0;
  94. bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
  95. sizeof(RGBQUAD) * m_nColorTableEntries;
  96. HANDLE hFile = ::CreateFile(strPathname, GENERIC_WRITE | GENERIC_READ, 0, NULL,
  97. CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  98. ASSERT(hFile != INVALID_HANDLE_VALUE);
  99. int nSize =  sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
  100. sizeof(RGBQUAD) * m_nColorTableEntries +  m_dwSizeImage;
  101. HANDLE hMap = ::CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, nSize, NULL);
  102. DWORD dwErr = ::GetLastError();
  103. ASSERT(hMap != NULL);
  104. LPVOID lpvFile = ::MapViewOfFile(hMap, FILE_MAP_WRITE, 0, 0, 0); // map whole file
  105. ASSERT(lpvFile != NULL);
  106. LPBYTE lpbCurrent = (LPBYTE) lpvFile;
  107. memcpy(lpbCurrent, &bmfh, sizeof(BITMAPFILEHEADER)); // file header
  108. lpbCurrent += sizeof(BITMAPFILEHEADER);
  109. LPBITMAPINFOHEADER lpBMIH = (LPBITMAPINFOHEADER) lpbCurrent;
  110. memcpy(lpbCurrent, m_lpBMIH,
  111. sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries); // info
  112. lpbCurrent += sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries;
  113. memcpy(lpbCurrent, m_lpImage, m_dwSizeImage); // bit image
  114. DWORD dwSizeImage = m_dwSizeImage;
  115. Empty();
  116. m_dwSizeImage = dwSizeImage;
  117. m_nBmihAlloc = m_nImageAlloc = noAlloc;
  118. m_lpBMIH = lpBMIH;
  119. m_lpImage = lpbCurrent;
  120. m_hFile = hFile;
  121. m_hMap = hMap;
  122. m_lpvFile = lpvFile;
  123. ComputePaletteSize(m_lpBMIH->biBitCount);
  124. ComputeMetrics();
  125. MakePalette();
  126. return TRUE;
  127. }
  128. BOOL CDib::AttachMemory(LPVOID lpvMem, BOOL bMustDelete, HGLOBAL hGlobal)
  129. {
  130. // assumes contiguous BITMAPINFOHEADER, color table, image
  131. // color table could be zero length
  132. Empty();
  133. m_hGlobal = hGlobal;
  134. if(bMustDelete == FALSE)
  135. {
  136. m_nBmihAlloc = noAlloc;
  137. }
  138. else
  139. {
  140. m_nBmihAlloc = ((hGlobal == NULL) ? crtAlloc : heapAlloc);
  141. }
  142. try
  143. {
  144. m_lpBMIH = (LPBITMAPINFOHEADER) lpvMem;
  145. ComputeMetrics();
  146. ComputePaletteSize(m_lpBMIH->biBitCount);
  147. m_lpImage = (LPBYTE) m_lpvColorTable + sizeof(RGBQUAD) * m_nColorTableEntries;
  148. MakePalette();
  149. }
  150. catch(CException* pe)
  151. {
  152. AfxMessageBox("AttachMemory error");
  153. pe->Delete();
  154. return FALSE;
  155. }
  156. return TRUE;
  157. }
  158. UINT CDib::UsePalette(CDC* pDC, BOOL bBackground /* = FALSE */)
  159. {
  160. if(m_hPalette == NULL) return 0;
  161. HDC hdc = pDC->GetSafeHdc();
  162. ::SelectPalette(hdc, m_hPalette, bBackground);
  163. return ::RealizePalette(hdc);
  164. }
  165. BOOL CDib::Draw(CDC* pDC, CPoint origin, CSize size)
  166. {
  167. if(m_lpBMIH == NULL) return FALSE;
  168. if(m_hPalette != NULL)
  169. {
  170. ::SelectPalette(pDC->GetSafeHdc(), m_hPalette, TRUE);
  171. }
  172. pDC->SetStretchBltMode(COLORONCOLOR);
  173. ::StretchDIBits(pDC->GetSafeHdc(), origin.x, origin.y, size.cx, size.cy,
  174. 0, 0, m_lpBMIH->biWidth, m_lpBMIH->biHeight,
  175. m_lpImage, (LPBITMAPINFO) m_lpBMIH, DIB_RGB_COLORS, SRCCOPY);
  176. return TRUE;
  177. }
  178. HBITMAP CDib::CreateSection(CDC* pDC /* = NULL */)
  179. {
  180. if(m_lpBMIH == NULL) return NULL;
  181. if(m_lpImage != NULL) return NULL; // can only do this if image doesn't exist
  182. m_hBitmap = ::CreateDIBSection(pDC->GetSafeHdc(), (LPBITMAPINFO) m_lpBMIH,
  183. DIB_RGB_COLORS, (LPVOID*) &m_lpImage, NULL, 0);
  184. ASSERT(m_lpImage != NULL);
  185. return m_hBitmap;
  186. }
  187. BOOL CDib::MakePalette()
  188. {
  189. // makes a logical palette (m_hPalette) from the DIB's color table
  190. // this palette will be selected and realized prior to drawing the DIB
  191. if(m_nColorTableEntries == 0) return FALSE;
  192. if(m_hPalette != NULL) ::DeleteObject(m_hPalette);
  193. TRACE("CDib::MakePalette -- m_nColorTableEntries = %dn", m_nColorTableEntries);
  194. LPLOGPALETTE pLogPal = (LPLOGPALETTE) new char[2 * sizeof(WORD) +
  195. m_nColorTableEntries * sizeof(PALETTEENTRY)];
  196. pLogPal->palVersion = 0x300;
  197. pLogPal->palNumEntries = m_nColorTableEntries;
  198. LPRGBQUAD pDibQuad = (LPRGBQUAD) m_lpvColorTable;
  199. for(int i = 0; i < m_nColorTableEntries; i++)
  200. {
  201. pLogPal->palPalEntry[i].peRed = pDibQuad->rgbRed;
  202. pLogPal->palPalEntry[i].peGreen = pDibQuad->rgbGreen;
  203. pLogPal->palPalEntry[i].peBlue = pDibQuad->rgbBlue;
  204. pLogPal->palPalEntry[i].peFlags = 0;
  205. pDibQuad++;
  206. }
  207. m_hPalette = ::CreatePalette(pLogPal);
  208. delete pLogPal;
  209. return TRUE;
  210. }
  211. BOOL CDib::SetSystemPalette(CDC* pDC)
  212. {
  213. // if the DIB doesn't have a color table, we can use the system's halftone palette
  214. if(m_nColorTableEntries != 0) return FALSE;
  215. m_hPalette = ::CreateHalftonePalette(pDC->GetSafeHdc());
  216. return TRUE;
  217. }
  218. HBITMAP CDib::CreateBitmap(CDC* pDC)
  219. {
  220.     if (m_dwSizeImage == 0) return NULL;
  221.     HBITMAP hBitmap = ::CreateDIBitmap(pDC->GetSafeHdc(), m_lpBMIH,
  222.             CBM_INIT, m_lpImage, (LPBITMAPINFO) m_lpBMIH, DIB_RGB_COLORS);
  223.     ASSERT(hBitmap != NULL);
  224.     return hBitmap;
  225. }
  226. BOOL CDib::Compress(CDC* pDC, BOOL bCompress /* = TRUE */)
  227. {
  228. // 1. makes GDI bitmap from existing DIB
  229. // 2. makes a new DIB from GDI bitmap with compression
  230. // 3. cleans up the original DIB
  231. // 4. puts the new DIB in the object
  232. if((m_lpBMIH->biBitCount != 4) && (m_lpBMIH->biBitCount != 8)) return FALSE;
  233. // compression supported only for 4 bpp and 8 bpp DIBs
  234. if(m_hBitmap) return FALSE; // can't compress a DIB Section!
  235. TRACE("Compress: original palette size = %dn", m_nColorTableEntries); 
  236. HDC hdc = pDC->GetSafeHdc();
  237. HPALETTE hOldPalette = ::SelectPalette(hdc, m_hPalette, FALSE);
  238. HBITMAP hBitmap;  // temporary
  239. if((hBitmap = CreateBitmap(pDC)) == NULL) return FALSE;
  240. int nSize = sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries;
  241. LPBITMAPINFOHEADER lpBMIH = (LPBITMAPINFOHEADER) new char[nSize];
  242. memcpy(lpBMIH, m_lpBMIH, nSize);  // new header
  243. if(bCompress)
  244. {
  245. switch (lpBMIH->biBitCount)
  246. {
  247. case 4:
  248. lpBMIH->biCompression = BI_RLE4;
  249. break;
  250. case 8:
  251. lpBMIH->biCompression = BI_RLE8;
  252. break;
  253. default:
  254. ASSERT(FALSE);
  255. }
  256. // calls GetDIBits with null data pointer to get size of compressed DIB
  257. if(!::GetDIBits(pDC->GetSafeHdc(), hBitmap, 0, (UINT) lpBMIH->biHeight,
  258. NULL, (LPBITMAPINFO) lpBMIH, DIB_RGB_COLORS))
  259. {
  260. AfxMessageBox("Unable to compress this DIB");
  261. // probably a problem with the color table
  262.   ::DeleteObject(hBitmap);
  263. delete [] lpBMIH;
  264. ::SelectPalette(hdc, hOldPalette, FALSE);
  265. return FALSE; 
  266. }
  267. if (lpBMIH->biSizeImage == 0)
  268. {
  269. AfxMessageBox("Driver can't do compression");
  270.   ::DeleteObject(hBitmap);
  271. delete [] lpBMIH;
  272. ::SelectPalette(hdc, hOldPalette, FALSE);
  273. return FALSE; 
  274. }
  275. else
  276. {
  277. m_dwSizeImage = lpBMIH->biSizeImage;
  278. }
  279. }
  280. else
  281. {
  282. lpBMIH->biCompression = BI_RGB; // decompress
  283. // figure the image size from the bitmap width and height
  284. DWORD dwBytes = ((DWORD) lpBMIH->biWidth * lpBMIH->biBitCount) / 32;
  285. if(((DWORD) lpBMIH->biWidth * lpBMIH->biBitCount) % 32)
  286. {
  287. dwBytes++;
  288. }
  289. dwBytes *= 4;
  290. m_dwSizeImage = dwBytes * lpBMIH->biHeight; // no compression
  291. lpBMIH->biSizeImage = m_dwSizeImage;
  292. // second GetDIBits call to make DIB
  293. LPBYTE lpImage = (LPBYTE) new char[m_dwSizeImage];
  294. VERIFY(::GetDIBits(pDC->GetSafeHdc(), hBitmap, 0, (UINT) lpBMIH->biHeight,
  295.      lpImage, (LPBITMAPINFO) lpBMIH, DIB_RGB_COLORS));
  296.     TRACE("dib successfully created - height = %dn", lpBMIH->biHeight);
  297. ::DeleteObject(hBitmap);
  298. Empty();
  299. m_nBmihAlloc = m_nImageAlloc = crtAlloc;
  300. m_lpBMIH = lpBMIH;
  301. m_lpImage = lpImage;
  302. ComputeMetrics();
  303. ComputePaletteSize(m_lpBMIH->biBitCount);
  304. MakePalette();
  305. ::SelectPalette(hdc, hOldPalette, FALSE);
  306. TRACE("Compress: new palette size = %dn", m_nColorTableEntries); 
  307. return TRUE;
  308. }
  309. BOOL CDib::Read(CFile* pFile)
  310. {
  311. // 1. read file header to get size of info hdr + color table
  312. // 2. read info hdr (to get image size) and color table
  313. // 3. read image
  314. // can't use bfSize in file header
  315. // 清除DIB
  316. Empty();
  317. int nCount, nSize;
  318. BITMAPFILEHEADER bmfh;
  319. // 尝试读取BMP文件
  320. try
  321. {
  322. // 读BMP文件头
  323. nCount = pFile->Read((LPVOID) &bmfh, sizeof(BITMAPFILEHEADER));
  324. // 判断读取文件头的大小是否
  325. if(nCount != sizeof(BITMAPFILEHEADER))
  326. {
  327. // 读文件出错
  328. throw new CException;
  329. }
  330. // 判断是否是"BM"
  331. if(bmfh.bfType != 0x4d42)
  332. {
  333. // 不是BMP文件,抛出异常
  334. throw new CException;
  335. }
  336. nSize = bmfh.bfOffBits - sizeof(BITMAPFILEHEADER);
  337. m_lpBMIH = (LPBITMAPINFOHEADER) new char[nSize];
  338. m_nBmihAlloc = m_nImageAlloc = crtAlloc;
  339. nCount = pFile->Read(m_lpBMIH, nSize); // info hdr & color table
  340. ComputeMetrics();
  341. ComputePaletteSize(m_lpBMIH->biBitCount);
  342. MakePalette();
  343. m_lpImage = (LPBYTE) new char[m_dwSizeImage];
  344. nCount = pFile->Read(m_lpImage, m_dwSizeImage); // image only
  345. }
  346. catch(CException* pe)
  347. {
  348. AfxMessageBox("Read error");
  349. pe->Delete();
  350. return FALSE;
  351. }
  352. return TRUE;
  353. }
  354. BOOL CDib::ReadSection(CFile* pFile, CDC* pDC /* = NULL */)
  355. {
  356. // new function reads BMP from disk and creates a DIB section
  357. //    allows modification of bitmaps from disk
  358. // 1. read file header to get size of info hdr + color table
  359. // 2. read info hdr (to get image size) and color table
  360. // 3. create DIB section based on header parms
  361. // 4. read image into memory that CreateDibSection allocates
  362. Empty();
  363. int nCount, nSize;
  364. BITMAPFILEHEADER bmfh;
  365. try
  366. {
  367. nCount = pFile->Read((LPVOID) &bmfh, sizeof(BITMAPFILEHEADER));
  368. if(nCount != sizeof(BITMAPFILEHEADER))
  369. {
  370. throw new CException;
  371. }
  372. if(bmfh.bfType != 0x4d42)
  373. {
  374. throw new CException;
  375. }
  376. nSize = bmfh.bfOffBits - sizeof(BITMAPFILEHEADER);
  377. m_lpBMIH = (LPBITMAPINFOHEADER) new char[nSize];
  378. m_nBmihAlloc = crtAlloc;
  379. m_nImageAlloc = noAlloc;
  380. nCount = pFile->Read(m_lpBMIH, nSize); // info hdr & color table
  381. if(m_lpBMIH->biCompression != BI_RGB)
  382. {
  383. throw new CException;
  384. }
  385. ComputeMetrics();
  386. ComputePaletteSize(m_lpBMIH->biBitCount);
  387. MakePalette();
  388. UsePalette(pDC);
  389. m_hBitmap = ::CreateDIBSection(pDC->GetSafeHdc(), (LPBITMAPINFO) m_lpBMIH,
  390. DIB_RGB_COLORS, (LPVOID*) &m_lpImage, NULL, 0);
  391. ASSERT(m_lpImage != NULL);
  392. nCount = pFile->Read(m_lpImage, m_dwSizeImage); // image only
  393. }
  394. catch(CException* pe)
  395. {
  396. AfxMessageBox("ReadSection error");
  397. pe->Delete();
  398. return FALSE;
  399. }
  400. return TRUE;
  401. }
  402. BOOL CDib::Write(CFile* pFile)
  403. {
  404. BITMAPFILEHEADER bmfh;
  405. bmfh.bfType = 0x4d42;  // 'BM'
  406. int nSizeHdr = sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries;
  407. bmfh.bfSize = 0;
  408. // bmfh.bfSize = sizeof(BITMAPFILEHEADER) + nSizeHdr + m_dwSizeImage;
  409. // meaning of bfSize open to interpretation (bytes, words, dwords?) -- we won't use it
  410. bmfh.bfReserved1 = bmfh.bfReserved2 = 0;
  411. bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
  412. sizeof(RGBQUAD) * m_nColorTableEntries;
  413. try
  414. {
  415. pFile->Write((LPVOID) &bmfh, sizeof(BITMAPFILEHEADER));
  416. pFile->Write((LPVOID) m_lpBMIH,  nSizeHdr);
  417. pFile->Write((LPVOID) m_lpImage, m_dwSizeImage);
  418. }
  419. catch(CException* pe)
  420. {
  421. pe->Delete();
  422. AfxMessageBox("write error");
  423. return FALSE;
  424. }
  425. return TRUE;
  426. }
  427. void CDib::Serialize(CArchive& ar)
  428. {
  429. DWORD dwPos;
  430. dwPos = ar.GetFile()->GetPosition();
  431. TRACE("CDib::Serialize -- pos = %dn", dwPos);
  432. ar.Flush();
  433. dwPos = ar.GetFile()->GetPosition();
  434. TRACE("CDib::Serialize -- pos = %dn", dwPos);
  435. if(ar.IsStoring())
  436. {
  437. Write(ar.GetFile());
  438. }
  439. else
  440. {
  441. Read(ar.GetFile());
  442. }
  443. }
  444. // helper functions
  445. void CDib::ComputePaletteSize(int nBitCount)
  446. {
  447. if((m_lpBMIH == NULL) || (m_lpBMIH->biClrUsed == 0))
  448. {
  449. switch(nBitCount)
  450. {
  451. case 1:
  452. m_nColorTableEntries = 2;
  453. break;
  454. case 4:
  455. m_nColorTableEntries = 16;
  456. break;
  457. case 8:
  458. m_nColorTableEntries = 256;
  459. break;
  460. case 16:
  461. case 24:
  462. case 32:
  463. m_nColorTableEntries = 0;
  464. break;
  465. default:
  466. ASSERT(FALSE);
  467. }
  468. }
  469. else
  470. {
  471. m_nColorTableEntries = m_lpBMIH->biClrUsed;
  472. }
  473. ASSERT((m_nColorTableEntries >= 0) && (m_nColorTableEntries <= 256)); 
  474. }
  475. void CDib::ComputeMetrics()
  476. {
  477. if(m_lpBMIH->biSize != sizeof(BITMAPINFOHEADER))
  478. {
  479. TRACE("Not a valid Windows bitmap -- probably an OS/2 bitmapn");
  480. throw new CException;
  481. }
  482. m_dwSizeImage = m_lpBMIH->biSizeImage;
  483. if(m_dwSizeImage == 0)
  484. {
  485. DWORD dwBytes = ((DWORD) m_lpBMIH->biWidth * m_lpBMIH->biBitCount) / 32;
  486. if(((DWORD) m_lpBMIH->biWidth * m_lpBMIH->biBitCount) % 32)
  487. {
  488. dwBytes++;
  489. }
  490. dwBytes *= 4;
  491. m_dwSizeImage = dwBytes * m_lpBMIH->biHeight; // no compression
  492. }
  493. m_lpvColorTable = (LPBYTE) m_lpBMIH + sizeof(BITMAPINFOHEADER);
  494. }
  495. void CDib::Empty()
  496. {
  497. // this is supposed to clean up whatever is in the DIB
  498. DetachMapFile();
  499. if(m_nBmihAlloc == crtAlloc)
  500. {
  501. delete [] m_lpBMIH;
  502. }
  503. else if(m_nBmihAlloc == heapAlloc)
  504. {
  505. ::GlobalUnlock(m_hGlobal);
  506. ::GlobalFree(m_hGlobal);
  507. }
  508. if(m_nImageAlloc == crtAlloc)
  509. {
  510. delete [] m_lpImage;
  511. }
  512. if(m_hPalette != NULL)
  513. {
  514. ::DeleteObject(m_hPalette);
  515. }
  516. if(m_hBitmap != NULL)
  517. {
  518. ::DeleteObject(m_hBitmap);
  519. }
  520. m_nBmihAlloc = m_nImageAlloc = noAlloc;
  521. m_hGlobal = NULL;
  522. m_lpBMIH = NULL;
  523. m_lpImage = NULL;
  524. m_lpvColorTable = NULL;
  525. m_nColorTableEntries = 0;
  526. m_dwSizeImage = 0;
  527. m_lpvFile = NULL;
  528. m_hMap = NULL;
  529. m_hFile = NULL;
  530. m_hBitmap = NULL;
  531. m_hPalette = NULL;
  532. }
  533. void CDib::DetachMapFile()
  534. {
  535. if(m_hFile == NULL)
  536. {
  537. return;
  538. }
  539. ::UnmapViewOfFile(m_lpvFile);
  540. ::CloseHandle(m_hMap);
  541. ::CloseHandle(m_hFile);
  542. m_hFile = NULL;
  543. }