BMP位图处理类(转)

1. /*
2.   目的：BMP位图处理类。（定义文件）
4.   创建：张伟(SXZ)
5.   版本：2.4
7.   SXZ software workgroup. No.200001
8. */
9. ///////////////////////////////////////////////////////////////////////
12. #ifndef __BMPPROC_H__
13. #define __BMPPROC_H__
15. /* 版本 */
16. #define BMPPROC_VERSION   0x240
18. // DIBSCANLINE_WIDTHBYTES 执行DIB扫描行的DWORD对齐操作。宏参数“bits”是
19. // DIB信息结构中成员biWidth和biBitCount的乘积。宏的结果是经过对齐后一个
20. // 扫描行所占的字节数。
21. #define DIBSCANLINE_WIDTHBYTES(bits)    (((bits)+31)/32*4)
22. // DDBSCANLINE_WIDTHBYTES 执行DDB扫描行的WORD对齐操作。宏参数“bits”是
23. // DDB信息结构中成员bmWidth和bmBitCount的乘积。宏的结果是经过对齐后一个
24. // 扫描行所占的字节数。
25. #define DDBSCANLINE_WIDTHBYTES(bits)    (((bits)+15)/16*2)
27. /* DIB 文件头标志（"BM") */
28. #define DIB_HEADER_MARKER   ((WORD)('M'<<8)|'B')
30. // 常用颜色定义
31. #define CBPCOLOR_BLACK        ((COLORREF)RGB(0,0,0))
32. #define CBPCOLOR_GRAY        ((COLORREF)RGB(128,128,128))
33. #define CBPCOLOR_HIGHGRAY    ((COLORREF)RGB(192,192,192))
34. #define CBPCOLOR_WHITE        ((COLORREF)RGB(255,255,255))
35. #define CBPCOLOR_RED        ((COLORREF)RGB(255,0,0))
36. #define CBPCOLOR_GREEN        ((COLORREF)RGB(0,255,0))
37. #define CBPCOLOR_BLUE        ((COLORREF)RGB(0,0,255))
40. // 注意：类CBmpProc是从CBitmap类公有继承而来的，但最好不要使用类CBitmap
41. // 中的函数！如果使用了（尤其是读入或创建型的函数），则就不要再使用CBmpProc
42. // 类中的函数，以免混乱。
44. class CBmpProc : public CBitmap
45. {
46. public:
47.     CBmpProc();
48.     ~CBmpProc();
50.     BOOL Create(int width, int height, WORD nBitCount, const void *lpBits=NULL);
51.     BOOL Create(CSize size, WORD nBitCount, const void *lpBits=NULL);
52.     BOOL CreateCompatible(int width, int height, CDC *pDC=NULL, const void *lpBits=NULL);
54.     BOOL CopyFromObject(CBmpProc& souBmp, CRect *pDesRect=NULL, CRect *pSouRect=NULL);
55.     BOOL CopyFromHbmp(HBITMAP souBmp, CRect *pDesRect=NULL, CRect *pSouRect=NULL);
56.     BOOL CopyTran(CBmpProc& souBmp, COLORREF crColour=CBPCOLOR_WHITE,
57.             CRect *pDesRect=NULL, CRect *pSouRect=NULL, int mode=0);
58.     BOOL CopyTran(CBmpProc& souBmp, COLORREF crColour=CBPCOLOR_WHITE,
59.             int x=0, int y=0, CRect *pSouRect=NULL, int mode=0);
60.     BOOL CopyTranCenter(CBmpProc& souBmp, CRect* crArea=NULL,
61.             COLORREF crColour=CBPCOLOR_WHITE, int mode=0);
62.     BOOL CopyTranTile(CBmpProc& souBmp, CRect* crArea=NULL,
63.             COLORREF crColour=CBPCOLOR_WHITE, int mode=0);
65.     BOOL LoadFromFile(LPCTSTR lpszPathName);
66.     BOOL LoadFromResourceID(UINT uID, HINSTANCE hInst);
67.     BOOL LoadFromResourceName(LPCTSTR lpResourceName, HINSTANCE hInst);
68.     BOOL LoadFromObject(CBmpProc& souBmp, CRect *pSouRect=NULL);
69.     BOOL LoadFromHbmp(HBITMAP sou, CRect *pSouRect=NULL);
70.     BOOL LoadFromClipboard();
72.     BOOL Save(LPCTSTR lpszNewFileName=NULL, WORD nBitsPerPixel=0);
73.     BOOL SaveToClipboard();
75.     BOOL Draw(CDC& dc, const CRect* rcDst=NULL, const CRect* rcSrc=NULL);
76.     BOOL DrawTile(CDC& dc, CRect* crArea);
77.     BOOL DrawCenter(CDC& dc, CRect* crArea);
78.     BOOL DrawTransparentInRect(CDC& dc, COLORREF crColour=CBPCOLOR_WHITE,
79.             CRect* crDest=NULL, CRect* crSou=NULL, int mode=0);
80.     BOOL DrawTransparentInPoint(CDC& dc, COLORREF crColour=CBPCOLOR_WHITE,
81.             int x=0, int y=0, CRect* crSou=NULL, int mode=0);
82.     BOOL DrawTranCenter(CDC& dc, CRect* crArea, COLORREF crColour=CBPCOLOR_WHITE, int mode=0);
83.     BOOL DrawTranTile(CDC& dc, CRect* crArea, COLORREF crColour=CBPCOLOR_WHITE, int mode=0);
85.     BOOL Attach(HBITMAP hBmp);
86.     HBITMAP Detach();
87.     void Clear();
88.     HRGN ExportRegion(COLORREF cTranColor=CBPCOLOR_WHITE);
89.     BOOL Fill(COLORREF crColour=CBPCOLOR_WHITE, CRect *crArea=NULL);
90.     BOOL ReSetColor(COLORREF oldcolr, COLORREF newcolr, CRect *crArea=NULL);
91.           
92.     // 重载操作符函数
93.     CBmpProc& operator=(const CBmpProc& ds);
94.     CBmpProc& operator=(const HBITMAP sou);
95.     BOOL operator==(const CBmpProc& ds);
96.     BOOL operator!=(const CBmpProc& ds);
97.     operator HBITMAP() const { return (HBITMAP)m_hObject; };
100.     // 类数据访问函数
101.     CSize Size() const;
102.     CRect Rect() const;
103.     int   Width() const;
104.     int   Height() const;
105.     int   ScanWidth() const;
106.     int   BitsPerPixel() const;
108.     BOOL  IsValid() const;
110.     //访问类内部数据的介面函数
111.     int   GetImageType() const;
112.     DWORD GetInAddInfo() const;
113.     const CString& GetFileName() const;
114.     BOOL  SetFileName(LPSTR pSou);
115.     int   GetObject(LPBITMAP lpBitmap) const;
117.     HANDLE GetHDib() const;
118.     WORD GetVersion() const;
120. #ifdef _DEBUG
121.     static DWORD GetObjectCount() {return m_ObjectCount;};
122. #endif
124. protected:
125.     // 助手函数（与类无关）
126.     LPSTR FindDIBBits(LPSTR lpbi) const;
127.     DWORD DIBWidth(LPBITMAPINFOHEADER lpbi) const;
128.     DWORD DIBHeight(LPBITMAPINFOHEADER lpbi) const;
129.     WORD PaletteSize(LPBITMAPINFOHEADER lpbi) const;
130.     WORD DIBNumColors(LPBITMAPINFOHEADER lpbi) const;
131.     int    GetBitsPerPixel(LPBITMAPINFOHEADER lpbi) const;
133.     LPVOID CreateMemoryBlockFromHandle(HANDLE handle, DWORD dwCount=0);
134.     LPVOID CreateMemoryBlockFromAddress(LPVOID pSou, DWORD dwCount=0);
136.     BOOL IsValidBmpFile(CFile& file);
137.     LPBITMAPINFO GetBmpFileInfo(CFile& file);
138.     LPSTR GetBmpFileBits(CFile& file);
139.     BOOL IsValidDibFormat(WORD nBitsPerPixel);
140.     BOOL IsFileExist(LPCTSTR lpFileName);
142.     DWORD CalculateDIBFileSize(LPBITMAPINFOHEADER lpbi) const;
143.     DWORD CalculateDIBSize(LPBITMAPINFOHEADER lpbi) const;
144.     DWORD CalculateDIBitsOff(LPBITMAPINFOHEADER lpbi) const;
145.     DWORD CalculateDIBInfoSize(LPBITMAPINFOHEADER lpbi) const;
146.     DWORD CalculateDIBitsSize(LPBITMAPINFOHEADER lpbi) const;
147.     
148.     BOOL PasteAvailable();
151.     // 内部服务函数（与类有关）
152.     BOOL SaveBaseSpecifyFileName(LPCTSTR fn);
153.     BOOL SaveBaseSpecifyFormat(WORD nBitsPerPixel);
154.     LPBITMAPINFO GetSpecifyFormatInfo(WORD newBitCount=0);
155.     BOOL ClearAndSetData(int type, DWORD addinfo, LPCTSTR lpFn, LPBITMAPINFO pInfo, HBITMAP hBmp);
157. public:
158.     enum            // 位图的初始来源类型：
159.     {
160.         IT_NULL,        // 无位图类型
161.         IT_DISKFILE,    // 文件位图
162.         IT_RESOURCE,    // 资源位图
163.         IT_MEMORY,        // 内存位图
164.         IT_CLIP,        // 剪贴板位图
165.         IT_CREATE        // 创建型位图
166.     };
168. private:
169.     // 数据成员
170.     BOOL m_mark;        // 类的有效标志。（TRUE-本类中有位图，
171.                         // FALSE-本类中没有位图）
172.     int  m_type;        // 图像类型，只能使用上面枚举类型值
173.     DWORD   m_addInfo;    // 附加信息。
174.     CString    m_cFileName;// 文件路径。
175.     LPBITMAPINFO  m_pInfo;    // DIB 信息结构
177. #ifdef _DEBUG
178.     static DWORD m_ObjectCount;    // 本类构造的实例目标个数，供调试使用
179. #endif
180. };
182. #endif /*__BMPPROC_H__*/
183. 
     
     源代码文件 BmpProc.cpp
     
     

复制代码

1. ///////////////////////////////////////////////////////////////////////
2. /*
3.   目的：BMP位图处理类。（源代码文件）
5.   创建：张伟(SXZ)
6.   版本：2.4
8.   SXZ software workgroup. No.200001
9. */
10. ///////////////////////////////////////////////////////////////////////
12. ///////////////////////////////////////////////////////////////////////
13. /*
14.   注释：
16.   # 类中的位图都是兼容于当前显示器颜色格式的DDB位图
17.   # 如果读入的位图格式与当前显示器的颜色格式不同，则读入函数会先将其转换
18.     为兼容于当前显示器颜色格式的位图之后才放入类中
19.   # 对于所有BOOL型返回的函数，TRUE表示成功，FALSE表示失败
22. */
23. ///////////////////////////////////////////////////////////////////////
25. #include "stdafx.h"
26. #include
27. #include
28. #include
29. #include
30. #include
31. #include
32. #include
33. #include
35. #include "BmpProc.h"
38. ////////////////////////////// defines ///////////////////////////////////
39. #ifdef _DEBUG
40. #define new DEBUG_NEW
41. #undef THIS_FILE
42. static char THIS_FILE[] = __FILE__;
43. #endif
47. // 用于调试目的计数变量，它表示程序中构造的CBmpProc类实例个数
48. // 可以用类中static DWORD GetObjectCount()成员函数访问该变量
49. // 注意：该变量和访问它的函数都只是在调试模式下才会有效，如果
50. //         转换为发布模式，它们都会失效。所以在使用GetObjectCount()
51. //         这个成员函数时，应加入#ifdef _DEBUG .... #endif语句块
52. #ifdef _DEBUG
53.     DWORD CBmpProc::m_ObjectCount = 0;
54. #endif
59. /*************************************************************************
60. * 构造函数。初始化类为空。
61. *************************************************************************/
64. CBmpProc::CBmpProc()
65. {
66.     // 初始化核心数据为空
67.     m_mark = FALSE;            // 有效标志。（TRUE-有有效位图，否则为FALSE）
68.     m_type = IT_NULL;        // 图像类型。
69.     m_addInfo = 0;            // 附加信息。
70.     m_cFileName.Empty();    // 文件路径。
71.     m_pInfo = NULL;            // DIB信息结构
72.     m_hObject = NULL;        // 清除核心DDB位图句柄。（基类成员）
74. #ifdef _DEBUG
75.     CBmpProc::m_ObjectCount++;
76. #endif
77. }
81. /*************************************************************************
82. * 调试用函数，获取进程中CBmpProc类目标的个数。
83. *************************************************************************
84. #ifdef _DEBUG
85. DWORD CBmpProc::GetObjectCount()
86. {
87.     return m_ObjectCount;
88. }
89. #endif
90. *************************************************************************/
93. /*************************************************************************
94. * 析构函数。如果类不为空则清空它。
95. *************************************************************************/
98. CBmpProc::~CBmpProc()
99. {
100.     Clear();
102. #ifdef _DEBUG
103.     CBmpProc::m_ObjectCount--;
104. #endif
105. }
110. /*************************************************************************
111. *
112. * operator=()
113. *
114. * 参数说明：
115. *
116. * const CBmpProc& ds        - 源位图类
117. *
118. * 返回值：
119. *
120. * CBmpProc&                - 类自身引用
121. *
122. * 描述：
123. *
124. * 复制取指定的位图类
125. *
126. * 如果函数成功，则类中原来的位图（如果有的话）将被删除，如果不成功，它保留
127. * 原位图。执行本函数之后，可调用该类的IsValid()函数判断是否成功复制（这种
128. * 情况只使用于没有图像的类，如果复制前类中就存在图像，可用==操作符判断该类
129. * 与源位图类是否相同，如果相同则表示复制成功，不同就说明失败）
130. *
131. ************************************************************************/
134. CBmpProc& CBmpProc::operator=(const CBmpProc& ds)
135. {
136.     // 如果类中没有图像，直接返回
137.     if (!ds.IsValid())
138.         return *this;
140.     ASSERT(ds.m_pInfo);
141.     ASSERT(ds.m_pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER));
143.     // 复制源图信息块
144.     LPBITMAPINFO pInfo = (LPBITMAPINFO)CreateMemoryBlockFromAddress(
145.         (LPVOID)ds.m_pInfo);
146.     if (!pInfo)
147.         return *this;
149.     // 复制源图
150.     CBitmap        tempBmp;
151.     HBITMAP        hBmp;
153.     HWND hWnd = ::GetDesktopWindow();
154.     ASSERT(hWnd);
155.     HDC hDC = ::GetDC(hWnd);
156.     CDC dc;
157.     dc.Attach(hDC);
159.     if (tempBmp.CreateCompatibleBitmap(&dc, ds.Width(), ds.Height()))
160.     {
161.         CDC            compDC, compDC2;
162.         CBitmap        *pOldBmp, *pOldBmp2;
164.         // 创建与当前显示设备兼容的内存设备描述表
165.         compDC.CreateCompatibleDC(NULL);
166.         compDC2.CreateCompatibleDC(NULL);
168.         pOldBmp    = compDC.SelectObject((CBitmap*)&tempBmp);
169.         pOldBmp2= compDC2.SelectObject((CBitmap*)&ds);
171.         // 复制指定尺寸的源位图到目标位图
172.         compDC.BitBlt(0, 0, ds.Width(), ds.Height(),
173.                     &compDC2, 0, 0, SRCCOPY);
175.         compDC2.SelectObject(pOldBmp2);
176.         compDC.SelectObject(pOldBmp);
178.         hBmp = (HBITMAP)tempBmp.Detach();
179.         // 如果分离操作失败，返回FALSE
180.         ASSERT(hBmp);
181.         if (!hBmp)
182.         {
183.             ::ReleaseDC(hWnd, dc.Detach());
184.             ::free((void*)pInfo);
185.             return *this;;
186.         }
187.         ::ReleaseDC(hWnd, dc.Detach());
189.         // 删除原来的图像，并且设置新的位图
190.         if (!ClearAndSetData(IT_MEMORY,0,(LPCTSTR)"",pInfo,hBmp))
191.         {
192.             ::free((void*)pInfo);
193.             ::DeleteObject(hBmp);
194.             return *this;
195.         }
196.         return *this;
197.     }
198.     else
199.     {
200.         ::ReleaseDC(hWnd, dc.Detach());
201.         ::free((void*)pInfo);
203.         return *this;;
204.     }
205. }
209. /*************************************************************************
210. *
211. * operator=()
212. *
213. * 参数说明：
214. *
215. * const HBITMAP sou        - 源位图句柄
216. *
217. * 返回值：
218. *
219. * CBmpProc&                - 类自身引用
220. *
221. * 描述：
222. *
223. * 复制取指定的位图
224. *
225. * 如果函数成功，则类中原来的位图（如果有的话）将被删除，如果不成功，它保留
226. * 原位图。执行本函数之后，可调用该类的IsValid()函数判断是否成功复制（这种
227. * 情况只使用于没有图像的类，如果复制前类中就存在图像，可用==操作符判断该类
228. * 与源位图类是否相同，如果相同则表示复制成功，不同就说明失败）
229. * 如果入口参数指定的位图句柄无效，则函数失败。
230. *
231. ************************************************************************/
234. CBmpProc& CBmpProc::operator=(const HBITMAP sou)
235. {
236.     // 入口检测
237.     if (!sou)
238.         return *this;
240.     CBmpProc tmp;
242.     if (!tmp.Attach(sou))
243.         return *this;
245.     ASSERT(sou == (HBITMAP)tmp);
247.     // 调用类赋值操作符函数
248.     *this = tmp;
249.     // 分离源位图，防止析构函数将其删除
250.     tmp.Detach();
252.     return *this;
253. }
257. /*************************************************************************
258. *
259. * operator==()
260. *
261. * 参数说明：
262. *
263. * const CBmpProc& ds        - 源位图类
264. *
265. * 返回值：
266. *
267. * BOOL                        - 如果相同返回TRUE，不同返回FALSE
268. *
269. * 描述：
270. *
271. * 判断源位图类与本身类是否相同
272. *
273. * 该函数通过比较两个类的位图来判定它们是否具有相同的图像。
274. *
275. * 注：# 如果两个类都是空的（即都没有图像），则该函数将视它们是不相同的
276. *
277. ************************************************************************/
280. BOOL CBmpProc::operator==(const CBmpProc& ds)
281. {
282.     // 如果两个类中有一个或都是空的（即都没有图像），则该函数将视它们
283.     // 是不相同的
284.     if ((ds.IsValid()==FALSE)||(IsValid()==FALSE))
285.         return FALSE;
287.     // 如果是与自身比较，则直接返回TRUE
288.     if (this == &ds)
289.         return TRUE;
291.     ASSERT(m_pInfo);
292.     ASSERT(ds.m_pInfo);
293.     ASSERT(m_pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER));
294.     ASSERT(ds.m_pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER));
296.     // 信息块长度比较
297.     if (::_msize(m_pInfo) != ::_msize(ds.m_pInfo))
298.         return FALSE;
300.     // 信息块内容比较
301.     if (::memcmp((const void*)m_pInfo, \
302.         (const void*)ds.m_pInfo,::_msize(m_pInfo)))
303.         return FALSE;
305.     // 创建存放DIB位数据的缓冲区
306.     LPSTR pBits1 = (LPSTR)CreateMemoryBlockFromAddress((LPVOID)NULL,
307.         CalculateDIBitsSize((LPBITMAPINFOHEADER)m_pInfo));
308.     if (!pBits1)
309.         return FALSE;
311.     LPSTR pBits2 = (LPSTR)CreateMemoryBlockFromAddress((LPVOID)NULL,
312.         CalculateDIBitsSize((LPBITMAPINFOHEADER)m_pInfo));
313.     if (!pBits2)
314.     {
315.         ::free((void*)pBits1);
316.         return FALSE;
317.     }
319.     // 复制位图信息块，因为GetDIBits()函数有可能会改变颜色表数据
320.     LPBITMAPINFO pInfo = (LPBITMAPINFO)CreateMemoryBlockFromAddress(
321.         (LPVOID)m_pInfo);
322.     if (!pInfo)
323.     {
324.         ::free((void*)pBits1);
325.         ::free((void*)pBits2);
326.         return FALSE;
327.     }
329.     ASSERT(pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER));
331.     HWND hWnd = ::GetDesktopWindow();
332.     ASSERT(hWnd);
333.     HDC hDC;
335.     // 获取位图的DIB位数据
336.     hDC = ::GetDC(hWnd);
337.     ASSERT(m_hObject);
338.     ASSERT(ds.m_hObject);
339.     if (!::GetDIBits(hDC,(HBITMAP)m_hObject,0,pInfo->bmiHeader.biHeight, \
340.             (LPVOID)pBits1,pInfo,DIB_RGB_COLORS))
341.     {
342.         ::free((void*)pBits1);
343.         ::free((void*)pBits2);
344.         ::free((void*)pInfo);
345.         ::ReleaseDC(hWnd, hDC);
346.         return FALSE;
347.     }
348.     if (!::GetDIBits(hDC,(HBITMAP)ds.m_hObject,0,pInfo->bmiHeader.biHeight, \
349.             (LPVOID)pBits2,pInfo,DIB_RGB_COLORS))
350.     {
351.         ::free((void*)pBits1);
352.         ::free((void*)pBits2);
353.         ::free((void*)pInfo);
354.         ::ReleaseDC(hWnd, hDC);
355.         return FALSE;
356.     }
357.     ::ReleaseDC(hWnd, hDC);
358.     ::free((void*)pInfo);
360.     // 位内容比较
361.     LONG leng = (LONG)CalculateDIBitsSize((LPBITMAPINFOHEADER)m_pInfo)/4;
362.     LPDWORD lp1 = (LPDWORD)pBits1;    // DIB位数据是DWORD对齐的
363.     LPDWORD lp2 = (LPDWORD)pBits2;
365.     // 因为不清楚memcmp()函数是否可以比较大于64K的数据，所以才采用这种
366.     // 老笨的方法。
367.     while(leng--)
368.     {
369.         if (*lp1 != *lp2) break;
370.         lp1++; lp2++;
371.     }
373.     // 比较完之后，位数据已无用，释放
374.     ::free((void*)pBits1);
375.     ::free((void*)pBits2);
376.     
377.     if (leng != -1L)
378.         return FALSE;    // 位数据不同返回FALSE
380.     return TRUE;
381. }

1. /*************************************************************************
2. *
3. * operator!=()
4. *
5. * 参数说明：
6. *
7. * const CBmpProc& ds        - 源位图类
8. *
9. * 返回值：
10. *
11. * BOOL                        - 如果不同返回TRUE，相同返回FALSE
12. *
13. * 描述：
14. *
15. * 判断源位图类是否与本身类不同
16. *
17. * 该函数通过比较两个类的位图来判定它们是否具有相同的图像。
18. *
19. * 注：# 如果两个类都是空的（即都没有图像），则该函数将视它们是不相同的
20. *
21. ************************************************************************/
24. BOOL CBmpProc::operator!=(const CBmpProc& ds)
25. {
26.     return ((*this) == ds) ? FALSE:TRUE;
27. }
31. /*************************************************************************
32. *
33. * Draw()
34. *
35. * 参数说明：
36. *
37. * CDC& dc                    - 显示位图的设备描述表
38. * const CRect* rcDst        - 目标矩形
39. * const CRect* rcSrc        - 源矩形
40. *
41. * 返回值：
42. *
43. * BOOL                        - 如果成功返回TRUE，否则返回FALSE
44. *
45. * 描述：
46. *
47. * 将类中指定区域的图像绘入目标设备描述表的指定区域，如果源区域（即矩形）
48. * 和目标区域不同，将产生拉伸或压缩动作
49. *
50. * 如果源矩形和目标矩形是NULL,则函数将视这两个矩形都等于类中图像的尺寸
51. *
52. * 如果类中没有图像，它什么也不作，直接返回
53. * 如果待绘制的图像不在当前剪贴区域内，则直接返回
54. *
55. ************************************************************************/
58. BOOL CBmpProc::Draw(CDC& dc, const CRect* rcDst, const CRect* rcSrc)
59. {
60.     // 如果类中没有图像，直接返回
61.     if (!IsValid())
62.         return TRUE;
64.     ASSERT(m_hObject);
66.     // 缺省矩形等于图像尺寸
67.     CRect DCRect(Rect());            // 目标位置数据
68.     CRect DibRect(Rect());            // 源位置数据
70.     if (rcDst)
71.         DCRect = *rcDst;
72.     if (rcSrc)
73.         DibRect = *rcSrc;
75.     // 如果待绘制的图像不在当前剪贴区域内，则直接返回
76.     if (!dc.RectVisible(&DCRect))
77.         return TRUE;
79.     CDC            compDC;
80.     CBitmap        *pOldBmp;
82.     compDC.CreateCompatibleDC(NULL);
83.     pOldBmp    = compDC.SelectObject((CBitmap*)this);
85.     /* 设置目标DC的拉伸模式为STRETCH_DELETESCANS，也就是不显示拉伸掉的图像 */
86.     int srlold = dc.SetStretchBltMode(STRETCH_DELETESCANS);
88.     // 显示位图
89.     dc.StretchBlt(DCRect.left, DCRect.top, DCRect.Width(), DCRect.Height(),
90.                     &compDC, DibRect.left, DibRect.top,
91.                     DibRect.Width(), DibRect.Height(), SRCCOPY);
92.     
93.     // 恢复设备描述表原来的设置
94.     dc.SetStretchBltMode(srlold);
95.     compDC.SelectObject(pOldBmp);
97.     return TRUE;
98. }
102. /*************************************************************************
103. *
104. * DrawTile()
105. *
106. * 参数说明：
107. *
108. * CDC& dc                    - 显示位图的设备描述表
109. * CRect* crArea            - 铺设范围（矩形坐标）
110. *
111. * 返回值：
112. *
113. * BOOL                        - 如果成功返回TRUE，否则返回FALSE
114. *
115. * 描述：
116. *
117. * 将类中的图像以平铺方式排满指定区域
118. *
119. * 如果入口参数crArea是NULL,则函数返回FALSE，如果矩形坐标不符合规范（比如
120. * 左边的坐标大于右边的坐标）则函数将自动将其规范化。如果矩形坐标的宽度
121. * 或高度是0，则函数将返回FALSE
122. *
123. * 如果类中没有图像，它什么也不作，直接返回
124. *
125. ************************************************************************/
128. BOOL CBmpProc::DrawTile(CDC& dc, CRect* crArea)
129. {
130.     if (!crArea)
131.         return FALSE;
133.     // 如果类中没有图像，直接返回
134.     if (!IsValid())
135.         return TRUE;
137.     CRect rect = *crArea;
138.     CRect tprc;
140.     // 矩形坐标规范化
141.     rect.NormalizeRect();
143.     if ((rect.Width()==0)||(rect.Height()==0))
144.         return FALSE;
146.     ASSERT(m_pInfo);
147.     ASSERT(m_hObject);
149.     // 因为下面的代码将改变设备描述表中剪贴区域的设置，所以先将其保存
150.     int savedc = dc.SaveDC();
152.     CRgn newrgn;
153.     newrgn.CreateRectRgnIndirect(&rect);
154.     // 只显示指定矩形中可见的部分（用AND操作）
155.     dc.SelectClipRgn(&newrgn, RGN_AND);
157.     for (int y=rect.top;y    {
158.         for (int x=rect.left;x        {
159.             // 以瓦片方式重复显示图像
160.             tprc.SetRect(x,y,x+Width(),y+Height());
161.             Draw(dc, &tprc);
162.         }
163.     }
165.     dc.RestoreDC(savedc);
166.     // 恢复设备描述表的内容之后，将区域的句柄显示的删除
167.     // （微软在文档中特意注明要用CGdiObject::DeleteObject()
168.     //   函数显示的删除区域句柄，不知是什么原因）
169.     newrgn.CGdiObject::DeleteObject();
171.     return TRUE;
172. }
176. /*************************************************************************
177. *
178. * DrawCenter()
179. *
180. * 参数说明：
181. *
182. * CDC& dc                    - 显示位图的设备描述表
183. * CRect* crArea            - 显示范围（矩形坐标）
184. *
185. * 返回值：
186. *
187. * BOOL                        - 如果成功返回TRUE，否则返回FALSE
188. *
189. * 描述：
190. *
191. * 将类中图像绘入目标设备描述表的指定区域（矩形）的中央，即图像中点与矩
192. * 形中点重合
193. *
194. * 如果矩形的尺寸小于图像尺寸，则图像的四周部分会不可见
195. * 如果入口参数crArea是NULL，函数将返回FALSE
196. * 如果类中没有图像，它什么也不作，直接返回
197. * 如果矩形坐标不符合规范（比如左边的坐标大于右边的坐标）则函数将自动将
198. * 其规范化。如果矩形坐标的宽度或高度是0，则函数将返回FALSE
199. *
200. ************************************************************************/
203. BOOL CBmpProc::DrawCenter(CDC& dc, CRect* crArea)
204. {
205.     if (!crArea)
206.         return FALSE;
208.     // 如果类中没有图像，直接返回
209.     if (!IsValid())
210.         return TRUE;
212.     CRect rect = *crArea;
214.     // 矩形坐标规范化
215.     rect.NormalizeRect();
217.     if ((rect.Width()==0)||(rect.Height()==0))
218.         return FALSE;
220.     ASSERT(m_pInfo);
221.     ASSERT(m_hObject);
223.     // 取指定矩形的中点坐标
224.     CPoint cpce = rect.CenterPoint();
225.     CRect  tprc(CPoint(cpce.x-Width()/2,cpce.y-Height()/2), Size());
227.     // 因为下面的代码将改变设备描述表中剪贴区域的设置，所以先将其保存
228.     int savedc = dc.SaveDC();
230.     CRgn newrgn;
231.     newrgn.CreateRectRgnIndirect(&rect);
232.     // 只显示指定矩形中可见的部分（用AND操作）
233.     dc.SelectClipRgn(&newrgn, RGN_AND);
235.     Draw(dc, &tprc);
237.     dc.RestoreDC(savedc);
238.     newrgn.CGdiObject::DeleteObject();
240.     return TRUE;
241. }
245. /*************************************************************************
246. *
247. * DrawTranCenter()
248. *
249. * 参数说明：
250. *
251. * CDC& dc                    - 显示位图的设备描述表
252. * CRect* crArea            - 显示范围（矩形坐标）
253. * COLORREF crColour        - 要滤掉或保留的颜色（缺省值是白色）
254. * int mode                    - 如果是0则将不显示指定的颜色，如果是1则保留指定
255. *                              的颜色（缺省值为0）
256. *
257. * 返回值：
258. *
259. * BOOL                        - 如果成功返回TRUE，否则返回FALSE
260. *
261. * 描述：
262. *
263. * 将类中图像透明的绘入目标设备描述表的指定区域（矩形）的中央，即图像中点
264. * 与矩形中点重合
265. *
266. * 如果矩形的尺寸小于图像尺寸，则超出矩形的图像部分会不可见
267. * 如果入口参数crArea是NULL，函数将返回FALSE
268. * 如果类中没有图像，它什么也不作，直接返回
269. * 如果矩形坐标不符合规范（比如左边的坐标大于右边的坐标）则函数将自动将
270. * 其规范化。如果矩形坐标的宽度或高度是0，则函数将返回FALSE
271. *
272. ************************************************************************/
275. BOOL CBmpProc::DrawTranCenter(CDC& dc,
276.                               CRect* crArea,
277.                               COLORREF crColour,
278.                               int mode)
279. {
280.     if (!crArea)
281.         return FALSE;
283.     // 如果类中没有图像，直接返回
284.     if (!IsValid())
285.         return TRUE;
287.     CRect rect = *crArea;
289.     // 矩形坐标规范化
290.     rect.NormalizeRect();
292.     if ((rect.Width()==0)||(rect.Height()==0))
293.         return FALSE;
295.     ASSERT(m_pInfo);
296.     ASSERT(m_hObject);
298.     // 取指定矩形的中点坐标
299.     CPoint cpce = rect.CenterPoint();
300.     CRect  tprc(CPoint(cpce.x-Width()/2,cpce.y-Height()/2), Size());
302.     // 因为下面的代码将改变设备描述表中剪贴区域的设置，所以先将其保存
303.     int savedc = dc.SaveDC();
305.     CRgn newrgn;
306.     newrgn.CreateRectRgnIndirect(&rect);
307.     // 只显示指定矩形中可见的部分（用AND操作）
308.     dc.SelectClipRgn(&newrgn, RGN_AND);
310.     DrawTransparentInRect(dc, crColour, &tprc, NULL, mode);    // 显示透明图像
312.     dc.RestoreDC(savedc);
313.     newrgn.CGdiObject::DeleteObject();
315.     return TRUE;
316. }
320. /*************************************************************************
321. *
322. * DrawTranTile()
323. *
324. * 参数说明：
325. *
326. * CDC& dc                    - 显示位图的设备描述表
327. * CRect* crArea            - 显示范围（矩形坐标）
328. * COLORREF crColour        - 要滤掉或保留的颜色（缺省值是白色）
329. * int mode                    - 如果是0则将不显示指定的颜色，如果是1则保留指定
330. *                              的颜色（缺省值为0）
331. *
332. * 返回值：
333. *
334. * BOOL                        - 如果成功返回TRUE，否则返回FALSE
335. *
336. * 描述：
337. *
338. * 将类中的图像以平铺并且是透明的方式排满指定区域
339. *
340. * 如果入口参数crArea是NULL,则函数返回FALSE，如果矩形坐标不符合规范（比如
341. * 左边的坐标大于右边的坐标）则函数将自动将其规范化。如果矩形坐标的宽度
342. * 或高度是0，则函数将返回FALSE
343. *
344. * 如果类中没有图像，它什么也不作，直接返回
345. *
346. ************************************************************************/
349. BOOL CBmpProc::DrawTranTile(CDC& dc,
350.                             CRect* crArea,
351.                             COLORREF crColour,
352.                             int mode)
353. {
354.     if (!crArea)
355.         return FALSE;
357.     // 如果类中没有图像，直接返回
358.     if (!IsValid())
359.         return TRUE;
361.     CRect rect = *crArea;
362.     CRect tprc;
364.     // 矩形坐标规范化
365.     rect.NormalizeRect();
367.     if ((rect.Width()==0)||(rect.Height()==0))
368.         return FALSE;
370.     ASSERT(m_pInfo);
371.     ASSERT(m_hObject);
373.     // 因为下面的代码将改变设备描述表中剪贴区域的设置，所以先将其保存
374.     int savedc = dc.SaveDC();
376.     CRgn newrgn;
377.     newrgn.CreateRectRgnIndirect(&rect);
378.     // 只显示指定矩形中可见的部分（用AND操作）
379.     dc.SelectClipRgn(&newrgn, RGN_AND);
381.     for (int y=rect.top;y    {
382.         for (int x=rect.left;x        {
383.             // 以瓦片方式重复显示图像
384.             tprc.SetRect(x,y,x+Width(),y+Height());
385.             // 显示透明图像
386.             DrawTransparentInRect(dc, crColour, &tprc, NULL, mode);
387.         }
388.     }
390.     dc.RestoreDC(savedc);
391.     newrgn.CGdiObject::DeleteObject();
393.     return TRUE;
394. }
398. /*************************************************************************
399. *
400. * Clear()
401. *
402. * 参数说明：无
403. *
404. *
405. * 返回值：无
406. *
407. *
408. * 描述：
409. *
410. * 清除类中的图像
411. *
412. * 这个函数将删除类中的位图句柄，并清除类中的描述变量
413. *
414. * 如果类中没有图像，它什么也不作，直接返回
415. *
416. ************************************************************************/
419. void CBmpProc::Clear()
420. {
421.     // 如果本类中没有有效的BMP，则直接返回
422.     if (m_mark == FALSE)
423.     {
424.         ASSERT(m_type == IT_NULL);
425.         ASSERT(m_pInfo == NULL);
426.         ASSERT(m_hObject == NULL);
427.         return;
428.     }
430.     switch(m_type)
431.     {
432.     case    IT_NULL:
433.         ASSERT(FALSE);    // 此时m_type不应该是IT_NULL
434.         break;
435.     case    IT_DISKFILE:
436.         ASSERT(!m_cFileName.IsEmpty());    // 文件来源的位图应该有文件名
437.     case    IT_RESOURCE:
438.     case    IT_MEMORY:
439.     case    IT_CLIP:
440.     case    IT_CREATE:
441.         m_cFileName.Empty();
443.         ASSERT(m_pInfo);
444.         ::free((void*)m_pInfo);
445.         m_pInfo = NULL;
447.         // 先分离出原来的BMP句柄，然后删除
448.         ASSERT((HBITMAP)m_hObject);
449.         ::DeleteObject(CGdiObject::Detach());
450.         m_hObject = NULL;
452.         m_addInfo = 0;
453.         m_type = IT_NULL;
454.         m_mark = FALSE;
455.         break;
456.     default:
457.         ASSERT(FALSE);
458.         break;
459.     }
460. }
464. /*************************************************************************
465. *
466. * Attach()
467. *
468. * 参数说明：
469. *
470. * HBITMAP hBmp                - 待粘贴的位图句柄
471. *
472. * 返回值：
473. *
474. * BOOL                        - 如果成功返回TRUE，否则返回FALSE
475. *
476. * 描述：
477. *
478. * 将指定的位图贴入本身类中。
479. *
480. * 注：
481. *
482. * # 如果hBmp是一个无效的句柄或是NULL，函数返回FALSE
483. * # 如果本身类中原来存在图像，则调用函数成功之后，原来的图像将被删除
484. * # hBmp必须是一个兼容于当前显示器颜色格式的DDB位图句柄
485. * # 如果函数执行成功后，调用它的程序不应再使用hBmp句柄，因为它已被贴入类中
486. * # 如果函数失败，调用它的程序仍可以正常使用hBmp句柄
487. *
488. ************************************************************************/
491. BOOL CBmpProc::Attach(HBITMAP hBmp)
492. {
493.     ASSERT(hBmp);
494.     // 如果hBmp是NULL，则立即返回
495.     if (!hBmp)
496.         return FALSE;
498.     HWND hWnd = ::GetDesktopWindow();
499.     ASSERT(hWnd);
500.     HDC hDC;
501.     BITMAP    bmp;
503.     // 获取给定位图的宽度、高度及颜色格式信息
504.     if (::GetObject(hBmp, sizeof(BITMAP), (LPVOID)&bmp) != sizeof(BITMAP))
505.         return FALSE;
507.     // 创建临时位图信息块（不带颜色表）
508.     LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER)CreateMemoryBlockFromAddress(
509.         (LPVOID)NULL, sizeof(BITMAPINFOHEADER));
510.     if (!lpbi)
511.         return FALSE;
513.     // 设置DIB信息块内容
514.     lpbi->biSize = sizeof(BITMAPINFOHEADER);
515.     lpbi->biWidth = bmp.bmWidth;
516.     lpbi->biHeight = bmp.bmHeight;
517.     lpbi->biPlanes = 1;
518.     // 在16色系统中，平面数是4，而位数是1，但这在DIB中是不允许的
519.     lpbi->biBitCount = max(bmp.bmPlanes, bmp.bmBitsPixel);
520.     if ((lpbi->biBitCount==16)||(lpbi->biBitCount==32))
521.         lpbi->biCompression = BI_BITFIELDS;
522.     else
523.         lpbi->biCompression = BI_RGB;
525.     // 计算设备分辩率
526.     hDC = ::GetDC(hWnd);
527.     lpbi->biXPelsPerMeter = \
528.         (GetDeviceCaps(hDC,HORZRES)*1000)/GetDeviceCaps(hDC,HORZSIZE);
529.     lpbi->biYPelsPerMeter = \
530.         (GetDeviceCaps(hDC,VERTRES)*1000)/GetDeviceCaps(hDC,VERTSIZE);
531.     ::ReleaseDC(hWnd, hDC);
533.     lpbi->biClrUsed = 0;
534.     lpbi->biClrImportant = 0;
535.     lpbi->biSizeImage = CalculateDIBitsSize(lpbi);
537.     // 计算颜色表的尺寸
538.     WORD wPalSize = PaletteSize(lpbi);
540.     // 创建带颜色表的信息块，并复制lpbi信息块中的内容
541.     LPBITMAPINFO pInfo = (LPBITMAPINFO)CreateMemoryBlockFromAddress(
542.         (LPVOID)lpbi, sizeof(BITMAPINFOHEADER)+wPalSize);
543.     if (!pInfo)
544.     {
545.         ::free((void*)lpbi);
546.         return FALSE;
547.     }
549.     ASSERT(pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER));
551.     // 此时该结构已经无用，释放
552.     ::free((void*)lpbi);
554.     // 创建存放DIB位数据的缓冲区
555.     LPSTR pBits = (LPSTR)CreateMemoryBlockFromAddress((LPVOID)NULL,
556.         pInfo->bmiHeader.biSizeImage);
557.     if (!pBits)
558.     {
559.         ::free((void*)pInfo);
560.         return FALSE;
561.     }
563.     // 下面的代码并不是要获取位图的DIB位数据，而是要取得位图的颜色表
564.     // 颜色表数据在函数（GetDIBits()）调用成功后被填写在pInfo结构中
565.     hDC = ::GetDC(hWnd);
566.     if (!::GetDIBits(hDC,hBmp,0,pInfo->bmiHeader.biHeight, \
567.             (LPVOID)pBits,pInfo,DIB_RGB_COLORS))
568.     {
569.         ::free((void*)pBits);
570.         ::free((void*)pInfo);
571.         ::ReleaseDC(hWnd, hDC);
572.         return FALSE;
573.     }
574.     ::ReleaseDC(hWnd, hDC);
576.     // 此时并不需要DIB位数据，释放
577.     ::free((void*)pBits);
579.     // 删除原来的图像，并且设置新的位图
580.     if (!ClearAndSetData(IT_MEMORY,0,(LPCTSTR)"",pInfo,hBmp))
581.     {
582.         ::free((void*)pInfo);
583.         // hBmp指定的位图并不删除
584.         return FALSE;
585.     }
587.     return TRUE;
588. }
592. /*************************************************************************
593. *
594. * Detach()
595. *
596. * 参数说明：无
597. *
598. *
599. * 返回值：
600. *
601. * HBITMAP                    - 如果成功，返回分离出的位图句柄，否则返回NULL
602. *
603. * 描述：
604. *
605. * 将本身类中的位图分离出来。
606. *
607. * 注：
608. *
609. * # 如果本身类中原来存在位图，函数成功调用之后，本身类将被清空
610. * # 如果本身类中原来没有位图，函数返回NULL
611. *
612. ************************************************************************/
615. HBITMAP CBmpProc::Detach()
616. {
617.     if (!IsValid())
618.         return NULL;
620.     ASSERT(m_pInfo);
621.     ASSERT(m_hObject);
623.     HBITMAP hBmp = (HBITMAP)CGdiObject::Detach();
624.     ASSERT(hBmp);
625.     if (!hBmp)
626.         return NULL;
628.     m_hObject = NULL;
630.     switch(m_type)
631.     {
632.     case    IT_NULL:
633.         ASSERT(FALSE);    // 此时m_type不应该是IT_NULL
634.         break;
635.     case    IT_DISKFILE:
636.         ASSERT(!m_cFileName.IsEmpty());    // 文件来源的位图应该有文件名
637.     case    IT_RESOURCE:
638.     case    IT_MEMORY:
639.     case    IT_CLIP:
640.     case    IT_CREATE:
641.         m_cFileName.Empty();
643.         ASSERT(m_pInfo);
644.         ::free((void*)m_pInfo);
645.         m_pInfo = NULL;
647.         m_addInfo = 0;
648.         m_type = IT_NULL;
649.         m_mark = FALSE;
650.         break;
651.     default:
652.         ASSERT(FALSE);
653.         break;
654.     }
656.     return hBmp;
657. }
661. /*************************************************************************
662. *
663. * Save()
664. *
665. * 参数说明：
666. *
667. * LPCTSTR lpszNewFileName    - 指定的新文件名（可以是NULL）
668. * WORD nBitsPerPixel        - 指定的新颜色格式（即每像素多少位，可以是0）
669. *
670. * 返回值：
671. *
672. * BOOL                        - 如果成功返回TRUE，否则返回FALSE
673. *
674. * 描述：
675. *
676. * 将本身类中的位图以新的格式或新的名称保存到文件中
677. *
678. * 注：
679. *
680. * # 如果没有指定新的文件名（入口参数lpszNewFileName被指定为NULL），函数
681. *   就使用类中原来的文件名，如果类中原来没有文件名则函数失败，返回FALSE
682. * # 如果没有指定新的位数（入口参数nBitsPerPixel被指定为0），函数就使用类
683. *   中原来的位数值。如果新指定的位数值非法则函数失败，返回FALSE。合法的
684. *   位数值是1,4,8,16,24,32 其中之一
685. * # 如果本身类中原来没有位图（空类），函数返回FALSE
686. * # 如果文件没有打开或是写文件时出错，函数返回FALSE
687. * # 函数执行成功之后，本身类中的文件名或位数将改为新值
688. * # 无论函数成功与否，本身类中的位图不会改变
689. *
690. ************************************************************************/
693. BOOL CBmpProc::Save(LPCTSTR lpszNewFileName, WORD nBitsPerPixel)
694. {
695.     // 如果本身类中原来没有位图，函数返回FALSE
696.     if (!IsValid())
697.         return FALSE;
699.     ASSERT(m_pInfo);
700.     ASSERT(m_pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER));
702.     LPBITMAPINFO pInfo;
703.     BOOL bRet;
704.     CString cOldFN;
706.     // 以原来的格式保存到原来的文件中
707.     if ((lpszNewFileName==NULL)&&(nBitsPerPixel==0))
708.     {
709.         // 应该有文件名
710.         if (m_cFileName.IsEmpty())
711.             return FALSE;
713.         return SaveBaseSpecifyFileName((LPCTSTR)m_cFileName);
714.     }
716.     // 以原来的格式保存到新的文件中
717.     if ((lpszNewFileName!=NULL)&&(nBitsPerPixel==0))
718.     {
719.         bRet = SaveBaseSpecifyFileName((LPCTSTR)lpszNewFileName);
721.         if (bRet)
722.             m_cFileName = lpszNewFileName;
724.         return bRet;
725.     }
727.     // 以新的格式保存到原来的文件中
728.     if ((lpszNewFileName==NULL)&&(nBitsPerPixel!=0))
729.     {
730.         // 检测位数合法性
731.         if (!IsValidDibFormat(nBitsPerPixel))
732.             return FALSE;
734.         // 应该有文件名
735.         if (m_cFileName.IsEmpty())
736.             return FALSE;
738.         bRet = SaveBaseSpecifyFormat(nBitsPerPixel);
740.         if (bRet)
741.         {
742.             pInfo = GetSpecifyFormatInfo(nBitsPerPixel);
743.             if (!pInfo)
744.                 return FALSE;
745.             ::free((void*)m_pInfo);
746.             m_pInfo = pInfo;
747.         }
748.         return bRet;
749.     }
751.     // 以新的格式保存到新的文件中
752.     if ((lpszNewFileName!=NULL)&&(nBitsPerPixel!=0))
753.     {
754.         // 检测位数合法性
755.         if (!IsValidDibFormat(nBitsPerPixel))
756.             return FALSE;
758.         cOldFN = m_cFileName;
759.         m_cFileName = lpszNewFileName;
761.         bRet = SaveBaseSpecifyFormat(nBitsPerPixel);
763.         if (bRet)
764.         {    // 获取指定格式的信息块
765.             pInfo = GetSpecifyFormatInfo(nBitsPerPixel);
766.             if (!pInfo)
767.             {
768.                 m_cFileName = cOldFN;
769.                 return FALSE;
770.             }
771.             ::free((void*)m_pInfo);
772.             m_pInfo = pInfo;
773.         }
774.         else
775.             m_cFileName = cOldFN;
777.         return bRet;
778.     }
780.     return FALSE;
781. }
785. /*************************************************************************
786. *
787. * SaveToClipboard()
788. *
789. * 参数说明：无
790. *
791. *
792. * 返回值：
793. *
794. * BOOL                        - 如果成功返回TRUE，否则返回FALSE
795. *
796. * 描述：
797. *
798. * 保存本身类中的位图到剪贴板
799. *
800. * 注：
801. *
802. * # 如果本身类中原来没有位图，函数返回FALSE
803. * # 如果在打开或写入剪贴板时出错，函数返回FALSE
804. * # 无论函数成功与否，本身类中的内容都不会改变
805. *
806. ************************************************************************/
809. BOOL CBmpProc::SaveToClipboard()
810. {
811.     // 如果本身类中原来没有位图，函数返回FALSE
812.     if (!IsValid())
813.         return FALSE;
815.     ASSERT(m_pInfo);
816.     ASSERT(m_pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER));
818.     // 打开剪贴板
819.     if (::OpenClipboard(NULL))
820.     {
821.         // 清空剪贴板
822.         if (::EmptyClipboard())
823.         {
824.             DWORD DibSize = CalculateDIBSize((LPBITMAPINFOHEADER)m_pInfo);
825.             DWORD infosize =CalculateDIBInfoSize((LPBITMAPINFOHEADER)m_pInfo);
827.             // 分配DIB内部格式内存块
828.             HANDLE hDib = ::GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE, DibSize);
829.             if (hDib)
830.             {
831.                 LPSTR lpDib = (LPSTR)::GlobalLock(hDib);
832.                 if (lpDib)
833.                 {
834.                     ::memcpy((void*)lpDib, (const void*)m_pInfo, infosize);
836.                     // 获取DIB位数据
837.                     HWND hWnd = ::GetDesktopWindow();
838.                     ASSERT(hWnd);
839.                     HDC hDC = ::GetDC(hWnd);
840.                     if (!::GetDIBits(hDC,(HBITMAP)m_hObject,0,m_pInfo->bmiHeader.biHeight,\
841.                             (LPVOID)((DWORD)lpDib+infosize),(LPBITMAPINFO)lpDib,DIB_RGB_COLORS))
842.                     {
843.                         ::GlobalUnlock(hDib);
844.                         ::GlobalFree(hDib);
845.                         ::CloseClipboard();
846.                         ::ReleaseDC(hWnd, hDC);
847.                         return FALSE;
848.                     }
849.                     ::ReleaseDC(hWnd, hDC);
851.                     ::GlobalUnlock(hDib);
853.                     // 将DIB数据贴入剪贴板
854.                     if (::SetClipboardData(CF_DIB, hDib))
855.                     {
856.                         // 如果成功，DIB句柄不应释放
857.                         ::CloseClipboard();
858.                         return TRUE;        // 成功
859.                     }
860.                     else
861.                     {
862.                         ::GlobalFree(hDib);
863.                         ::CloseClipboard();
864.                         return FALSE;        // 失败
865.                     }
866.                 }
867.                 ::GlobalFree(hDib);
868.             }
869.         }
870.         ::CloseClipboard();
871.     }
873.     return FALSE;    // 失败
874. }