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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DNA > 查看源码
dib.cpp
资源名称：COM 原理与应用.rar　[点击查看]
上传用户：biuytresa
上传日期：2007-12-07
资源大小：721k
文件大小：16k
源码类别：

DNA

开发平台：

Visual C++

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