home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / WinCE / SDKWindowsCE / HandHeldPCPro30 / sdk.exe / Jupiter SDK / data1.cab / MFC / src / wingdi.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-19  |  34.5 KB  |  1,423 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12.  
  13. #ifdef AFX_CORE2_SEG
  14. #pragma code_seg(AFX_CORE2_SEG)
  15. #endif
  16.  
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[] = __FILE__;
  20. #endif
  21.  
  22. /////////////////////////////////////////////////////////////////////////////
  23. // Diagnostic Output
  24. #ifdef _DEBUG
  25. CDumpContext& AFXAPI operator<<(CDumpContext& dc, SIZE size)
  26. {
  27.     return dc << "(" << size.cx << " x " << size.cy << ")";
  28. }
  29.  
  30. CDumpContext& AFXAPI operator<<(CDumpContext& dc, POINT point)
  31. {
  32.     return dc << "(" << point.x << ", " << point.y << ")";
  33. }
  34.  
  35. CDumpContext& AFXAPI operator<<(CDumpContext& dc, const RECT& rect)
  36. {
  37.     return dc << "(L " << rect.left << ", T " << rect.top << ", R " <<
  38.         rect.right << ", B " << rect.bottom << ")";
  39. }
  40. #endif //_DEBUG
  41.  
  42. /////////////////////////////////////////////////////////////////////////////
  43. // CDC
  44.  
  45. CDC::CDC()
  46. {
  47.     m_hDC = NULL;
  48.     m_hAttribDC = NULL;
  49. #if !defined(_WIN32_WCE_NO_PRINTING)
  50.     m_bPrinting = FALSE;
  51. #endif // _WIN32_WCE_NO_PRINTING
  52. #if defined(_WIN32_WCE)
  53.     m_ptCurPos.x = 0;
  54.     m_ptCurPos.y = 0;
  55. #endif // _WIN32_WCE
  56. }
  57.  
  58. #ifdef _DEBUG
  59. void CDC::AssertValid() const
  60. {
  61.     CObject::AssertValid();
  62. }
  63.  
  64. void CDC::Dump(CDumpContext& dc) const
  65. {
  66.     CObject::Dump(dc);
  67.  
  68.     dc << "m_hDC = " << (UINT)m_hDC;
  69.     dc << "\nm_hAttribDC = " << (UINT)m_hAttribDC;
  70. #if !defined(_WIN32_WCE_NO_PRINTING)
  71.     dc << "\nm_bPrinting = " << m_bPrinting;
  72. #endif // _WIN32_WCE_NO_PRINTING
  73.  
  74.     dc << "\n";
  75. }
  76. #endif //_DEBUG
  77.  
  78. #if !defined(_WIN32_WCE)
  79. #include "fixalloc.h"
  80.  
  81. class CTempDC : public CDC
  82. {
  83.     DECLARE_DYNCREATE(CTempDC)
  84.     DECLARE_FIXED_ALLOC(CTempDC);
  85. };
  86. #endif // _WIN32_WCE
  87.  
  88. CHandleMap* PASCAL afxMapHDC(BOOL bCreate)
  89. {
  90.     AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
  91.     if (pState->m_pmapHDC == NULL && bCreate)
  92.     {
  93.         BOOL bEnable = AfxEnableMemoryTracking(FALSE);
  94. #ifndef _AFX_PORTABLE
  95.         _PNH pnhOldHandler = AfxSetNewHandler(&AfxCriticalNewHandler);
  96. #endif
  97.         pState->m_pmapHDC = new CHandleMap(WCE_IF(RUNTIME_CLASS(CDC),RUNTIME_CLASS(CTempDC)),
  98.             offsetof(CDC, m_hDC), 2);
  99.  
  100. #ifndef _AFX_PORTABLE
  101.         AfxSetNewHandler(pnhOldHandler);
  102. #endif
  103.         AfxEnableMemoryTracking(bEnable);
  104.     }
  105.     return pState->m_pmapHDC;
  106. }
  107.  
  108. CDC* PASCAL CDC::FromHandle(HDC hDC)
  109. {
  110.     CHandleMap* pMap = afxMapHDC(TRUE); //create map if not exist
  111.     ASSERT(pMap != NULL);
  112.     CDC* pDC = (CDC*)pMap->FromHandle(hDC);
  113.     ASSERT(pDC == NULL || pDC->m_hDC == hDC);
  114.     return pDC;
  115. }
  116.  
  117. BOOL CDC::Attach(HDC hDC)
  118. {
  119.     ASSERT(m_hDC == NULL);      // only attach once, detach on destroy
  120.     ASSERT(m_hAttribDC == NULL);    // only attach to an empty DC
  121.  
  122.     if (hDC == NULL)
  123.         return FALSE;
  124.     CHandleMap* pMap = afxMapHDC(TRUE); // create map if not exist
  125.     ASSERT(pMap != NULL);
  126.     pMap->SetPermanent(m_hDC = hDC, this);
  127.  
  128.     SetAttribDC(m_hDC);     // Default to same as output
  129.     return TRUE;
  130. }
  131.  
  132. HDC CDC::Detach()
  133. {
  134.     HDC hDC = m_hDC;
  135.     if (hDC != NULL)
  136.     {
  137.         CHandleMap* pMap = afxMapHDC(); // don't create if not exist
  138.         if (pMap != NULL)
  139.             pMap->RemoveHandle(m_hDC);
  140.     }
  141.  
  142.     ReleaseAttribDC();
  143.     m_hDC = NULL;
  144.     return hDC;
  145. }
  146.  
  147. BOOL CDC::DeleteDC()
  148. {
  149.     if (m_hDC == NULL)
  150.         return FALSE;
  151.  
  152.     return ::DeleteDC(Detach());
  153. }
  154.  
  155. CDC::~CDC()
  156. {
  157.     if (m_hDC != NULL)
  158.         ::DeleteDC(Detach());
  159. }
  160.  
  161.  
  162. void CDC::SetAttribDC(HDC hDC)  // Set the Attribute DC
  163. {
  164.     m_hAttribDC = hDC;
  165. }
  166.  
  167. void CDC::SetOutputDC(HDC hDC)  // Set the Output DC
  168. {
  169. #ifdef _DEBUG
  170.     CHandleMap* pMap = afxMapHDC();
  171.     if (pMap != NULL && pMap->LookupPermanent(m_hDC) == this)
  172.     {
  173.         TRACE0("Cannot Set Output hDC on Attached CDC.\n");
  174.         ASSERT(FALSE);
  175.     }
  176. #endif
  177.     m_hDC = hDC;
  178. }
  179.  
  180. void CDC::ReleaseAttribDC()     // Release the Attribute DC
  181. {
  182.     m_hAttribDC = NULL;
  183. }
  184.  
  185. void CDC::ReleaseOutputDC()     // Release the Output DC
  186. {
  187. #ifdef _DEBUG
  188.     CHandleMap* pMap = afxMapHDC();
  189.     if (pMap != NULL && pMap->LookupPermanent(m_hDC) == this)
  190.     {
  191.         TRACE0("Cannot Release Output hDC on Attached CDC.\n");
  192.         ASSERT(FALSE);
  193.     }
  194. #endif
  195.     m_hDC = NULL;
  196. }
  197.  
  198. /////////////////////////////////////////////////////////////////////////////
  199. // Out-of-line routines
  200.  
  201. #if !defined(_WIN32_WCE_NO_PRINTING)
  202. int CDC::StartDoc(LPCTSTR lpszDocName)
  203. {
  204.     DOCINFO di;
  205.     memset(&di, 0, sizeof(DOCINFO));
  206.     di.cbSize = sizeof(DOCINFO);
  207.     di.lpszDocName = lpszDocName;
  208.     return StartDoc(&di);
  209. }
  210. #endif // _WIN32_WCE_NO_PRINTING
  211.  
  212. int CDC::SaveDC()
  213. {
  214.     ASSERT(m_hDC != NULL);
  215.     int nRetVal = 0;
  216.     if (m_hAttribDC != NULL)
  217.         nRetVal = ::SaveDC(m_hAttribDC);
  218.     if (m_hDC != m_hAttribDC && ::SaveDC(m_hDC) != 0)
  219.         nRetVal = -1;   // -1 is the only valid restore value for complex DCs
  220.     return nRetVal;
  221. }
  222.  
  223. BOOL CDC::RestoreDC(int nSavedDC)
  224. {
  225.     // if two distinct DCs, nSavedDC can only be -1
  226.     ASSERT(m_hDC != NULL);
  227.     ASSERT(m_hDC == m_hAttribDC || nSavedDC == -1);
  228.  
  229.     BOOL bRetVal = TRUE;
  230.     if (m_hDC != m_hAttribDC)
  231.         bRetVal = ::RestoreDC(m_hDC, nSavedDC);
  232.     if (m_hAttribDC != NULL)
  233.         bRetVal = (bRetVal && ::RestoreDC(m_hAttribDC, nSavedDC));
  234.     return bRetVal;
  235. }
  236.  
  237. CGdiObject* PASCAL CDC::SelectGdiObject(HDC hDC, HGDIOBJ h)
  238. {
  239.     return CGdiObject::FromHandle(::SelectObject(hDC, h));
  240. }
  241.  
  242. CGdiObject* CDC::SelectStockObject(int nIndex)
  243. {
  244.     ASSERT(m_hDC != NULL);
  245.  
  246.     HGDIOBJ hObject = ::GetStockObject(nIndex);
  247.     HGDIOBJ hOldObj = NULL;
  248.  
  249.     ASSERT(hObject != NULL);
  250.     if (m_hDC != m_hAttribDC)
  251.         hOldObj = ::SelectObject(m_hDC, hObject);
  252.     if (m_hAttribDC != NULL)
  253.         hOldObj = ::SelectObject(m_hAttribDC, hObject);
  254.     return CGdiObject::FromHandle(hOldObj);
  255. }
  256.  
  257. CPen* CDC::SelectObject(CPen* pPen)
  258. {
  259.     ASSERT(m_hDC != NULL);
  260.     HGDIOBJ hOldObj = NULL;
  261.  
  262.     if (m_hDC != m_hAttribDC)
  263.         hOldObj = ::SelectObject(m_hDC, pPen->GetSafeHandle());
  264.     if (m_hAttribDC != NULL)
  265.         hOldObj = ::SelectObject(m_hAttribDC, pPen->GetSafeHandle());
  266.     return (CPen*)CGdiObject::FromHandle(hOldObj);
  267. }
  268.  
  269. CBrush* CDC::SelectObject(CBrush* pBrush)
  270. {
  271.     ASSERT(m_hDC != NULL);
  272.     HGDIOBJ hOldObj = NULL;
  273.  
  274.     if (m_hDC != m_hAttribDC)
  275.         hOldObj = ::SelectObject(m_hDC, pBrush->GetSafeHandle());
  276.     if (m_hAttribDC != NULL)
  277.         hOldObj = ::SelectObject(m_hAttribDC, pBrush->GetSafeHandle());
  278.     return (CBrush*)CGdiObject::FromHandle(hOldObj);
  279. }
  280.  
  281. CFont* CDC::SelectObject(CFont* pFont)
  282. {
  283.     ASSERT(m_hDC != NULL);
  284.     HGDIOBJ hOldObj = NULL;
  285.  
  286.     if (m_hDC != m_hAttribDC)
  287.         hOldObj = ::SelectObject(m_hDC, pFont->GetSafeHandle());
  288.     if (m_hAttribDC != NULL)
  289.         hOldObj = ::SelectObject(m_hAttribDC, pFont->GetSafeHandle());
  290.     return (CFont*)CGdiObject::FromHandle(hOldObj);
  291. }
  292.  
  293. int CDC::SelectObject(CRgn* pRgn)
  294. {
  295.     ASSERT(m_hDC != NULL);
  296.     int nRetVal = GDI_ERROR;
  297.  
  298.     if (m_hDC != m_hAttribDC)
  299.         nRetVal = (int)::SelectObject(m_hDC, pRgn->GetSafeHandle());
  300.     if (m_hAttribDC != NULL)
  301.         nRetVal = (int)::SelectObject(m_hAttribDC, pRgn->GetSafeHandle());
  302.     return nRetVal;
  303. }
  304.  
  305. CPalette* CDC::SelectPalette(CPalette* pPalette, BOOL bForceBackground)
  306. {
  307.     ASSERT(m_hDC != NULL);
  308.  
  309.     return (CPalette*) CGdiObject::FromHandle(::SelectPalette(m_hDC,
  310.         (HPALETTE)pPalette->GetSafeHandle(), bForceBackground));
  311. }
  312.  
  313. COLORREF CDC::SetBkColor(COLORREF crColor)
  314. {
  315.     ASSERT(m_hDC != NULL);
  316.     COLORREF crRetVal = CLR_INVALID; 
  317.  
  318.     if (m_hDC != m_hAttribDC)
  319.         crRetVal = ::SetBkColor(m_hDC, crColor);
  320.     if (m_hAttribDC != NULL)
  321.         crRetVal = ::SetBkColor(m_hAttribDC, crColor);
  322.     return crRetVal;
  323. }
  324.  
  325. int CDC::SetBkMode(int nBkMode)
  326. {
  327.     ASSERT(m_hDC != NULL);
  328.     int nRetVal = 0;
  329.  
  330.     if (m_hDC != m_hAttribDC)
  331.         nRetVal = ::SetBkMode(m_hDC, nBkMode);
  332.     if (m_hAttribDC != NULL)
  333.         nRetVal = ::SetBkMode(m_hAttribDC, nBkMode);
  334.     return nRetVal;
  335. }
  336.  
  337. #if !defined(_WIN32_WCE)
  338. int CDC::SetPolyFillMode(int nPolyFillMode)
  339. {
  340.     ASSERT(m_hDC != NULL);
  341.     int nRetVal = 0;
  342.  
  343.     if (m_hDC != m_hAttribDC)
  344.         nRetVal = ::SetPolyFillMode(m_hDC, nPolyFillMode);
  345.     if (m_hAttribDC != NULL)
  346.         nRetVal = ::SetPolyFillMode(m_hAttribDC, nPolyFillMode);
  347.     return nRetVal;
  348. }
  349. #endif // _WIN32_WCE
  350.  
  351. int CDC::SetROP2(int nDrawMode)
  352. {
  353.     ASSERT(m_hDC != NULL);
  354.     int nRetVal = 0;
  355.  
  356.     if (m_hDC != m_hAttribDC)
  357.         nRetVal = ::SetROP2(m_hDC, nDrawMode);
  358.     if (m_hAttribDC != NULL)
  359.         nRetVal = ::SetROP2(m_hAttribDC, nDrawMode);
  360.     return nRetVal;
  361. }
  362.  
  363. #if !defined(_WIN32_WCE)
  364. int CDC::SetStretchBltMode(int nStretchMode)
  365. {
  366.     ASSERT(m_hDC != NULL);
  367.     int nRetVal = 0;
  368.  
  369.     if (m_hDC != m_hAttribDC)
  370.         nRetVal = ::SetStretchBltMode(m_hDC, nStretchMode);
  371.     if (m_hAttribDC != NULL)
  372.         nRetVal = ::SetStretchBltMode(m_hAttribDC, nStretchMode);
  373.     return nRetVal;
  374. }
  375. #endif // _WIN32_WCE
  376.  
  377. COLORREF CDC::SetTextColor(COLORREF crColor)
  378. {
  379.     ASSERT(m_hDC != NULL);
  380.     COLORREF crRetVal = CLR_INVALID;
  381.  
  382.     if (m_hDC != m_hAttribDC)
  383.         crRetVal = ::SetTextColor(m_hDC, crColor);
  384.     if (m_hAttribDC != NULL)
  385.         crRetVal = ::SetTextColor(m_hAttribDC, crColor);
  386.     return crRetVal;
  387. }
  388.  
  389. #if !defined(_WIN32_WCE_NO_GDITRANSFORM)
  390. int CDC::SetMapMode(int nMapMode)
  391. {
  392.     ASSERT(m_hDC != NULL);
  393.     int nRetVal = 0;
  394.  
  395.     if (m_hDC != m_hAttribDC)
  396.         nRetVal = ::SetMapMode(m_hDC, nMapMode);
  397.     if (m_hAttribDC != NULL)
  398.         nRetVal = ::SetMapMode(m_hAttribDC, nMapMode);
  399.     return nRetVal;
  400. }
  401.  
  402. CPoint CDC::SetViewportOrg(int x, int y)
  403. {
  404.     ASSERT(m_hDC != NULL);
  405.     CPoint point;
  406.  
  407.     if (m_hDC != m_hAttribDC)
  408.         VERIFY(::SetViewportOrgEx(m_hDC, x, y, &point));
  409.     if (m_hAttribDC != NULL)
  410.         VERIFY(::SetViewportOrgEx(m_hAttribDC, x, y, &point));
  411.     return point;
  412. }
  413.  
  414. CPoint CDC::OffsetViewportOrg(int nWidth, int nHeight)
  415. {
  416.     ASSERT(m_hDC != NULL);
  417.     CPoint point;
  418.  
  419.     if (m_hDC != m_hAttribDC)
  420.         VERIFY(::OffsetViewportOrgEx(m_hDC, nWidth, nHeight, &point));
  421.     if (m_hAttribDC != NULL)
  422.         VERIFY(::OffsetViewportOrgEx(m_hAttribDC, nWidth, nHeight, &point));
  423.     return point;
  424. }
  425.  
  426. CSize CDC::SetViewportExt(int x, int y)
  427. {
  428.     ASSERT(m_hDC != NULL);
  429.     CSize size;
  430.     
  431.     if (m_hDC != m_hAttribDC)
  432.         VERIFY(::SetViewportExtEx(m_hDC, x, y, &size));
  433.     if (m_hAttribDC != NULL)
  434.         VERIFY(::SetViewportExtEx(m_hAttribDC, x, y, &size));
  435.     return size;
  436. }
  437.  
  438. CSize CDC::ScaleViewportExt(int xNum, int xDenom, int yNum, int yDenom)
  439. {
  440.     ASSERT(m_hDC != NULL);
  441.     CSize size;
  442.  
  443.     if (m_hDC != m_hAttribDC)
  444.         VERIFY(::ScaleViewportExtEx(m_hDC, xNum, xDenom, yNum, yDenom, &size));
  445.     if (m_hAttribDC != NULL)
  446.         VERIFY(::ScaleViewportExtEx(m_hAttribDC, xNum, xDenom, yNum, yDenom, &size));
  447.     return size;
  448. }
  449.  
  450. CPoint CDC::SetWindowOrg(int x, int y)
  451. {
  452.     ASSERT(m_hDC != NULL);
  453.     CPoint point;
  454.     
  455.     if (m_hDC != m_hAttribDC)
  456.         VERIFY(::SetWindowOrgEx(m_hDC, x, y, &point));
  457.     if (m_hAttribDC != NULL)
  458.         VERIFY(::SetWindowOrgEx(m_hAttribDC, x, y, &point));
  459.     return point;
  460. }
  461.  
  462. CPoint CDC::OffsetWindowOrg(int nWidth, int nHeight)
  463. {
  464.     ASSERT(m_hDC != NULL);
  465.     CPoint point;
  466.  
  467.     if (m_hDC != m_hAttribDC)
  468.         VERIFY(::OffsetWindowOrgEx(m_hDC, nWidth, nHeight, &point));
  469.     if (m_hAttribDC != NULL)
  470.         VERIFY(::OffsetWindowOrgEx(m_hAttribDC, nWidth, nHeight, &point));
  471.     return point;
  472. }
  473.  
  474. CSize CDC::SetWindowExt(int x, int y)
  475. {
  476.     ASSERT(m_hDC != NULL);
  477.     CSize size;
  478.  
  479.     if (m_hDC != m_hAttribDC)
  480.         VERIFY(::SetWindowExtEx(m_hDC, x, y, &size));
  481.     if (m_hAttribDC != NULL)
  482.         VERIFY(::SetWindowExtEx(m_hAttribDC, x, y, &size));
  483.     return size;
  484. }
  485.  
  486. CSize CDC::ScaleWindowExt(int xNum, int xDenom, int yNum, int yDenom)
  487. {
  488.     ASSERT(m_hDC != NULL);
  489.     CSize size;
  490.  
  491.     if (m_hDC != m_hAttribDC)
  492.         VERIFY(::ScaleWindowExtEx(m_hDC, xNum, xDenom, yNum, yDenom, &size));
  493.     if (m_hAttribDC != NULL)
  494.         VERIFY(::ScaleWindowExtEx(m_hAttribDC, xNum, xDenom, yNum, yDenom, &size));
  495.     return size;
  496. }
  497. #endif // _WIN32_WCE_NO_GDITRANSFORM
  498.  
  499. int CDC::GetClipBox(LPRECT lpRect) const
  500. {
  501.     ASSERT(m_hDC != NULL);
  502.     return ::GetClipBox(m_hDC, lpRect);
  503. }
  504.  
  505. int CDC::SelectClipRgn(CRgn* pRgn)
  506. {
  507.     ASSERT(m_hDC != NULL);
  508.     int nRetVal = ERROR;
  509.  
  510.     if (m_hDC != m_hAttribDC)
  511.         nRetVal = ::SelectClipRgn(m_hDC, (HRGN)pRgn->GetSafeHandle());
  512.     if (m_hAttribDC != NULL)
  513.         nRetVal = ::SelectClipRgn(m_hAttribDC, (HRGN)pRgn->GetSafeHandle());
  514.     return nRetVal;
  515. }
  516.  
  517. int CDC::ExcludeClipRect(int x1, int y1, int x2, int y2)
  518. {
  519.     ASSERT(m_hDC != NULL);
  520.     int nRetVal = ERROR;
  521.  
  522.     if (m_hDC != m_hAttribDC)
  523.         nRetVal = ::ExcludeClipRect(m_hDC, x1, y1, x2, y2);
  524.     if (m_hAttribDC != NULL)
  525.         nRetVal = ::ExcludeClipRect(m_hAttribDC, x1, y1, x2, y2);
  526.     return nRetVal;
  527. }
  528.  
  529. int CDC::ExcludeClipRect(LPCRECT lpRect)
  530. {
  531.     ASSERT(m_hDC != NULL);
  532.     int nRetVal = ERROR;
  533.  
  534.     if (m_hDC != m_hAttribDC)
  535.         nRetVal = ::ExcludeClipRect(m_hDC, lpRect->left, lpRect->top,
  536.             lpRect->right, lpRect->bottom);
  537.     if (m_hAttribDC != NULL)
  538.         nRetVal = ::ExcludeClipRect(m_hAttribDC, lpRect->left, lpRect->top,
  539.             lpRect->right, lpRect->bottom);
  540.     return nRetVal;
  541. }
  542.  
  543. int CDC::IntersectClipRect(int x1, int y1, int x2, int y2)
  544. {
  545.     ASSERT(m_hDC != NULL);
  546.     int nRetVal = ERROR;
  547.  
  548.     if (m_hDC != m_hAttribDC)
  549.         nRetVal = ::IntersectClipRect(m_hDC, x1, y1, x2, y2);
  550.     if (m_hAttribDC != NULL)
  551.         nRetVal = ::IntersectClipRect(m_hAttribDC, x1, y1, x2, y2);
  552.     return nRetVal;
  553. }
  554.  
  555. int CDC::IntersectClipRect(LPCRECT lpRect)
  556. {
  557.     ASSERT(m_hDC != NULL);
  558.     int nRetVal = ERROR;
  559.  
  560.     if (m_hDC != m_hAttribDC)
  561.         nRetVal = ::IntersectClipRect(m_hDC, lpRect->left, lpRect->top,
  562.             lpRect->right, lpRect->bottom);
  563.     if (m_hAttribDC != NULL)
  564.         nRetVal = ::IntersectClipRect(m_hAttribDC, lpRect->left, lpRect->top,
  565.             lpRect->right, lpRect->bottom);
  566.     return nRetVal;
  567. }
  568.  
  569. int CDC::OffsetClipRgn(int x, int y)
  570. {
  571.     ASSERT(m_hDC != NULL);
  572.     int nRetVal = ERROR;
  573.  
  574.     if (m_hDC != m_hAttribDC)
  575.         nRetVal = ::WCE_FCTN(OffsetClipRgn)(m_hDC, x, y);
  576.     if (m_hAttribDC != NULL)
  577.         nRetVal = ::WCE_FCTN(OffsetClipRgn)(m_hAttribDC, x, y);
  578.     return nRetVal;
  579. }
  580.  
  581. int CDC::OffsetClipRgn(SIZE size)
  582. {
  583.     ASSERT(m_hDC != NULL);
  584.     int nRetVal = ERROR;
  585.  
  586.     if (m_hDC != m_hAttribDC)
  587.         nRetVal = ::WCE_FCTN(OffsetClipRgn)(m_hDC, size.cx, size.cy);
  588.     if (m_hAttribDC != NULL)
  589.         nRetVal = ::WCE_FCTN(OffsetClipRgn)(m_hAttribDC, size.cx, size.cy);
  590.     return nRetVal;
  591. }
  592.  
  593. #if defined(_WIN32_WCE)
  594. CPoint CDC::MoveTo(int x, int y) 
  595. { 
  596.     CPoint ptOld(m_ptCurPos); 
  597.     m_ptCurPos.x = x; 
  598.     m_ptCurPos.y = y; 
  599.     return ptOld; 
  600. } 
  601.  
  602. BOOL CDC::LineTo(int x, int y) 
  603. { 
  604.     ASSERT(m_hDC != NULL); 
  605.     CPoint ptTo(x,y); 
  606.     CPoint points[2] = { m_ptCurPos, ptTo }; 
  607.     BOOL bResult = ::Polyline(m_hDC, points, 2); 
  608.     if (bResult)  
  609.         m_ptCurPos = ptTo; 
  610.     return bResult; 
  611. } 
  612. #else // _WIN32_WCE
  613. CPoint CDC::MoveTo(int x, int y)
  614. {
  615.     ASSERT(m_hDC != NULL);
  616.     CPoint point;
  617.  
  618.     if (m_hDC != m_hAttribDC)
  619.         VERIFY(::MoveToEx(m_hDC, x, y, &point));
  620.     if (m_hAttribDC != NULL)
  621.         VERIFY(::MoveToEx(m_hAttribDC, x, y, &point));
  622.     return point;
  623. }
  624.  
  625. BOOL CDC::LineTo(int x, int y)
  626. {
  627.     ASSERT(m_hDC != NULL);
  628.     if (m_hAttribDC != NULL && m_hDC != m_hAttribDC)
  629.         ::MoveToEx(m_hAttribDC, x, y, NULL);
  630.     return ::LineTo(m_hDC, x, y);
  631. }
  632. #endif // _WIN32_WCE
  633.  
  634. #if !defined(_WIN32_WCE)
  635. UINT CDC::SetTextAlign(UINT nFlags)
  636. {
  637.     ASSERT(m_hDC != NULL);
  638.     UINT nRetVal = GDI_ERROR;
  639.  
  640.     if (m_hDC != m_hAttribDC)
  641.         ::SetTextAlign(m_hDC, nFlags);
  642.     if (m_hAttribDC != NULL)
  643.         nRetVal = ::SetTextAlign(m_hAttribDC, nFlags);
  644.     return nRetVal;
  645. }
  646.  
  647. int CDC::SetTextJustification(int nBreakExtra, int nBreakCount)
  648. {
  649.     ASSERT(m_hDC != NULL);
  650.     int nRetVal = 0;
  651.  
  652.     if (m_hDC != m_hAttribDC)
  653.         nRetVal = ::SetTextJustification(m_hDC, nBreakExtra, nBreakCount);
  654.     if (m_hAttribDC != NULL)
  655.         nRetVal = ::SetTextJustification(m_hAttribDC, nBreakExtra, nBreakCount);
  656.     return nRetVal;
  657. }
  658.  
  659. int CDC::SetTextCharacterExtra(int nCharExtra)
  660. {
  661.     ASSERT(m_hDC != NULL);
  662.     int nRetVal = 0x8000000;
  663.     if (m_hDC != m_hAttribDC)
  664.         nRetVal = ::SetTextCharacterExtra(m_hDC, nCharExtra);
  665.     if (m_hAttribDC != NULL)
  666.         nRetVal = ::SetTextCharacterExtra(m_hAttribDC, nCharExtra);
  667.     return nRetVal;
  668. }
  669.  
  670. DWORD CDC::SetMapperFlags(DWORD dwFlag)
  671. {
  672.     ASSERT(m_hDC != NULL);
  673.     DWORD dwRetVal = GDI_ERROR;
  674.     if (m_hDC != m_hAttribDC)
  675.         dwRetVal = ::SetMapperFlags(m_hDC, dwFlag);
  676.     if (m_hAttribDC != NULL)
  677.         dwRetVal = ::SetMapperFlags(m_hAttribDC, dwFlag);
  678.     return dwRetVal;
  679. }
  680.  
  681. typedef DWORD (CALLBACK* AFX_GDIGETLAYOUTPROC)(HDC);
  682. typedef DWORD (CALLBACK* AFX_GDISETLAYOUTPROC)(HDC, DWORD);
  683.  
  684. DWORD CDC::GetLayout() const
  685. {
  686.     ASSERT(m_hDC != NULL);
  687.  
  688.     HINSTANCE hInst = ::GetModuleHandleA("GDI32.DLL");
  689.     ASSERT(hInst != NULL);
  690.  
  691.     DWORD dwGetLayout = LAYOUT_LTR;
  692.  
  693.     AFX_GDIGETLAYOUTPROC pfn;
  694.     pfn = (AFX_GDIGETLAYOUTPROC) GetProcAddress(hInst, "GetLayout");
  695.     
  696.     if (pfn != NULL)
  697.         dwGetLayout = (*pfn)(m_hDC);
  698.     
  699.     return dwGetLayout;
  700. }
  701.  
  702. DWORD CDC::SetLayout(DWORD dwSetLayout)
  703. {
  704.     ASSERT(m_hDC != NULL);
  705.  
  706.     HINSTANCE hInst = ::GetModuleHandleA("GDI32.DLL");
  707.     ASSERT(hInst != NULL);
  708.  
  709.     DWORD dwGetLayout = LAYOUT_LTR;
  710.  
  711.     AFX_GDISETLAYOUTPROC pfn;
  712.     pfn = (AFX_GDISETLAYOUTPROC) GetProcAddress(hInst, "SetLayout");
  713.     
  714.     if (pfn != NULL)
  715.         dwGetLayout = (*pfn)(m_hDC, dwSetLayout);
  716.     else if (dwSetLayout == 0)
  717.     {
  718.         dwGetLayout = GDI_ERROR;
  719.         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  720.     }
  721.     
  722.     return dwGetLayout;
  723. }
  724. #endif // _WIN32_WCE
  725.  
  726. /////////////////////////////////////////////////////////////////////////////
  727. // Advanced Win32 GDI functions
  728.  
  729. #if !defined(_WIN32_WCE) 
  730. BOOL CDC::ArcTo(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
  731. {
  732.     ASSERT(m_hDC != NULL);
  733.     BOOL bResult = ::ArcTo(m_hDC, x1, y1, x2, y2, x3, y3, x4, y4);
  734.     if (m_hDC != m_hAttribDC)
  735.     {
  736.         CPoint pt;
  737.         VERIFY(::GetCurrentPositionEx(m_hDC, &pt));
  738.         VERIFY(::MoveToEx(m_hAttribDC, pt.x, pt.y, NULL));
  739.     }
  740.     return bResult;
  741. }
  742.  
  743. int CDC::SetArcDirection(int nArcDirection)
  744. {
  745.     ASSERT(m_hDC != NULL);
  746.     int nResult = 0;
  747.     if (m_hDC != m_hAttribDC)
  748.         nResult = ::SetArcDirection(m_hDC, nArcDirection);
  749.     if (m_hAttribDC != NULL)
  750.         nResult = ::SetArcDirection(m_hAttribDC, nArcDirection);
  751.     return nResult;
  752. }
  753.  
  754. BOOL CDC::PolyDraw(const POINT* lpPoints, const BYTE* lpTypes, int nCount)
  755. {
  756.     ASSERT(m_hDC != NULL);
  757.     BOOL bResult = ::PolyDraw(m_hDC, lpPoints, lpTypes, nCount);
  758.     if (m_hDC != m_hAttribDC)
  759.     {
  760.         CPoint pt;
  761.         VERIFY(::GetCurrentPositionEx(m_hDC, &pt));
  762.         VERIFY(::MoveToEx(m_hAttribDC, pt.x, pt.y, NULL));
  763.     }
  764.     return bResult;
  765. }
  766. #endif // _WIN32_WCE
  767.  
  768. #if defined(_WIN32_WCE)
  769. BOOL CDC::PolylineTo(const POINT* lpPoints, int nCount)
  770. {
  771.     ASSERT(m_hDC != NULL);
  772.     CPoint firstSeg[2] = { m_ptCurPos, lpPoints[0] };
  773.     BOOL bResult = ::Polyline(m_hDC, firstSeg, 2);
  774.     if (bResult) 
  775.     {
  776.         bResult = ::Polyline(m_hDC, lpPoints, nCount);
  777.         if (bResult) 
  778.             m_ptCurPos = lpPoints[nCount-1];
  779.     }
  780.     return bResult;
  781. }
  782. #else // _WIN32_WCE
  783. BOOL CDC::PolylineTo(const POINT* lpPoints, int nCount)
  784. {
  785.     ASSERT(m_hDC != NULL);
  786.     BOOL bResult = ::PolylineTo(m_hDC, lpPoints, nCount);
  787.     if (m_hDC != m_hAttribDC)
  788.     {
  789.         CPoint pt;
  790.         VERIFY(::GetCurrentPositionEx(m_hDC, &pt));
  791.         VERIFY(::MoveToEx(m_hAttribDC, pt.x, pt.y, NULL));
  792.     }
  793.     return bResult;
  794. }
  795. #endif // _WIN32_WCE
  796.  
  797. #if !defined(_WIN32_WCE)
  798. BOOL CDC::SetColorAdjustment(const COLORADJUSTMENT* lpColorAdjust)
  799. {
  800.     ASSERT(m_hDC != NULL);
  801.     BOOL bResult = FALSE;
  802.     if (m_hDC != m_hAttribDC)
  803.         bResult = ::SetColorAdjustment(m_hDC, lpColorAdjust);
  804.     if (m_hAttribDC != NULL)
  805.         bResult = ::SetColorAdjustment(m_hAttribDC, lpColorAdjust);
  806.     return bResult;
  807. }
  808.  
  809. BOOL CDC::PolyBezierTo(const POINT* lpPoints, int nCount)
  810. {
  811.     ASSERT(m_hDC != NULL);
  812.     BOOL bResult = ::PolyBezierTo(m_hDC, lpPoints, nCount);
  813.     if (m_hDC != m_hAttribDC)
  814.     {
  815.         CPoint pt;
  816.         VERIFY(::GetCurrentPositionEx(m_hDC, &pt));
  817.         VERIFY(::MoveToEx(m_hAttribDC, pt.x, pt.y, NULL));
  818.     }
  819.     return bResult;
  820. }
  821.  
  822. BOOL CDC::SelectClipPath(int nMode)
  823. {
  824.     ASSERT(m_hDC != NULL);
  825.  
  826.     // output DC always holds the current path
  827.     if (!::SelectClipPath(m_hDC, nMode))
  828.         return FALSE;
  829.  
  830.     // transfer clipping region into the attribute DC
  831.     BOOL bResult = TRUE;
  832.     if (m_hDC != m_hAttribDC)
  833.     {
  834.         HRGN hRgn = ::CreateRectRgn(0, 0, 0, 0);
  835.         if (::GetClipRgn(m_hDC, hRgn) < 0 || !::SelectClipRgn(m_hAttribDC, hRgn))
  836.         {
  837.             TRACE0("Error: unable to transfer clip region in CDC::SelectClipPath!\n");
  838.             bResult = FALSE;
  839.         }
  840.         DeleteObject(hRgn);
  841.     }
  842.     return bResult;
  843. }
  844. #endif // _WIN32_WCE
  845.  
  846. int CDC::SelectClipRgn(CRgn* pRgn, int nMode)
  847. {
  848.     ASSERT(m_hDC != NULL);
  849.     int nRetVal = ERROR;
  850.     if (m_hDC != m_hAttribDC)
  851.         nRetVal = ::WCE_FCTN(ExtSelectClipRgn)(m_hDC, (HRGN)pRgn->GetSafeHandle(), nMode);
  852.     if (m_hAttribDC != NULL)
  853.         nRetVal = ::WCE_FCTN(ExtSelectClipRgn)(m_hAttribDC, (HRGN)pRgn->GetSafeHandle(), nMode);
  854.     return nRetVal;
  855. }
  856.  
  857. /////////////////////////////////////////////////////////////////////////////
  858. // Special handling for metafile playback
  859.  
  860. #if !defined(_WIN32_WCE)
  861. int CALLBACK AfxEnumMetaFileProc(HDC hDC,
  862.     HANDLETABLE* pHandleTable, METARECORD* pMetaRec, int nHandles, LPARAM lParam)
  863. {
  864.     CDC* pDC = (CDC*)lParam;
  865.     ASSERT_VALID(pDC);
  866.  
  867.     switch (pMetaRec->rdFunction)
  868.     {
  869.     // these records have effects different for each CDC derived class
  870.     case META_SETMAPMODE:
  871.         pDC->SetMapMode((int)(short)pMetaRec->rdParm[0]);
  872.         break;
  873.     case META_SETWINDOWEXT:
  874.         pDC->SetWindowExt(
  875.             (int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
  876.         break;
  877.     case META_SETWINDOWORG:
  878.         pDC->SetWindowOrg(
  879.             (int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
  880.         break;
  881.     case META_SETVIEWPORTEXT:
  882.         pDC->SetViewportExt(
  883.             (int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
  884.         break;
  885.     case META_SETVIEWPORTORG:
  886.         pDC->SetViewportOrg(
  887.             (int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
  888.         break;
  889.     case META_SCALEWINDOWEXT:
  890.         pDC->ScaleWindowExt(
  891.             (int)(short)pMetaRec->rdParm[3], (int)(short)pMetaRec->rdParm[2],
  892.             (int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
  893.         break;
  894.     case META_SCALEVIEWPORTEXT:
  895.         pDC->ScaleViewportExt(
  896.             (int)(short)pMetaRec->rdParm[3], (int)(short)pMetaRec->rdParm[2],
  897.             (int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
  898.         break;
  899.     case META_OFFSETVIEWPORTORG:
  900.         pDC->OffsetViewportOrg(
  901.             (int)(short)pMetaRec->rdParm[1], (int)(short)pMetaRec->rdParm[0]);
  902.         break;
  903.     case META_SAVEDC:
  904.         pDC->SaveDC();
  905.         break;
  906.     case META_RESTOREDC:
  907.         pDC->RestoreDC((int)(short)pMetaRec->rdParm[0]);
  908.         break;
  909.     case META_SETBKCOLOR:
  910.         pDC->SetBkColor(*(UNALIGNED COLORREF*)&pMetaRec->rdParm[0]);
  911.         break;
  912.     case META_SETTEXTCOLOR:
  913.         pDC->SetTextColor(*(UNALIGNED COLORREF*)&pMetaRec->rdParm[0]);
  914.         break;
  915.  
  916.     // need to watch out for SelectObject(HFONT), for custom font mapping
  917.     case META_SELECTOBJECT:
  918.         {
  919.             HGDIOBJ hObject = pHandleTable->objectHandle[pMetaRec->rdParm[0]];
  920.             UINT nObjType = GetObjectType(hObject);
  921.             if (nObjType == 0)
  922.             {
  923.                 // object type is unknown, determine if it is a font
  924.                 HFONT hStockFont = (HFONT)::GetStockObject(SYSTEM_FONT);
  925.                 HFONT hFontOld = (HFONT)::SelectObject(pDC->m_hDC, hStockFont);
  926.                 HGDIOBJ hObjOld = ::SelectObject(pDC->m_hDC, hObject);
  927.                 if (hObjOld == hStockFont)
  928.                 {
  929.                     // got the stock object back, so must be selecting a font
  930.                     pDC->SelectObject(CFont::FromHandle((HFONT)hObject));
  931.                     break;  // don't play the default record
  932.                 }
  933.                 else
  934.                 {
  935.                     // didn't get the stock object back, so restore everything
  936.                     ::SelectObject(pDC->m_hDC, hFontOld);
  937.                     ::SelectObject(pDC->m_hDC, hObjOld);
  938.                 }
  939.                 // and fall through to PlayMetaFileRecord...
  940.             }
  941.             else if (nObjType == OBJ_FONT)
  942.             {
  943.                 // play back as CDC::SelectObject(CFont*)
  944.                 pDC->SelectObject(CFont::FromHandle((HFONT)hObject));
  945.                 break;  // don't play the default record
  946.             }
  947.         }
  948.         // fall through...
  949.  
  950.     default:
  951.         ::PlayMetaFileRecord(hDC, pHandleTable, pMetaRec, nHandles);
  952.         break;
  953.     }
  954.  
  955.     return 1;
  956. }
  957.  
  958. BOOL CDC::PlayMetaFile(HMETAFILE hMF)
  959. {
  960.     if (::GetDeviceCaps(m_hDC, TECHNOLOGY) == DT_METAFILE)
  961.     {
  962.         // playing metafile in metafile, just use core windows API
  963.         return ::PlayMetaFile(m_hDC, hMF);
  964.     }
  965.  
  966.     // for special playback, lParam == pDC
  967.     return ::EnumMetaFile(m_hDC, hMF, AfxEnumMetaFileProc, (LPARAM)this);
  968. }
  969. #endif // _WIN32_WCE
  970.  
  971. /////////////////////////////////////////////////////////////////////////////
  972. // Coordinate transforms
  973.  
  974. void CDC::LPtoDP(LPSIZE lpSize) const
  975. {
  976.     ASSERT(AfxIsValidAddress(lpSize, sizeof(SIZE)));
  977.  
  978.     CSize sizeWinExt = GetWindowExt();
  979.     CSize sizeVpExt = GetViewportExt();
  980.     lpSize->cx = WCE_FCTN(MulDiv)(lpSize->cx, abs(sizeVpExt.cx), abs(sizeWinExt.cx));
  981.     lpSize->cy = WCE_FCTN(MulDiv)(lpSize->cy, abs(sizeVpExt.cy), abs(sizeWinExt.cy));
  982. }
  983.  
  984. void CDC::DPtoLP(LPSIZE lpSize) const
  985. {
  986.     ASSERT(AfxIsValidAddress(lpSize, sizeof(SIZE)));
  987.  
  988.     CSize sizeWinExt = GetWindowExt();
  989.     CSize sizeVpExt = GetViewportExt();
  990.     lpSize->cx = WCE_FCTN(MulDiv)(lpSize->cx, abs(sizeWinExt.cx), abs(sizeVpExt.cx));
  991.     lpSize->cy = WCE_FCTN(MulDiv)(lpSize->cy, abs(sizeWinExt.cy), abs(sizeVpExt.cy));
  992. }
  993.  
  994. /////////////////////////////////////////////////////////////////////////////
  995. // Helper DCs
  996.  
  997. #ifdef _DEBUG
  998. void CClientDC::AssertValid() const
  999. {
  1000.     CDC::AssertValid();
  1001.     ASSERT(m_hWnd == NULL || ::IsWindow(m_hWnd));
  1002. }
  1003.  
  1004. void CClientDC::Dump(CDumpContext& dc) const
  1005. {
  1006.     CDC::Dump(dc);
  1007.  
  1008.     dc << "m_hWnd = " << (UINT)m_hWnd;
  1009.     dc << "\n";
  1010. }
  1011. #endif
  1012.  
  1013. CClientDC::CClientDC(CWnd* pWnd)
  1014. {
  1015.     ASSERT(pWnd == NULL || ::IsWindow(pWnd->m_hWnd));
  1016.  
  1017.     if (!Attach(::GetDC(m_hWnd = pWnd->GetSafeHwnd())))
  1018.         AfxThrowResourceException();
  1019. }
  1020.  
  1021. CClientDC::~CClientDC()
  1022. {
  1023.     ASSERT(m_hDC != NULL);
  1024.     ::ReleaseDC(m_hWnd, Detach());
  1025. }
  1026.  
  1027. #ifdef _DEBUG
  1028. void CWindowDC::AssertValid() const
  1029. {
  1030.     CDC::AssertValid();
  1031.     ASSERT(m_hWnd == NULL || ::IsWindow(m_hWnd));
  1032. }
  1033.  
  1034. void CWindowDC::Dump(CDumpContext& dc) const
  1035. {
  1036.     CDC::Dump(dc);
  1037.  
  1038.     dc << "m_hWnd = " << (UINT)m_hWnd;
  1039.     dc << "\n";
  1040. }
  1041. #endif
  1042.  
  1043. CWindowDC::CWindowDC(CWnd* pWnd)
  1044. {
  1045.     ASSERT(pWnd == NULL || ::IsWindow(pWnd->m_hWnd));
  1046.  
  1047.     if (!Attach(::GetWindowDC(m_hWnd = pWnd->GetSafeHwnd())))
  1048.         AfxThrowResourceException();
  1049. }
  1050.  
  1051. CWindowDC::~CWindowDC()
  1052. {
  1053.     ASSERT(m_hDC != NULL);
  1054.     ::ReleaseDC(m_hWnd, Detach());
  1055. }
  1056.  
  1057. #ifdef _DEBUG
  1058. void CPaintDC::AssertValid() const
  1059. {
  1060.     CDC::AssertValid();
  1061.     ASSERT(::IsWindow(m_hWnd));
  1062. }
  1063.  
  1064. void CPaintDC::Dump(CDumpContext& dc) const
  1065. {
  1066.     CDC::Dump(dc);
  1067.  
  1068.     dc << "m_hWnd = " << (UINT)m_hWnd;
  1069.     dc << "\nm_ps.hdc = " << (UINT)m_ps.hdc;
  1070.     dc << "\nm_ps.fErase = " << m_ps.fErase;
  1071.     dc << "\nm_ps.rcPaint = " << (CRect)m_ps.rcPaint;
  1072.  
  1073.     dc << "\n";
  1074. }
  1075. #endif
  1076.  
  1077. CPaintDC::CPaintDC(CWnd* pWnd)
  1078. {
  1079.     ASSERT_VALID(pWnd);
  1080.     ASSERT(::IsWindow(pWnd->m_hWnd));
  1081.  
  1082.     if (!Attach(::BeginPaint(m_hWnd = pWnd->m_hWnd, &m_ps)))
  1083.         AfxThrowResourceException();
  1084. }
  1085.  
  1086. CPaintDC::~CPaintDC()
  1087. {
  1088.     ASSERT(m_hDC != NULL);
  1089.     ASSERT(::IsWindow(m_hWnd));
  1090.  
  1091.     ::EndPaint(m_hWnd, &m_ps);
  1092.     Detach();
  1093. }
  1094.  
  1095. /////////////////////////////////////////////////////////////////////////////
  1096. // CGdiObject
  1097.  
  1098. #ifdef _DEBUG
  1099. void CGdiObject::Dump(CDumpContext& dc) const
  1100. {
  1101.     CObject::Dump(dc);
  1102.  
  1103.     dc << "m_hObject = " << (UINT)m_hObject;
  1104.     dc << "\n";
  1105. }
  1106.  
  1107. void CGdiObject::AssertValid() const
  1108. {
  1109.     CObject::AssertValid();
  1110.     ASSERT(m_hObject == NULL ||
  1111.         (afxData.bWin95 || ::GetObjectType(m_hObject) != 0));
  1112. }
  1113. #endif
  1114.  
  1115. #if !defined(_WIN32_WCE)
  1116. #include "fixalloc.h"
  1117.  
  1118. class CTempGdiObject : public CGdiObject
  1119. {
  1120.     DECLARE_DYNCREATE(CTempGdiObject)
  1121.     DECLARE_FIXED_ALLOC(CTempGdiObject);
  1122. };
  1123. #endif // _WIN32_WCE
  1124.  
  1125. CHandleMap* PASCAL afxMapHGDIOBJ(BOOL bCreate)
  1126. {
  1127.     AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
  1128.     if (pState->m_pmapHGDIOBJ == NULL && bCreate)
  1129.     {
  1130.         BOOL bEnable = AfxEnableMemoryTracking(FALSE);
  1131. #ifndef _AFX_PORTABLE
  1132.         _PNH pnhOldHandler = AfxSetNewHandler(&AfxCriticalNewHandler);
  1133. #endif
  1134.         pState->m_pmapHGDIOBJ = new CHandleMap(WCE_IF(RUNTIME_CLASS(CGdiObject),RUNTIME_CLASS(CTempGdiObject)),
  1135.             offsetof(CGdiObject, m_hObject));
  1136.  
  1137. #ifndef _AFX_PORTABLE
  1138.         AfxSetNewHandler(pnhOldHandler);
  1139. #endif
  1140.         AfxEnableMemoryTracking(bEnable);
  1141.     }
  1142.     return pState->m_pmapHGDIOBJ;
  1143. }
  1144.  
  1145. CGdiObject* PASCAL CGdiObject::FromHandle(HGDIOBJ h)
  1146. {
  1147.     CHandleMap* pMap = afxMapHGDIOBJ(TRUE); //create map if not exist
  1148.     ASSERT(pMap != NULL);
  1149.     CGdiObject* pObject = (CGdiObject*)pMap->FromHandle(h);
  1150.     ASSERT(pObject == NULL || pObject->m_hObject == h);
  1151.     return pObject;
  1152. }
  1153.  
  1154. BOOL CGdiObject::Attach(HGDIOBJ hObject)
  1155. {
  1156.     ASSERT(m_hObject == NULL);      // only attach once, detach on destroy
  1157.     if (hObject == NULL)
  1158.         return FALSE;
  1159.     CHandleMap* pMap = afxMapHGDIOBJ(TRUE); // create map if not exist
  1160.     ASSERT(pMap != NULL);
  1161.     pMap->SetPermanent(m_hObject = hObject, this);
  1162.     return TRUE;
  1163. }
  1164.  
  1165. HGDIOBJ CGdiObject::Detach()
  1166. {
  1167.     HGDIOBJ hObject = m_hObject;
  1168.     if (hObject != NULL)
  1169.     {
  1170.         CHandleMap* pMap = afxMapHGDIOBJ(); // don't create if not exist
  1171.         if (pMap != NULL)
  1172.             pMap->RemoveHandle(m_hObject);
  1173.     }
  1174.  
  1175.     m_hObject = NULL;
  1176.     return hObject;
  1177. }
  1178.  
  1179. BOOL CGdiObject::DeleteObject()
  1180. {
  1181.     if (m_hObject == NULL)
  1182.         return FALSE;
  1183.     return ::DeleteObject(Detach());
  1184. }
  1185.  
  1186. /////////////////////////////////////////////////////////////////////////////
  1187. // Standard GDI objects
  1188.  
  1189. /////////////////////////////////////////////////////////////////////////////
  1190. // CPen
  1191.  
  1192. CPen::CPen(int nPenStyle, int nWidth, COLORREF crColor)
  1193. {
  1194.     if (!Attach(::WCE_FCTN(CreatePen)(nPenStyle, nWidth, crColor)))
  1195.         AfxThrowResourceException();
  1196. }
  1197.  
  1198. #if !defined(_WIN32_WCE)
  1199. CPen::CPen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush,
  1200.     int nStyleCount, const DWORD* lpStyle)
  1201. {
  1202.     if (!Attach(::ExtCreatePen(nPenStyle, nWidth, pLogBrush, nStyleCount,
  1203.             lpStyle)))
  1204.         AfxThrowResourceException();
  1205. }
  1206. #endif // _WIN32_WCE
  1207.  
  1208. /////////////////////////////////////////////////////////////////////////////
  1209.  
  1210. #ifdef _DEBUG
  1211. void CPen::Dump(CDumpContext& dc) const
  1212. {
  1213.     CGdiObject::Dump(dc);
  1214.  
  1215.     if (m_hObject == NULL)
  1216.         return;
  1217.  
  1218.     if (!afxData.bWin95 && ::GetObjectType(m_hObject) != OBJ_PEN)
  1219.     {
  1220.         // not a valid object
  1221.         dc << "has ILLEGAL HPEN!";
  1222.         return;
  1223.     }
  1224.  
  1225.     LOGPEN lp;
  1226.     VERIFY(GetObject(sizeof(lp), &lp));
  1227.     dc << "lgpn.lopnStyle = " << lp.lopnStyle;
  1228.     dc << "\nlgpn.lopnWidth.x (width) = " << lp.lopnWidth.x;
  1229.     dc << "\nlgpn.lopnColor = " << (void*)lp.lopnColor;
  1230.  
  1231.     dc << "\n";
  1232. }
  1233. #endif
  1234.  
  1235. /////////////////////////////////////////////////////////////////////////////
  1236. // CBrush
  1237.  
  1238. CBrush::CBrush(COLORREF crColor)
  1239. {
  1240.     if (!Attach(::CreateSolidBrush(crColor)))
  1241.         AfxThrowResourceException();
  1242. }
  1243.  
  1244. #if !defined(_WIN32_WCE)
  1245. CBrush::CBrush(int nIndex, COLORREF crColor)
  1246. {
  1247.     if (!Attach(::CreateHatchBrush(nIndex, crColor)))
  1248.         AfxThrowResourceException();
  1249. }
  1250. #endif // _WIN32_WCE
  1251.  
  1252. CBrush::CBrush(CBitmap* pBitmap)
  1253. {
  1254.     ASSERT_VALID(pBitmap);
  1255.  
  1256.     if (!Attach(::CreatePatternBrush((HBITMAP)pBitmap->m_hObject)))
  1257.         AfxThrowResourceException();
  1258. }
  1259.  
  1260. BOOL CBrush::CreateDIBPatternBrush(HGLOBAL hPackedDIB, UINT nUsage)
  1261. {
  1262.     ASSERT(hPackedDIB != NULL);
  1263.     const void* lpPackedDIB = ::WCE_FCTN(GlobalLock)(hPackedDIB);
  1264.     ASSERT(lpPackedDIB != NULL);
  1265.     BOOL bResult = Attach(::CreateDIBPatternBrushPt(lpPackedDIB, nUsage));
  1266.     ::WCE_FCTN(GlobalUnlock)(hPackedDIB);
  1267.     return bResult;
  1268. }
  1269.  
  1270. #ifdef _DEBUG
  1271. void CBrush::Dump(CDumpContext& dc) const
  1272. {
  1273.     CGdiObject::Dump(dc);
  1274.  
  1275.     if (m_hObject == NULL)
  1276.         return;
  1277.  
  1278.     if (!afxData.bWin95 && ::GetObjectType(m_hObject) != OBJ_BRUSH)
  1279.     {
  1280.         // not a valid window
  1281.         dc << "has ILLEGAL HBRUSH!";
  1282.         return;
  1283.     }
  1284.  
  1285.     LOGBRUSH lb;
  1286.     VERIFY(GetObject(sizeof(lb), &lb));
  1287.     dc << "lb.lbStyle = " << lb.lbStyle;
  1288.     dc << "\nlb.lbHatch = " << lb.lbHatch;
  1289.     dc << "\nlb.lbColor = " << (void*)lb.lbColor;
  1290.  
  1291.     dc << "\n";
  1292. }
  1293. #endif
  1294.  
  1295. /////////////////////////////////////////////////////////////////////////////
  1296.  
  1297. #ifdef _DEBUG
  1298. void CFont::Dump(CDumpContext& dc) const
  1299. {
  1300.     CGdiObject::Dump(dc);
  1301.  
  1302.     if (m_hObject == NULL)
  1303.         return;
  1304.  
  1305.     if (!afxData.bWin95 && ::GetObjectType(m_hObject) != OBJ_FONT)
  1306.     {
  1307.         // not a valid GDI object
  1308.         dc << "has ILLEGAL HFONT!";
  1309.         return;
  1310.     }
  1311.  
  1312.     LOGFONT lf;
  1313.     VERIFY(GetObject(sizeof(lf), &lf));
  1314.     dc << "lf.lfHeight = " << lf.lfHeight;
  1315.     dc << "\nlf.lfWidth = " << lf.lfWidth;
  1316.     dc << "\nlf.lfEscapement = " << lf.lfEscapement;
  1317.     dc << "\nlf.lfOrientation = " << lf.lfOrientation;
  1318.     dc << "\nlf.lfWeight = " << lf.lfWeight;
  1319.     dc << "\nlf.lfItalic = " << (int)lf.lfItalic;
  1320.     dc << "\nlf.lfUnderline = " << (int)lf.lfUnderline;
  1321.     dc << "\nlf.lfStrikeOut = " << (int)lf.lfStrikeOut;
  1322.     dc << "\nlf.lfCharSet = " << (int)lf.lfCharSet;
  1323.     dc << "\nlf.lfOutPrecision = " << (int)lf.lfOutPrecision;
  1324.     dc << "\nlf.lfClipPrecision = " << (int)lf.lfClipPrecision;
  1325.     dc << "\nlf.lfQuality = " << (int)lf.lfQuality;
  1326.     dc << "\nlf.lfPitchAndFamily = " << (int)lf.lfPitchAndFamily;
  1327.     dc << "\nlf.lfFaceName = " << (LPCTSTR)lf.lfFaceName;
  1328.  
  1329.     dc << "\n";
  1330. }
  1331. #endif
  1332.  
  1333. /////////////////////////////////////////////////////////////////////////////
  1334.  
  1335. #ifdef _DEBUG
  1336. void CBitmap::Dump(CDumpContext& dc) const
  1337. {
  1338.     CGdiObject::Dump(dc);
  1339.  
  1340.     if (m_hObject == NULL)
  1341.         return;
  1342.  
  1343.     if (!afxData.bWin95 && ::GetObjectType(m_hObject) != OBJ_BITMAP)
  1344.     {
  1345.         // not a valid object
  1346.         dc << "has ILLEGAL HBITMAP!";
  1347.         return;
  1348.     }
  1349.  
  1350.     BITMAP bm;
  1351.     VERIFY(GetObject(sizeof(bm), &bm));
  1352.     dc << "bm.bmType = " << bm.bmType;
  1353.     dc << "\nbm.bmHeight = " << bm.bmHeight;
  1354.     dc << "\nbm.bmWidth = " << bm.bmWidth;
  1355.     dc << "\nbm.bmWidthBytes = " << bm.bmWidthBytes;
  1356.     dc << "\nbm.bmPlanes = " << bm.bmPlanes;
  1357.     dc << "\nbm.bmBitsPixel = " << bm.bmBitsPixel;
  1358.  
  1359.     dc << "\n";
  1360. }
  1361. #endif
  1362.  
  1363. #ifdef AFX_INIT_SEG
  1364. #pragma code_seg(AFX_INIT_SEG)
  1365. #endif
  1366.  
  1367. IMPLEMENT_DYNAMIC(CResourceException, CException)
  1368. CResourceException _simpleResourceException(FALSE, AFX_IDS_RESOURCE_EXCEPTION);
  1369.  
  1370. IMPLEMENT_DYNAMIC(CUserException, CException)
  1371. CUserException _simpleUserException(FALSE, AFX_IDS_USER_EXCEPTION);
  1372.  
  1373. IMPLEMENT_DYNCREATE(CDC, CObject)
  1374. IMPLEMENT_DYNAMIC(CClientDC, CDC)
  1375. IMPLEMENT_DYNAMIC(CWindowDC, CDC)
  1376. IMPLEMENT_DYNAMIC(CPaintDC, CDC)
  1377. IMPLEMENT_DYNCREATE(CGdiObject, CObject)
  1378.  
  1379. IMPLEMENT_DYNAMIC(CPen, CGdiObject)
  1380. IMPLEMENT_DYNAMIC(CBrush, CGdiObject)
  1381. IMPLEMENT_DYNAMIC(CFont, CGdiObject)
  1382. IMPLEMENT_DYNAMIC(CBitmap, CGdiObject)
  1383. IMPLEMENT_DYNAMIC(CPalette, CGdiObject)
  1384. IMPLEMENT_DYNAMIC(CRgn, CGdiObject)
  1385.  
  1386. #if !defined(_WIN32_WCE)
  1387. IMPLEMENT_DYNCREATE(CTempDC, CDC);
  1388.  
  1389. IMPLEMENT_DYNCREATE(CTempGdiObject, CGdiObject);
  1390. #endif // _WIN32_WCE
  1391.  
  1392. /////////////////////////////////////////////////////////////////////////////
  1393. // Standard exception processing
  1394.  
  1395. #ifdef AFX_CORE2_SEG
  1396. #pragma code_seg(AFX_CORE2_SEG)
  1397. #endif
  1398.  
  1399. // resource failure
  1400. void AFXAPI AfxThrowResourceException()
  1401. {
  1402.     THROW((CResourceException*)&_simpleResourceException);
  1403. }
  1404.  
  1405. // user alert
  1406. void AFXAPI AfxThrowUserException()
  1407. {
  1408.     THROW((CUserException*)&_simpleUserException);
  1409. }
  1410.  
  1411. #ifdef AFX_INIT_SEG
  1412. #pragma code_seg(AFX_INIT_SEG)
  1413. #endif
  1414.  
  1415. #if !defined(_WIN32_WCE)
  1416. #pragma warning(disable: 4074)
  1417. #pragma init_seg(compiler)
  1418. IMPLEMENT_FIXED_ALLOC(CTempDC, 64);
  1419. IMPLEMENT_FIXED_ALLOC(CTempGdiObject, 64);
  1420. #endif // _WIN32_WCE
  1421.  
  1422. /////////////////////////////////////////////////////////////////////////////
  1423.