?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync DrDump crash handler with TortoiseSVN codebase
[TortoiseGit.git] / ext / CrashServer / external / WTL / Include / atlgdi.h
blob2272753b182444ea69197ad0ae23dee1be8591b0
1 // Windows Template Library - WTL version 9.0
2 // Copyright (C) Microsoft Corporation, WTL Team. All rights reserved.
3 //
4 // This file is a part of the Windows Template Library.
5 // The use and distribution terms for this software are covered by the
6 // Common Public License 1.0 (http://opensource.org/licenses/cpl1.0.php)
7 // which can be found in the file CPL.TXT at the root of this distribution.
8 // By using this software in any fashion, you are agreeing to be bound by
9 // the terms of this license. You must not remove this notice, or
10 // any other, from this software.
11
12 #ifndef __ATLGDI_H__
13 #define __ATLGDI_H__
14
15 #pragma once
16
17 #ifndef __ATLAPP_H__
18 #error atlgdi.h requires atlapp.h to be included first
19 #endif
20
21
22 // protect template members from windowsx.h macros
23 #ifdef _INC_WINDOWSX
24 #undef CopyRgn
25 #undef CreateBrush
26 #undef CreatePen
27 #undef SelectBrush
28 #undef SelectPen
29 #undef SelectFont
30 #undef SelectBitmap
31 #endif // _INC_WINDOWSX
32
33 // required libraries
34 #if !defined(_ATL_NO_MSIMG) && !defined(_WIN32_WCE)
35 #pragma comment(lib, "msimg32.lib")
36 #endif
37 #if !defined(_ATL_NO_OPENGL) && !defined(_WIN32_WCE)
38 #pragma comment(lib, "opengl32.lib")
39 #endif
40
41
42 ///////////////////////////////////////////////////////////////////////////////
43 // Classes in this file:
44 //
45 // CPenT<t_bManaged>
46 // CBrushT<t_bManaged>
47 // CLogFont
48 // CFontT<t_bManaged>
49 // CBitmapT<t_bManaged>
50 // CPaletteT<t_bManaged>
51 // CRgnT<t_bManaged>
52 // CDCT<t_bManaged>
53 // CPaintDC
54 // CClientDC
55 // CWindowDC
56 // CMemoryDC
57 // CEnhMetaFileInfo
58 // CEnhMetaFileT<t_bManaged>
59 // CEnhMetaFileDC
60 //
61 // Global functions:
62 // AtlGetBitmapResourceInfo()
63 // AtlGetBitmapResourceBitsPerPixel()
64 // AtlIsAlphaBitmapResource()
65 // AtlIsDib16()
66 // AtlGetDibColorTableSize()
67 // AtlGetDibNumColors(),
68 // AtlGetDibBitmap()
69 // AtlCopyBitmap()
70 // AtlCreatePackedDib16()
71 // AtlSetClipboardDib16()
72 // AtlGetClipboardDib()
73
74
75 namespace WTL
76 {
77
78 ///////////////////////////////////////////////////////////////////////////////
79 // Bitmap resource helpers to extract bitmap information for a bitmap resource
80
81 inline LPBITMAPINFOHEADER AtlGetBitmapResourceInfo(HMODULE hModule, ATL::_U_STRINGorID image)
82 {
83 HRSRC hResource = ::FindResource(hModule, image.m_lpstr, RT_BITMAP);
84 ATLASSERT(hResource != NULL);
85 HGLOBAL hGlobal = ::LoadResource(hModule, hResource);
86 ATLASSERT(hGlobal != NULL);
87 LPBITMAPINFOHEADER pBitmapInfoHeader = (LPBITMAPINFOHEADER)::LockResource(hGlobal);
88 ATLASSERT(pBitmapInfoHeader != NULL);
89 return pBitmapInfoHeader;
90 }
91
92 inline WORD AtlGetBitmapResourceBitsPerPixel(HMODULE hModule, ATL::_U_STRINGorID image)
93 {
94 LPBITMAPINFOHEADER pBitmapInfoHeader = AtlGetBitmapResourceInfo(hModule, image);
95 ATLASSERT(pBitmapInfoHeader != NULL);
96 return pBitmapInfoHeader->biBitCount;
97 }
98
99 inline WORD AtlGetBitmapResourceBitsPerPixel(ATL::_U_STRINGorID image)
100 {
101 return AtlGetBitmapResourceBitsPerPixel(ModuleHelper::GetResourceInstance(), image);
102 }
103
104 ///////////////////////////////////////////////////////////////////////////////
105 // 32-bit (alpha channel) bitmap resource helper
106
107 // Note: 32-bit (alpha channel) images work only on Windows XP with Common Controls version 6.
108 // If you want your app to work on older version of Windows, load non-alpha images if Common
109 // Controls version is less than 6.
110
111 inline bool AtlIsAlphaBitmapResource(ATL::_U_STRINGorID image)
112 {
113 return (AtlGetBitmapResourceBitsPerPixel(image) == 32);
114 }
115
116
117 ///////////////////////////////////////////////////////////////////////////////
118 // CPen
119
120 template <bool t_bManaged>
121 class CPenT
122 {
123 public:
124 // Data members
125 HPEN m_hPen;
126
127 // Constructor/destructor/operators
128 CPenT(HPEN hPen = NULL) : m_hPen(hPen)
129 { }
130
131 ~CPenT()
132 {
133 if(t_bManaged && m_hPen != NULL)
134 DeleteObject();
135 }
136
137 CPenT<t_bManaged>& operator =(HPEN hPen)
138 {
139 Attach(hPen);
140 return *this;
141 }
142
143 void Attach(HPEN hPen)
144 {
145 if(t_bManaged && m_hPen != NULL && m_hPen != hPen)
146 ::DeleteObject(m_hPen);
147 m_hPen = hPen;
148 }
149
150 HPEN Detach()
151 {
152 HPEN hPen = m_hPen;
153 m_hPen = NULL;
154 return hPen;
155 }
156
157 operator HPEN() const { return m_hPen; }
158
159 bool IsNull() const { return (m_hPen == NULL); }
160
161 // Create methods
162 HPEN CreatePen(int nPenStyle, int nWidth, COLORREF crColor)
163 {
164 ATLASSERT(m_hPen == NULL);
165 m_hPen = ::CreatePen(nPenStyle, nWidth, crColor);
166 return m_hPen;
167 }
168
169 #ifndef _WIN32_WCE
170 HPEN CreatePen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush, int nStyleCount = 0, const DWORD* lpStyle = NULL)
171 {
172 ATLASSERT(m_hPen == NULL);
173 m_hPen = ::ExtCreatePen(nPenStyle, nWidth, pLogBrush, nStyleCount, lpStyle);
174 return m_hPen;
175 }
176 #endif // !_WIN32_WCE
177
178 HPEN CreatePenIndirect(LPLOGPEN lpLogPen)
179 {
180 ATLASSERT(m_hPen == NULL);
181 m_hPen = ::CreatePenIndirect(lpLogPen);
182 return m_hPen;
183 }
184
185 BOOL DeleteObject()
186 {
187 ATLASSERT(m_hPen != NULL);
188 BOOL bRet = ::DeleteObject(m_hPen);
189 if(bRet)
190 m_hPen = NULL;
191 return bRet;
192 }
193
194 // Attributes
195 int GetLogPen(LOGPEN* pLogPen) const
196 {
197 ATLASSERT(m_hPen != NULL);
198 return ::GetObject(m_hPen, sizeof(LOGPEN), pLogPen);
199 }
200
201 bool GetLogPen(LOGPEN& LogPen) const
202 {
203 ATLASSERT(m_hPen != NULL);
204 return (::GetObject(m_hPen, sizeof(LOGPEN), &LogPen) == sizeof(LOGPEN));
205 }
206
207 #ifndef _WIN32_WCE
208 int GetExtLogPen(EXTLOGPEN* pLogPen, int nSize = sizeof(EXTLOGPEN)) const
209 {
210 ATLASSERT(m_hPen != NULL);
211 return ::GetObject(m_hPen, nSize, pLogPen);
212 }
213
214 bool GetExtLogPen(EXTLOGPEN& ExtLogPen, int nSize = sizeof(EXTLOGPEN)) const
215 {
216 ATLASSERT(m_hPen != NULL);
217 int nRet = ::GetObject(m_hPen, nSize, &ExtLogPen);
218 return ((nRet > 0) && (nRet <= nSize));
219 }
220 #endif // !_WIN32_WCE
221 };
222
223 typedef CPenT<false> CPenHandle;
224 typedef CPenT<true> CPen;
225
226
227 ///////////////////////////////////////////////////////////////////////////////
228 // CBrush
229
230 template <bool t_bManaged>
231 class CBrushT
232 {
233 public:
234 // Data members
235 HBRUSH m_hBrush;
236
237 // Constructor/destructor/operators
238 CBrushT(HBRUSH hBrush = NULL) : m_hBrush(hBrush)
239 { }
240
241 ~CBrushT()
242 {
243 if(t_bManaged && m_hBrush != NULL)
244 DeleteObject();
245 }
246
247 CBrushT<t_bManaged>& operator =(HBRUSH hBrush)
248 {
249 Attach(hBrush);
250 return *this;
251 }
252
253 void Attach(HBRUSH hBrush)
254 {
255 if(t_bManaged && m_hBrush != NULL && m_hBrush != hBrush)
256 ::DeleteObject(m_hBrush);
257 m_hBrush = hBrush;
258 }
259
260 HBRUSH Detach()
261 {
262 HBRUSH hBrush = m_hBrush;
263 m_hBrush = NULL;
264 return hBrush;
265 }
266
267 operator HBRUSH() const { return m_hBrush; }
268
269 bool IsNull() const { return (m_hBrush == NULL); }
270
271 // Create methods
272 HBRUSH CreateSolidBrush(COLORREF crColor)
273 {
274 ATLASSERT(m_hBrush == NULL);
275 m_hBrush = ::CreateSolidBrush(crColor);
276 return m_hBrush;
277 }
278
279 #ifndef _WIN32_WCE
280 HBRUSH CreateHatchBrush(int nIndex, COLORREF crColor)
281 {
282 ATLASSERT(m_hBrush == NULL);
283 m_hBrush = ::CreateHatchBrush(nIndex, crColor);
284 return m_hBrush;
285 }
286 #endif // !_WIN32_WCE
287
288 #if !defined(_WIN32_WCE) || (_ATL_VER >= 0x0800)
289 HBRUSH CreateBrushIndirect(const LOGBRUSH* lpLogBrush)
290 {
291 ATLASSERT(m_hBrush == NULL);
292 #ifndef _WIN32_WCE
293 m_hBrush = ::CreateBrushIndirect(lpLogBrush);
294 #else // CE specific
295 m_hBrush = ATL::CreateBrushIndirect(lpLogBrush);
296 #endif // _WIN32_WCE
297 return m_hBrush;
298 }
299 #endif // !defined(_WIN32_WCE) || (_ATL_VER >= 0x0800)
300
301 HBRUSH CreatePatternBrush(HBITMAP hBitmap)
302 {
303 ATLASSERT(m_hBrush == NULL);
304 m_hBrush = ::CreatePatternBrush(hBitmap);
305 return m_hBrush;
306 }
307
308 HBRUSH CreateDIBPatternBrush(HGLOBAL hPackedDIB, UINT nUsage)
309 {
310 ATLASSERT(hPackedDIB != NULL);
311 const void* lpPackedDIB = GlobalLock(hPackedDIB);
312 ATLASSERT(lpPackedDIB != NULL);
313 m_hBrush = ::CreateDIBPatternBrushPt(lpPackedDIB, nUsage);
314 GlobalUnlock(hPackedDIB);
315 return m_hBrush;
316 }
317
318 HBRUSH CreateDIBPatternBrush(const void* lpPackedDIB, UINT nUsage)
319 {
320 ATLASSERT(m_hBrush == NULL);
321 m_hBrush = ::CreateDIBPatternBrushPt(lpPackedDIB, nUsage);
322 return m_hBrush;
323 }
324
325 HBRUSH CreateSysColorBrush(int nIndex)
326 {
327 ATLASSERT(m_hBrush == NULL);
328 m_hBrush = ::GetSysColorBrush(nIndex);
329 return m_hBrush;
330 }
331
332 BOOL DeleteObject()
333 {
334 ATLASSERT(m_hBrush != NULL);
335 BOOL bRet = ::DeleteObject(m_hBrush);
336 if(bRet)
337 m_hBrush = NULL;
338 return bRet;
339 }
340
341 // Attributes
342 int GetLogBrush(LOGBRUSH* pLogBrush) const
343 {
344 ATLASSERT(m_hBrush != NULL);
345 return ::GetObject(m_hBrush, sizeof(LOGBRUSH), pLogBrush);
346 }
347
348 bool GetLogBrush(LOGBRUSH& LogBrush) const
349 {
350 ATLASSERT(m_hBrush != NULL);
351 return (::GetObject(m_hBrush, sizeof(LOGBRUSH), &LogBrush) == sizeof(LOGBRUSH));
352 }
353 };
354
355 typedef CBrushT<false> CBrushHandle;
356 typedef CBrushT<true> CBrush;
357
358
359 ///////////////////////////////////////////////////////////////////////////////
360 // CFont
361
362 class CLogFont : public LOGFONT
363 {
364 public:
365 CLogFont()
366 {
367 memset(this, 0, sizeof(LOGFONT));
368 }
369
370 CLogFont(const LOGFONT& lf)
371 {
372 Copy(&lf);
373 }
374
375 CLogFont(HFONT hFont)
376 {
377 ATLASSERT(::GetObjectType(hFont) == OBJ_FONT);
378 ::GetObject(hFont, sizeof(LOGFONT), (LOGFONT*)this);
379 }
380
381 HFONT CreateFontIndirect()
382 {
383 return ::CreateFontIndirect(this);
384 }
385
386 void SetBold()
387 {
388 lfWeight = FW_BOLD;
389 }
390
391 bool IsBold() const
392 {
393 return (lfWeight >= FW_BOLD);
394 }
395
396 void MakeBolder(int iScale = 1)
397 {
398 lfWeight += FW_BOLD * iScale;
399 }
400
401 void MakeLarger(int iScale)
402 {
403 if(lfHeight > 0)
404 lfHeight += iScale;
405 else
406 lfHeight -= iScale;
407 }
408
409 void SetHeight(LONG nPointSize, HDC hDC = NULL)
410 {
411 HDC hDC1 = (hDC != NULL) ? hDC : ::GetDC(NULL);
412 // For MM_TEXT mapping mode
413 lfHeight = -::MulDiv(nPointSize, ::GetDeviceCaps(hDC1, LOGPIXELSY), 72);
414 if(hDC == NULL)
415 ::ReleaseDC(NULL, hDC1);
416 }
417
418 LONG GetHeight(HDC hDC = NULL) const
419 {
420 HDC hDC1 = (hDC != NULL) ? hDC : ::GetDC(NULL);
421 // For MM_TEXT mapping mode
422 LONG nPointSize = ::MulDiv(-lfHeight, 72, ::GetDeviceCaps(hDC1, LOGPIXELSY));
423 if(hDC == NULL)
424 ::ReleaseDC(NULL, hDC1);
425
426 return nPointSize;
427 }
428
429 LONG GetDeciPointHeight(HDC hDC = NULL) const
430 {
431 HDC hDC1 = (hDC != NULL) ? hDC : ::GetDC(NULL);
432 #ifndef _WIN32_WCE
433 POINT ptOrg = { 0, 0 };
434 ::DPtoLP(hDC1, &ptOrg, 1);
435 POINT pt = { 0, 0 };
436 pt.y = abs(lfHeight) + ptOrg.y;
437 ::LPtoDP(hDC1, &pt,1);
438 LONG nDeciPoint = ::MulDiv(pt.y, 720, ::GetDeviceCaps(hDC1, LOGPIXELSY)); // 72 points/inch, 10 decipoints/point
439 #else // CE specific
440 // DP and LP are always the same on CE
441 LONG nDeciPoint = ::MulDiv(abs(lfHeight), 720, ::GetDeviceCaps(hDC1, LOGPIXELSY)); // 72 points/inch, 10 decipoints/point
442 #endif // _WIN32_WCE
443 if(hDC == NULL)
444 ::ReleaseDC(NULL, hDC1);
445
446 return nDeciPoint;
447 }
448
449 void SetHeightFromDeciPoint(LONG nDeciPtHeight, HDC hDC = NULL)
450 {
451 HDC hDC1 = (hDC != NULL) ? hDC : ::GetDC(NULL);
452 #ifndef _WIN32_WCE
453 POINT pt = { 0, 0 };
454 pt.y = ::MulDiv(::GetDeviceCaps(hDC1, LOGPIXELSY), nDeciPtHeight, 720); // 72 points/inch, 10 decipoints/point
455 ::DPtoLP(hDC1, &pt, 1);
456 POINT ptOrg = { 0, 0 };
457 ::DPtoLP(hDC1, &ptOrg, 1);
458 lfHeight = -abs(pt.y - ptOrg.y);
459 #else // CE specific
460 // DP and LP are always the same on CE
461 lfHeight = -abs(::MulDiv(::GetDeviceCaps(hDC1, LOGPIXELSY), nDeciPtHeight, 720)); // 72 points/inch, 10 decipoints/point
462 #endif // _WIN32_WCE
463 if(hDC == NULL)
464 ::ReleaseDC(NULL, hDC1);
465 }
466
467 #ifndef _WIN32_WCE
468 void SetCaptionFont()
469 {
470 NONCLIENTMETRICS ncm = { RunTimeHelper::SizeOf_NONCLIENTMETRICS() };
471 ATLVERIFY(::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0));
472 Copy(&ncm.lfCaptionFont);
473 }
474
475 void SetMenuFont()
476 {
477 NONCLIENTMETRICS ncm = { RunTimeHelper::SizeOf_NONCLIENTMETRICS() };
478 ATLVERIFY(::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0));
479 Copy(&ncm.lfMenuFont);
480 }
481
482 void SetStatusFont()
483 {
484 NONCLIENTMETRICS ncm = { RunTimeHelper::SizeOf_NONCLIENTMETRICS() };
485 ATLVERIFY(::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0));
486 Copy(&ncm.lfStatusFont);
487 }
488
489 void SetMessageBoxFont()
490 {
491 NONCLIENTMETRICS ncm = { RunTimeHelper::SizeOf_NONCLIENTMETRICS() };
492 ATLVERIFY(::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0));
493 Copy(&ncm.lfMessageFont);
494 }
495 #endif // !_WIN32_WCE
496
497 void Copy(const LOGFONT* pLogFont)
498 {
499 ATLASSERT(pLogFont != NULL);
500 *(LOGFONT*)this = *pLogFont;
501 }
502
503 CLogFont& operator =(const CLogFont& src)
504 {
505 Copy(&src);
506 return *this;
507 }
508
509 CLogFont& operator =(const LOGFONT& src)
510 {
511 Copy(&src);
512 return *this;
513 }
514
515 CLogFont& operator =(HFONT hFont)
516 {
517 ATLASSERT(::GetObjectType(hFont) == OBJ_FONT);
518 ::GetObject(hFont, sizeof(LOGFONT), (LOGFONT*)this);
519 return *this;
520 }
521
522 bool operator ==(const LOGFONT& logfont) const
523 {
524 return(logfont.lfHeight == lfHeight &&
525 logfont.lfWidth == lfWidth &&
526 logfont.lfEscapement == lfEscapement &&
527 logfont.lfOrientation == lfOrientation &&
528 logfont.lfWeight == lfWeight &&
529 logfont.lfItalic == lfItalic &&
530 logfont.lfUnderline == lfUnderline &&
531 logfont.lfStrikeOut == lfStrikeOut &&
532 logfont.lfCharSet == lfCharSet &&
533 logfont.lfOutPrecision == lfOutPrecision &&
534 logfont.lfClipPrecision == lfClipPrecision &&
535 logfont.lfQuality == lfQuality &&
536 logfont.lfPitchAndFamily == lfPitchAndFamily &&
537 lstrcmp(logfont.lfFaceName, lfFaceName) == 0);
538 }
539 };
540
541
542 template <bool t_bManaged>
543 class CFontT
544 {
545 public:
546 // Data members
547 HFONT m_hFont;
548
549 // Constructor/destructor/operators
550 CFontT(HFONT hFont = NULL) : m_hFont(hFont)
551 { }
552
553 ~CFontT()
554 {
555 if(t_bManaged && m_hFont != NULL)
556 DeleteObject();
557 }
558
559 CFontT<t_bManaged>& operator =(HFONT hFont)
560 {
561 Attach(hFont);
562 return *this;
563 }
564
565 void Attach(HFONT hFont)
566 {
567 if(t_bManaged && m_hFont != NULL && m_hFont != hFont)
568 ::DeleteObject(m_hFont);
569 m_hFont = hFont;
570 }
571
572 HFONT Detach()
573 {
574 HFONT hFont = m_hFont;
575 m_hFont = NULL;
576 return hFont;
577 }
578
579 operator HFONT() const { return m_hFont; }
580
581 bool IsNull() const { return (m_hFont == NULL); }
582
583 // Create methods
584 HFONT CreateFontIndirect(const LOGFONT* lpLogFont)
585 {
586 ATLASSERT(m_hFont == NULL);
587 m_hFont = ::CreateFontIndirect(lpLogFont);
588 return m_hFont;
589 }
590
591 #if !defined(_WIN32_WCE) && (_WIN32_WINNT >= 0x0500)
592 HFONT CreateFontIndirectEx(CONST ENUMLOGFONTEXDV* penumlfex)
593 {
594 ATLASSERT(m_hFont == NULL);
595 m_hFont = ::CreateFontIndirectEx(penumlfex);
596 return m_hFont;
597 }
598 #endif // !defined(_WIN32_WCE) && (_WIN32_WINNT >= 0x0500)
599
600 #if !defined(_WIN32_WCE) || (_ATL_VER >= 0x0800)
601 HFONT CreateFont(int nHeight, int nWidth, int nEscapement,
602 int nOrientation, int nWeight, BYTE bItalic, BYTE bUnderline,
603 BYTE cStrikeOut, BYTE nCharSet, BYTE nOutPrecision,
604 BYTE nClipPrecision, BYTE nQuality, BYTE nPitchAndFamily,
605 LPCTSTR lpszFacename)
606 {
607 ATLASSERT(m_hFont == NULL);
608 #ifndef _WIN32_WCE
609 m_hFont = ::CreateFont(nHeight, nWidth, nEscapement,
610 nOrientation, nWeight, bItalic, bUnderline, cStrikeOut,
611 nCharSet, nOutPrecision, nClipPrecision, nQuality,
612 nPitchAndFamily, lpszFacename);
613 #else // CE specific
614 m_hFont = ATL::CreateFont(nHeight, nWidth, nEscapement,
615 nOrientation, nWeight, bItalic, bUnderline, cStrikeOut,
616 nCharSet, nOutPrecision, nClipPrecision, nQuality,
617 nPitchAndFamily, lpszFacename);
618 #endif // _WIN32_WCE
619 return m_hFont;
620 }
621 #endif // !defined(_WIN32_WCE) || (_ATL_VER >= 0x0800)
622
623 HFONT CreatePointFont(int nPointSize, LPCTSTR lpszFaceName, HDC hDC = NULL, bool bBold = false, bool bItalic = false)
624 {
625 LOGFONT logFont = { 0 };
626 logFont.lfCharSet = DEFAULT_CHARSET;
627 logFont.lfHeight = nPointSize;
628 SecureHelper::strncpy_x(logFont.lfFaceName, _countof(logFont.lfFaceName), lpszFaceName, _TRUNCATE);
629
630 if(bBold)
631 logFont.lfWeight = FW_BOLD;
632 if(bItalic)
633 logFont.lfItalic = (BYTE)TRUE;
634
635 return CreatePointFontIndirect(&logFont, hDC);
636 }
637
638 HFONT CreatePointFontIndirect(const LOGFONT* lpLogFont, HDC hDC = NULL)
639 {
640 HDC hDC1 = (hDC != NULL) ? hDC : ::GetDC(NULL);
641
642 // convert nPointSize to logical units based on hDC
643 LOGFONT logFont = *lpLogFont;
644 #ifndef _WIN32_WCE
645 POINT pt = { 0, 0 };
646 pt.y = ::MulDiv(::GetDeviceCaps(hDC1, LOGPIXELSY), logFont.lfHeight, 720); // 72 points/inch, 10 decipoints/point
647 ::DPtoLP(hDC1, &pt, 1);
648 POINT ptOrg = { 0, 0 };
649 ::DPtoLP(hDC1, &ptOrg, 1);
650 logFont.lfHeight = -abs(pt.y - ptOrg.y);
651 #else // CE specific
652 // DP and LP are always the same on CE
653 logFont.lfHeight = -abs(::MulDiv(::GetDeviceCaps(hDC1, LOGPIXELSY), logFont.lfHeight, 720)); // 72 points/inch, 10 decipoints/point
654 #endif // _WIN32_WCE
655
656 if(hDC == NULL)
657 ::ReleaseDC(NULL, hDC1);
658
659 return CreateFontIndirect(&logFont);
660 }
661
662 BOOL DeleteObject()
663 {
664 ATLASSERT(m_hFont != NULL);
665 BOOL bRet = ::DeleteObject(m_hFont);
666 if(bRet)
667 m_hFont = NULL;
668 return bRet;
669 }
670
671 // Attributes
672 int GetLogFont(LOGFONT* pLogFont) const
673 {
674 ATLASSERT(m_hFont != NULL);
675 return ::GetObject(m_hFont, sizeof(LOGFONT), pLogFont);
676 }
677
678 bool GetLogFont(LOGFONT& LogFont) const
679 {
680 ATLASSERT(m_hFont != NULL);
681 return (::GetObject(m_hFont, sizeof(LOGFONT), &LogFont) == sizeof(LOGFONT));
682 }
683 };
684
685 typedef CFontT<false> CFontHandle;
686 typedef CFontT<true> CFont;
687
688
689 ///////////////////////////////////////////////////////////////////////////////
690 // CBitmap
691
692 template <bool t_bManaged>
693 class CBitmapT
694 {
695 public:
696 // Data members
697 HBITMAP m_hBitmap;
698
699 // Constructor/destructor/operators
700 CBitmapT(HBITMAP hBitmap = NULL) : m_hBitmap(hBitmap)
701 { }
702
703 ~CBitmapT()
704 {
705 if(t_bManaged && m_hBitmap != NULL)
706 DeleteObject();
707 }
708
709 CBitmapT<t_bManaged>& operator =(HBITMAP hBitmap)
710 {
711 Attach(hBitmap);
712 return *this;
713 }
714
715 void Attach(HBITMAP hBitmap)
716 {
717 if(t_bManaged && m_hBitmap != NULL&& m_hBitmap != hBitmap)
718 ::DeleteObject(m_hBitmap);
719 m_hBitmap = hBitmap;
720 }
721
722 HBITMAP Detach()
723 {
724 HBITMAP hBitmap = m_hBitmap;
725 m_hBitmap = NULL;
726 return hBitmap;
727 }
728
729 operator HBITMAP() const { return m_hBitmap; }
730
731 bool IsNull() const { return (m_hBitmap == NULL); }
732
733 // Create and load methods
734 HBITMAP LoadBitmap(ATL::_U_STRINGorID bitmap)
735 {
736 ATLASSERT(m_hBitmap == NULL);
737 m_hBitmap = ::LoadBitmap(ModuleHelper::GetResourceInstance(), bitmap.m_lpstr);
738 return m_hBitmap;
739 }
740
741 HBITMAP LoadOEMBitmap(UINT nIDBitmap) // for OBM_/OCR_/OIC_
742 {
743 ATLASSERT(m_hBitmap == NULL);
744 m_hBitmap = ::LoadBitmap(NULL, MAKEINTRESOURCE(nIDBitmap));
745 return m_hBitmap;
746 }
747
748 #ifndef _WIN32_WCE
749 HBITMAP LoadMappedBitmap(UINT nIDBitmap, UINT nFlags = 0, LPCOLORMAP lpColorMap = NULL, int nMapSize = 0)
750 {
751 ATLASSERT(m_hBitmap == NULL);
752 m_hBitmap = ::CreateMappedBitmap(ModuleHelper::GetResourceInstance(), nIDBitmap, (WORD)nFlags, lpColorMap, nMapSize);
753 return m_hBitmap;
754 }
755 #endif // !_WIN32_WCE
756
757 HBITMAP CreateBitmap(int nWidth, int nHeight, UINT nPlanes, UINT nBitsPerPixel, const void* lpBits)
758 {
759 ATLASSERT(m_hBitmap == NULL);
760 m_hBitmap = ::CreateBitmap(nWidth, nHeight, nPlanes, nBitsPerPixel, lpBits);
761 return m_hBitmap;
762 }
763
764 #ifndef _WIN32_WCE
765 HBITMAP CreateBitmapIndirect(LPBITMAP lpBitmap)
766 {
767 ATLASSERT(m_hBitmap == NULL);
768 m_hBitmap = ::CreateBitmapIndirect(lpBitmap);
769 return m_hBitmap;
770 }
771 #endif // !_WIN32_WCE
772
773 HBITMAP CreateCompatibleBitmap(HDC hDC, int nWidth, int nHeight)
774 {
775 ATLASSERT(m_hBitmap == NULL);
776 m_hBitmap = ::CreateCompatibleBitmap(hDC, nWidth, nHeight);
777 return m_hBitmap;
778 }
779
780 #ifndef _WIN32_WCE
781 HBITMAP CreateDiscardableBitmap(HDC hDC, int nWidth, int nHeight)
782 {
783 ATLASSERT(m_hBitmap == NULL);
784 m_hBitmap = ::CreateDiscardableBitmap(hDC, nWidth, nHeight);
785 return m_hBitmap;
786 }
787 #endif // !_WIN32_WCE
788
789 BOOL DeleteObject()
790 {
791 ATLASSERT(m_hBitmap != NULL);
792 BOOL bRet = ::DeleteObject(m_hBitmap);
793 if(bRet)
794 m_hBitmap = NULL;
795 return bRet;
796 }
797
798 // Attributes
799 int GetBitmap(BITMAP* pBitMap) const
800 {
801 ATLASSERT(m_hBitmap != NULL);
802 return ::GetObject(m_hBitmap, sizeof(BITMAP), pBitMap);
803 }
804
805 bool GetBitmap(BITMAP& bm) const
806 {
807 ATLASSERT(m_hBitmap != NULL);
808 return (::GetObject(m_hBitmap, sizeof(BITMAP), &bm) == sizeof(BITMAP));
809 }
810
811 bool GetSize(SIZE& size) const
812 {
813 ATLASSERT(m_hBitmap != NULL);
814 BITMAP bm = { 0 };
815 if(!GetBitmap(&bm))
816 return false;
817 size.cx = bm.bmWidth;
818 size.cy = bm.bmHeight;
819 return true;
820 }
821
822 #ifndef _WIN32_WCE
823 DWORD GetBitmapBits(DWORD dwCount, LPVOID lpBits) const
824 {
825 ATLASSERT(m_hBitmap != NULL);
826 return ::GetBitmapBits(m_hBitmap, dwCount, lpBits);
827 }
828 #endif // !_WIN32_WCE
829
830 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 410)
831 DWORD SetBitmapBits(DWORD dwCount, const void* lpBits)
832 {
833 ATLASSERT(m_hBitmap != NULL);
834 return ::SetBitmapBits(m_hBitmap, dwCount, lpBits);
835 }
836 #endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 410)
837
838 #ifndef _WIN32_WCE
839 BOOL GetBitmapDimension(LPSIZE lpSize) const
840 {
841 ATLASSERT(m_hBitmap != NULL);
842 return ::GetBitmapDimensionEx(m_hBitmap, lpSize);
843 }
844
845 BOOL SetBitmapDimension(int nWidth, int nHeight, LPSIZE lpSize = NULL)
846 {
847 ATLASSERT(m_hBitmap != NULL);
848 return ::SetBitmapDimensionEx(m_hBitmap, nWidth, nHeight, lpSize);
849 }
850
851 // DIB support
852 HBITMAP CreateDIBitmap(HDC hDC, CONST BITMAPINFOHEADER* lpbmih, DWORD dwInit, CONST VOID* lpbInit, CONST BITMAPINFO* lpbmi, UINT uColorUse)
853 {
854 ATLASSERT(m_hBitmap == NULL);
855 m_hBitmap = ::CreateDIBitmap(hDC, lpbmih, dwInit, lpbInit, lpbmi, uColorUse);
856 return m_hBitmap;
857 }
858 #endif // !_WIN32_WCE
859
860 HBITMAP CreateDIBSection(HDC hDC, CONST BITMAPINFO* lpbmi, UINT uColorUse, VOID** ppvBits, HANDLE hSection, DWORD dwOffset)
861 {
862 ATLASSERT(m_hBitmap == NULL);
863 m_hBitmap = ::CreateDIBSection(hDC, lpbmi, uColorUse, ppvBits, hSection, dwOffset);
864 return m_hBitmap;
865 }
866
867 #ifndef _WIN32_WCE
868 int GetDIBits(HDC hDC, UINT uStartScan, UINT cScanLines, LPVOID lpvBits, LPBITMAPINFO lpbmi, UINT uColorUse) const
869 {
870 ATLASSERT(m_hBitmap != NULL);
871 return ::GetDIBits(hDC, m_hBitmap, uStartScan, cScanLines, lpvBits, lpbmi, uColorUse);
872 }
873
874 int SetDIBits(HDC hDC, UINT uStartScan, UINT cScanLines, CONST VOID* lpvBits, CONST BITMAPINFO* lpbmi, UINT uColorUse)
875 {
876 ATLASSERT(m_hBitmap != NULL);
877 return ::SetDIBits(hDC, m_hBitmap, uStartScan, cScanLines, lpvBits, lpbmi, uColorUse);
878 }
879 #endif // !_WIN32_WCE
880 };
881
882 typedef CBitmapT<false> CBitmapHandle;
883 typedef CBitmapT<true> CBitmap;
884
885
886 ///////////////////////////////////////////////////////////////////////////////
887 // CPalette
888
889 template <bool t_bManaged>
890 class CPaletteT
891 {
892 public:
893 // Data members
894 HPALETTE m_hPalette;
895
896 // Constructor/destructor/operators
897 CPaletteT(HPALETTE hPalette = NULL) : m_hPalette(hPalette)
898 { }
899
900 ~CPaletteT()
901 {
902 if(t_bManaged && m_hPalette != NULL)
903 DeleteObject();
904 }
905
906 CPaletteT<t_bManaged>& operator =(HPALETTE hPalette)
907 {
908 Attach(hPalette);
909 return *this;
910 }
911
912 void Attach(HPALETTE hPalette)
913 {
914 if(t_bManaged && m_hPalette != NULL && m_hPalette != hPalette)
915 ::DeleteObject(m_hPalette);
916 m_hPalette = hPalette;
917 }
918
919 HPALETTE Detach()
920 {
921 HPALETTE hPalette = m_hPalette;
922 m_hPalette = NULL;
923 return hPalette;
924 }
925
926 operator HPALETTE() const { return m_hPalette; }
927
928 bool IsNull() const { return (m_hPalette == NULL); }
929
930 // Create methods
931 HPALETTE CreatePalette(LPLOGPALETTE lpLogPalette)
932 {
933 ATLASSERT(m_hPalette == NULL);
934 m_hPalette = ::CreatePalette(lpLogPalette);
935 return m_hPalette;
936 }
937
938 #ifndef _WIN32_WCE
939 HPALETTE CreateHalftonePalette(HDC hDC)
940 {
941 ATLASSERT(m_hPalette == NULL);
942 ATLASSERT(hDC != NULL);
943 m_hPalette = ::CreateHalftonePalette(hDC);
944 return m_hPalette;
945 }
946 #endif // !_WIN32_WCE
947
948 BOOL DeleteObject()
949 {
950 ATLASSERT(m_hPalette != NULL);
951 BOOL bRet = ::DeleteObject(m_hPalette);
952 if(bRet)
953 m_hPalette = NULL;
954 return bRet;
955 }
956
957 // Attributes
958 int GetEntryCount() const
959 {
960 ATLASSERT(m_hPalette != NULL);
961 WORD nEntries = 0;
962 ::GetObject(m_hPalette, sizeof(WORD), &nEntries);
963 return (int)nEntries;
964 }
965
966 UINT GetPaletteEntries(UINT nStartIndex, UINT nNumEntries, LPPALETTEENTRY lpPaletteColors) const
967 {
968 ATLASSERT(m_hPalette != NULL);
969 return ::GetPaletteEntries(m_hPalette, nStartIndex, nNumEntries, lpPaletteColors);
970 }
971
972 UINT SetPaletteEntries(UINT nStartIndex, UINT nNumEntries, LPPALETTEENTRY lpPaletteColors)
973 {
974 ATLASSERT(m_hPalette != NULL);
975 return ::SetPaletteEntries(m_hPalette, nStartIndex, nNumEntries, lpPaletteColors);
976 }
977
978 // Operations
979 #ifndef _WIN32_WCE
980 void AnimatePalette(UINT nStartIndex, UINT nNumEntries, LPPALETTEENTRY lpPaletteColors)
981 {
982 ATLASSERT(m_hPalette != NULL);
983 ::AnimatePalette(m_hPalette, nStartIndex, nNumEntries, lpPaletteColors);
984 }
985
986 BOOL ResizePalette(UINT nNumEntries)
987 {
988 ATLASSERT(m_hPalette != NULL);
989 return ::ResizePalette(m_hPalette, nNumEntries);
990 }
991 #endif // !_WIN32_WCE
992
993 UINT GetNearestPaletteIndex(COLORREF crColor) const
994 {
995 ATLASSERT(m_hPalette != NULL);
996 return ::GetNearestPaletteIndex(m_hPalette, crColor);
997 }
998 };
999
1000 typedef CPaletteT<false> CPaletteHandle;
1001 typedef CPaletteT<true> CPalette;
1002
1003
1004 ///////////////////////////////////////////////////////////////////////////////
1005 // CRgn
1006
1007 template <bool t_bManaged>
1008 class CRgnT
1009 {
1010 public:
1011 // Data members
1012 HRGN m_hRgn;
1013
1014 // Constructor/destructor/operators
1015 CRgnT(HRGN hRgn = NULL) : m_hRgn(hRgn)
1016 { }
1017
1018 ~CRgnT()
1019 {
1020 if(t_bManaged && m_hRgn != NULL)
1021 DeleteObject();
1022 }
1023
1024 CRgnT<t_bManaged>& operator =(HRGN hRgn)
1025 {
1026 Attach(hRgn);
1027 return *this;
1028 }
1029
1030 void Attach(HRGN hRgn)
1031 {
1032 if(t_bManaged && m_hRgn != NULL && m_hRgn != hRgn)
1033 ::DeleteObject(m_hRgn);
1034 m_hRgn = hRgn;
1035 }
1036
1037 HRGN Detach()
1038 {
1039 HRGN hRgn = m_hRgn;
1040 m_hRgn = NULL;
1041 return hRgn;
1042 }
1043
1044 operator HRGN() const { return m_hRgn; }
1045
1046 bool IsNull() const { return (m_hRgn == NULL); }
1047
1048 // Create methods
1049 HRGN CreateRectRgn(int x1, int y1, int x2, int y2)
1050 {
1051 ATLASSERT(m_hRgn == NULL);
1052 m_hRgn = ::CreateRectRgn(x1, y1, x2, y2);
1053 return m_hRgn;
1054 }
1055
1056 HRGN CreateRectRgnIndirect(LPCRECT lpRect)
1057 {
1058 ATLASSERT(m_hRgn == NULL);
1059 m_hRgn = ::CreateRectRgnIndirect(lpRect);
1060 return m_hRgn;
1061 }
1062
1063 #ifndef _WIN32_WCE
1064 HRGN CreateEllipticRgn(int x1, int y1, int x2, int y2)
1065 {
1066 ATLASSERT(m_hRgn == NULL);
1067 m_hRgn = ::CreateEllipticRgn(x1, y1, x2, y2);
1068 return m_hRgn;
1069 }
1070
1071 HRGN CreateEllipticRgnIndirect(LPCRECT lpRect)
1072 {
1073 ATLASSERT(m_hRgn == NULL);
1074 m_hRgn = ::CreateEllipticRgnIndirect(lpRect);
1075 return m_hRgn;
1076 }
1077
1078 HRGN CreatePolygonRgn(LPPOINT lpPoints, int nCount, int nMode)
1079 {
1080 ATLASSERT(m_hRgn == NULL);
1081 m_hRgn = ::CreatePolygonRgn(lpPoints, nCount, nMode);
1082 return m_hRgn;
1083 }
1084
1085 HRGN CreatePolyPolygonRgn(LPPOINT lpPoints, LPINT lpPolyCounts, int nCount, int nPolyFillMode)
1086 {
1087 ATLASSERT(m_hRgn == NULL);
1088 m_hRgn = ::CreatePolyPolygonRgn(lpPoints, lpPolyCounts, nCount, nPolyFillMode);
1089 return m_hRgn;
1090 }
1091
1092 HRGN CreateRoundRectRgn(int x1, int y1, int x2, int y2, int x3, int y3)
1093 {
1094 ATLASSERT(m_hRgn == NULL);
1095 m_hRgn = ::CreateRoundRectRgn(x1, y1, x2, y2, x3, y3);
1096 return m_hRgn;
1097 }
1098
1099 HRGN CreateFromPath(HDC hDC)
1100 {
1101 ATLASSERT(m_hRgn == NULL);
1102 ATLASSERT(hDC != NULL);
1103 m_hRgn = ::PathToRegion(hDC);
1104 return m_hRgn;
1105 }
1106
1107 HRGN CreateFromData(const XFORM* lpXForm, int nCount, const RGNDATA* pRgnData)
1108 {
1109 ATLASSERT(m_hRgn == NULL);
1110 m_hRgn = ::ExtCreateRegion(lpXForm, nCount, pRgnData);
1111 return m_hRgn;
1112 }
1113 #endif // !_WIN32_WCE
1114
1115 BOOL DeleteObject()
1116 {
1117 ATLASSERT(m_hRgn != NULL);
1118 BOOL bRet = ::DeleteObject(m_hRgn);
1119 if(bRet)
1120 m_hRgn = NULL;
1121 return bRet;
1122 }
1123
1124 // Operations
1125 void SetRectRgn(int x1, int y1, int x2, int y2)
1126 {
1127 ATLASSERT(m_hRgn != NULL);
1128 ::SetRectRgn(m_hRgn, x1, y1, x2, y2);
1129 }
1130
1131 void SetRectRgn(LPCRECT lpRect)
1132 {
1133 ATLASSERT(m_hRgn != NULL);
1134 ::SetRectRgn(m_hRgn, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
1135 }
1136
1137 int CombineRgn(HRGN hRgnSrc1, HRGN hRgnSrc2, int nCombineMode)
1138 {
1139 ATLASSERT(m_hRgn != NULL);
1140 return ::CombineRgn(m_hRgn, hRgnSrc1, hRgnSrc2, nCombineMode);
1141 }
1142
1143 int CombineRgn(HRGN hRgnSrc, int nCombineMode)
1144 {
1145 ATLASSERT(m_hRgn != NULL);
1146 return ::CombineRgn(m_hRgn, m_hRgn, hRgnSrc, nCombineMode);
1147 }
1148
1149 int CopyRgn(HRGN hRgnSrc)
1150 {
1151 ATLASSERT(m_hRgn != NULL);
1152 return ::CombineRgn(m_hRgn, hRgnSrc, NULL, RGN_COPY);
1153 }
1154
1155 BOOL EqualRgn(HRGN hRgn) const
1156 {
1157 ATLASSERT(m_hRgn != NULL);
1158 return ::EqualRgn(m_hRgn, hRgn);
1159 }
1160
1161 int OffsetRgn(int x, int y)
1162 {
1163 ATLASSERT(m_hRgn != NULL);
1164 return ::OffsetRgn(m_hRgn, x, y);
1165 }
1166
1167 int OffsetRgn(POINT point)
1168 {
1169 ATLASSERT(m_hRgn != NULL);
1170 return ::OffsetRgn(m_hRgn, point.x, point.y);
1171 }
1172
1173 int GetRgnBox(LPRECT lpRect) const
1174 {
1175 ATLASSERT(m_hRgn != NULL);
1176 return ::GetRgnBox(m_hRgn, lpRect);
1177 }
1178
1179 BOOL PtInRegion(int x, int y) const
1180 {
1181 ATLASSERT(m_hRgn != NULL);
1182 return ::PtInRegion(m_hRgn, x, y);
1183 }
1184
1185 BOOL PtInRegion(POINT point) const
1186 {
1187 ATLASSERT(m_hRgn != NULL);
1188 return ::PtInRegion(m_hRgn, point.x, point.y);
1189 }
1190
1191 BOOL RectInRegion(LPCRECT lpRect) const
1192 {
1193 ATLASSERT(m_hRgn != NULL);
1194 return ::RectInRegion(m_hRgn, lpRect);
1195 }
1196
1197 int GetRegionData(LPRGNDATA lpRgnData, int nDataSize) const
1198 {
1199 ATLASSERT(m_hRgn != NULL);
1200 return (int)::GetRegionData(m_hRgn, nDataSize, lpRgnData);
1201 }
1202 };
1203
1204 typedef CRgnT<false> CRgnHandle;
1205 typedef CRgnT<true> CRgn;
1206
1207
1208 ///////////////////////////////////////////////////////////////////////////////
1209 // CDC - The device context class
1210
1211 template <bool t_bManaged>
1212 class CDCT
1213 {
1214 public:
1215 // Data members
1216 HDC m_hDC;
1217
1218 // Constructor/destructor/operators
1219 CDCT(HDC hDC = NULL) : m_hDC(hDC)
1220 {
1221 }
1222
1223 ~CDCT()
1224 {
1225 if(t_bManaged && m_hDC != NULL)
1226 ::DeleteDC(Detach());
1227 }
1228
1229 CDCT<t_bManaged>& operator =(HDC hDC)
1230 {
1231 Attach(hDC);
1232 return *this;
1233 }
1234
1235 void Attach(HDC hDC)
1236 {
1237 if(t_bManaged && m_hDC != NULL && m_hDC != hDC)
1238 ::DeleteDC(m_hDC);
1239 m_hDC = hDC;
1240 }
1241
1242 HDC Detach()
1243 {
1244 HDC hDC = m_hDC;
1245 m_hDC = NULL;
1246 return hDC;
1247 }
1248
1249 operator HDC() const { return m_hDC; }
1250
1251 bool IsNull() const { return (m_hDC == NULL); }
1252
1253 // Operations
1254 #ifndef _WIN32_WCE
1255 HWND WindowFromDC() const
1256 {
1257 ATLASSERT(m_hDC != NULL);
1258 return ::WindowFromDC(m_hDC);
1259 }
1260 #endif // !_WIN32_WCE
1261
1262 CPenHandle GetCurrentPen() const
1263 {
1264 ATLASSERT(m_hDC != NULL);
1265 return CPenHandle((HPEN)::GetCurrentObject(m_hDC, OBJ_PEN));
1266 }
1267
1268 CBrushHandle GetCurrentBrush() const
1269 {
1270 ATLASSERT(m_hDC != NULL);
1271 return CBrushHandle((HBRUSH)::GetCurrentObject(m_hDC, OBJ_BRUSH));
1272 }
1273
1274 CPaletteHandle GetCurrentPalette() const
1275 {
1276 ATLASSERT(m_hDC != NULL);
1277 return CPaletteHandle((HPALETTE)::GetCurrentObject(m_hDC, OBJ_PAL));
1278 }
1279
1280 CFontHandle GetCurrentFont() const
1281 {
1282 ATLASSERT(m_hDC != NULL);
1283 return CFontHandle((HFONT)::GetCurrentObject(m_hDC, OBJ_FONT));
1284 }
1285
1286 CBitmapHandle GetCurrentBitmap() const
1287 {
1288 ATLASSERT(m_hDC != NULL);
1289 return CBitmapHandle((HBITMAP)::GetCurrentObject(m_hDC, OBJ_BITMAP));
1290 }
1291
1292 HDC CreateDC(LPCTSTR lpszDriverName, LPCTSTR lpszDeviceName, LPCTSTR lpszOutput, const DEVMODE* lpInitData)
1293 {
1294 ATLASSERT(m_hDC == NULL);
1295 m_hDC = ::CreateDC(lpszDriverName, lpszDeviceName, lpszOutput, lpInitData);
1296 return m_hDC;
1297 }
1298
1299 HDC CreateCompatibleDC(HDC hDC = NULL)
1300 {
1301 ATLASSERT(m_hDC == NULL);
1302 m_hDC = ::CreateCompatibleDC(hDC);
1303 return m_hDC;
1304 }
1305
1306 BOOL DeleteDC()
1307 {
1308 if(m_hDC == NULL)
1309 return FALSE;
1310 BOOL bRet = ::DeleteDC(m_hDC);
1311 if(bRet)
1312 m_hDC = NULL;
1313 return bRet;
1314 }
1315
1316 // Device-Context Functions
1317 int SaveDC()
1318 {
1319 ATLASSERT(m_hDC != NULL);
1320 return ::SaveDC(m_hDC);
1321 }
1322
1323 BOOL RestoreDC(int nSavedDC)
1324 {
1325 ATLASSERT(m_hDC != NULL);
1326 return ::RestoreDC(m_hDC, nSavedDC);
1327 }
1328
1329 int GetDeviceCaps(int nIndex) const
1330 {
1331 ATLASSERT(m_hDC != NULL);
1332 return ::GetDeviceCaps(m_hDC, nIndex);
1333 }
1334
1335 #ifndef _WIN32_WCE
1336 UINT SetBoundsRect(LPCRECT lpRectBounds, UINT flags)
1337 {
1338 ATLASSERT(m_hDC != NULL);
1339 return ::SetBoundsRect(m_hDC, lpRectBounds, flags);
1340 }
1341
1342 UINT GetBoundsRect(LPRECT lpRectBounds, UINT flags) const
1343 {
1344 ATLASSERT(m_hDC != NULL);
1345 return ::GetBoundsRect(m_hDC, lpRectBounds, flags);
1346 }
1347
1348 BOOL ResetDC(const DEVMODE* lpDevMode)
1349 {
1350 ATLASSERT(m_hDC != NULL);
1351 return ::ResetDC(m_hDC, lpDevMode) != NULL;
1352 }
1353
1354 // Drawing-Tool Functions
1355 BOOL GetBrushOrg(LPPOINT lpPoint) const
1356 {
1357 ATLASSERT(m_hDC != NULL);
1358 return ::GetBrushOrgEx(m_hDC, lpPoint);
1359 }
1360 #endif // !_WIN32_WCE
1361
1362 BOOL SetBrushOrg(int x, int y, LPPOINT lpPoint = NULL)
1363 {
1364 ATLASSERT(m_hDC != NULL);
1365 return ::SetBrushOrgEx(m_hDC, x, y, lpPoint);
1366 }
1367
1368 BOOL SetBrushOrg(POINT point, LPPOINT lpPointRet = NULL)
1369 {
1370 ATLASSERT(m_hDC != NULL);
1371 return ::SetBrushOrgEx(m_hDC, point.x, point.y, lpPointRet);
1372 }
1373
1374 #ifndef _WIN32_WCE
1375 int EnumObjects(int nObjectType, int (CALLBACK* lpfn)(LPVOID, LPARAM), LPARAM lpData)
1376 {
1377 ATLASSERT(m_hDC != NULL);
1378 #ifdef STRICT
1379 return ::EnumObjects(m_hDC, nObjectType, (GOBJENUMPROC)lpfn, lpData);
1380 #else
1381 return ::EnumObjects(m_hDC, nObjectType, (GOBJENUMPROC)lpfn, (LPVOID)lpData);
1382 #endif
1383 }
1384 #endif // !_WIN32_WCE
1385
1386 // Type-safe selection helpers
1387 HPEN SelectPen(HPEN hPen)
1388 {
1389 ATLASSERT(m_hDC != NULL);
1390 #ifndef _WIN32_WCE
1391 ATLASSERT(hPen == NULL || ::GetObjectType(hPen) == OBJ_PEN || ::GetObjectType(hPen) == OBJ_EXTPEN);
1392 #else // CE specific
1393 ATLASSERT(hPen == NULL || ::GetObjectType(hPen) == OBJ_PEN);
1394 #endif // _WIN32_WCE
1395 return (HPEN)::SelectObject(m_hDC, hPen);
1396 }
1397
1398 HBRUSH SelectBrush(HBRUSH hBrush)
1399 {
1400 ATLASSERT(m_hDC != NULL);
1401 ATLASSERT(hBrush == NULL || ::GetObjectType(hBrush) == OBJ_BRUSH);
1402 return (HBRUSH)::SelectObject(m_hDC, hBrush);
1403 }
1404
1405 HFONT SelectFont(HFONT hFont)
1406 {
1407 ATLASSERT(m_hDC != NULL);
1408 ATLASSERT(hFont == NULL || ::GetObjectType(hFont) == OBJ_FONT);
1409 return (HFONT)::SelectObject(m_hDC, hFont);
1410 }
1411
1412 HBITMAP SelectBitmap(HBITMAP hBitmap)
1413 {
1414 ATLASSERT(m_hDC != NULL);
1415 ATLASSERT(hBitmap == NULL || ::GetObjectType(hBitmap) == OBJ_BITMAP);
1416 return (HBITMAP)::SelectObject(m_hDC, hBitmap);
1417 }
1418
1419 int SelectRgn(HRGN hRgn) // special return for regions
1420 {
1421 ATLASSERT(m_hDC != NULL);
1422 ATLASSERT(hRgn == NULL || ::GetObjectType(hRgn) == OBJ_REGION);
1423 return PtrToInt(::SelectObject(m_hDC, hRgn));
1424 }
1425
1426 // Type-safe selection helpers for stock objects
1427 HPEN SelectStockPen(int nPen)
1428 {
1429 ATLASSERT(m_hDC != NULL);
1430 #if (_WIN32_WINNT >= 0x0500)
1431 ATLASSERT(nPen == WHITE_PEN || nPen == BLACK_PEN || nPen == NULL_PEN || nPen == DC_PEN);
1432 #else
1433 ATLASSERT(nPen == WHITE_PEN || nPen == BLACK_PEN || nPen == NULL_PEN);
1434 #endif // !(_WIN32_WINNT >= 0x0500)
1435 return SelectPen((HPEN)::GetStockObject(nPen));
1436 }
1437
1438 HBRUSH SelectStockBrush(int nBrush)
1439 {
1440 #if (_WIN32_WINNT >= 0x0500)
1441 ATLASSERT((nBrush >= WHITE_BRUSH && nBrush <= HOLLOW_BRUSH) || nBrush == DC_BRUSH);
1442 #else
1443 ATLASSERT(nBrush >= WHITE_BRUSH && nBrush <= HOLLOW_BRUSH);
1444 #endif // !(_WIN32_WINNT >= 0x0500)
1445 return SelectBrush((HBRUSH)::GetStockObject(nBrush));
1446 }
1447
1448 HFONT SelectStockFont(int nFont)
1449 {
1450 #ifndef _WIN32_WCE
1451 ATLASSERT((nFont >= OEM_FIXED_FONT && nFont <= SYSTEM_FIXED_FONT) || nFont == DEFAULT_GUI_FONT);
1452 #else // CE specific
1453 ATLASSERT(nFont == SYSTEM_FONT);
1454 #endif // _WIN32_WCE
1455 return SelectFont((HFONT)::GetStockObject(nFont));
1456 }
1457
1458 HPALETTE SelectStockPalette(int nPalette, BOOL bForceBackground)
1459 {
1460 ATLASSERT(nPalette == DEFAULT_PALETTE); // the only one supported
1461 return SelectPalette((HPALETTE)::GetStockObject(nPalette), bForceBackground);
1462 }
1463
1464 // Color and Color Palette Functions
1465 COLORREF GetNearestColor(COLORREF crColor) const
1466 {
1467 ATLASSERT(m_hDC != NULL);
1468 return ::GetNearestColor(m_hDC, crColor);
1469 }
1470
1471 HPALETTE SelectPalette(HPALETTE hPalette, BOOL bForceBackground)
1472 {
1473 ATLASSERT(m_hDC != NULL);
1474
1475 return ::SelectPalette(m_hDC, hPalette, bForceBackground);
1476 }
1477
1478 UINT RealizePalette()
1479 {
1480 ATLASSERT(m_hDC != NULL);
1481 return ::RealizePalette(m_hDC);
1482 }
1483
1484 #ifndef _WIN32_WCE
1485 void UpdateColors()
1486 {
1487 ATLASSERT(m_hDC != NULL);
1488 ::UpdateColors(m_hDC);
1489 }
1490 #endif // !_WIN32_WCE
1491
1492 // Drawing-Attribute Functions
1493 COLORREF GetBkColor() const
1494 {
1495 ATLASSERT(m_hDC != NULL);
1496 return ::GetBkColor(m_hDC);
1497 }
1498
1499 int GetBkMode() const
1500 {
1501 ATLASSERT(m_hDC != NULL);
1502 return ::GetBkMode(m_hDC);
1503 }
1504
1505 #ifndef _WIN32_WCE
1506 int GetPolyFillMode() const
1507 {
1508 ATLASSERT(m_hDC != NULL);
1509 return ::GetPolyFillMode(m_hDC);
1510 }
1511
1512 int GetROP2() const
1513 {
1514 ATLASSERT(m_hDC != NULL);
1515 return ::GetROP2(m_hDC);
1516 }
1517
1518 int GetStretchBltMode() const
1519 {
1520 ATLASSERT(m_hDC != NULL);
1521 return ::GetStretchBltMode(m_hDC);
1522 }
1523 #endif // !_WIN32_WCE
1524
1525 COLORREF GetTextColor() const
1526 {
1527 ATLASSERT(m_hDC != NULL);
1528 return ::GetTextColor(m_hDC);
1529 }
1530
1531 COLORREF SetBkColor(COLORREF crColor)
1532 {
1533 ATLASSERT(m_hDC != NULL);
1534 return ::SetBkColor(m_hDC, crColor);
1535 }
1536
1537 int SetBkMode(int nBkMode)
1538 {
1539 ATLASSERT(m_hDC != NULL);
1540 return ::SetBkMode(m_hDC, nBkMode);
1541 }
1542
1543 #ifndef _WIN32_WCE
1544 int SetPolyFillMode(int nPolyFillMode)
1545 {
1546 ATLASSERT(m_hDC != NULL);
1547 return ::SetPolyFillMode(m_hDC, nPolyFillMode);
1548 }
1549 #endif // !_WIN32_WCE
1550
1551 int SetROP2(int nDrawMode)
1552 {
1553 ATLASSERT(m_hDC != NULL);
1554 return ::SetROP2(m_hDC, nDrawMode);
1555 }
1556
1557 #ifndef _WIN32_WCE
1558 int SetStretchBltMode(int nStretchMode)
1559 {
1560 ATLASSERT(m_hDC != NULL);
1561 return ::SetStretchBltMode(m_hDC, nStretchMode);
1562 }
1563 #endif // !_WIN32_WCE
1564
1565 COLORREF SetTextColor(COLORREF crColor)
1566 {
1567 ATLASSERT(m_hDC != NULL);
1568 return ::SetTextColor(m_hDC, crColor);
1569 }
1570
1571 #ifndef _WIN32_WCE
1572 BOOL GetColorAdjustment(LPCOLORADJUSTMENT lpColorAdjust) const
1573 {
1574 ATLASSERT(m_hDC != NULL);
1575 return ::GetColorAdjustment(m_hDC, lpColorAdjust);
1576 }
1577
1578 BOOL SetColorAdjustment(const COLORADJUSTMENT* lpColorAdjust)
1579 {
1580 ATLASSERT(m_hDC != NULL);
1581 return ::SetColorAdjustment(m_hDC, lpColorAdjust);
1582 }
1583
1584 // Mapping Functions
1585 int GetMapMode() const
1586 {
1587 ATLASSERT(m_hDC != NULL);
1588 return ::GetMapMode(m_hDC);
1589 }
1590
1591 BOOL GetViewportOrg(LPPOINT lpPoint) const
1592 {
1593 ATLASSERT(m_hDC != NULL);
1594 return ::GetViewportOrgEx(m_hDC, lpPoint);
1595 }
1596
1597 int SetMapMode(int nMapMode)
1598 {
1599 ATLASSERT(m_hDC != NULL);
1600 return ::SetMapMode(m_hDC, nMapMode);
1601 }
1602 #endif // !_WIN32_WCE
1603
1604 // Viewport Origin
1605 BOOL SetViewportOrg(int x, int y, LPPOINT lpPoint = NULL)
1606 {
1607 ATLASSERT(m_hDC != NULL);
1608 return ::SetViewportOrgEx(m_hDC, x, y, lpPoint);
1609 }
1610
1611 BOOL SetViewportOrg(POINT point, LPPOINT lpPointRet = NULL)
1612 {
1613 ATLASSERT(m_hDC != NULL);
1614 return SetViewportOrg(point.x, point.y, lpPointRet);
1615 }
1616
1617 #ifndef _WIN32_WCE
1618 BOOL OffsetViewportOrg(int nWidth, int nHeight, LPPOINT lpPoint = NULL)
1619 {
1620 ATLASSERT(m_hDC != NULL);
1621 return ::OffsetViewportOrgEx(m_hDC, nWidth, nHeight, lpPoint);
1622 }
1623
1624 // Viewport Extent
1625 BOOL GetViewportExt(LPSIZE lpSize) const
1626 {
1627 ATLASSERT(m_hDC != NULL);
1628 return ::GetViewportExtEx(m_hDC, lpSize);
1629 }
1630
1631 BOOL SetViewportExt(int x, int y, LPSIZE lpSize = NULL)
1632 {
1633 ATLASSERT(m_hDC != NULL);
1634 return ::SetViewportExtEx(m_hDC, x, y, lpSize);
1635 }
1636
1637 BOOL SetViewportExt(SIZE size, LPSIZE lpSizeRet = NULL)
1638 {
1639 ATLASSERT(m_hDC != NULL);
1640 return SetViewportExt(size.cx, size.cy, lpSizeRet);
1641 }
1642
1643 BOOL ScaleViewportExt(int xNum, int xDenom, int yNum, int yDenom, LPSIZE lpSize = NULL)
1644 {
1645 ATLASSERT(m_hDC != NULL);
1646 return ::ScaleViewportExtEx(m_hDC, xNum, xDenom, yNum, yDenom, lpSize);
1647 }
1648 #endif // !_WIN32_WCE
1649
1650 // Window Origin
1651 #ifndef _WIN32_WCE
1652 BOOL GetWindowOrg(LPPOINT lpPoint) const
1653 {
1654 ATLASSERT(m_hDC != NULL);
1655 return ::GetWindowOrgEx(m_hDC, lpPoint);
1656 }
1657
1658 BOOL SetWindowOrg(int x, int y, LPPOINT lpPoint = NULL)
1659 {
1660 ATLASSERT(m_hDC != NULL);
1661 return ::SetWindowOrgEx(m_hDC, x, y, lpPoint);
1662 }
1663
1664 BOOL SetWindowOrg(POINT point, LPPOINT lpPointRet = NULL)
1665 {
1666 ATLASSERT(m_hDC != NULL);
1667 return SetWindowOrg(point.x, point.y, lpPointRet);
1668 }
1669
1670 BOOL OffsetWindowOrg(int nWidth, int nHeight, LPPOINT lpPoint = NULL)
1671 {
1672 ATLASSERT(m_hDC != NULL);
1673 return ::OffsetWindowOrgEx(m_hDC, nWidth, nHeight, lpPoint);
1674 }
1675
1676 // Window extent
1677 BOOL GetWindowExt(LPSIZE lpSize) const
1678 {
1679 ATLASSERT(m_hDC != NULL);
1680 return ::GetWindowExtEx(m_hDC, lpSize);
1681 }
1682
1683 BOOL SetWindowExt(int x, int y, LPSIZE lpSize = NULL)
1684 {
1685 ATLASSERT(m_hDC != NULL);
1686 return ::SetWindowExtEx(m_hDC, x, y, lpSize);
1687 }
1688
1689 BOOL SetWindowExt(SIZE size, LPSIZE lpSizeRet = NULL)
1690 {
1691 ATLASSERT(m_hDC != NULL);
1692 return SetWindowExt(size.cx, size.cy, lpSizeRet);
1693 }
1694
1695 BOOL ScaleWindowExt(int xNum, int xDenom, int yNum, int yDenom, LPSIZE lpSize = NULL)
1696 {
1697 ATLASSERT(m_hDC != NULL);
1698 return ::ScaleWindowExtEx(m_hDC, xNum, xDenom, yNum, yDenom, lpSize);
1699 }
1700
1701 // Coordinate Functions
1702 BOOL DPtoLP(LPPOINT lpPoints, int nCount = 1) const
1703 {
1704 ATLASSERT(m_hDC != NULL);
1705 return ::DPtoLP(m_hDC, lpPoints, nCount);
1706 }
1707
1708 BOOL DPtoLP(LPRECT lpRect) const
1709 {
1710 ATLASSERT(m_hDC != NULL);
1711 return ::DPtoLP(m_hDC, (LPPOINT)lpRect, 2);
1712 }
1713
1714 BOOL DPtoLP(LPSIZE lpSize) const
1715 {
1716 SIZE sizeWinExt = { 0, 0 };
1717 if(!GetWindowExt(&sizeWinExt))
1718 return FALSE;
1719 SIZE sizeVpExt = { 0, 0 };
1720 if(!GetViewportExt(&sizeVpExt))
1721 return FALSE;
1722 lpSize->cx = ::MulDiv(lpSize->cx, abs(sizeWinExt.cx), abs(sizeVpExt.cx));
1723 lpSize->cy = ::MulDiv(lpSize->cy, abs(sizeWinExt.cy), abs(sizeVpExt.cy));
1724 return TRUE;
1725 }
1726
1727 BOOL LPtoDP(LPPOINT lpPoints, int nCount = 1) const
1728 {
1729 ATLASSERT(m_hDC != NULL);
1730 return ::LPtoDP(m_hDC, lpPoints, nCount);
1731 }
1732
1733 BOOL LPtoDP(LPRECT lpRect) const
1734 {
1735 ATLASSERT(m_hDC != NULL);
1736 return ::LPtoDP(m_hDC, (LPPOINT)lpRect, 2);
1737 }
1738
1739 BOOL LPtoDP(LPSIZE lpSize) const
1740 {
1741 SIZE sizeWinExt = { 0, 0 };
1742 if(!GetWindowExt(&sizeWinExt))
1743 return FALSE;
1744 SIZE sizeVpExt = { 0, 0 };
1745 if(!GetViewportExt(&sizeVpExt))
1746 return FALSE;
1747 lpSize->cx = ::MulDiv(lpSize->cx, abs(sizeVpExt.cx), abs(sizeWinExt.cx));
1748 lpSize->cy = ::MulDiv(lpSize->cy, abs(sizeVpExt.cy), abs(sizeWinExt.cy));
1749 return TRUE;
1750 }
1751
1752 // Special Coordinate Functions (useful for dealing with metafiles and OLE)
1753 #define HIMETRIC_INCH 2540 // HIMETRIC units per inch
1754
1755 void DPtoHIMETRIC(LPSIZE lpSize) const
1756 {
1757 ATLASSERT(m_hDC != NULL);
1758 int nMapMode;
1759 if((nMapMode = GetMapMode()) < MM_ISOTROPIC && nMapMode != MM_TEXT)
1760 {
1761 // when using a constrained map mode, map against physical inch
1762 ((CDCHandle*)this)->SetMapMode(MM_HIMETRIC);
1763 DPtoLP(lpSize);
1764 ((CDCHandle*)this)->SetMapMode(nMapMode);
1765 }
1766 else
1767 {
1768 // map against logical inch for non-constrained mapping modes
1769 int cxPerInch = GetDeviceCaps(LOGPIXELSX);
1770 int cyPerInch = GetDeviceCaps(LOGPIXELSY);
1771 ATLASSERT(cxPerInch != 0 && cyPerInch != 0);
1772 lpSize->cx = ::MulDiv(lpSize->cx, HIMETRIC_INCH, cxPerInch);
1773 lpSize->cy = ::MulDiv(lpSize->cy, HIMETRIC_INCH, cyPerInch);
1774 }
1775 }
1776
1777 void HIMETRICtoDP(LPSIZE lpSize) const
1778 {
1779 ATLASSERT(m_hDC != NULL);
1780 int nMapMode;
1781 if((nMapMode = GetMapMode()) < MM_ISOTROPIC && nMapMode != MM_TEXT)
1782 {
1783 // when using a constrained map mode, map against physical inch
1784 ((CDCHandle*)this)->SetMapMode(MM_HIMETRIC);
1785 LPtoDP(lpSize);
1786 ((CDCHandle*)this)->SetMapMode(nMapMode);
1787 }
1788 else
1789 {
1790 // map against logical inch for non-constrained mapping modes
1791 int cxPerInch = GetDeviceCaps(LOGPIXELSX);
1792 int cyPerInch = GetDeviceCaps(LOGPIXELSY);
1793 ATLASSERT(cxPerInch != 0 && cyPerInch != 0);
1794 lpSize->cx = ::MulDiv(lpSize->cx, cxPerInch, HIMETRIC_INCH);
1795 lpSize->cy = ::MulDiv(lpSize->cy, cyPerInch, HIMETRIC_INCH);
1796 }
1797 }
1798
1799 void LPtoHIMETRIC(LPSIZE lpSize) const
1800 {
1801 LPtoDP(lpSize);
1802 DPtoHIMETRIC(lpSize);
1803 }
1804
1805 void HIMETRICtoLP(LPSIZE lpSize) const
1806 {
1807 HIMETRICtoDP(lpSize);
1808 DPtoLP(lpSize);
1809 }
1810 #endif // !_WIN32_WCE
1811
1812 // Region Functions
1813 BOOL FillRgn(HRGN hRgn, HBRUSH hBrush)
1814 {
1815 ATLASSERT(m_hDC != NULL);
1816 return ::FillRgn(m_hDC, hRgn, hBrush);
1817 }
1818
1819 #ifndef _WIN32_WCE
1820 BOOL FrameRgn(HRGN hRgn, HBRUSH hBrush, int nWidth, int nHeight)
1821 {
1822 ATLASSERT(m_hDC != NULL);
1823 return ::FrameRgn(m_hDC, hRgn, hBrush, nWidth, nHeight);
1824 }
1825
1826 BOOL InvertRgn(HRGN hRgn)
1827 {
1828 ATLASSERT(m_hDC != NULL);
1829 return ::InvertRgn(m_hDC, hRgn);
1830 }
1831
1832 BOOL PaintRgn(HRGN hRgn)
1833 {
1834 ATLASSERT(m_hDC != NULL);
1835 return ::PaintRgn(m_hDC, hRgn);
1836 }
1837 #endif // !_WIN32_WCE
1838
1839 // Clipping Functions
1840 int GetClipBox(LPRECT lpRect) const
1841 {
1842 ATLASSERT(m_hDC != NULL);
1843 return ::GetClipBox(m_hDC, lpRect);
1844 }
1845
1846 int GetClipRgn(CRgn& region) const
1847 {
1848 ATLASSERT(m_hDC != NULL);
1849 if(region.IsNull())
1850 region.CreateRectRgn(0, 0, 0, 0);
1851
1852 int nRet = ::GetClipRgn(m_hDC, region);
1853 if(nRet != 1)
1854 region.DeleteObject();
1855
1856 return nRet;
1857 }
1858
1859 #ifndef _WIN32_WCE
1860 BOOL PtVisible(int x, int y) const
1861 {
1862 ATLASSERT(m_hDC != NULL);
1863 return ::PtVisible(m_hDC, x, y);
1864 }
1865
1866 BOOL PtVisible(POINT point) const
1867 {
1868 ATLASSERT(m_hDC != NULL);
1869 return ::PtVisible(m_hDC, point.x, point.y);
1870 }
1871 #endif // !_WIN32_WCE
1872
1873 BOOL RectVisible(LPCRECT lpRect) const
1874 {
1875 ATLASSERT(m_hDC != NULL);
1876 return ::RectVisible(m_hDC, lpRect);
1877 }
1878
1879 int SelectClipRgn(HRGN hRgn)
1880 {
1881 ATLASSERT(m_hDC != NULL);
1882 return ::SelectClipRgn(m_hDC, (HRGN)hRgn);
1883 }
1884
1885 int ExcludeClipRect(int x1, int y1, int x2, int y2)
1886 {
1887 ATLASSERT(m_hDC != NULL);
1888 return ::ExcludeClipRect(m_hDC, x1, y1, x2, y2);
1889 }
1890
1891 int ExcludeClipRect(LPCRECT lpRect)
1892 {
1893 ATLASSERT(m_hDC != NULL);
1894 return ::ExcludeClipRect(m_hDC, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
1895 }
1896
1897 #ifndef _WIN32_WCE
1898 int ExcludeUpdateRgn(HWND hWnd)
1899 {
1900 ATLASSERT(m_hDC != NULL);
1901 return ::ExcludeUpdateRgn(m_hDC, hWnd);
1902 }
1903 #endif // !_WIN32_WCE
1904
1905 int IntersectClipRect(int x1, int y1, int x2, int y2)
1906 {
1907 ATLASSERT(m_hDC != NULL);
1908 return ::IntersectClipRect(m_hDC, x1, y1, x2, y2);
1909 }
1910
1911 int IntersectClipRect(LPCRECT lpRect)
1912 {
1913 ATLASSERT(m_hDC != NULL);
1914 return ::IntersectClipRect(m_hDC, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
1915 }
1916
1917 #ifndef _WIN32_WCE
1918 int OffsetClipRgn(int x, int y)
1919 {
1920 ATLASSERT(m_hDC != NULL);
1921 return ::OffsetClipRgn(m_hDC, x, y);
1922 }
1923
1924 int OffsetClipRgn(SIZE size)
1925 {
1926 ATLASSERT(m_hDC != NULL);
1927 return ::OffsetClipRgn(m_hDC, size.cx, size.cy);
1928 }
1929
1930 int SelectClipRgn(HRGN hRgn, int nMode)
1931 {
1932 ATLASSERT(m_hDC != NULL);
1933 return ::ExtSelectClipRgn(m_hDC, hRgn, nMode);
1934 }
1935 #endif // !_WIN32_WCE
1936
1937 // Line-Output Functions
1938 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
1939 BOOL GetCurrentPosition(LPPOINT lpPoint) const
1940 {
1941 ATLASSERT(m_hDC != NULL);
1942 return ::GetCurrentPositionEx(m_hDC, lpPoint);
1943 }
1944
1945 BOOL MoveTo(int x, int y, LPPOINT lpPoint = NULL)
1946 {
1947 ATLASSERT(m_hDC != NULL);
1948 return ::MoveToEx(m_hDC, x, y, lpPoint);
1949 }
1950
1951 BOOL MoveTo(POINT point, LPPOINT lpPointRet = NULL)
1952 {
1953 ATLASSERT(m_hDC != NULL);
1954 return MoveTo(point.x, point.y, lpPointRet);
1955 }
1956
1957 BOOL LineTo(int x, int y)
1958 {
1959 ATLASSERT(m_hDC != NULL);
1960 return ::LineTo(m_hDC, x, y);
1961 }
1962
1963 BOOL LineTo(POINT point)
1964 {
1965 ATLASSERT(m_hDC != NULL);
1966 return LineTo(point.x, point.y);
1967 }
1968 #endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
1969
1970 #ifndef _WIN32_WCE
1971 BOOL Arc(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
1972 {
1973 ATLASSERT(m_hDC != NULL);
1974 return ::Arc(m_hDC, x1, y1, x2, y2, x3, y3, x4, y4);
1975 }
1976
1977 BOOL Arc(LPCRECT lpRect, POINT ptStart, POINT ptEnd)
1978 {
1979 ATLASSERT(m_hDC != NULL);
1980 return ::Arc(m_hDC, lpRect->left, lpRect->top,
1981 lpRect->right, lpRect->bottom, ptStart.x, ptStart.y,
1982 ptEnd.x, ptEnd.y);
1983 }
1984 #endif // !_WIN32_WCE
1985
1986 BOOL Polyline(const POINT* lpPoints, int nCount)
1987 {
1988 ATLASSERT(m_hDC != NULL);
1989 return ::Polyline(m_hDC, lpPoints, nCount);
1990 }
1991
1992 #ifndef _WIN32_WCE
1993 BOOL AngleArc(int x, int y, int nRadius, float fStartAngle, float fSweepAngle)
1994 {
1995 ATLASSERT(m_hDC != NULL);
1996 return ::AngleArc(m_hDC, x, y, nRadius, fStartAngle, fSweepAngle);
1997 }
1998
1999 BOOL ArcTo(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
2000 {
2001 ATLASSERT(m_hDC != NULL);
2002 return ::ArcTo(m_hDC, x1, y1, x2, y2, x3, y3, x4, y4);
2003 }
2004
2005 BOOL ArcTo(LPCRECT lpRect, POINT ptStart, POINT ptEnd)
2006 {
2007 ATLASSERT(m_hDC != NULL);
2008 return ArcTo(lpRect->left, lpRect->top, lpRect->right,
2009 lpRect->bottom, ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
2010 }
2011
2012 int GetArcDirection() const
2013 {
2014 ATLASSERT(m_hDC != NULL);
2015 return ::GetArcDirection(m_hDC);
2016 }
2017
2018 int SetArcDirection(int nArcDirection)
2019 {
2020 ATLASSERT(m_hDC != NULL);
2021 return ::SetArcDirection(m_hDC, nArcDirection);
2022 }
2023
2024 BOOL PolyDraw(const POINT* lpPoints, const BYTE* lpTypes, int nCount)
2025 {
2026 ATLASSERT(m_hDC != NULL);
2027 return ::PolyDraw(m_hDC, lpPoints, lpTypes, nCount);
2028 }
2029
2030 BOOL PolylineTo(const POINT* lpPoints, int nCount)
2031 {
2032 ATLASSERT(m_hDC != NULL);
2033 return ::PolylineTo(m_hDC, lpPoints, nCount);
2034 }
2035
2036 BOOL PolyPolyline(const POINT* lpPoints,
2037 const DWORD* lpPolyPoints, int nCount)
2038 {
2039 ATLASSERT(m_hDC != NULL);
2040 return ::PolyPolyline(m_hDC, lpPoints, lpPolyPoints, nCount);
2041 }
2042
2043 BOOL PolyBezier(const POINT* lpPoints, int nCount)
2044 {
2045 ATLASSERT(m_hDC != NULL);
2046 return ::PolyBezier(m_hDC, lpPoints, nCount);
2047 }
2048
2049 BOOL PolyBezierTo(const POINT* lpPoints, int nCount)
2050 {
2051 ATLASSERT(m_hDC != NULL);
2052 return ::PolyBezierTo(m_hDC, lpPoints, nCount);
2053 }
2054 #endif // !_WIN32_WCE
2055
2056 // Simple Drawing Functions
2057 BOOL FillRect(LPCRECT lpRect, HBRUSH hBrush)
2058 {
2059 ATLASSERT(m_hDC != NULL);
2060 return ::FillRect(m_hDC, lpRect, hBrush);
2061 }
2062
2063 BOOL FillRect(LPCRECT lpRect, int nColorIndex)
2064 {
2065 ATLASSERT(m_hDC != NULL);
2066 #ifndef _WIN32_WCE
2067 return ::FillRect(m_hDC, lpRect, (HBRUSH)LongToPtr(nColorIndex + 1));
2068 #else // CE specific
2069 return ::FillRect(m_hDC, lpRect, ::GetSysColorBrush(nColorIndex));
2070 #endif // _WIN32_WCE
2071 }
2072
2073 #ifndef _WIN32_WCE
2074 BOOL FrameRect(LPCRECT lpRect, HBRUSH hBrush)
2075 {
2076 ATLASSERT(m_hDC != NULL);
2077 return ::FrameRect(m_hDC, lpRect, hBrush);
2078 }
2079 #endif // !_WIN32_WCE
2080
2081 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 420)
2082 BOOL InvertRect(LPCRECT lpRect)
2083 {
2084 ATLASSERT(m_hDC != NULL);
2085 return ::InvertRect(m_hDC, lpRect);
2086 }
2087 #endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 420)
2088
2089 BOOL DrawIcon(int x, int y, HICON hIcon)
2090 {
2091 ATLASSERT(m_hDC != NULL);
2092 #ifndef _WIN32_WCE
2093 return ::DrawIcon(m_hDC, x, y, hIcon);
2094 #else // CE specific
2095 return ::DrawIconEx(m_hDC, x, y, hIcon, 0, 0, 0, NULL, DI_NORMAL);
2096 #endif // _WIN32_WCE
2097 }
2098
2099 BOOL DrawIcon(POINT point, HICON hIcon)
2100 {
2101 ATLASSERT(m_hDC != NULL);
2102 #ifndef _WIN32_WCE
2103 return ::DrawIcon(m_hDC, point.x, point.y, hIcon);
2104 #else // CE specific
2105 return ::DrawIconEx(m_hDC, point.x, point.y, hIcon, 0, 0, 0, NULL, DI_NORMAL);
2106 #endif // _WIN32_WCE
2107 }
2108
2109 BOOL DrawIconEx(int x, int y, HICON hIcon, int cxWidth, int cyWidth, UINT uStepIfAniCur = 0, HBRUSH hbrFlickerFreeDraw = NULL, UINT uFlags = DI_NORMAL)
2110 {
2111 ATLASSERT(m_hDC != NULL);
2112 return ::DrawIconEx(m_hDC, x, y, hIcon, cxWidth, cyWidth, uStepIfAniCur, hbrFlickerFreeDraw, uFlags);
2113 }
2114
2115 BOOL DrawIconEx(POINT point, HICON hIcon, SIZE size, UINT uStepIfAniCur = 0, HBRUSH hbrFlickerFreeDraw = NULL, UINT uFlags = DI_NORMAL)
2116 {
2117 ATLASSERT(m_hDC != NULL);
2118 return ::DrawIconEx(m_hDC, point.x, point.y, hIcon, size.cx, size.cy, uStepIfAniCur, hbrFlickerFreeDraw, uFlags);
2119 }
2120
2121 #ifndef _WIN32_WCE
2122 BOOL DrawState(POINT pt, SIZE size, HBITMAP hBitmap, UINT nFlags, HBRUSH hBrush = NULL)
2123 {
2124 ATLASSERT(m_hDC != NULL);
2125 return ::DrawState(m_hDC, hBrush, NULL, (LPARAM)hBitmap, 0, pt.x, pt.y, size.cx, size.cy, nFlags | DST_BITMAP);
2126 }
2127
2128 BOOL DrawState(POINT pt, SIZE size, HICON hIcon, UINT nFlags, HBRUSH hBrush = NULL)
2129 {
2130 ATLASSERT(m_hDC != NULL);
2131 return ::DrawState(m_hDC, hBrush, NULL, (LPARAM)hIcon, 0, pt.x, pt.y, size.cx, size.cy, nFlags | DST_ICON);
2132 }
2133
2134 BOOL DrawState(POINT pt, SIZE size, LPCTSTR lpszText, UINT nFlags, BOOL bPrefixText = TRUE, int nTextLen = 0, HBRUSH hBrush = NULL)
2135 {
2136 ATLASSERT(m_hDC != NULL);
2137 return ::DrawState(m_hDC, hBrush, NULL, (LPARAM)lpszText, (WPARAM)nTextLen, pt.x, pt.y, size.cx, size.cy, nFlags | (bPrefixText ? DST_PREFIXTEXT : DST_TEXT));
2138 }
2139
2140 BOOL DrawState(POINT pt, SIZE size, DRAWSTATEPROC lpDrawProc, LPARAM lData, UINT nFlags, HBRUSH hBrush = NULL)
2141 {
2142 ATLASSERT(m_hDC != NULL);
2143 return ::DrawState(m_hDC, hBrush, lpDrawProc, lData, 0, pt.x, pt.y, size.cx, size.cy, nFlags | DST_COMPLEX);
2144 }
2145 #endif // !_WIN32_WCE
2146
2147 // Ellipse and Polygon Functions
2148 #ifndef _WIN32_WCE
2149 BOOL Chord(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
2150 {
2151 ATLASSERT(m_hDC != NULL);
2152 return ::Chord(m_hDC, x1, y1, x2, y2, x3, y3, x4, y4);
2153 }
2154
2155 BOOL Chord(LPCRECT lpRect, POINT ptStart, POINT ptEnd)
2156 {
2157 ATLASSERT(m_hDC != NULL);
2158 return ::Chord(m_hDC, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom, ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
2159 }
2160 #endif // !_WIN32_WCE
2161
2162 void DrawFocusRect(LPCRECT lpRect)
2163 {
2164 ATLASSERT(m_hDC != NULL);
2165 ::DrawFocusRect(m_hDC, lpRect);
2166 }
2167
2168 BOOL Ellipse(int x1, int y1, int x2, int y2)
2169 {
2170 ATLASSERT(m_hDC != NULL);
2171 return ::Ellipse(m_hDC, x1, y1, x2, y2);
2172 }
2173
2174 BOOL Ellipse(LPCRECT lpRect)
2175 {
2176 ATLASSERT(m_hDC != NULL);
2177 return ::Ellipse(m_hDC, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
2178 }
2179
2180 #ifndef _WIN32_WCE
2181 BOOL Pie(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
2182 {
2183 ATLASSERT(m_hDC != NULL);
2184 return ::Pie(m_hDC, x1, y1, x2, y2, x3, y3, x4, y4);
2185 }
2186
2187 BOOL Pie(LPCRECT lpRect, POINT ptStart, POINT ptEnd)
2188 {
2189 ATLASSERT(m_hDC != NULL);
2190 return ::Pie(m_hDC, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom, ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
2191 }
2192 #endif // !_WIN32_WCE
2193
2194 BOOL Polygon(const POINT* lpPoints, int nCount)
2195 {
2196 ATLASSERT(m_hDC != NULL);
2197 return ::Polygon(m_hDC, lpPoints, nCount);
2198 }
2199
2200 #ifndef _WIN32_WCE
2201 BOOL PolyPolygon(const POINT* lpPoints, const INT* lpPolyCounts, int nCount)
2202 {
2203 ATLASSERT(m_hDC != NULL);
2204 return ::PolyPolygon(m_hDC, lpPoints, lpPolyCounts, nCount);
2205 }
2206 #endif // !_WIN32_WCE
2207
2208 BOOL Rectangle(int x1, int y1, int x2, int y2)
2209 {
2210 ATLASSERT(m_hDC != NULL);
2211 return ::Rectangle(m_hDC, x1, y1, x2, y2);
2212 }
2213
2214 BOOL Rectangle(LPCRECT lpRect)
2215 {
2216 ATLASSERT(m_hDC != NULL);
2217 return ::Rectangle(m_hDC, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
2218 }
2219
2220 BOOL RoundRect(int x1, int y1, int x2, int y2, int x3, int y3)
2221 {
2222 ATLASSERT(m_hDC != NULL);
2223 return ::RoundRect(m_hDC, x1, y1, x2, y2, x3, y3);
2224 }
2225
2226 BOOL RoundRect(LPCRECT lpRect, POINT point)
2227 {
2228 ATLASSERT(m_hDC != NULL);
2229 return ::RoundRect(m_hDC, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom, point.x, point.y);
2230 }
2231
2232 // Bitmap Functions
2233 BOOL PatBlt(int x, int y, int nWidth, int nHeight, DWORD dwRop)
2234 {
2235 ATLASSERT(m_hDC != NULL);
2236 return ::PatBlt(m_hDC, x, y, nWidth, nHeight, dwRop);
2237 }
2238
2239 BOOL BitBlt(int x, int y, int nWidth, int nHeight, HDC hSrcDC,
2240 int xSrc, int ySrc, DWORD dwRop)
2241 {
2242 ATLASSERT(m_hDC != NULL);
2243 return ::BitBlt(m_hDC, x, y, nWidth, nHeight, hSrcDC, xSrc, ySrc, dwRop);
2244 }
2245
2246 BOOL StretchBlt(int x, int y, int nWidth, int nHeight, HDC hSrcDC, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, DWORD dwRop)
2247 {
2248 ATLASSERT(m_hDC != NULL);
2249 return ::StretchBlt(m_hDC, x, y, nWidth, nHeight, hSrcDC, xSrc, ySrc, nSrcWidth, nSrcHeight, dwRop);
2250 }
2251
2252 COLORREF GetPixel(int x, int y) const
2253 {
2254 ATLASSERT(m_hDC != NULL);
2255 return ::GetPixel(m_hDC, x, y);
2256 }
2257
2258 COLORREF GetPixel(POINT point) const
2259 {
2260 ATLASSERT(m_hDC != NULL);
2261 return ::GetPixel(m_hDC, point.x, point.y);
2262 }
2263
2264 COLORREF SetPixel(int x, int y, COLORREF crColor)
2265 {
2266 ATLASSERT(m_hDC != NULL);
2267 return ::SetPixel(m_hDC, x, y, crColor);
2268 }
2269
2270 COLORREF SetPixel(POINT point, COLORREF crColor)
2271 {
2272 ATLASSERT(m_hDC != NULL);
2273 return ::SetPixel(m_hDC, point.x, point.y, crColor);
2274 }
2275
2276 #ifndef _WIN32_WCE
2277 BOOL FloodFill(int x, int y, COLORREF crColor)
2278 {
2279 ATLASSERT(m_hDC != NULL);
2280 return ::FloodFill(m_hDC, x, y, crColor);
2281 }
2282
2283 BOOL ExtFloodFill(int x, int y, COLORREF crColor, UINT nFillType)
2284 {
2285 ATLASSERT(m_hDC != NULL);
2286 return ::ExtFloodFill(m_hDC, x, y, crColor, nFillType);
2287 }
2288 #endif // !_WIN32_WCE
2289
2290 BOOL MaskBlt(int x, int y, int nWidth, int nHeight, HDC hSrcDC, int xSrc, int ySrc, HBITMAP hMaskBitmap, int xMask, int yMask, DWORD dwRop)
2291 {
2292 ATLASSERT(m_hDC != NULL);
2293 return ::MaskBlt(m_hDC, x, y, nWidth, nHeight, hSrcDC, xSrc, ySrc, hMaskBitmap, xMask, yMask, dwRop);
2294 }
2295
2296 #ifndef _WIN32_WCE
2297 BOOL PlgBlt(LPPOINT lpPoint, HDC hSrcDC, int xSrc, int ySrc, int nWidth, int nHeight, HBITMAP hMaskBitmap, int xMask, int yMask)
2298 {
2299 ATLASSERT(m_hDC != NULL);
2300 return ::PlgBlt(m_hDC, lpPoint, hSrcDC, xSrc, ySrc, nWidth, nHeight, hMaskBitmap, xMask, yMask);
2301 }
2302
2303 BOOL SetPixelV(int x, int y, COLORREF crColor)
2304 {
2305 ATLASSERT(m_hDC != NULL);
2306 return ::SetPixelV(m_hDC, x, y, crColor);
2307 }
2308
2309 BOOL SetPixelV(POINT point, COLORREF crColor)
2310 {
2311 ATLASSERT(m_hDC != NULL);
2312 return ::SetPixelV(m_hDC, point.x, point.y, crColor);
2313 }
2314 #endif // !_WIN32_WCE
2315
2316 #if !defined(_ATL_NO_MSIMG) || defined(_WIN32_WCE)
2317 #ifndef _WIN32_WCE
2318 BOOL TransparentBlt(int x, int y, int nWidth, int nHeight, HDC hSrcDC, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, UINT crTransparent)
2319 {
2320 ATLASSERT(m_hDC != NULL);
2321 return ::TransparentBlt(m_hDC, x, y, nWidth, nHeight, hSrcDC, xSrc, ySrc, nSrcWidth, nSrcHeight, crTransparent);
2322 }
2323 #else // CE specific
2324 BOOL TransparentImage(int x, int y, int nWidth, int nHeight, HDC hSrcDC, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, UINT crTransparent)
2325 {
2326 ATLASSERT(m_hDC != NULL);
2327 return ::TransparentImage(m_hDC, x, y, nWidth, nHeight, hSrcDC, xSrc, ySrc, nSrcWidth, nSrcHeight, crTransparent);
2328 }
2329 #endif // _WIN32_WCE
2330
2331 #if (!defined(_WIN32_WCE) || (_WIN32_WCE >= 420))
2332 BOOL GradientFill(const PTRIVERTEX pVertices, DWORD nVertices, void* pMeshElements, DWORD nMeshElements, DWORD dwMode)
2333 {
2334 ATLASSERT(m_hDC != NULL);
2335 return ::GradientFill(m_hDC, pVertices, nVertices, pMeshElements, nMeshElements, dwMode);
2336 }
2337
2338 BOOL GradientFillRect(RECT& rect, COLORREF clr1, COLORREF clr2, bool bHorizontal)
2339 {
2340 ATLASSERT(m_hDC != NULL);
2341
2342 TRIVERTEX arrTvx[2] = { { 0 }, { 0 } };
2343
2344 arrTvx[0].x = rect.left;
2345 arrTvx[0].y = rect.top;
2346 arrTvx[0].Red = MAKEWORD(0, GetRValue(clr1));
2347 arrTvx[0].Green = MAKEWORD(0, GetGValue(clr1));
2348 arrTvx[0].Blue = MAKEWORD(0, GetBValue(clr1));
2349 arrTvx[0].Alpha = 0;
2350
2351 arrTvx[1].x = rect.right;
2352 arrTvx[1].y = rect.bottom;
2353 arrTvx[1].Red = MAKEWORD(0, GetRValue(clr2));
2354 arrTvx[1].Green = MAKEWORD(0, GetGValue(clr2));
2355 arrTvx[1].Blue = MAKEWORD(0, GetBValue(clr2));
2356 arrTvx[1].Alpha = 0;
2357
2358 GRADIENT_RECT gr = { 0, 1 };
2359
2360 return ::GradientFill(m_hDC, arrTvx, 2, &gr, 1, bHorizontal ? GRADIENT_FILL_RECT_H : GRADIENT_FILL_RECT_V);
2361 }
2362 #endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 420)
2363
2364 #if !defined(_WIN32_WCE) || (_WIN32_WCE > 0x500)
2365 BOOL AlphaBlend(int x, int y, int nWidth, int nHeight, HDC hSrcDC, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, BLENDFUNCTION bf)
2366 {
2367 ATLASSERT(m_hDC != NULL);
2368 return ::AlphaBlend(m_hDC, x, y, nWidth, nHeight, hSrcDC, xSrc, ySrc, nSrcWidth, nSrcHeight, bf);
2369 }
2370 #endif // !defined(_WIN32_WCE) || (_WIN32_WCE > 0x500)
2371 #endif // !defined(_ATL_NO_MSIMG) || defined(_WIN32_WCE)
2372
2373 // Extra bitmap functions
2374 // Helper function for painting a disabled toolbar or menu bitmap
2375 // This function can take either an HBITMAP (for SS) or a DC with
2376 // the bitmap already painted (for cmdbar)
2377 BOOL DitherBlt(int x, int y, int nWidth, int nHeight, HDC hSrcDC, HBITMAP hBitmap, int xSrc, int ySrc,
2378 HBRUSH hBrushBackground = ::GetSysColorBrush(COLOR_3DFACE),
2379 HBRUSH hBrush3DEffect = ::GetSysColorBrush(COLOR_3DHILIGHT),
2380 HBRUSH hBrushDisabledImage = ::GetSysColorBrush(COLOR_3DSHADOW))
2381 {
2382 ATLASSERT(m_hDC != NULL || hBitmap != NULL);
2383 ATLASSERT(nWidth > 0 && nHeight > 0);
2384
2385 // Create a generic DC for all BitBlts
2386 CDCHandle dc = (hSrcDC != NULL) ? hSrcDC : ::CreateCompatibleDC(m_hDC);
2387 ATLASSERT(dc.m_hDC != NULL);
2388 if(dc.m_hDC == NULL)
2389 return FALSE;
2390
2391 // Create a DC for the monochrome DIB section
2392 CDC dcBW = ::CreateCompatibleDC(m_hDC);
2393 ATLASSERT(dcBW.m_hDC != NULL);
2394 if(dcBW.m_hDC == NULL)
2395 {
2396 if(hSrcDC == NULL)
2397 dc.DeleteDC();
2398 return FALSE;
2399 }
2400
2401 // Create the monochrome DIB section with a black and white palette
2402 struct RGBBWBITMAPINFO
2403 {
2404 BITMAPINFOHEADER bmiHeader;
2405 RGBQUAD bmiColors[2];
2406 };
2407
2408 RGBBWBITMAPINFO rgbBWBitmapInfo =
2409 {
2410 { sizeof(BITMAPINFOHEADER), nWidth, nHeight, 1, 1, BI_RGB, 0, 0, 0, 0, 0 },
2411 { { 0x00, 0x00, 0x00, 0x00 }, { 0xFF, 0xFF, 0xFF, 0x00 } }
2412 };
2413
2414 VOID* pbitsBW;
2415 CBitmap bmpBW = ::CreateDIBSection(dcBW, (LPBITMAPINFO)&rgbBWBitmapInfo, DIB_RGB_COLORS, &pbitsBW, NULL, 0);
2416 ATLASSERT(bmpBW.m_hBitmap != NULL);
2417 if(bmpBW.m_hBitmap == NULL)
2418 {
2419 if(hSrcDC == NULL)
2420 dc.DeleteDC();
2421 return FALSE;
2422 }
2423
2424 // Attach the monochrome DIB section and the bitmap to the DCs
2425 HBITMAP hbmOldBW = dcBW.SelectBitmap(bmpBW);
2426 HBITMAP hbmOldDC = NULL;
2427 if(hBitmap != NULL)
2428 hbmOldDC = dc.SelectBitmap(hBitmap);
2429
2430 // Block: Dark gray removal: we want (128, 128, 128) pixels to become black and not white
2431 {
2432 CDC dcTemp1 = ::CreateCompatibleDC(m_hDC);
2433 CDC dcTemp2 = ::CreateCompatibleDC(m_hDC);
2434 CBitmap bmpTemp1;
2435 bmpTemp1.CreateCompatibleBitmap(dc, nWidth, nHeight);
2436 CBitmap bmpTemp2;
2437 bmpTemp2.CreateBitmap(nWidth, nHeight, 1, 1, NULL);
2438 HBITMAP hOldBmp1 = dcTemp1.SelectBitmap(bmpTemp1);
2439 HBITMAP hOldBmp2 = dcTemp2.SelectBitmap(bmpTemp2);
2440 // Let's copy our image, it will be altered
2441 dcTemp1.BitBlt(0, 0, nWidth, nHeight, dc, xSrc, ySrc, SRCCOPY);
2442
2443 // All dark gray pixels will become white, the others black
2444 dcTemp1.SetBkColor(RGB(128, 128, 128));
2445 dcTemp2.BitBlt(0, 0, nWidth, nHeight, dcTemp1, 0, 0, SRCCOPY);
2446 // Do an XOR to set to black these white pixels
2447 dcTemp1.BitBlt(0, 0, nWidth, nHeight, dcTemp2, 0, 0, SRCINVERT);
2448
2449 // BitBlt the bitmap into the monochrome DIB section
2450 // The DIB section will do a true monochrome conversion
2451 // The magenta background being closer to white will become white
2452 dcBW.BitBlt(0, 0, nWidth, nHeight, dcTemp1, 0, 0, SRCCOPY);
2453
2454 // Cleanup
2455 dcTemp1.SelectBitmap(hOldBmp1);
2456 dcTemp2.SelectBitmap(hOldBmp2);
2457 }
2458
2459 // Paint the destination rectangle using hBrushBackground
2460 if(hBrushBackground != NULL)
2461 {
2462 RECT rc = { x, y, x + nWidth, y + nHeight };
2463 FillRect(&rc, hBrushBackground);
2464 }
2465
2466 // BitBlt the black bits in the monochrome bitmap into hBrush3DEffect color in the destination DC
2467 // The magic ROP comes from the Charles Petzold's book
2468 HBRUSH hOldBrush = SelectBrush(hBrush3DEffect);
2469 BitBlt(x + 1, y + 1, nWidth, nHeight, dcBW, 0, 0, 0xB8074A);
2470
2471 // BitBlt the black bits in the monochrome bitmap into hBrushDisabledImage color in the destination DC
2472 SelectBrush(hBrushDisabledImage);
2473 BitBlt(x, y, nWidth, nHeight, dcBW, 0, 0, 0xB8074A);
2474
2475 SelectBrush(hOldBrush);
2476 dcBW.SelectBitmap(hbmOldBW);
2477 dc.SelectBitmap(hbmOldDC);
2478
2479 if(hSrcDC == NULL)
2480 dc.DeleteDC();
2481
2482 return TRUE;
2483 }
2484
2485 // Text Functions
2486 #ifndef _WIN32_WCE
2487 BOOL TextOut(int x, int y, LPCTSTR lpszString, int nCount = -1)
2488 {
2489 ATLASSERT(m_hDC != NULL);
2490 if(nCount == -1)
2491 nCount = lstrlen(lpszString);
2492 return ::TextOut(m_hDC, x, y, lpszString, nCount);
2493 }
2494 #endif // !_WIN32_WCE
2495
2496 BOOL ExtTextOut(int x, int y, UINT nOptions, LPCRECT lpRect, LPCTSTR lpszString, UINT nCount = -1, LPINT lpDxWidths = NULL)
2497 {
2498 ATLASSERT(m_hDC != NULL);
2499 if(nCount == -1)
2500 nCount = lstrlen(lpszString);
2501 return ::ExtTextOut(m_hDC, x, y, nOptions, lpRect, lpszString, nCount, lpDxWidths);
2502 }
2503
2504 #ifndef _WIN32_WCE
2505 SIZE TabbedTextOut(int x, int y, LPCTSTR lpszString, int nCount = -1, int nTabPositions = 0, LPINT lpnTabStopPositions = NULL, int nTabOrigin = 0)
2506 {
2507 ATLASSERT(m_hDC != NULL);
2508 if(nCount == -1)
2509 nCount = lstrlen(lpszString);
2510 LONG lRes = ::TabbedTextOut(m_hDC, x, y, lpszString, nCount, nTabPositions, lpnTabStopPositions, nTabOrigin);
2511 SIZE size = { GET_X_LPARAM(lRes), GET_Y_LPARAM(lRes) };
2512 return size;
2513 }
2514 #endif // !_WIN32_WCE
2515
2516 int DrawText(LPCTSTR lpstrText, int cchText, LPRECT lpRect, UINT uFormat)
2517 {
2518 ATLASSERT(m_hDC != NULL);
2519 #ifndef _WIN32_WCE
2520 ATLASSERT((uFormat & DT_MODIFYSTRING) == 0);
2521 #endif // !_WIN32_WCE
2522 return ::DrawText(m_hDC, lpstrText, cchText, lpRect, uFormat);
2523 }
2524
2525 int DrawText(LPTSTR lpstrText, int cchText, LPRECT lpRect, UINT uFormat)
2526 {
2527 ATLASSERT(m_hDC != NULL);
2528 return ::DrawText(m_hDC, lpstrText, cchText, lpRect, uFormat);
2529 }
2530
2531 #ifndef _WIN32_WCE
2532 int DrawTextEx(LPTSTR lpstrText, int cchText, LPRECT lpRect, UINT uFormat, LPDRAWTEXTPARAMS lpDTParams = NULL)
2533 {
2534 ATLASSERT(m_hDC != NULL);
2535 return ::DrawTextEx(m_hDC, lpstrText, cchText, lpRect, uFormat, lpDTParams);
2536 }
2537 #endif // !_WIN32_WCE
2538
2539 #if (_WIN32_WINNT >= 0x0501)
2540 int DrawShadowText(LPCWSTR lpstrText, int cchText, LPRECT lpRect, DWORD dwFlags, COLORREF clrText, COLORREF clrShadow, int xOffset, int yOffset)
2541 {
2542 ATLASSERT(m_hDC != NULL);
2543 // This function is present only if comctl32.dll version 6 is loaded;
2544 // we use LoadLibrary/GetProcAddress to allow apps compiled with
2545 // _WIN32_WINNT >= 0x0501 to run on older Windows/CommCtrl
2546 int nRet = 0;
2547 HMODULE hCommCtrlDLL = ::LoadLibrary(_T("comctl32.dll"));
2548 ATLASSERT(hCommCtrlDLL != NULL);
2549 if(hCommCtrlDLL != NULL)
2550 {
2551 typedef int (WINAPI *PFN_DrawShadowText)(HDC hDC, LPCWSTR lpstrText, UINT cchText, LPRECT lpRect, DWORD dwFlags, COLORREF clrText, COLORREF clrShadow, int xOffset, int yOffset);
2552 PFN_DrawShadowText pfnDrawShadowText = (PFN_DrawShadowText)::GetProcAddress(hCommCtrlDLL, "DrawShadowText");
2553 ATLASSERT(pfnDrawShadowText != NULL); // this function requires CommCtrl6
2554 if(pfnDrawShadowText != NULL)
2555 nRet = pfnDrawShadowText(m_hDC, lpstrText, cchText, lpRect, dwFlags, clrText, clrShadow, xOffset, yOffset);
2556 ::FreeLibrary(hCommCtrlDLL);
2557 }
2558 return nRet;
2559 }
2560 #endif // (_WIN32_WINNT >= 0x0501)
2561
2562 BOOL GetTextExtent(LPCTSTR lpszString, int nCount, LPSIZE lpSize) const
2563 {
2564 ATLASSERT(m_hDC != NULL);
2565 if(nCount == -1)
2566 nCount = lstrlen(lpszString);
2567 return ::GetTextExtentPoint32(m_hDC, lpszString, nCount, lpSize);
2568 }
2569
2570 BOOL GetTextExtentExPoint(LPCTSTR lpszString, int cchString, LPSIZE lpSize, int nMaxExtent, LPINT lpnFit = NULL, LPINT alpDx = NULL)
2571 {
2572 ATLASSERT(m_hDC != NULL);
2573 return ::GetTextExtentExPoint(m_hDC, lpszString, cchString, nMaxExtent, lpnFit, alpDx, lpSize);
2574 }
2575
2576 #ifndef _WIN32_WCE
2577 DWORD GetTabbedTextExtent(LPCTSTR lpszString, int nCount = -1, int nTabPositions = 0, LPINT lpnTabStopPositions = NULL) const
2578 {
2579 ATLASSERT(m_hDC != NULL);
2580 if(nCount == -1)
2581 nCount = lstrlen(lpszString);
2582 return ::GetTabbedTextExtent(m_hDC, lpszString, nCount, nTabPositions, lpnTabStopPositions);
2583 }
2584
2585 BOOL GrayString(HBRUSH hBrush, BOOL (CALLBACK* lpfnOutput)(HDC, LPARAM, int), LPARAM lpData, int nCount, int x, int y, int nWidth, int nHeight)
2586 {
2587 ATLASSERT(m_hDC != NULL);
2588 return ::GrayString(m_hDC, hBrush, (GRAYSTRINGPROC)lpfnOutput, lpData, nCount, x, y, nWidth, nHeight);
2589 }
2590 #endif // !_WIN32_WCE
2591
2592 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
2593 UINT GetTextAlign() const
2594 {
2595 ATLASSERT(m_hDC != NULL);
2596 return ::GetTextAlign(m_hDC);
2597 }
2598
2599 UINT SetTextAlign(UINT nFlags)
2600 {
2601 ATLASSERT(m_hDC != NULL);
2602 return ::SetTextAlign(m_hDC, nFlags);
2603 }
2604 #endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
2605
2606 int GetTextFace(LPTSTR lpszFacename, int nCount) const
2607 {
2608 ATLASSERT(m_hDC != NULL);
2609 return ::GetTextFace(m_hDC, nCount, lpszFacename);
2610 }
2611
2612 int GetTextFaceLen() const
2613 {
2614 ATLASSERT(m_hDC != NULL);
2615 return ::GetTextFace(m_hDC, 0, NULL);
2616 }
2617
2618 #ifndef _ATL_NO_COM
2619 #ifdef _OLEAUTO_H_
2620 BOOL GetTextFace(BSTR& bstrFace) const
2621 {
2622 USES_CONVERSION;
2623 ATLASSERT(m_hDC != NULL);
2624 ATLASSERT(bstrFace == NULL);
2625
2626 int nLen = GetTextFaceLen();
2627 if(nLen == 0)
2628 return FALSE;
2629
2630 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
2631 LPTSTR lpszText = buff.Allocate(nLen);
2632 if(lpszText == NULL)
2633 return FALSE;
2634
2635 if(!GetTextFace(lpszText, nLen))
2636 return FALSE;
2637
2638 bstrFace = ::SysAllocString(T2OLE(lpszText));
2639 return (bstrFace != NULL) ? TRUE : FALSE;
2640 }
2641 #endif
2642 #endif // !_ATL_NO_COM
2643
2644 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
2645 int GetTextFace(_CSTRING_NS::CString& strFace) const
2646 {
2647 ATLASSERT(m_hDC != NULL);
2648
2649 int nLen = GetTextFaceLen();
2650 if(nLen == 0)
2651 return 0;
2652
2653 LPTSTR lpstr = strFace.GetBufferSetLength(nLen);
2654 if(lpstr == NULL)
2655 return 0;
2656 int nRet = GetTextFace(lpstr, nLen);
2657 strFace.ReleaseBuffer();
2658 return nRet;
2659 }
2660 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
2661
2662 BOOL GetTextMetrics(LPTEXTMETRIC lpMetrics) const
2663 {
2664 ATLASSERT(m_hDC != NULL);
2665 return ::GetTextMetrics(m_hDC, lpMetrics);
2666 }
2667
2668 #ifndef _WIN32_WCE
2669 int SetTextJustification(int nBreakExtra, int nBreakCount)
2670 {
2671 ATLASSERT(m_hDC != NULL);
2672 return ::SetTextJustification(m_hDC, nBreakExtra, nBreakCount);
2673 }
2674
2675 int GetTextCharacterExtra() const
2676 {
2677 ATLASSERT(m_hDC != NULL);
2678 return ::GetTextCharacterExtra(m_hDC);
2679 }
2680
2681 int SetTextCharacterExtra(int nCharExtra)
2682 {
2683 ATLASSERT(m_hDC != NULL);
2684 return ::SetTextCharacterExtra(m_hDC, nCharExtra);
2685 }
2686 #endif // !_WIN32_WCE
2687
2688 // Advanced Drawing
2689 BOOL DrawEdge(LPRECT lpRect, UINT nEdge, UINT nFlags)
2690 {
2691 ATLASSERT(m_hDC != NULL);
2692 return ::DrawEdge(m_hDC, lpRect, nEdge, nFlags);
2693 }
2694
2695 BOOL DrawFrameControl(LPRECT lpRect, UINT nType, UINT nState)
2696 {
2697 ATLASSERT(m_hDC != NULL);
2698 return ::DrawFrameControl(m_hDC, lpRect, nType, nState);
2699 }
2700
2701 // Scrolling Functions
2702 BOOL ScrollDC(int dx, int dy, LPCRECT lpRectScroll, LPCRECT lpRectClip, HRGN hRgnUpdate, LPRECT lpRectUpdate)
2703 {
2704 ATLASSERT(m_hDC != NULL);
2705 return ::ScrollDC(m_hDC, dx, dy, lpRectScroll, lpRectClip, hRgnUpdate, lpRectUpdate);
2706 }
2707
2708 // Font Functions
2709 #ifndef _WIN32_WCE
2710 BOOL GetCharWidth(UINT nFirstChar, UINT nLastChar, LPINT lpBuffer) const
2711 {
2712 ATLASSERT(m_hDC != NULL);
2713 return ::GetCharWidth(m_hDC, nFirstChar, nLastChar, lpBuffer);
2714 }
2715
2716 // GetCharWidth32 is not supported under Win9x
2717 BOOL GetCharWidth32(UINT nFirstChar, UINT nLastChar, LPINT lpBuffer) const
2718 {
2719 ATLASSERT(m_hDC != NULL);
2720 return ::GetCharWidth32(m_hDC, nFirstChar, nLastChar, lpBuffer);
2721 }
2722
2723 DWORD SetMapperFlags(DWORD dwFlag)
2724 {
2725 ATLASSERT(m_hDC != NULL);
2726 return ::SetMapperFlags(m_hDC, dwFlag);
2727 }
2728
2729 BOOL GetAspectRatioFilter(LPSIZE lpSize) const
2730 {
2731 ATLASSERT(m_hDC != NULL);
2732 return ::GetAspectRatioFilterEx(m_hDC, lpSize);
2733 }
2734
2735 BOOL GetCharABCWidths(UINT nFirstChar, UINT nLastChar, LPABC lpabc) const
2736 {
2737 ATLASSERT(m_hDC != NULL);
2738 return ::GetCharABCWidths(m_hDC, nFirstChar, nLastChar, lpabc);
2739 }
2740
2741 DWORD GetFontData(DWORD dwTable, DWORD dwOffset, LPVOID lpData, DWORD cbData) const
2742 {
2743 ATLASSERT(m_hDC != NULL);
2744 return ::GetFontData(m_hDC, dwTable, dwOffset, lpData, cbData);
2745 }
2746
2747 int GetKerningPairs(int nPairs, LPKERNINGPAIR lpkrnpair) const
2748 {
2749 ATLASSERT(m_hDC != NULL);
2750 return ::GetKerningPairs(m_hDC, nPairs, lpkrnpair);
2751 }
2752
2753 UINT GetOutlineTextMetrics(UINT cbData, LPOUTLINETEXTMETRIC lpotm) const
2754 {
2755 ATLASSERT(m_hDC != NULL);
2756 return ::GetOutlineTextMetrics(m_hDC, cbData, lpotm);
2757 }
2758
2759 DWORD GetGlyphOutline(UINT nChar, UINT nFormat, LPGLYPHMETRICS lpgm, DWORD cbBuffer, LPVOID lpBuffer, const MAT2* lpmat2) const
2760 {
2761 ATLASSERT(m_hDC != NULL);
2762 return ::GetGlyphOutline(m_hDC, nChar, nFormat, lpgm, cbBuffer, lpBuffer, lpmat2);
2763 }
2764
2765 BOOL GetCharABCWidths(UINT nFirstChar, UINT nLastChar, LPABCFLOAT lpABCF) const
2766 {
2767 ATLASSERT(m_hDC != NULL);
2768 return ::GetCharABCWidthsFloat(m_hDC, nFirstChar, nLastChar, lpABCF);
2769 }
2770
2771 BOOL GetCharWidth(UINT nFirstChar, UINT nLastChar, float* lpFloatBuffer) const
2772 {
2773 ATLASSERT(m_hDC != NULL);
2774 return ::GetCharWidthFloat(m_hDC, nFirstChar, nLastChar, lpFloatBuffer);
2775 }
2776 #endif // !_WIN32_WCE
2777
2778 // Printer/Device Escape Functions
2779 #ifndef _WIN32_WCE
2780 int Escape(int nEscape, int nCount, LPCSTR lpszInData, LPVOID lpOutData)
2781 {
2782 ATLASSERT(m_hDC != NULL);
2783 return ::Escape(m_hDC, nEscape, nCount, lpszInData, lpOutData);
2784 }
2785 #endif // !_WIN32_WCE
2786
2787 int Escape(int nEscape, int nInputSize, LPCSTR lpszInputData,
2788 int nOutputSize, LPSTR lpszOutputData)
2789 {
2790 ATLASSERT(m_hDC != NULL);
2791 return ::ExtEscape(m_hDC, nEscape, nInputSize, lpszInputData, nOutputSize, lpszOutputData);
2792 }
2793
2794 #ifndef _WIN32_WCE
2795 int DrawEscape(int nEscape, int nInputSize, LPCSTR lpszInputData)
2796 {
2797 ATLASSERT(m_hDC != NULL);
2798 return ::DrawEscape(m_hDC, nEscape, nInputSize, lpszInputData);
2799 }
2800 #endif // !_WIN32_WCE
2801
2802 // Escape helpers
2803 #if !defined(_WIN32_WCE) || ((_WIN32_WCE >= 200) && defined(StartDoc))
2804 int StartDoc(LPCTSTR lpszDocName) // old Win3.0 version
2805 {
2806 DOCINFO di = { 0 };
2807 di.cbSize = sizeof(DOCINFO);
2808 di.lpszDocName = lpszDocName;
2809 return StartDoc(&di);
2810 }
2811
2812 int StartDoc(LPDOCINFO lpDocInfo)
2813 {
2814 ATLASSERT(m_hDC != NULL);
2815 return ::StartDoc(m_hDC, lpDocInfo);
2816 }
2817
2818 int StartPage()
2819 {
2820 ATLASSERT(m_hDC != NULL);
2821 return ::StartPage(m_hDC);
2822 }
2823
2824 int EndPage()
2825 {
2826 ATLASSERT(m_hDC != NULL);
2827 return ::EndPage(m_hDC);
2828 }
2829
2830 int SetAbortProc(BOOL (CALLBACK* lpfn)(HDC, int))
2831 {
2832 ATLASSERT(m_hDC != NULL);
2833 return ::SetAbortProc(m_hDC, (ABORTPROC)lpfn);
2834 }
2835
2836 int AbortDoc()
2837 {
2838 ATLASSERT(m_hDC != NULL);
2839 return ::AbortDoc(m_hDC);
2840 }
2841
2842 int EndDoc()
2843 {
2844 ATLASSERT(m_hDC != NULL);
2845 return ::EndDoc(m_hDC);
2846 }
2847 #endif // !defined(_WIN32_WCE) || ((_WIN32_WCE >= 200) && defined(StartDoc))
2848
2849 // MetaFile Functions
2850 #ifndef _WIN32_WCE
2851 BOOL PlayMetaFile(HMETAFILE hMF)
2852 {
2853 ATLASSERT(m_hDC != NULL);
2854 if(::GetDeviceCaps(m_hDC, TECHNOLOGY) == DT_METAFILE)
2855 {
2856 // playing metafile in metafile, just use core windows API
2857 return ::PlayMetaFile(m_hDC, hMF);
2858 }
2859
2860 // for special playback, lParam == pDC
2861 return ::EnumMetaFile(m_hDC, hMF, EnumMetaFileProc, (LPARAM)this);
2862 }
2863
2864 BOOL PlayMetaFile(HENHMETAFILE hEnhMetaFile, LPCRECT lpBounds)
2865 {
2866 ATLASSERT(m_hDC != NULL);
2867 return ::PlayEnhMetaFile(m_hDC, hEnhMetaFile, lpBounds);
2868 }
2869
2870 BOOL AddMetaFileComment(UINT nDataSize, const BYTE* pCommentData) // can be used for enhanced metafiles only
2871 {
2872 ATLASSERT(m_hDC != NULL);
2873 return ::GdiComment(m_hDC, nDataSize, pCommentData);
2874 }
2875
2876 // Special handling for metafile playback
2877 static int CALLBACK EnumMetaFileProc(HDC hDC, HANDLETABLE* pHandleTable, METARECORD* pMetaRec, int nHandles, LPARAM lParam)
2878 {
2879 CDCHandle* pDC = (CDCHandle*)lParam;
2880
2881 switch (pMetaRec->rdFunction)
2882 {
2883 case META_SETMAPMODE:
2884 pDC->SetMapMode((int)(short)pMetaRec->rdParm[0]);
2885 break;
2886 case META_SETWINDOWEXT:
2887 pDC->SetWindowExt((int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
2888 break;
2889 case META_SETWINDOWORG:
2890 pDC->SetWindowOrg((int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
2891 break;
2892 case META_SETVIEWPORTEXT:
2893 pDC->SetViewportExt((int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
2894 break;
2895 case META_SETVIEWPORTORG:
2896 pDC->SetViewportOrg((int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
2897 break;
2898 case META_SCALEWINDOWEXT:
2899 pDC->ScaleWindowExt((int)(short)pMetaRec->rdParm[3], (int)(short)pMetaRec->rdParm[2],
2900 (int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
2901 break;
2902 case META_SCALEVIEWPORTEXT:
2903 pDC->ScaleViewportExt((int)(short)pMetaRec->rdParm[3], (int)(short)pMetaRec->rdParm[2],
2904 (int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
2905 break;
2906 case META_OFFSETVIEWPORTORG:
2907 pDC->OffsetViewportOrg((int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
2908 break;
2909 case META_SAVEDC:
2910 pDC->SaveDC();
2911 break;
2912 case META_RESTOREDC:
2913 pDC->RestoreDC((int)(short)pMetaRec->rdParm[0]);
2914 break;
2915 case META_SETBKCOLOR:
2916 pDC->SetBkColor(*(UNALIGNED COLORREF*)&pMetaRec->rdParm[0]);
2917 break;
2918 case META_SETTEXTCOLOR:
2919 pDC->SetTextColor(*(UNALIGNED COLORREF*)&pMetaRec->rdParm[0]);
2920 break;
2921
2922 // need to watch out for SelectObject(HFONT), for custom font mapping
2923 case META_SELECTOBJECT:
2924 {
2925 HGDIOBJ hObject = pHandleTable->objectHandle[pMetaRec->rdParm[0]];
2926 UINT nObjType = ::GetObjectType(hObject);
2927 if(nObjType == 0)
2928 {
2929 // object type is unknown, determine if it is a font
2930 HFONT hStockFont = (HFONT)::GetStockObject(SYSTEM_FONT);
2931 HFONT hFontOld = (HFONT)::SelectObject(pDC->m_hDC, hStockFont);
2932 HGDIOBJ hObjOld = ::SelectObject(pDC->m_hDC, hObject);
2933 if(hObjOld == hStockFont)
2934 {
2935 // got the stock object back, so must be selecting a font
2936 pDC->SelectFont((HFONT)hObject);
2937 break; // don't play the default record
2938 }
2939 else
2940 {
2941 // didn't get the stock object back, so restore everything
2942 ::SelectObject(pDC->m_hDC, hFontOld);
2943 ::SelectObject(pDC->m_hDC, hObjOld);
2944 }
2945 // and fall through to PlayMetaFileRecord...
2946 }
2947 else if(nObjType == OBJ_FONT)
2948 {
2949 // play back as CDCHandle::SelectFont(HFONT)
2950 pDC->SelectFont((HFONT)hObject);
2951 break; // don't play the default record
2952 }
2953 }
2954 // fall through...
2955
2956 default:
2957 ::PlayMetaFileRecord(hDC, pHandleTable, pMetaRec, nHandles);
2958 break;
2959 }
2960
2961 return 1;
2962 }
2963 #endif // !_WIN32_WCE
2964
2965 // Path Functions
2966 #ifndef _WIN32_WCE
2967 BOOL AbortPath()
2968 {
2969 ATLASSERT(m_hDC != NULL);
2970 return ::AbortPath(m_hDC);
2971 }
2972
2973 BOOL BeginPath()
2974 {
2975 ATLASSERT(m_hDC != NULL);
2976 return ::BeginPath(m_hDC);
2977 }
2978
2979 BOOL CloseFigure()
2980 {
2981 ATLASSERT(m_hDC != NULL);
2982 return ::CloseFigure(m_hDC);
2983 }
2984
2985 BOOL EndPath()
2986 {
2987 ATLASSERT(m_hDC != NULL);
2988 return ::EndPath(m_hDC);
2989 }
2990
2991 BOOL FillPath()
2992 {
2993 ATLASSERT(m_hDC != NULL);
2994 return ::FillPath(m_hDC);
2995 }
2996
2997 BOOL FlattenPath()
2998 {
2999 ATLASSERT(m_hDC != NULL);
3000 return ::FlattenPath(m_hDC);
3001 }
3002
3003 BOOL StrokeAndFillPath()
3004 {
3005 ATLASSERT(m_hDC != NULL);
3006 return ::StrokeAndFillPath(m_hDC);
3007 }
3008
3009 BOOL StrokePath()
3010 {
3011 ATLASSERT(m_hDC != NULL);
3012 return ::StrokePath(m_hDC);
3013 }
3014
3015 BOOL WidenPath()
3016 {
3017 ATLASSERT(m_hDC != NULL);
3018 return ::WidenPath(m_hDC);
3019 }
3020
3021 BOOL GetMiterLimit(PFLOAT pfMiterLimit) const
3022 {
3023 ATLASSERT(m_hDC != NULL);
3024 return ::GetMiterLimit(m_hDC, pfMiterLimit);
3025 }
3026
3027 BOOL SetMiterLimit(float fMiterLimit)
3028 {
3029 ATLASSERT(m_hDC != NULL);
3030 return ::SetMiterLimit(m_hDC, fMiterLimit, NULL);
3031 }
3032
3033 int GetPath(LPPOINT lpPoints, LPBYTE lpTypes, int nCount) const
3034 {
3035 ATLASSERT(m_hDC != NULL);
3036 return ::GetPath(m_hDC, lpPoints, lpTypes, nCount);
3037 }
3038
3039 BOOL SelectClipPath(int nMode)
3040 {
3041 ATLASSERT(m_hDC != NULL);
3042 return ::SelectClipPath(m_hDC, nMode);
3043 }
3044 #endif // !_WIN32_WCE
3045
3046 // Misc Helper Functions
3047 static CBrushHandle PASCAL GetHalftoneBrush()
3048 {
3049 HBRUSH halftoneBrush = NULL;
3050 WORD grayPattern[8] = { 0 };
3051 for(int i = 0; i < 8; i++)
3052 grayPattern[i] = (WORD)(0x5555 << (i & 1));
3053 HBITMAP grayBitmap = CreateBitmap(8, 8, 1, 1, &grayPattern);
3054 if(grayBitmap != NULL)
3055 {
3056 halftoneBrush = ::CreatePatternBrush(grayBitmap);
3057 DeleteObject(grayBitmap);
3058 }
3059 return CBrushHandle(halftoneBrush);
3060 }
3061
3062 void DrawDragRect(LPCRECT lpRect, SIZE size, LPCRECT lpRectLast, SIZE sizeLast, HBRUSH hBrush = NULL, HBRUSH hBrushLast = NULL)
3063 {
3064 // first, determine the update region and select it
3065 CRgn rgnOutside;
3066 rgnOutside.CreateRectRgnIndirect(lpRect);
3067 RECT rect = *lpRect;
3068 ::InflateRect(&rect, -size.cx, -size.cy);
3069 ::IntersectRect(&rect, &rect, lpRect);
3070 CRgn rgnInside;
3071 rgnInside.CreateRectRgnIndirect(&rect);
3072 CRgn rgnNew;
3073 rgnNew.CreateRectRgn(0, 0, 0, 0);
3074 rgnNew.CombineRgn(rgnOutside, rgnInside, RGN_XOR);
3075
3076 HBRUSH hBrushOld = NULL;
3077 CBrush brushHalftone;
3078 if(hBrush == NULL)
3079 brushHalftone = hBrush = CDCHandle::GetHalftoneBrush();
3080 if(hBrushLast == NULL)
3081 hBrushLast = hBrush;
3082
3083 CRgn rgnLast;
3084 CRgn rgnUpdate;
3085 if(lpRectLast != NULL)
3086 {
3087 // find difference between new region and old region
3088 rgnLast.CreateRectRgn(0, 0, 0, 0);
3089 rgnOutside.SetRectRgn(lpRectLast->left, lpRectLast->top, lpRectLast->right, lpRectLast->bottom);
3090 rect = *lpRectLast;
3091 ::InflateRect(&rect, -sizeLast.cx, -sizeLast.cy);
3092 ::IntersectRect(&rect, &rect, lpRectLast);
3093 rgnInside.SetRectRgn(rect.left, rect.top, rect.right, rect.bottom);
3094 rgnLast.CombineRgn(rgnOutside, rgnInside, RGN_XOR);
3095
3096 // only diff them if brushes are the same
3097 if(hBrush == hBrushLast)
3098 {
3099 rgnUpdate.CreateRectRgn(0, 0, 0, 0);
3100 rgnUpdate.CombineRgn(rgnLast, rgnNew, RGN_XOR);
3101 }
3102 }
3103 if(hBrush != hBrushLast && lpRectLast != NULL)
3104 {
3105 // brushes are different -- erase old region first
3106 SelectClipRgn(rgnLast);
3107 GetClipBox(&rect);
3108 hBrushOld = SelectBrush(hBrushLast);
3109 PatBlt(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, PATINVERT);
3110 SelectBrush(hBrushOld);
3111 hBrushOld = NULL;
3112 }
3113
3114 // draw into the update/new region
3115 SelectClipRgn(rgnUpdate.IsNull() ? rgnNew : rgnUpdate);
3116 GetClipBox(&rect);
3117 hBrushOld = SelectBrush(hBrush);
3118 PatBlt(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, PATINVERT);
3119
3120 // cleanup DC
3121 if(hBrushOld != NULL)
3122 SelectBrush(hBrushOld);
3123 SelectClipRgn(NULL);
3124 }
3125
3126 void FillSolidRect(LPCRECT lpRect, COLORREF clr)
3127 {
3128 ATLASSERT(m_hDC != NULL);
3129
3130 COLORREF clrOld = ::SetBkColor(m_hDC, clr);
3131 ATLASSERT(clrOld != CLR_INVALID);
3132 if(clrOld != CLR_INVALID)
3133 {
3134 ::ExtTextOut(m_hDC, 0, 0, ETO_OPAQUE, lpRect, NULL, 0, NULL);
3135 ::SetBkColor(m_hDC, clrOld);
3136 }
3137 }
3138
3139 void FillSolidRect(int x, int y, int cx, int cy, COLORREF clr)
3140 {
3141 ATLASSERT(m_hDC != NULL);
3142
3143 RECT rect = { x, y, x + cx, y + cy };
3144 FillSolidRect(&rect, clr);
3145 }
3146
3147 void Draw3dRect(LPCRECT lpRect, COLORREF clrTopLeft, COLORREF clrBottomRight)
3148 {
3149 Draw3dRect(lpRect->left, lpRect->top, lpRect->right - lpRect->left,
3150 lpRect->bottom - lpRect->top, clrTopLeft, clrBottomRight);
3151 }
3152
3153 void Draw3dRect(int x, int y, int cx, int cy, COLORREF clrTopLeft, COLORREF clrBottomRight)
3154 {
3155 FillSolidRect(x, y, cx - 1, 1, clrTopLeft);
3156 FillSolidRect(x, y, 1, cy - 1, clrTopLeft);
3157 FillSolidRect(x + cx, y, -1, cy, clrBottomRight);
3158 FillSolidRect(x, y + cy, cx, -1, clrBottomRight);
3159 }
3160
3161 // DIB support
3162 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 410)
3163 int SetDIBitsToDevice(int x, int y, DWORD dwWidth, DWORD dwHeight, int xSrc, int ySrc, UINT uStartScan, UINT cScanLines, CONST VOID* lpvBits, CONST BITMAPINFO* lpbmi, UINT uColorUse)
3164 {
3165 ATLASSERT(m_hDC != NULL);
3166 return ::SetDIBitsToDevice(m_hDC, x, y, dwWidth, dwHeight, xSrc, ySrc, uStartScan, cScanLines, lpvBits, lpbmi, uColorUse);
3167 }
3168 #endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 410)
3169
3170 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
3171 int StretchDIBits(int x, int y, int nWidth, int nHeight, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, CONST VOID* lpvBits, CONST BITMAPINFO* lpbmi, UINT uColorUse, DWORD dwRop)
3172 {
3173 ATLASSERT(m_hDC != NULL);
3174 return ::StretchDIBits(m_hDC, x, y, nWidth, nHeight, xSrc, ySrc, nSrcWidth, nSrcHeight, lpvBits, lpbmi, uColorUse, dwRop);
3175 }
3176
3177 UINT GetDIBColorTable(UINT uStartIndex, UINT cEntries, RGBQUAD* pColors) const
3178 {
3179 ATLASSERT(m_hDC != NULL);
3180 return ::GetDIBColorTable(m_hDC, uStartIndex, cEntries, pColors);
3181 }
3182
3183 UINT SetDIBColorTable(UINT uStartIndex, UINT cEntries, CONST RGBQUAD* pColors)
3184 {
3185 ATLASSERT(m_hDC != NULL);
3186 return ::SetDIBColorTable(m_hDC, uStartIndex, cEntries, pColors);
3187 }
3188 #endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
3189
3190 // OpenGL support
3191 #if !defined(_ATL_NO_OPENGL) && !defined(_WIN32_WCE)
3192 int ChoosePixelFormat(CONST PIXELFORMATDESCRIPTOR* ppfd)
3193 {
3194 ATLASSERT(m_hDC != NULL);
3195 return ::ChoosePixelFormat(m_hDC, ppfd);
3196 }
3197
3198 int DescribePixelFormat(int iPixelFormat, UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd)
3199 {
3200 ATLASSERT(m_hDC != NULL);
3201 return ::DescribePixelFormat(m_hDC, iPixelFormat, nBytes, ppfd);
3202 }
3203
3204 int GetPixelFormat() const
3205 {
3206 ATLASSERT(m_hDC != NULL);
3207 return ::GetPixelFormat(m_hDC);
3208 }
3209
3210 BOOL SetPixelFormat(int iPixelFormat, CONST PIXELFORMATDESCRIPTOR* ppfd)
3211 {
3212 ATLASSERT(m_hDC != NULL);
3213 return ::SetPixelFormat(m_hDC, iPixelFormat, ppfd);
3214 }
3215
3216 BOOL SwapBuffers()
3217 {
3218 ATLASSERT(m_hDC != NULL);
3219 return ::SwapBuffers(m_hDC);
3220 }
3221
3222 HGLRC wglCreateContext()
3223 {
3224 ATLASSERT(m_hDC != NULL);
3225 return ::wglCreateContext(m_hDC);
3226 }
3227
3228 HGLRC wglCreateLayerContext(int iLayerPlane)
3229 {
3230 ATLASSERT(m_hDC != NULL);
3231 return ::wglCreateLayerContext(m_hDC, iLayerPlane);
3232 }
3233
3234 BOOL wglMakeCurrent(HGLRC hglrc)
3235 {
3236 ATLASSERT(m_hDC != NULL);
3237 return ::wglMakeCurrent(m_hDC, hglrc);
3238 }
3239
3240 BOOL wglUseFontBitmaps(DWORD dwFirst, DWORD dwCount, DWORD listBase)
3241 {
3242 ATLASSERT(m_hDC != NULL);
3243 return ::wglUseFontBitmaps(m_hDC, dwFirst, dwCount, listBase);
3244 }
3245
3246 BOOL wglUseFontOutlines(DWORD dwFirst, DWORD dwCount, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
3247 {
3248 ATLASSERT(m_hDC != NULL);
3249 return ::wglUseFontOutlines(m_hDC, dwFirst, dwCount, listBase, deviation, extrusion, format, lpgmf);
3250 }
3251
3252 BOOL wglDescribeLayerPlane(int iPixelFormat, int iLayerPlane, UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd)
3253 {
3254 ATLASSERT(m_hDC != NULL);
3255 return ::wglDescribeLayerPlane(m_hDC, iPixelFormat, iLayerPlane, nBytes, plpd);
3256 }
3257
3258 int wglSetLayerPaletteEntries(int iLayerPlane, int iStart, int cEntries, CONST COLORREF* pclr)
3259 {
3260 ATLASSERT(m_hDC != NULL);
3261 return ::wglSetLayerPaletteEntries(m_hDC, iLayerPlane, iStart, cEntries, pclr);
3262 }
3263
3264 int wglGetLayerPaletteEntries(int iLayerPlane, int iStart, int cEntries, COLORREF* pclr)
3265 {
3266 ATLASSERT(m_hDC != NULL);
3267 return ::wglGetLayerPaletteEntries(m_hDC, iLayerPlane, iStart, cEntries, pclr);
3268 }
3269
3270 BOOL wglRealizeLayerPalette(int iLayerPlane, BOOL bRealize)
3271 {
3272 ATLASSERT(m_hDC != NULL);
3273 return ::wglRealizeLayerPalette(m_hDC, iLayerPlane, bRealize);
3274 }
3275
3276 BOOL wglSwapLayerBuffers(UINT uPlanes)
3277 {
3278 ATLASSERT(m_hDC != NULL);
3279 return ::wglSwapLayerBuffers(m_hDC, uPlanes);
3280 }
3281 #endif // !defined(_ATL_NO_OPENGL) && !defined(_WIN32_WCE)
3282
3283 // New for Windows 2000 only
3284 #if (_WIN32_WINNT >= 0x0500)
3285 COLORREF GetDCPenColor() const
3286 {
3287 ATLASSERT(m_hDC != NULL);
3288 return ::GetDCPenColor(m_hDC);
3289 }
3290
3291 COLORREF SetDCPenColor(COLORREF clr)
3292 {
3293 ATLASSERT(m_hDC != NULL);
3294 return ::SetDCPenColor(m_hDC, clr);
3295 }
3296
3297 COLORREF GetDCBrushColor() const
3298 {
3299 ATLASSERT(m_hDC != NULL);
3300 return ::GetDCBrushColor(m_hDC);
3301 }
3302
3303 COLORREF SetDCBrushColor(COLORREF clr)
3304 {
3305 ATLASSERT(m_hDC != NULL);
3306 return ::SetDCBrushColor(m_hDC, clr);
3307 }
3308
3309 #ifndef _WIN32_WCE
3310 DWORD GetFontUnicodeRanges(LPGLYPHSET lpgs) const
3311 {
3312 ATLASSERT(m_hDC != NULL);
3313 return ::GetFontUnicodeRanges(m_hDC, lpgs);
3314 }
3315 #endif // !_WIN32_WCE
3316
3317 DWORD GetGlyphIndices(LPCTSTR lpstr, int cch, LPWORD pgi, DWORD dwFlags) const
3318 {
3319 ATLASSERT(m_hDC != NULL);
3320 return ::GetGlyphIndices(m_hDC, lpstr, cch, pgi, dwFlags);
3321 }
3322
3323 BOOL GetTextExtentPointI(LPWORD pgiIn, int cgi, LPSIZE lpSize) const
3324 {
3325 ATLASSERT(m_hDC != NULL);
3326 return ::GetTextExtentPointI(m_hDC, pgiIn, cgi, lpSize);
3327 }
3328
3329 BOOL GetTextExtentExPointI(LPWORD pgiIn, int cgi, int nMaxExtent, LPINT lpnFit, LPINT alpDx, LPSIZE lpSize) const
3330 {
3331 ATLASSERT(m_hDC != NULL);
3332 return ::GetTextExtentExPointI(m_hDC, pgiIn, cgi, nMaxExtent, lpnFit, alpDx, lpSize);
3333 }
3334
3335 BOOL GetCharWidthI(UINT giFirst, UINT cgi, LPWORD pgi, LPINT lpBuffer) const
3336 {
3337 ATLASSERT(m_hDC != NULL);
3338 return ::GetCharWidthI(m_hDC, giFirst, cgi, pgi, lpBuffer);
3339 }
3340
3341 BOOL GetCharABCWidthsI(UINT giFirst, UINT cgi, LPWORD pgi, LPABC lpabc) const
3342 {
3343 ATLASSERT(m_hDC != NULL);
3344 return ::GetCharABCWidthsI(m_hDC, giFirst, cgi, pgi, lpabc);
3345 }
3346 #endif // (_WIN32_WINNT >= 0x0500)
3347
3348 // New for Windows 2000 and Windows 98
3349 #if (WINVER >= 0x0500) && !defined(_WIN32_WCE)
3350 BOOL ColorCorrectPalette(HPALETTE hPalette, DWORD dwFirstEntry, DWORD dwNumOfEntries)
3351 {
3352 ATLASSERT(m_hDC != NULL);
3353 return ::ColorCorrectPalette(m_hDC, hPalette, dwFirstEntry, dwNumOfEntries);
3354 }
3355 #endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)
3356 };
3357
3358 typedef CDCT<false> CDCHandle;
3359 typedef CDCT<true> CDC;
3360
3361
3362 ///////////////////////////////////////////////////////////////////////////////
3363 // CDC Helpers
3364
3365 class CPaintDC : public CDC
3366 {
3367 public:
3368 // Data members
3369 HWND m_hWnd;
3370 PAINTSTRUCT m_ps;
3371
3372 // Constructor/destructor
3373 CPaintDC(HWND hWnd)
3374 {
3375 ATLASSERT(::IsWindow(hWnd));
3376 m_hWnd = hWnd;
3377 m_hDC = ::BeginPaint(hWnd, &m_ps);
3378 }
3379
3380 ~CPaintDC()
3381 {
3382 ATLASSERT(m_hDC != NULL);
3383 ATLASSERT(::IsWindow(m_hWnd));
3384 ::EndPaint(m_hWnd, &m_ps);
3385 Detach();
3386 }
3387 };
3388
3389 class CClientDC : public CDC
3390 {
3391 public:
3392 // Data members
3393 HWND m_hWnd;
3394
3395 // Constructor/destructor
3396 CClientDC(HWND hWnd)
3397 {
3398 ATLASSERT(hWnd == NULL || ::IsWindow(hWnd));
3399 m_hWnd = hWnd;
3400 m_hDC = ::GetDC(hWnd);
3401 }
3402
3403 ~CClientDC()
3404 {
3405 ATLASSERT(m_hDC != NULL);
3406 ::ReleaseDC(m_hWnd, Detach());
3407 }
3408 };
3409
3410 class CWindowDC : public CDC
3411 {
3412 public:
3413 // Data members
3414 HWND m_hWnd;
3415
3416 // Constructor/destructor
3417 CWindowDC(HWND hWnd)
3418 {
3419 ATLASSERT(hWnd == NULL || ::IsWindow(hWnd));
3420 m_hWnd = hWnd;
3421 m_hDC = ::GetWindowDC(hWnd);
3422 }
3423
3424 ~CWindowDC()
3425 {
3426 ATLASSERT(m_hDC != NULL);
3427 ::ReleaseDC(m_hWnd, Detach());
3428 }
3429 };
3430
3431 class CMemoryDC : public CDC
3432 {
3433 public:
3434 // Data members
3435 HDC m_hDCOriginal;
3436 RECT m_rcPaint;
3437 CBitmap m_bmp;
3438 HBITMAP m_hBmpOld;
3439
3440 // Constructor/destructor
3441 CMemoryDC(HDC hDC, const RECT& rcPaint) : m_hDCOriginal(hDC), m_hBmpOld(NULL)
3442 {
3443 m_rcPaint = rcPaint;
3444 CreateCompatibleDC(m_hDCOriginal);
3445 ATLASSERT(m_hDC != NULL);
3446 m_bmp.CreateCompatibleBitmap(m_hDCOriginal, m_rcPaint.right - m_rcPaint.left, m_rcPaint.bottom - m_rcPaint.top);
3447 ATLASSERT(m_bmp.m_hBitmap != NULL);
3448 m_hBmpOld = SelectBitmap(m_bmp);
3449 SetViewportOrg(-m_rcPaint.left, -m_rcPaint.top);
3450 }
3451
3452 ~CMemoryDC()
3453 {
3454 ::BitBlt(m_hDCOriginal, m_rcPaint.left, m_rcPaint.top, m_rcPaint.right - m_rcPaint.left, m_rcPaint.bottom - m_rcPaint.top, m_hDC, m_rcPaint.left, m_rcPaint.top, SRCCOPY);
3455 SelectBitmap(m_hBmpOld);
3456 }
3457 };
3458
3459
3460 ///////////////////////////////////////////////////////////////////////////////
3461 // Enhanced metafile support
3462
3463 #ifndef _WIN32_WCE
3464
3465 class CEnhMetaFileInfo
3466 {
3467 public:
3468 // Data members
3469 HENHMETAFILE m_hEMF;
3470 BYTE* m_pBits;
3471 TCHAR* m_pDesc;
3472 ENHMETAHEADER m_header;
3473 PIXELFORMATDESCRIPTOR m_pfd;
3474
3475 // Constructor/destructor
3476 CEnhMetaFileInfo(HENHMETAFILE hEMF) : m_pBits(NULL), m_pDesc(NULL), m_hEMF(hEMF)
3477 { }
3478
3479 ~CEnhMetaFileInfo()
3480 {
3481 delete [] m_pBits;
3482 delete [] m_pDesc;
3483 }
3484
3485 // Operations
3486 BYTE* GetEnhMetaFileBits()
3487 {
3488 ATLASSERT(m_hEMF != NULL);
3489 UINT nBytes = ::GetEnhMetaFileBits(m_hEMF, 0, NULL);
3490 delete [] m_pBits;
3491 m_pBits = NULL;
3492 ATLTRY(m_pBits = new BYTE[nBytes]);
3493 if (m_pBits != NULL)
3494 ::GetEnhMetaFileBits(m_hEMF, nBytes, m_pBits);
3495 return m_pBits;
3496 }
3497
3498 LPTSTR GetEnhMetaFileDescription()
3499 {
3500 ATLASSERT(m_hEMF != NULL);
3501 UINT nLen = ::GetEnhMetaFileDescription(m_hEMF, 0, NULL);
3502 delete [] m_pDesc;
3503 m_pDesc = NULL;
3504 ATLTRY(m_pDesc = new TCHAR[nLen]);
3505 if (m_pDesc != NULL)
3506 nLen = ::GetEnhMetaFileDescription(m_hEMF, nLen, m_pDesc);
3507 return m_pDesc;
3508 }
3509
3510 ENHMETAHEADER* GetEnhMetaFileHeader()
3511 {
3512 ATLASSERT(m_hEMF != NULL);
3513 memset(&m_header, 0, sizeof(m_header));
3514 m_header.iType = EMR_HEADER;
3515 m_header.nSize = sizeof(ENHMETAHEADER);
3516 UINT n = ::GetEnhMetaFileHeader(m_hEMF, sizeof(ENHMETAHEADER), &m_header);
3517 return (n != 0) ? &m_header : NULL;
3518 }
3519
3520 PIXELFORMATDESCRIPTOR* GetEnhMetaFilePixelFormat()
3521 {
3522 ATLASSERT(m_hEMF != NULL);
3523 memset(&m_pfd, 0, sizeof(m_pfd));
3524 UINT n = ::GetEnhMetaFilePixelFormat(m_hEMF, sizeof(m_pfd), &m_pfd);
3525 return (n != 0) ? &m_pfd : NULL;
3526 }
3527 };
3528
3529
3530 template <bool t_bManaged>
3531 class CEnhMetaFileT
3532 {
3533 public:
3534 // Data members
3535 HENHMETAFILE m_hEMF;
3536
3537 // Constructor/destructor
3538 CEnhMetaFileT(HENHMETAFILE hEMF = NULL) : m_hEMF(hEMF)
3539 {
3540 }
3541
3542 ~CEnhMetaFileT()
3543 {
3544 if(t_bManaged && m_hEMF != NULL)
3545 DeleteObject();
3546 }
3547
3548 // Operations
3549 CEnhMetaFileT<t_bManaged>& operator =(HENHMETAFILE hEMF)
3550 {
3551 Attach(hEMF);
3552 return *this;
3553 }
3554
3555 void Attach(HENHMETAFILE hEMF)
3556 {
3557 if(t_bManaged && m_hEMF != NULL && m_hEMF != hEMF)
3558 DeleteObject();
3559 m_hEMF = hEMF;
3560 }
3561
3562 HENHMETAFILE Detach()
3563 {
3564 HENHMETAFILE hEMF = m_hEMF;
3565 m_hEMF = NULL;
3566 return hEMF;
3567 }
3568
3569 operator HENHMETAFILE() const { return m_hEMF; }
3570
3571 bool IsNull() const { return (m_hEMF == NULL); }
3572
3573 BOOL DeleteObject()
3574 {
3575 ATLASSERT(m_hEMF != NULL);
3576 BOOL bRet = ::DeleteEnhMetaFile(m_hEMF);
3577 m_hEMF = NULL;
3578 return bRet;
3579 }
3580
3581 UINT GetEnhMetaFileBits(UINT cbBuffer, LPBYTE lpbBuffer) const
3582 {
3583 ATLASSERT(m_hEMF != NULL);
3584 return ::GetEnhMetaFileBits(m_hEMF, cbBuffer, lpbBuffer);
3585 }
3586
3587 UINT GetEnhMetaFileDescription(UINT cchBuffer, LPTSTR lpszDescription) const
3588 {
3589 ATLASSERT(m_hEMF != NULL);
3590 return ::GetEnhMetaFileDescription(m_hEMF, cchBuffer, lpszDescription);
3591 }
3592
3593 UINT GetEnhMetaFileHeader(LPENHMETAHEADER lpemh) const
3594 {
3595 ATLASSERT(m_hEMF != NULL);
3596 lpemh->iType = EMR_HEADER;
3597 lpemh->nSize = sizeof(ENHMETAHEADER);
3598 return ::GetEnhMetaFileHeader(m_hEMF, sizeof(ENHMETAHEADER), lpemh);
3599 }
3600
3601 UINT GetEnhMetaFilePaletteEntries(UINT cEntries, LPPALETTEENTRY lppe) const
3602 {
3603 ATLASSERT(m_hEMF != NULL);
3604 return ::GetEnhMetaFilePaletteEntries(m_hEMF, cEntries, lppe);
3605 }
3606
3607 UINT GetEnhMetaFilePixelFormat(DWORD cbBuffer, PIXELFORMATDESCRIPTOR* ppfd) const
3608 {
3609 ATLASSERT(m_hEMF != NULL);
3610 return ::GetEnhMetaFilePixelFormat(m_hEMF, cbBuffer, ppfd);
3611 }
3612 };
3613
3614 typedef CEnhMetaFileT<false> CEnhMetaFileHandle;
3615 typedef CEnhMetaFileT<true> CEnhMetaFile;
3616
3617
3618 class CEnhMetaFileDC : public CDC
3619 {
3620 public:
3621 // Constructor/destructor
3622 CEnhMetaFileDC()
3623 {
3624 }
3625
3626 CEnhMetaFileDC(HDC hdc, LPCRECT lpRect)
3627 {
3628 Create(hdc, NULL, lpRect, NULL);
3629 ATLASSERT(m_hDC != NULL);
3630 }
3631
3632 CEnhMetaFileDC(HDC hdcRef, LPCTSTR lpFilename, LPCRECT lpRect, LPCTSTR lpDescription)
3633 {
3634 Create(hdcRef, lpFilename, lpRect, lpDescription);
3635 ATLASSERT(m_hDC != NULL);
3636 }
3637
3638 ~CEnhMetaFileDC()
3639 {
3640 HENHMETAFILE hEMF = Close();
3641 if (hEMF != NULL)
3642 ::DeleteEnhMetaFile(hEMF);
3643 }
3644
3645 // Operations
3646 void Create(HDC hdcRef, LPCTSTR lpFilename, LPCRECT lpRect, LPCTSTR lpDescription)
3647 {
3648 ATLASSERT(m_hDC == NULL);
3649 m_hDC = ::CreateEnhMetaFile(hdcRef, lpFilename, lpRect, lpDescription);
3650 }
3651
3652 HENHMETAFILE Close()
3653 {
3654 HENHMETAFILE hEMF = NULL;
3655 if (m_hDC != NULL)
3656 {
3657 hEMF = ::CloseEnhMetaFile(m_hDC);
3658 m_hDC = NULL;
3659 }
3660 return hEMF;
3661 }
3662 };
3663
3664 #endif // !_WIN32_WCE
3665
3666
3667 ///////////////////////////////////////////////////////////////////////////////
3668 // WinCE compatible clipboard CF_DIB format support functions
3669
3670 #ifndef _WTL_NO_DIB16
3671
3672 #define DIBINFO16_BITFIELDS { 31744, 992, 31 }
3673
3674 // DIBINFO16 - To avoid color table problems in WinCE we only create this type of Dib
3675 struct DIBINFO16 // a BITMAPINFO with 2 additional color bitfields
3676 {
3677 BITMAPINFOHEADER bmiHeader;
3678 RGBQUAD bmiColors[3];
3679
3680 DIBINFO16(SIZE size)
3681 {
3682 BITMAPINFOHEADER bmih = { sizeof(BITMAPINFOHEADER), size.cx, size.cy,
3683 1, 16, BI_BITFIELDS, 2 * size.cx * size.cy , 0, 0, 3 };
3684 DWORD dw[3] = DIBINFO16_BITFIELDS ;
3685
3686 bmiHeader = bmih;
3687 SecureHelper::memcpy_x(bmiColors, sizeof(bmiColors), dw, 3 * sizeof(DWORD));
3688 }
3689 };
3690
3691
3692 // AtlxxxDibxxx minimal packed DIB implementation and helpers to copy and paste CF_DIB
3693
3694 inline bool AtlIsDib16(LPBITMAPINFOHEADER pbmih)
3695 {
3696 return (pbmih->biBitCount == 16) && (pbmih->biCompression == BI_BITFIELDS);
3697 }
3698
3699 inline int AtlGetDibColorTableSize(LPBITMAPINFOHEADER pbmih)
3700 {
3701 switch (pbmih->biBitCount)
3702 {
3703 case 2:
3704 case 4:
3705 case 8:
3706 return pbmih->biClrUsed ? pbmih->biClrUsed : 1 << pbmih->biBitCount;
3707 case 24:
3708 break;
3709 case 16:
3710 case 32:
3711 return pbmih->biCompression == BI_BITFIELDS ? 3 : 0;
3712 default:
3713 ATLASSERT(FALSE); // should never come here
3714 }
3715
3716 return 0;
3717 }
3718
3719 inline int AtlGetDibNumColors(LPBITMAPINFOHEADER pbmih)
3720 {
3721 switch (pbmih->biBitCount)
3722 {
3723 case 2:
3724 case 4:
3725 case 8:
3726 if (pbmih->biClrUsed)
3727 return pbmih->biClrUsed;
3728 else
3729 break;
3730 case 16:
3731 if (pbmih->biCompression == BI_BITFIELDS )
3732 return 1 << 15;
3733 else
3734 break;
3735 case 24:
3736 break;
3737 case 32:
3738 if (pbmih->biCompression == BI_BITFIELDS )
3739 return 1 << 24;
3740 else
3741 break;
3742 default:
3743 ATLASSERT(FALSE);
3744 }
3745
3746 return 1 << pbmih->biBitCount;
3747 }
3748
3749 inline HBITMAP AtlGetDibBitmap(LPBITMAPINFO pbmi)
3750 {
3751 CDC dc(NULL);
3752 void* pBits = NULL;
3753
3754 LPBYTE pDibBits = (LPBYTE)pbmi + sizeof(BITMAPINFOHEADER) + AtlGetDibColorTableSize(&pbmi->bmiHeader) * sizeof(RGBQUAD);
3755 HBITMAP hbm = CreateDIBSection(dc, pbmi, DIB_RGB_COLORS, &pBits, NULL, NULL);
3756 if (hbm != NULL)
3757 {
3758 int cbBits = pbmi->bmiHeader.biWidth * pbmi->bmiHeader.biHeight * pbmi->bmiHeader.biBitCount / 8;
3759 SecureHelper::memcpy_x(pBits, cbBits, pDibBits, pbmi->bmiHeader.biSizeImage);
3760 }
3761
3762 return hbm;
3763 }
3764
3765 inline HBITMAP AtlCopyBitmap(HBITMAP hbm, SIZE sizeDst, bool bAsBitmap = false)
3766 {
3767 CDC hdcSrc = CreateCompatibleDC(NULL);
3768 CDC hdcDst = CreateCompatibleDC(NULL);
3769
3770 CBitmapHandle hbmOld = NULL, hbmOld2 = NULL, bmSrc = hbm;
3771
3772 CBitmap bmNew = NULL;
3773
3774 SIZE sizeSrc = { 0 };
3775 bmSrc.GetSize(sizeSrc);
3776
3777 hbmOld = hdcSrc.SelectBitmap(bmSrc);
3778
3779 if (bAsBitmap)
3780 {
3781 bmNew.CreateCompatibleBitmap(hdcSrc, sizeDst.cx, sizeDst.cy);
3782 }
3783 else
3784 {
3785 DIBINFO16 dib16(sizeDst);
3786 LPVOID pBits = NULL;
3787 bmNew = CreateDIBSection(hdcDst, (const BITMAPINFO*)&dib16, DIB_RGB_COLORS, &pBits, NULL, NULL);
3788 }
3789
3790 ATLASSERT(!bmNew.IsNull());
3791
3792 hbmOld2 = hdcDst.SelectBitmap(bmNew);
3793 BOOL bOK = FALSE;
3794
3795 if ((sizeDst.cx == sizeSrc.cx) && (sizeDst.cy == sizeSrc.cy))
3796 bOK = hdcDst.BitBlt(0, 0, sizeDst.cx, sizeDst.cy, hdcSrc, 0, 0, SRCCOPY);
3797 else
3798 bOK = hdcDst.StretchBlt(0, 0, sizeDst.cx, sizeDst.cy, hdcSrc, 0, 0, sizeSrc.cx, sizeSrc.cy, SRCCOPY);
3799
3800 hdcSrc.SelectBitmap(hbmOld);
3801 hdcDst.SelectBitmap(hbmOld2);
3802
3803 if (bOK == FALSE)
3804 bmNew.DeleteObject();
3805
3806 return bmNew.Detach();
3807 }
3808
3809 inline HLOCAL AtlCreatePackedDib16(HBITMAP hbm, SIZE size)
3810 {
3811 DIBSECTION ds = { 0 };
3812 LPBYTE pDib = NULL;
3813 bool bCopied = false;
3814
3815 bool bOK = GetObject(hbm, sizeof(ds), &ds) == sizeof(ds);
3816 if ((bOK == FALSE) || (ds.dsBm.bmBits == NULL) || (AtlIsDib16(&ds.dsBmih) == FALSE) ||
3817 (ds.dsBmih.biWidth != size.cx ) || (ds.dsBmih.biHeight != size.cy ))
3818 {
3819 if ((hbm = AtlCopyBitmap(hbm, size)) != NULL)
3820 {
3821 bCopied = true;
3822 bOK = GetObject(hbm, sizeof(ds), &ds) == sizeof(ds);
3823 }
3824 else
3825 {
3826 bOK = FALSE;
3827 }
3828 }
3829
3830 if((bOK != FALSE) && (AtlIsDib16(&ds.dsBmih) != FALSE) && (ds.dsBm.bmBits != NULL))
3831 {
3832 pDib = (LPBYTE)LocalAlloc(LMEM_ZEROINIT, sizeof(DIBINFO16) + ds.dsBmih.biSizeImage);
3833 if (pDib != NULL)
3834 {
3835 SecureHelper::memcpy_x(pDib, sizeof(DIBINFO16) + ds.dsBmih.biSizeImage, &ds.dsBmih, sizeof(DIBINFO16));
3836 SecureHelper::memcpy_x(pDib + sizeof(DIBINFO16), ds.dsBmih.biSizeImage, ds.dsBm.bmBits, ds.dsBmih.biSizeImage);
3837 }
3838 }
3839
3840 if (bCopied == true)
3841 DeleteObject(hbm);
3842
3843 return (HLOCAL)pDib;
3844 }
3845
3846 inline bool AtlSetClipboardDib16(HBITMAP hbm, SIZE size, HWND hWnd)
3847 {
3848 ATLASSERT(::IsWindow(hWnd));
3849 BOOL bOK = OpenClipboard(hWnd);
3850 if (bOK != FALSE)
3851 {
3852 bOK = EmptyClipboard();
3853 if (bOK != FALSE)
3854 {
3855 HLOCAL hDib = AtlCreatePackedDib16(hbm, size);
3856 if (hDib != NULL)
3857 {
3858 bOK = SetClipboardData(CF_DIB, hDib) != NULL;
3859 if (bOK == FALSE)
3860 LocalFree(hDib);
3861 }
3862 else
3863 {
3864 bOK = FALSE;
3865 }
3866 }
3867 CloseClipboard();
3868 }
3869
3870 return (bOK != FALSE);
3871 }
3872
3873 inline HBITMAP AtlGetClipboardDib(HWND hWnd)
3874 {
3875 ATLASSERT(::IsWindow(hWnd) != FALSE);
3876 HBITMAP hbm = NULL;
3877 if (OpenClipboard(hWnd) != FALSE)
3878 {
3879 LPBITMAPINFO pbmi = (LPBITMAPINFO)GetClipboardData(CF_DIB);
3880 if (pbmi != NULL)
3881 hbm = AtlGetDibBitmap(pbmi);
3882 CloseClipboard();
3883 }
3884
3885 return hbm;
3886 }
3887
3888 #endif // _WTL_NO_DIB16
3889
3890 }; // namespace WTL
3891
3892 #endif // __ATLGDI_H__
Windows Explorer Extension to Operate Git