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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPDrawHelpers.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：49k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPDrawHelpers.cpp：源码内容
  1. // XTPDrawHelpers.cpp: implementation of the CXTPDrawHelpers class.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "resource.h"
  24. #include "XTPSystemHelpers.h"
  25. #include "XTPColorManager.h"
  26. #include "XTPDrawHelpers.h"
  27. #include "XTPVC50Helpers.h"
  28. #include "XTPResourceManager.h"
  30. #ifdef _DEBUG
  31. #undef THIS_FILE
  32. static char THIS_FILE[] = __FILE__;
  33. #define new DEBUG_NEW
  34. #endif
  36. HHOOK CXTPMouseMonitor::m_hHookMouse = 0;
  37. CWnd* CXTPMouseMonitor::m_pWndMonitor = 0;
  39. //////////////////////////////////////////////////////////////////////////
  40. // CXTPMouseMonitor
  41. //////////////////////////////////////////////////////////////////////////
  43. void CXTPMouseMonitor::SetupHook(CWnd* pWndMonitor)
  44. {
  45. if (pWndMonitor && m_hHookMouse == 0)
  46. {
  47. m_hHookMouse = SetWindowsHookEx(WH_MOUSE, MouseProc, 0, GetCurrentThreadId ());
  48. }
  49. if (!pWndMonitor && m_hHookMouse)
  50. {
  51. UnhookWindowsHookEx(m_hHookMouse);
  52. m_hHookMouse = 0;
  53. }
  54. m_pWndMonitor = pWndMonitor;
  55. }
  57. BOOL CXTPMouseMonitor::IsMouseHooked()
  58. {
  59. return m_pWndMonitor != NULL;
  60. }
  62. LRESULT CALLBACK CXTPMouseMonitor::MouseProc(int nCode, WPARAM wParam, LPARAM lParam)
  63. {
  64. if (nCode != HC_ACTION || !m_pWndMonitor)
  65. return CallNextHookEx(m_hHookMouse, nCode, wParam, lParam);
  67. CXTPWindowRect rc(m_pWndMonitor);
  69. if (!rc.PtInRect(((PMOUSEHOOKSTRUCT)lParam)->pt))
  70. {
  71. switch (wParam)
  72. {
  73. case WM_LBUTTONDOWN:
  74. case WM_NCLBUTTONDOWN:
  75. case WM_RBUTTONDOWN:
  76. case WM_NCRBUTTONDOWN:
  77. case WM_MBUTTONDOWN:
  78. case WM_NCMBUTTONDOWN:
  79. m_pWndMonitor->GetOwner()->SetFocus();
  80. return TRUE;
  81. }
  82. }
  84. return CallNextHookEx(m_hHookMouse, nCode, wParam, lParam);
  85. }
  88. //===========================================================================
  89. // CXTPClientCursorPos class
  90. //===========================================================================
  92. CXTPTransparentBitmap::CXTPTransparentBitmap(HBITMAP hBitmap)
  93. : m_hBitmap(hBitmap)
  94. {
  95. }
  97. // Not foolproof, but works 99% of the time :).  Assumes the top
  98. // left pixel is the transparent color.
  100. COLORREF CXTPTransparentBitmap::GetTransparentColor() const
  101. {
  102. CBitmap* pBitmap = CBitmap::FromHandle(m_hBitmap);
  103. if (pBitmap != NULL)
  104. {
  105. CXTPCompatibleDC dc(NULL, pBitmap);
  106. return dc.GetPixel(0, 0);
  107. }
  108. return (COLORREF)-1;
  109. }
  112. HICON CXTPTransparentBitmap::ConvertToIcon() const
  113. {
  114. if (m_hBitmap == NULL)
  115. return NULL;
  117. COLORREF crTransparent = GetTransparentColor();
  119. BITMAP bmp;
  120. if (!::GetObject(m_hBitmap, sizeof(BITMAP), &bmp))
  121. return NULL;
  123. if (bmp.bmHeight == 0 || bmp.bmWidth == 0)
  124. return NULL;
  126. CImageList il;
  127. il.Create(bmp.bmWidth, bmp.bmHeight, ILC_COLOR24 | ILC_MASK, 0, 1);
  128. il.Add(CBitmap::FromHandle(m_hBitmap), crTransparent);
  130. ASSERT(il.GetImageCount() == 1);
  132. return il.ExtractIcon(0);
  133. }
  135. //===========================================================================
  136. // CXTPClientCursorPos class
  137. //===========================================================================
  139. CXTPClientCursorPos::CXTPClientCursorPos(CWnd* pWnd)
  140. {
  141. GetCursorPos(this);
  142. pWnd->ScreenToClient(this);
  143. }
  145. //===========================================================================
  146. // CXTPEmptySize class
  147. //===========================================================================
  149. CXTPEmptySize::CXTPEmptySize()
  150. {
  151. SetSizeEmpty();
  152. }
  154. void CXTPEmptySize::SetSizeEmpty()
  155. {
  156. cx = 0;
  157. cy = 0;
  158. }
  160. const SIZE& CXTPEmptySize::operator=(const SIZE& srcSize)
  161. {
  162. cx = srcSize.cx;
  163. cy = srcSize.cy;
  164. return *this;
  165. }
  167. //===========================================================================
  168. // CXTPEmptyRect class
  169. //===========================================================================
  171. CXTPEmptyRect::CXTPEmptyRect()
  172. {
  173. SetRectEmpty();
  174. }
  176. //===========================================================================
  177. // CXTPWindowRect class
  178. //===========================================================================
  180. CXTPWindowRect::CXTPWindowRect(HWND hWnd)
  181. {
  182. if (::IsWindow(hWnd))
  183. ::GetWindowRect(hWnd, this);
  184. else
  185. SetRectEmpty();
  186. }
  188. CXTPWindowRect::CXTPWindowRect(const CWnd* pWnd)
  189. {
  190. if (::IsWindow(pWnd->GetSafeHwnd()))
  191. ::GetWindowRect(pWnd->GetSafeHwnd(), this);
  192. else
  193. SetRectEmpty();
  194. }
  196. //===========================================================================
  197. // CXTPClientRect class
  198. //===========================================================================
  200. CXTPClientRect::CXTPClientRect(HWND hWnd)
  201. {
  202. if (::IsWindow(hWnd))
  203. ::GetClientRect(hWnd, this);
  204. else
  205. SetRectEmpty();
  206. }
  208. CXTPClientRect::CXTPClientRect(const CWnd* pWnd)
  209. {
  210. if (::IsWindow(pWnd->GetSafeHwnd()))
  211. ::GetClientRect(pWnd->GetSafeHwnd(), this);
  212. else
  213. SetRectEmpty();
  214. }
  216. //===========================================================================
  217. // CXTPBufferDC class
  218. //===========================================================================
  220. CXTPBufferDC::CXTPBufferDC(HDC hDestDC, const CRect& rcPaint) : m_hDestDC (hDestDC)
  221. {
  222. m_rect = rcPaint;
  223. Attach (::CreateCompatibleDC (m_hDestDC));
  224. if (!m_hDC)
  225. return;
  227. m_bitmap.Attach (::CreateCompatibleBitmap(
  228. m_hDestDC, m_rect.right, m_rect.bottom));
  229. m_hOldBitmap = ::SelectObject (m_hDC, m_bitmap);
  230. }
  232. CXTPBufferDC::CXTPBufferDC(CPaintDC& paintDC)
  233. {
  234. m_hDestDC = paintDC.GetSafeHdc();
  235. m_rect = paintDC.m_ps.rcPaint;
  237. Attach (::CreateCompatibleDC (m_hDestDC));
  238. if (!m_hDC)
  239. return;
  241. m_bitmap.Attach (::CreateCompatibleBitmap(
  242. m_hDestDC, max(1, m_rect.right), max(1, m_rect.bottom)));
  243. m_hOldBitmap = ::SelectObject (m_hDC, m_bitmap);
  245. CRgn rgn;
  246. rgn.CreateRectRgnIndirect(&m_rect);
  248. SelectClipRgn(&rgn);
  249. }
  251. CXTPBufferDC::~CXTPBufferDC()
  252. {
  253. if (!m_hDC)
  254. return;
  256. if (m_hDestDC)
  257. {
  258. ::BitBlt (m_hDestDC, m_rect.left, m_rect.top, m_rect.Width(),
  259. m_rect.Height(), m_hDC, m_rect.left, m_rect.top, SRCCOPY);
  260. }
  261. ::SelectObject (m_hDC, m_hOldBitmap);
  262. }
  263. void CXTPBufferDC::Discard()
  264. {
  265. m_hDestDC = 0;
  266. }
  268. CDC* CXTPBufferDC::GetDestDC()
  269. {
  270. return CDC::FromHandle(m_hDestDC);
  271. }
  273. //===========================================================================
  274. // CXTPBufferDC class
  275. //===========================================================================
  277. CXTPBufferDCEx::CXTPBufferDCEx(HDC hDestDC, const CRect rcPaint) : m_hDestDC (hDestDC)
  278. {
  279. m_rect = rcPaint;
  280. Attach (::CreateCompatibleDC (m_hDestDC));
  281. m_bitmap = ::CreateCompatibleBitmap(
  282. m_hDestDC, m_rect.Width(), m_rect.Height());
  284. m_hOldBitmap = ::SelectObject (m_hDC, m_bitmap);
  286. SetViewportOrg(-rcPaint.left, -rcPaint.top);
  287. }
  289. CXTPBufferDCEx::~CXTPBufferDCEx()
  290. {
  291. SetViewportOrg(0, 0);
  293. ::BitBlt (m_hDestDC, m_rect.left, m_rect.top, m_rect.Width(),
  294. m_rect.Height(), m_hDC, 0, 0, SRCCOPY);
  295. ::SelectObject (m_hDC, m_hOldBitmap);
  296. ::DeleteObject(m_bitmap);
  297. }
  299. //===========================================================================
  300. // CXTPBitmapDC class
  301. //===========================================================================
  303. CXTPBitmapDC::CXTPBitmapDC(CDC* pDC, CBitmap* pBitmap)
  304. : m_hDC(pDC->GetSafeHdc())
  305. {
  306. m_hOldBitmap = SelectObject(m_hDC, pBitmap->GetSafeHandle());
  307. }
  310. CXTPBitmapDC::CXTPBitmapDC(CDC* pDC, HBITMAP hBitmap)
  311. : m_hDC(pDC->GetSafeHdc())
  312. {
  313. m_hOldBitmap = SelectObject(m_hDC, hBitmap);
  314. }
  316. CXTPBitmapDC::~CXTPBitmapDC()
  317. {
  318. ::SelectObject(m_hDC, m_hOldBitmap);
  319. }
  321. void CXTPBitmapDC::SetBitmap(CBitmap* pBitmap)
  322. {
  323. ::SelectObject(m_hDC, m_hOldBitmap);
  324. m_hOldBitmap = SelectObject(m_hDC, pBitmap->GetSafeHandle());
  325. }
  327. //===========================================================================
  328. // CXTPFontDC class
  329. //===========================================================================
  331. CXTPFontDC::CXTPFontDC(CDC* pDC, CFont* pFont)
  332. {
  333. ASSERT(pDC);
  335. m_pDC = pDC;
  336. m_pOldFont = NULL;
  337. m_clrOldTextColor = COLORREF_NULL;
  339. if (pFont)
  340. {
  341. SetFont(pFont);
  342. }
  343. }
  345. CXTPFontDC::CXTPFontDC(CDC* pDC, CFont* pFont, COLORREF clrTextColor)
  346. {
  347. ASSERT(pDC);
  348. ASSERT(clrTextColor != COLORREF_NULL);
  350. m_pDC = pDC;
  351. m_pOldFont = NULL;
  352. m_clrOldTextColor = COLORREF_NULL;
  355. if (pFont)
  356. {
  357. SetFont(pFont);
  358. }
  360. SetColor(clrTextColor);
  361. }
  363. CXTPFontDC::~CXTPFontDC()
  364. {
  365. ReleaseFont();
  366. ReleaseColor();
  367. }
  369. void CXTPFontDC::SetFont(CFont* pFont)
  370. {
  371. if (m_pDC && pFont)
  372. {
  373. CFont* pFontPrev = m_pDC->SelectObject(pFont);
  375. if (!m_pOldFont && pFontPrev)
  376. {
  377. m_pOldFont = pFontPrev;
  378. }
  379. }
  380. }
  382. void CXTPFontDC::SetColor(COLORREF clrTextColor)
  383. {
  384. ASSERT(clrTextColor != COLORREF_NULL);
  385. ASSERT(m_pDC);
  387. if (m_pDC && clrTextColor != COLORREF_NULL)
  388. {
  389. COLORREF clrTextColorPrev= m_pDC->SetTextColor(clrTextColor);
  391. if (m_clrOldTextColor == COLORREF_NULL)
  392. {
  393. m_clrOldTextColor = clrTextColorPrev;
  394. }
  395. }
  396. }
  398. void CXTPFontDC::SetFontColor(CFont* pFont, COLORREF clrTextColor)
  399. {
  400. SetFont(pFont);
  401. SetColor(clrTextColor);
  402. }
  404. void CXTPFontDC::ReleaseFont()
  405. {
  406. ASSERT(m_pDC);
  407. if (m_pDC && m_pOldFont)
  408. {
  409. m_pDC->SelectObject(m_pOldFont);
  410. m_pOldFont = NULL;
  411. }
  412. }
  414. void CXTPFontDC::ReleaseColor()
  415. {
  416. ASSERT(m_pDC);
  417. if (m_pDC && m_clrOldTextColor != COLORREF_NULL)
  418. {
  419. m_pDC->SetTextColor(m_clrOldTextColor);
  420. m_clrOldTextColor = COLORREF_NULL;
  421. }
  422. }
  424. //===========================================================================
  425. // CXTPPenDC class
  426. //===========================================================================
  428. CXTPPenDC::CXTPPenDC(CDC* pDC, CPen* pPen)
  429. : m_hDC(pDC->GetSafeHdc())
  430. {
  431. m_hOldPen = (HPEN)::SelectObject(m_hDC, pPen->GetSafeHandle());
  432. }
  434. CXTPPenDC::CXTPPenDC(HDC hDC, COLORREF crColor)
  435. : m_hDC (hDC)
  436. {
  437. VERIFY(m_pen.CreatePen (PS_SOLID, 1, crColor));
  438. m_hOldPen = (HPEN)::SelectObject (m_hDC, m_pen);
  439. }
  441. CXTPPenDC::~CXTPPenDC ()
  442. {
  443. ::SelectObject (m_hDC, m_hOldPen);
  444. }
  446. void CXTPPenDC::Color(COLORREF crColor)
  447. {
  448. ::SelectObject (m_hDC, m_hOldPen);
  449. VERIFY(m_pen.DeleteObject());
  450. VERIFY(m_pen.CreatePen (PS_SOLID, 1, crColor));
  451. m_hOldPen = (HPEN)::SelectObject (m_hDC, m_pen);
  452. }
  454. COLORREF CXTPPenDC::Color()
  455. {
  456. LOGPEN logPen;
  457. m_pen.GetLogPen(&logPen);
  458. return logPen.lopnColor;
  459. }
  461. //===========================================================================
  462. // CXTPBrushDC class
  463. //===========================================================================
  465. CXTPBrushDC::CXTPBrushDC(HDC hDC, COLORREF crColor)
  466. : m_hDC (hDC)
  467. {
  468. VERIFY(m_brush.CreateSolidBrush (crColor));
  469. m_hOldBrush = (HBRUSH)::SelectObject (m_hDC, m_brush);
  470. }
  472. CXTPBrushDC::~CXTPBrushDC()
  473. {
  474. ::SelectObject(m_hDC, m_hOldBrush);
  475. }
  477. void CXTPBrushDC::Color(COLORREF crColor)
  478. {
  479. ::SelectObject(m_hDC, m_hOldBrush);
  480. VERIFY(m_brush.DeleteObject());
  481. VERIFY(m_brush.CreateSolidBrush(crColor));
  482. m_hOldBrush = (HBRUSH)::SelectObject (m_hDC, m_brush);
  483. }
  485. //===========================================================================
  486. // CXTPCompatibleDC class
  487. //===========================================================================
  489. CXTPCompatibleDC::CXTPCompatibleDC(CDC* pDC, CBitmap* pBitmap)
  490. {
  491. CreateCompatibleDC(pDC);
  492. m_hOldBitmap = (HBITMAP)::SelectObject(GetSafeHdc(), pBitmap->GetSafeHandle());
  493. }
  495. CXTPCompatibleDC::CXTPCompatibleDC(CDC* pDC, HBITMAP hBitmap)
  496. {
  497. CreateCompatibleDC(pDC);
  498. m_hOldBitmap = (HBITMAP)::SelectObject(GetSafeHdc(), hBitmap);
  499. }
  501. CXTPCompatibleDC::~CXTPCompatibleDC()
  502. {
  503. ::SelectObject(GetSafeHdc(), m_hOldBitmap);
  504. DeleteDC();
  505. }
  509. //===========================================================================
  510. // CXTPSplitterTracker class
  511. //===========================================================================
  512. CXTPSplitterTracker::CXTPSplitterTracker(BOOL bSolid /*= FALSE*/)
  513. {
  514. m_bSolid = bSolid;
  515. m_rcBoundRect.SetRectEmpty();
  516. m_pDC = 0;
  517. }
  520. void CXTPSplitterTracker::OnInvertTracker(CRect rect)
  521. {
  522. ASSERT(!rect.IsRectEmpty());
  524. if (m_bSolid)
  525. {
  526. m_pDC->InvertRect(rect);
  527. }
  528. else
  529. {
  530. CBrush* pDitherBrush = CDC::GetHalftoneBrush();
  531. CBrush* pBrush = (CBrush*)m_pDC->SelectObject(pDitherBrush);
  533. m_pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
  534. m_pDC->SelectObject(pBrush);
  535. }
  536. }
  538. BOOL CXTPSplitterTracker::Track(CWnd* pTrackWnd, CRect rcAvail, CRect& rectTracker, CPoint point, BOOL bHoriz)
  539. {
  540. pTrackWnd->SetCapture();
  541. m_pDC = 0;
  543. CWnd* pWnd = CWnd::GetDesktopWindow();
  544. if (pWnd->LockWindowUpdate())
  545. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
  546. else
  547. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE);
  548. ASSERT(m_pDC != NULL);
  550. CPoint ptOffset = bHoriz ? CPoint(rectTracker.left - point.x, 0) :
  551. CPoint(0, rectTracker.top - point.y);
  553. OnInvertTracker(rectTracker);
  555. if (!m_rcBoundRect.IsRectEmpty())
  556. OnInvertTracker(m_rcBoundRect);
  558. BOOL bAccept = FALSE;
  559. while (CWnd::GetCapture() == pTrackWnd)
  560. {
  561. MSG msg;
  562. if (!GetMessage(&msg, NULL, 0, 0))
  563. break;
  565. if (msg.message == WM_MOUSEMOVE)
  566. {
  567. point = CPoint(msg.lParam);
  568. pTrackWnd->ClientToScreen(&point);
  569. point += ptOffset;
  571. point.x = max(min(point.x, rcAvail.right), rcAvail.left);
  572. point.y = max(min(point.y, rcAvail.bottom), rcAvail.top);
  574. if (bHoriz)
  575. {
  576. if (rectTracker.left != point.x)
  577. {
  578. OnInvertTracker(rectTracker);
  579. rectTracker.OffsetRect(point.x - rectTracker.left, 0);
  580. OnInvertTracker(rectTracker);
  581. }
  583. }
  584. else
  585. {
  586. if (rectTracker.top != point.y)
  587. {
  588. OnInvertTracker(rectTracker);
  589. rectTracker.OffsetRect(0, point.y - rectTracker.top);
  590. OnInvertTracker(rectTracker);
  591. }
  592. }
  593. }
  594. else if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE) break;
  595. else if (msg.message == WM_LBUTTONUP)
  596. {
  597. bAccept = TRUE;
  598. break;
  599. }
  600. else  ::DispatchMessage(&msg);
  601. }
  603. if (!m_rcBoundRect.IsRectEmpty())
  604. OnInvertTracker(m_rcBoundRect);
  606. OnInvertTracker(rectTracker);
  608. if (CWnd::GetCapture() == pTrackWnd) ReleaseCapture();
  609. pWnd = CWnd::GetDesktopWindow();
  610. pWnd->UnlockWindowUpdate();
  611. if (m_pDC != NULL)
  612. {
  613. pWnd->ReleaseDC(m_pDC);
  614. m_pDC = NULL;
  615. }
  617. return bAccept;
  618. }
  619. //===========================================================================
  620. // CXTPDrawHelpers class
  621. //===========================================================================
  623. CXTPDrawHelpers::CXTPDrawHelpers()
  624. {
  625. m_pfnFastGradientFill = 0;
  626. m_pfnAlphaBlend = 0;
  627. m_pfnTransparentBlt = 0;
  629. // Don't use CXTPModuleHandle to reduce dependence between common source
  630. m_hMsImgDll = ::LoadLibrary(_T("msimg32.dll"));
  632. if (m_hMsImgDll)
  633. {
  634. m_pfnFastGradientFill = (PFNGRADIENTFILL)GetProcAddress(m_hMsImgDll, "GradientFill");
  635. m_pfnAlphaBlend = (PFNALPHABLEND)::GetProcAddress(m_hMsImgDll, "AlphaBlend");
  636. m_pfnTransparentBlt = (PFNTRANSPARENTBLT)::GetProcAddress(m_hMsImgDll, "TransparentBlt");
  637. }
  638. }
  640. CXTPDrawHelpers* AFX_CDECL XTPDrawHelpers()
  641. {
  642. static CXTPDrawHelpers s_instance; // singleton
  643. return &s_instance;
  644. }
  646. CXTPDrawHelpers::~CXTPDrawHelpers()
  647. {
  648. if (m_hMsImgDll != NULL)
  649. {
  650. //::FreeLibrary(m_hMsImgDll); Dangerous to call FreeLibrary in destructor of static object.
  651. }
  652. }
  654. BOOL CXTPDrawHelpers::GradientFill(HDC hdc, PTRIVERTEX pVertex, ULONG dwNumVertex, PVOID pMesh, ULONG dwNumMesh, ULONG dwMode)
  655. {
  656. if (m_pfnFastGradientFill)
  657. {
  658. return (*m_pfnFastGradientFill)(hdc, pVertex, dwNumVertex, pMesh, dwNumMesh, dwMode);
  659. }
  661. return FALSE;
  662. }
  664. void CXTPDrawHelpers::GradientFillSlow(CDC* pDC, LPCRECT lpRect, COLORREF crFrom, COLORREF crTo, BOOL bHorz)
  665. {
  666. int cx = max(1, lpRect->right - lpRect->left);
  667. int cy = max(1, lpRect->bottom - lpRect->top);
  669. CRect rc;
  670. pDC->GetClipBox(&rc);
  672. if (rc.IsRectEmpty())
  673. rc = *lpRect;
  674. else
  675. rc.IntersectRect(rc, lpRect);
  677. if (bHorz)
  678. {
  679. for (int nX = rc.left; nX < rc.right; nX++)
  680. {
  681. pDC->FillSolidRect(nX, rc.top, 1, rc.Height(), BlendColors(
  682. crFrom, crTo, (double)(1.0 - ((nX - lpRect->left) / (double)cx))));
  683. }
  684. }
  685. else
  686. {
  687. for (int nY = rc.top; nY < rc.bottom; nY++)
  688. {
  689. pDC->FillSolidRect(rc.left, nY, rc.Width(), 1, BlendColors(
  690. crFrom, crTo, (double)(1.0 - ((nY - lpRect->top)) / (double)cy)));
  691. }
  692. }
  693. }
  695. void CXTPDrawHelpers::GradientFillFast(CDC* pDC, LPCRECT lpRect, COLORREF crFrom, COLORREF crTo, BOOL bHorz)
  696. {
  697. TRIVERTEX vert[2];
  698. vert[0].x = lpRect->left;
  699. vert[0].y = lpRect->top;
  700. vert[0].Red = (COLOR16)(GetRValue(crFrom) << 8);
  701. vert[0].Green = (COLOR16)(GetGValue(crFrom) << 8);
  702. vert[0].Blue = (COLOR16)(GetBValue(crFrom) << 8);
  703. vert[0].Alpha = 0x0000;
  705. vert[1].x = lpRect->right;
  706. vert[1].y = lpRect->bottom;
  707. vert[1].Red = (COLOR16)(GetRValue(crTo) << 8);
  708. vert[1].Green = (COLOR16)(GetGValue(crTo) << 8);
  709. vert[1].Blue = (COLOR16)(GetBValue(crTo) << 8);
  710. vert[1].Alpha = 0x0000;
  712. GRADIENT_RECT gRect = { 0, 1 };
  714. GradientFill(*pDC, vert, 2, &gRect, 1, bHorz ? GRADIENT_FILL_RECT_H : GRADIENT_FILL_RECT_V);
  715. }
  717. void CXTPDrawHelpers::GradientFill(CDC* pDC, LPCRECT lpRect, COLORREF crFrom, COLORREF crTo, BOOL bHorz)
  718. {
  719. if (!lpRect)
  720. return;
  722. if (::IsRectEmpty(lpRect))
  723. return;
  725. if (IsLowResolution(pDC->GetSafeHdc()))
  726. {
  727. pDC->FillSolidRect(lpRect, crFrom);
  728. }
  729. else if (crFrom == crTo)
  730. {
  731. pDC->FillSolidRect(lpRect, crFrom);
  732. }
  733. else if ((m_pfnFastGradientFill == NULL) || (IsContextRTL(pDC) && XTPSystemVersion()->IsWin9x()))
  734. {
  735. GradientFillSlow(pDC, lpRect, crFrom, crTo, bHorz);
  736. }
  737. else
  738. {
  739. GradientFillFast(pDC, lpRect, crFrom, crTo, bHorz);
  740. }
  741. }
  743. void CXTPDrawHelpers::GradientFill(CDC* pDC, LPCRECT lpRect, COLORREF crFrom, COLORREF crTo, BOOL bHorz, LPCRECT lpRectClip)
  744. {
  745. CRect rc(lpRect);
  747. if (lpRectClip == NULL)
  748. {
  749. GradientFill(pDC, lpRect, crFrom, crTo, bHorz);
  750. return;
  751. }
  753. COLORREF crFrom1 = crFrom;
  755. if (bHorz)
  756. {
  757. if (rc.top < lpRectClip->top)
  758. {
  759. rc.top = lpRectClip->top;
  760. }
  762. if (rc.bottom > lpRectClip->bottom)
  763. {
  764. rc.bottom = lpRectClip->bottom;
  765. }
  767. if ((rc.left > lpRectClip->right) || (rc.right < lpRectClip->left))
  768. return;
  770. if (rc.left < lpRectClip->left)
  771. {
  772. rc.left = lpRectClip->left;
  774. crFrom = BlendColors(crFrom, crTo,
  775. (float)(lpRect->right - lpRectClip->left) / (float)(lpRect->right - lpRect->left));
  776. }
  778. if (rc.right > lpRectClip->right)
  779. {
  780. rc.right = lpRectClip->right;
  782. crTo = BlendColors(crFrom1, crTo,
  783. (float)(lpRect->right - lpRectClip->right) / (float)(lpRect->right - lpRect->left));
  785. }
  787. GradientFill(pDC, rc, crFrom, crTo, bHorz);
  789. }
  790. else
  791. {
  792. if (rc.left < lpRectClip->left)
  793. {
  794. rc.left = lpRectClip->left;
  795. }
  797. if (rc.right > lpRectClip->right)
  798. {
  799. rc.right = lpRectClip->right;
  800. }
  802. if ((rc.top > lpRectClip->bottom) || (rc.bottom < lpRectClip->top))
  803. return;
  805. if (rc.top < lpRectClip->top)
  806. {
  807. rc.top = lpRectClip->top;
  809. crFrom = BlendColors(crFrom, crTo,
  810. (float)(lpRect->bottom - lpRectClip->top) / (float)(lpRect->bottom - lpRect->top));
  811. }
  813. if (rc.bottom > lpRectClip->bottom)
  814. {
  815. rc.bottom = lpRectClip->bottom;
  817. crTo = BlendColors(crFrom1, crTo,
  818. (float)(lpRect->bottom - lpRectClip->bottom) / (float)(lpRect->bottom - lpRect->top));
  820. }
  822. GradientFill(pDC, rc, crFrom, crTo, bHorz);
  823. }
  824. }
  826. void CXTPDrawHelpers::GradientFill(CDC* pDC, LPCRECT lpRect, const CXTPPaintManagerColorGradient& grc, BOOL bHorz, LPCRECT lpRectClip)
  827. {
  828. // using gradient factor color gradient fill
  829. if (grc.fGradientFactor != 0.5f)
  830. {
  831. COLORREF clrMid = BlendColors(grc.clrLight, grc.clrDark, grc.fGradientFactor);
  833. if (bHorz)
  834. {
  835. CRect rcLeft(lpRect);
  836. rcLeft.right -= rcLeft.Width()/2;
  837. GradientFill(pDC, &rcLeft, grc.clrLight, clrMid, bHorz, lpRectClip);
  839. CRect rcRight(lpRect);
  840. rcRight.left = rcLeft.right;
  841. GradientFill(pDC, &rcRight, clrMid, grc.clrDark, bHorz, lpRectClip);
  842. }
  843. else
  844. {
  845. CRect rcTop(lpRect);
  846. rcTop.bottom -= rcTop.Height()/2;
  847. GradientFill(pDC, &rcTop, grc.clrLight, clrMid, bHorz, lpRectClip);
  849. CRect rcBottom(lpRect);
  850. rcBottom.top = rcTop.bottom;
  851. GradientFill(pDC, &rcBottom, clrMid, grc.clrDark, bHorz, lpRectClip);
  852. }
  853. }
  854. // using 2 color gradient fill
  855. else
  856. {
  857. GradientFill(pDC, lpRect, grc.clrLight, grc.clrDark, bHorz, lpRectClip);
  858. }
  859. }
  861. void CXTPDrawHelpers::ExcludeCorners(CDC* pDC, CRect rc)
  862. {
  863. pDC->ExcludeClipRect(rc.left, rc.top, rc.left + 1, rc.top + 1);
  864. pDC->ExcludeClipRect(rc.right - 1, rc.top, rc.right, rc.top + 1);
  865. pDC->ExcludeClipRect(rc.left, rc.bottom - 1, rc.left + 1, rc.bottom);
  866. pDC->ExcludeClipRect(rc.right - 1, rc.bottom - 1, rc.right, rc.bottom);
  867. }
  869. void CXTPDrawHelpers::StripMnemonics(CString& strClear)
  870. {
  871. for (int i = 0; i < strClear.GetLength(); i++)
  872. {
  873. if (strClear[i] == _T('&') && (i == strClear.GetLength() - 1 || strClear[i + 1] != _T('&')))
  874. {
  875. DELETE_S(strClear, i);
  876. }
  877. }
  878. }
  880. void CXTPDrawHelpers::StripMnemonics(LPTSTR lpszClear)
  881. {
  882. if (lpszClear == NULL || lpszClear == LPSTR_TEXTCALLBACK)
  883. return;
  885. LPTSTR lpszResult = lpszClear;
  887. while (*lpszClear)
  888. {
  889. if (*lpszClear == _T('&') && *(lpszClear + 1) != _T('&'))
  890. {
  891. lpszClear++;
  892. continue;
  893. }
  895. *lpszResult++ = *lpszClear++;
  896. }
  898. *lpszResult = 0;
  899. }
  901. void CXTPDrawHelpers::BlurPoints(CDC* pDC, LPPOINT pts, int nCount)
  902. {
  903. for (int i = 0; i < nCount; i += 2)
  904. {
  905. CPoint ptBlur = pts[i];
  906. CPoint ptDirection(pts[i].x + pts[i + 1].x, pts[i].y + pts[i + 1].y);
  908. COLORREF clrBlur = pDC->GetPixel(ptDirection);
  909. COLORREF clrDirection = pDC->GetPixel(ptBlur);
  911. pDC->SetPixel(ptBlur, RGB(
  912. (GetRValue(clrBlur) + GetRValue(clrDirection)) / 2,
  913. (GetGValue(clrBlur) + GetGValue(clrDirection)) / 2,
  914. (GetBValue(clrBlur) + GetBValue(clrDirection)) / 2));
  915. }
  916. }
  918. COLORREF CXTPDrawHelpers::BlendColors(COLORREF crA, COLORREF crB, double fAmountA)
  919. {
  920. double fAmountB = (1.0 - fAmountA);
  921. int btR = (int)(GetRValue(crA) * fAmountA + GetRValue(crB) * fAmountB);
  922. int btG = (int)(GetGValue(crA) * fAmountA + GetGValue(crB) * fAmountB);
  923. int btB = (int)(GetBValue(crA) * fAmountA + GetBValue(crB) * fAmountB);
  925. return RGB(min(255, btR), (BYTE)min(255, btG), (BYTE)min(255, btB));
  926. }
  928. COLORREF CXTPDrawHelpers::DarkenColor(long lScale, COLORREF lColor)
  929. {
  930. long red   = MulDiv(GetRValue(lColor), (255 - lScale), 255);
  931. long green = MulDiv(GetGValue(lColor), (255 - lScale), 255);
  932. long blue  = MulDiv(GetBValue(lColor), (255 - lScale), 255);
  934. return RGB(red, green, blue);
  935. }
  937. COLORREF CXTPDrawHelpers::LightenColor(long lScale, COLORREF lColor)
  938. {
  939. long R = MulDiv(255 - GetRValue(lColor), lScale, 255) + GetRValue(lColor);
  940. long G = MulDiv(255 - GetGValue(lColor), lScale, 255) + GetGValue(lColor);
  941. long B = MulDiv(255 - GetBValue(lColor), lScale, 255) + GetBValue(lColor);
  943. return RGB(R, G, B);
  944. }
  946. CPoint CXTPDrawHelpers::Dlu2Pix(int dluX, int dluY)
  947. {
  948. CPoint baseXY(::GetDialogBaseUnits());
  949. CPoint pixXY(0,0);
  950. pixXY.x = ::MulDiv(dluX, baseXY.x, 4);
  951. pixXY.y = ::MulDiv(dluY, baseXY.y, 8);
  952. return pixXY;
  953. }
  955. COLORREF CXTPDrawHelpers::RGBtoHSL(COLORREF rgb)
  956. {
  957. int delta, sum;
  958. int nH, nS, nL;
  959. int r = GetRValue(rgb);
  960. int g = GetGValue(rgb);
  961. int b = GetBValue(rgb);
  962. int cmax = ((r) >= (g) ? ((r) >= (b) ? (r) : (b)) : (g) >= (b) ? (g) : (b));
  963. int cmin = ((r) <= (g) ? ((r) <= (b) ? (r) : (b)) : (g) <= (b) ? (g) : (b));
  965. nL = (cmax + cmin + 1) / 2;
  966. if(cmax == cmin)
  967. {
  968. nH = 255; // H is really undefined
  969. nS = 0;
  970. }
  971. else
  972. {
  973. delta = cmax - cmin;
  974. sum = cmax + cmin;
  975. if(nL < 127)
  976. nS = ((delta + 1) * 256) / sum;
  977. else
  978. nS = (delta * 256) / ((2 * 256) - sum);
  979. if(r == cmax)
  980. nH = ((g - b) * 256) / delta;
  981. else if(g == cmax)
  982. nH = (2 * 256) + ((b - r) * 256) / delta;
  983. else
  984. nH = (4 * 256) + ((r - g) * 256) / delta;
  985. nH /= 6;
  986. if(nH < 0)
  987. nH += 256;
  988. }
  989. nH = nH * 239 / 255;
  990. nS = nS * 240 / 255;
  991. nL = nL * 240 / 255;
  993. return RGB((BYTE)min(nH, 239), (BYTE)min(nS, 240), (BYTE)min(nL, 240));
  994. }
  996. void CXTPDrawHelpers::RGBtoHSL(COLORREF clr, double& h, double& s, double& l)
  997. {
  998. double r = (double)GetRValue(clr)/255.0;
  999. double g = (double)GetGValue(clr)/255.0;
  1000. double b = (double)GetBValue(clr)/255.0;
  1002. double maxcolor = __max(r, __max(g, b));
  1003. double mincolor = __min(r, __min(g, b));
  1005. l = (maxcolor + mincolor)/2;
  1007. if (maxcolor == mincolor)
  1008. {
  1009. h = 0;
  1010. s = 0;
  1011. }
  1012. else
  1013. {
  1014. if (l < 0.5)
  1015. s = (maxcolor-mincolor)/(maxcolor + mincolor);
  1016. else
  1017. s = (maxcolor-mincolor)/(2.0-maxcolor-mincolor);
  1019. if (r == maxcolor)
  1020. h = (g-b)/(maxcolor-mincolor);
  1021. else if (g == maxcolor)
  1022. h = 2.0+(b-r)/(maxcolor-mincolor);
  1023. else
  1024. h = 4.0+(r-g)/(maxcolor-mincolor);
  1026. h /= 6.0;
  1027. if (h < 0.0) h += 1;
  1028. }
  1029. }
  1031. double CXTPDrawHelpers::HueToRGB(double temp1, double temp2, double temp3)
  1032. {
  1033. if (temp3 < 0)
  1034. temp3 = temp3 + 1.0;
  1035. if (temp3 > 1)
  1036. temp3 = temp3-1.0;
  1038. if (6.0*temp3 < 1)
  1039. return (temp1+(temp2-temp1)*temp3 * 6.0);
  1041. else if (2.0*temp3 < 1)
  1042. return temp2;
  1044. else if (3.0*temp3 < 2.0)
  1045. return (temp1+(temp2-temp1)*((2.0/3.0)-temp3)*6.0);
  1047. return temp1;
  1048. }
  1050. int CXTPDrawHelpers::HueToRGB(int m1, int m2, int h)
  1051. {
  1052. if(h < 0)
  1053. h += 255;
  1055. if(h > 255)
  1056. h -= 255;
  1058. if((6 * h) < 255)
  1059. return ((m1 + ((m2 - m1) / 255 * h * 6)) / 255);
  1061. if((2 * h) < 255)
  1062. return m2 / 255;
  1064. if((3 * h) < (2 * 255))
  1065. return ((m1 + (m2 - m1) / 255 * ((255 * 2 / 3) - h) * 6) / 255);
  1067. return (m1 / 255);
  1068. }
  1070. COLORREF CXTPDrawHelpers::HSLtoRGB(COLORREF hsl)
  1071. {
  1072. int r, g, b;
  1073. int m1, m2;
  1074. int nH = GetRValue(hsl) * 255 / 239;
  1075. int nS = GetGValue(hsl) * 255 / 240;
  1076. int nL = GetBValue(hsl) * 255 / 240;
  1078. if(nS == 0)
  1079. r = g = b = nL;
  1080. else
  1081. {
  1082. if(nL <= 127)
  1083. m2 = nL * (255 + nS);
  1084. else
  1085. m2 = (nL + nS - ((nL * nS) / 255)) * 255;
  1086. m1 = (2 * 255 * nL) - m2;
  1087. r = HueToRGB(m1, m2, nH + (255 / 3));
  1088. g = HueToRGB(m1, m2, nH);
  1089. b = HueToRGB(m1, m2, nH - (255 / 3));
  1090. }
  1091. return RGB((BYTE)min(r, 255), (BYTE)min(g, 255), (BYTE)min(b, 255));
  1092. }
  1094. COLORREF CXTPDrawHelpers::HSLtoRGB(double h, double s, double l)
  1095. {
  1096. double r, g, b;
  1097. double temp1, temp2;
  1099. if (s == 0)
  1100. {
  1101. r = g = b = l;
  1102. }
  1103. else
  1104. {
  1105. if (l < 0.5)
  1106. temp2 = l*(1.0 + s);
  1107. else
  1108. temp2 = l + s-l*s;
  1110. temp1 = 2.0 * l-temp2;
  1112. r = HueToRGB(temp1, temp2, h + 1.0/3.0);
  1113. g = HueToRGB(temp1, temp2, h);
  1114. b = HueToRGB(temp1, temp2, h - 1.0/3.0);
  1115. }
  1117. return RGB((BYTE)(r * 255), (BYTE)(g * 255), (BYTE)(b * 255));
  1118. }
  1120. static int CALLBACK XTPEnumFontFamExProc(ENUMLOGFONTEX* pelf, NEWTEXTMETRICEX* /*lpntm*/, int /*FontType*/, LPVOID pThis)
  1121. {
  1122. LPCTSTR strFontName = (LPCTSTR)pThis;
  1123. CString strFaceName = pelf->elfLogFont.lfFaceName;
  1125. if (strFaceName.CompareNoCase(strFontName) == 0)
  1126. return 0;
  1128. return 1;
  1129. }
  1131. BOOL CXTPDrawHelpers::FontExists(LPCTSTR strFaceName)
  1132. {
  1133. // Enumerate all styles and charsets of all fonts:
  1134. LOGFONT lfEnum;
  1135. ::ZeroMemory(&lfEnum, sizeof(LOGFONT));
  1137. lfEnum.lfFaceName[ 0 ] = 0;
  1138. lfEnum.lfCharSet = DEFAULT_CHARSET;
  1140. CWindowDC dc(NULL);
  1142. return  ::EnumFontFamiliesEx(dc.m_hDC, &lfEnum, (FONTENUMPROC)
  1143. XTPEnumFontFamExProc, (LPARAM)strFaceName, 0) == 0;
  1144. }
  1146. CString CXTPDrawHelpers::GetDefaultFontName()
  1147. {
  1148. LOGFONT lfFont;
  1149. ZeroMemory(&lfFont, sizeof(LOGFONT));
  1150. ::GetObject(::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lfFont);
  1152. return CString(lfFont.lfFaceName);
  1153. }
  1155. CString AFX_CDECL CXTPDrawHelpers::GetVerticalFontName(BOOL bUseOfficeFont)
  1156. {
  1157. LOGFONT lfFont;
  1158. ZeroMemory(&lfFont, sizeof(LOGFONT));
  1159. ::GetObject(::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lfFont);
  1160. bool bUseSystemFont = lfFont.lfCharSet > SYMBOL_CHARSET;
  1162. if (bUseSystemFont && !XTPSystemVersion()->IsWin2KOrGreater())
  1163. bUseSystemFont = FALSE;
  1165. if (bUseSystemFont && (_tcsicmp(lfFont.lfFaceName, _T("MS Shell Dlg")) == 0))
  1166. bUseSystemFont = FALSE; // Can draw it vertically in Windows 2000.
  1168. CString strVerticalFaceName = _T("Arial");
  1169. LPCTSTR strOfficeFont = _T("Tahoma");
  1171. if (bUseSystemFont || !FontExists(strVerticalFaceName))
  1172. {
  1173. strVerticalFaceName = lfFont.lfFaceName;
  1174. }
  1175. else if (bUseOfficeFont && !bUseSystemFont && FontExists(strOfficeFont))
  1176. {
  1177. strVerticalFaceName = strOfficeFont;
  1178. }
  1180. return strVerticalFaceName;
  1181. }
  1183. BOOL CXTPDrawHelpers::IsContextRTL(CDC* pDC)
  1184. {
  1185. return pDC && IsContextRTL(pDC->GetSafeHdc());
  1186. }
  1188. BOOL CXTPDrawHelpers::IsContextRTL(HDC hDC)
  1189. {
  1190. typedef DWORD (CALLBACK* PFNGDIGETLAYOUTPROC)(HDC);
  1191. static PFNGDIGETLAYOUTPROC s_pfn = (PFNGDIGETLAYOUTPROC)-1;
  1193. if (s_pfn == (PFNGDIGETLAYOUTPROC)-1)
  1194. {
  1195. HINSTANCE hInst = ::GetModuleHandleA("GDI32.DLL");
  1197. s_pfn = hInst ? (PFNGDIGETLAYOUTPROC)GetProcAddress(hInst, "GetLayout") : NULL;
  1198. }
  1200. return s_pfn ? (*s_pfn)(hDC) : FALSE;
  1201. }
  1203. void CXTPDrawHelpers::SetContextRTL(CDC* pDC, BOOL bLayoutRTL)
  1204. {
  1205. if (pDC) SetContextRTL(pDC->GetSafeHdc(), bLayoutRTL);
  1206. }
  1208. void CXTPDrawHelpers::SetContextRTL(HDC hDC, BOOL bLayoutRTL)
  1209. {
  1210. typedef DWORD (CALLBACK* PFNGDISETLAYOUTPROC)(HDC, DWORD);
  1211. static PFNGDISETLAYOUTPROC s_pfn = (PFNGDISETLAYOUTPROC)-1;
  1213. if (s_pfn == (PFNGDISETLAYOUTPROC)-1)
  1214. {
  1215. HINSTANCE hInst = ::GetModuleHandleA("GDI32.DLL");
  1217. s_pfn = hInst ? (PFNGDISETLAYOUTPROC)GetProcAddress(hInst, "SetLayout") : NULL;
  1218. }
  1220. if (s_pfn != NULL)
  1221. {
  1222. (*s_pfn)(hDC, bLayoutRTL);
  1223. }
  1224. }
  1227. void CXTPDrawHelpers::KeyToLayout(CWnd* pWnd, UINT& nChar)
  1228. {
  1229. ASSERT(pWnd);
  1230. if (!pWnd || !pWnd->GetSafeHwnd())
  1231. return;
  1233. if (nChar == VK_LEFT && pWnd->GetExStyle() & WS_EX_LAYOUTRTL)
  1234. nChar = VK_RIGHT;
  1235. else if (nChar == VK_RIGHT && pWnd->GetExStyle() & WS_EX_LAYOUTRTL)
  1236. nChar = VK_LEFT;
  1238. }
  1240. void CXTPDrawHelpers::Triangle(CDC* pDC, CPoint pt0, CPoint pt1, CPoint pt2, COLORREF clr)
  1241. {
  1242. CXTPPenDC pen (*pDC, clr);
  1243. CXTPBrushDC brush (*pDC, clr);
  1245. Triangle(pDC, pt0, pt1, pt2);
  1246. }
  1248. BOOL CXTPDrawHelpers::DrawLine(CDC* pDC, int x, int y, int nLength, int nHeight, COLORREF crLine)
  1249. {
  1250. if (pDC->GetSafeHdc())
  1251. {
  1252. CXTPPenDC penDC(*pDC, crLine);
  1253. pDC->MoveTo(x, y);
  1254. pDC->LineTo(x + nLength, y + nHeight);
  1255. return TRUE;
  1256. }
  1257. return FALSE;
  1258. }
  1260. DWORD CXTPDrawHelpers::GetComCtlVersion()
  1261. {
  1262. return XTPSystemVersion()->GetComCtlVersion();
  1263. }
  1265. BOOL CXTPDrawHelpers::IsLowResolution(HDC hDC/* = 0*/)
  1266. {
  1267. return XTPColorManager()->IsLowResolution(hDC);
  1268. }
  1270. CRect CXTPDrawHelpers::GetWorkArea(LPCRECT rect)
  1271. {
  1272. return XTPMultiMonitor()->GetWorkArea(rect);
  1273. }
  1275. CRect CXTPDrawHelpers::GetWorkArea(const CWnd* pWnd)
  1276. {
  1277. return XTPMultiMonitor()->GetWorkArea(pWnd);
  1278. }
  1280. CRect CXTPDrawHelpers::GetScreenArea(const CWnd* pWnd)
  1281. {
  1282. return XTPMultiMonitor()->GetScreenArea(pWnd);
  1283. }
  1285. CRect CXTPDrawHelpers::GetWorkArea(const POINT& point)
  1286. {
  1287. return XTPMultiMonitor()->GetWorkArea(point);
  1288. }
  1290. CRect CXTPDrawHelpers::GetWorkArea()
  1291. {
  1292. return XTPMultiMonitor()->GetWorkArea();
  1293. }
  1297. BOOL CXTPDrawHelpers::IsTopParentActive(HWND hWnd)
  1298. {
  1299. HWND hwndForeground = ::GetForegroundWindow();
  1301. HWND hWndT;
  1302. while ((hWndT = AfxGetParentOwner(hWnd)) != NULL)
  1303. {
  1304. hWnd = hWndT;
  1305. }
  1307. HWND hwndActivePopup = ::GetLastActivePopup(hWnd);
  1309. if (hwndForeground == hwndActivePopup)
  1310. return TRUE;
  1313. return FALSE;
  1314. }
  1315. void CXTPDrawHelpers::ScreenToWindow(CWnd* pWnd, LPPOINT lpPoint)
  1316. {
  1317. RECT rc;
  1318. ::GetWindowRect(pWnd->GetSafeHwnd(), &rc);
  1320. lpPoint->y -= rc.top;
  1322. if (GetWindowLong(pWnd->GetSafeHwnd(), GWL_EXSTYLE) & WS_EX_LAYOUTRTL )
  1323. {
  1324. lpPoint->x = rc.right - lpPoint->x;
  1325. }
  1326. else
  1327. {
  1328. lpPoint->x -= rc.left;
  1329. }
  1330. }
  1332. BOOL AFX_CDECL CXTPDrawHelpers::RegisterWndClass(HINSTANCE hInstance, LPCTSTR lpszClassName, UINT style, HICON hIcon)
  1333. {
  1334. WNDCLASS wndcls;
  1335. ZeroMemory(&wndcls, sizeof(wndcls));
  1337. wndcls.style = style;
  1338. wndcls.lpfnWndProc = ::DefWindowProc;
  1339. wndcls.hInstance = hInstance ? hInstance : AfxGetInstanceHandle();
  1340. wndcls.hCursor = AfxGetApp()->LoadStandardCursor(IDC_ARROW);
  1341. wndcls.lpszClassName = lpszClassName;
  1342. wndcls.hIcon = hIcon;
  1344. return AfxRegisterClass(&wndcls);
  1345. }
  1347. void CXTPDrawHelpers::GetWindowCaption(HWND hWnd, CString& strWindowText)
  1348. {
  1349. #ifdef _UNICODE
  1350. int nLen = (int)::DefWindowProc(hWnd, WM_GETTEXTLENGTH, 0, 0);
  1351. ::DefWindowProc(hWnd, WM_GETTEXT, nLen + 1, (WPARAM)(LPCTSTR)strWindowText.GetBuffer(nLen));
  1352. strWindowText.ReleaseBuffer();
  1353. #else
  1354. int nLen = ::GetWindowTextLength(hWnd);
  1355. ::GetWindowText(hWnd, strWindowText.GetBufferSetLength(nLen), nLen + 1);
  1356. strWindowText.ReleaseBuffer();
  1357. #endif
  1358. }
  1360. BOOL AFX_CDECL XTPGetPrinterDeviceDefaults(HGLOBAL& ref_hDevMode, HGLOBAL& ref_hDevNames)
  1361. {
  1362. CWinApp* pApp = AfxGetApp();
  1363. if (pApp)
  1364. {
  1365. PRINTDLG _pd;
  1366. ::ZeroMemory(&_pd, sizeof(_pd));
  1367. if (pApp->GetPrinterDeviceDefaults(&_pd))
  1368. {
  1369. ref_hDevMode = _pd.hDevMode;
  1370. ref_hDevNames = _pd.hDevNames;
  1371. return TRUE;
  1372. }
  1373. }
  1374. return FALSE;
  1375. }
  1377. //////////////////////////////////////////////////////////////////////////
  1378. IMPLEMENT_DYNAMIC(CXTPPrinterInfo, CCmdTarget)
  1380. CXTPPrinterInfo::CXTPPrinterInfo()
  1381. {
  1383. }
  1385. CXTPPrinterInfo::~CXTPPrinterInfo()
  1386. {
  1388. }
  1390. CString CXTPPrinterInfo::GetName(XTPEnumDeviceName eNameID)
  1391. {
  1392. CString strName;
  1393. HGLOBAL hDevMode = NULL, hDevNames = NULL;
  1395. if (XTPGetPrinterDeviceDefaults(hDevMode, hDevNames) && hDevNames != NULL)
  1396. {
  1397. LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(hDevNames);
  1398. if (lpDev)
  1399. {
  1400. strName = (LPCTSTR)lpDev + _GetNameOffset(lpDev, eNameID);
  1401. }
  1402. ::GlobalUnlock(hDevNames);
  1403. }
  1404. return strName;
  1405. }
  1407. WORD CXTPPrinterInfo::_GetNameOffset(LPDEVNAMES pDevNames, XTPEnumDeviceName eNameID)
  1408. {
  1409. ASSERT(pDevNames);
  1410. if (!pDevNames)
  1411. return 0;
  1413. switch(eNameID)
  1414. {
  1415. case xtpDevName_Driver:
  1416. return pDevNames->wDriverOffset;
  1417. case xtpDevName_Device:
  1418. return pDevNames->wDeviceOffset;
  1419. case xtpDevName_Port:
  1420. return pDevNames->wOutputOffset;
  1421. };
  1423. ASSERT(FALSE);
  1424. return 0;
  1425. }
  1427. /////////////////////////////////////////////////////////////////////////////
  1428. IMPLEMENT_DYNAMIC(CXTPPrintPageHeaderFooter, CCmdTarget)
  1430. CXTPPrintPageHeaderFooter::CXTPPrintPageHeaderFooter(CXTPPrintOptions* pOwner, BOOL bHeader)
  1431. {
  1432. ASSERT(pOwner);
  1434. m_bHeader = bHeader;
  1435. m_pOwner = pOwner;
  1437. VERIFY( ::SystemParametersInfo( SPI_GETICONTITLELOGFONT, sizeof(m_lfFont), &m_lfFont, 0 ) );
  1438. m_clrColor = RGB(0, 0, 0);
  1440. }
  1442. CXTPPrintPageHeaderFooter::~CXTPPrintPageHeaderFooter()
  1443. {
  1444. }
  1446. void CXTPPrintPageHeaderFooter::Set(const CXTPPrintPageHeaderFooter* pSrc)
  1447. {
  1448. ASSERT(pSrc);
  1449. if (!pSrc)
  1450. return;
  1452. m_lfFont = pSrc->m_lfFont;
  1453. m_clrColor = pSrc->m_clrColor;
  1455. m_strFormatString = pSrc->m_strFormatString;
  1457. m_strLeft = pSrc->m_strLeft;
  1458. m_strCenter = pSrc->m_strCenter;
  1459. m_strRight = pSrc->m_strRight;
  1460. }
  1462. void CXTPPrintPageHeaderFooter::Clear()
  1463. {
  1464. VERIFY( ::SystemParametersInfo( SPI_GETICONTITLELOGFONT, sizeof(m_lfFont), &m_lfFont, 0 ) );
  1465. m_clrColor = RGB(0, 0, 0);
  1466. m_strFormatString.Empty();
  1468. m_strLeft.Empty();
  1469. m_strCenter.Empty();
  1470. m_strRight.Empty();
  1471. }
  1473. BOOL CXTPPrintPageHeaderFooter::IsEmpty()
  1474. {
  1475. return m_strLeft.IsEmpty() && m_strCenter.IsEmpty() && m_strRight.IsEmpty();
  1476. }
  1478. //===========================================================================
  1479. //  &w      Window title
  1480. //
  1481. //  &d      Date in short format (as specified by Regional Settings in Control Panel)
  1482. //  &D      Date in long format (as specified by Regional Settings in Control Panel)
  1483. //
  1484. //  &t      Time in the format specified by Regional Settings in Control Panel
  1485. //  &T      Time in 24-hour format
  1486. //
  1487. //  &p      Current page number
  1488. //  &P      Total number of pages
  1489. //
  1490. //  &b      The text immediately following these characters as centered.
  1491. //  &b&b    The text immediately following the first "&b" as centered, and the text following the second "&b" as right-justified.
  1492. //
  1493. //  &&      A single ampersand (&)
  1494. //===========================================================================
  1495. void CXTPPrintPageHeaderFooter::FormatTexts(CPrintInfo* pInfo, LPCTSTR pcszWndTitle)
  1496. {
  1497. ASSERT(pInfo);
  1498. if (m_strFormatString.IsEmpty() || !pInfo)
  1499. return;
  1501. LCID lcidLocale = m_pOwner ? m_pOwner->GetActiveLCID() : LOCALE_USER_DEFAULT;
  1503. CString strFormat = m_strFormatString;
  1504. REPLACE_S(strFormat, _T("&&"), _T("1"));
  1506. CString str_p, str_P = _T("*");
  1507. str_p.Format(_T("%d"), pInfo->m_nCurPage);
  1509. if (pInfo->GetMaxPage() != 65535)
  1510. str_P.Format(_T("%d"), pInfo->GetMaxPage());
  1512. REPLACE_S(strFormat, _T("&p"), str_p);
  1513. REPLACE_S(strFormat, _T("&P"), str_P);
  1515. REPLACE_S(strFormat, _T("\n"), _T("n"));
  1517. _SplitFormatLCR(strFormat);
  1519. _FormatDateTime(m_strLeft, lcidLocale);
  1520. _FormatDateTime(m_strCenter, lcidLocale);
  1521. _FormatDateTime(m_strRight, lcidLocale);
  1523. if (pcszWndTitle)
  1524. {
  1525. REPLACE_S(m_strLeft, _T("&w"), pcszWndTitle);
  1526. REPLACE_S(m_strCenter, _T("&w"), pcszWndTitle);
  1527. REPLACE_S(m_strRight, _T("&w"), pcszWndTitle);
  1528. }
  1530. REPLACE_S(m_strLeft,  _T("1"), _T("&"));
  1531. REPLACE_S(m_strCenter, _T("1"), _T("&"));
  1532. REPLACE_S(m_strRight, _T("1"), _T("&"));
  1533. }
  1535. CString CXTPPrintPageHeaderFooter::GetParentFrameTitle(CWnd* pWnd)
  1536. {
  1537. CString strTitle;
  1539. ASSERT(pWnd);
  1540. if (!pWnd)
  1541. return strTitle;
  1543. pWnd->GetWindowText(strTitle);
  1544. if (strTitle.IsEmpty() || !pWnd->IsFrameWnd())
  1545. {
  1546. if (pWnd->GetParentFrame())
  1547. pWnd->GetParentFrame()->GetWindowText(strTitle);
  1549. if (strTitle.IsEmpty())
  1550. {
  1551. if (pWnd->GetParentOwner())
  1552. pWnd->GetParentOwner()->GetWindowText(strTitle);
  1553. }
  1554. }
  1555. return strTitle;
  1556. }
  1558. void CXTPPrintPageHeaderFooter::_FormatDateTime(CString& strFormat, LCID lcidLocale)
  1559. {
  1560. SYSTEMTIME stNow;
  1561. ::GetLocalTime(&stNow);
  1563. const int cnBufferSize = 200;
  1564. TCHAR szDateFormatShort[cnBufferSize] = {0};
  1565. TCHAR szDateFormatLong[cnBufferSize] = {0};
  1567. TCHAR szTimeFormat[cnBufferSize] = {0};
  1568. TCHAR szTimeFormat24[cnBufferSize] = {0};
  1570. ::GetDateFormat(lcidLocale, DATE_SHORTDATE, &stNow, NULL, szDateFormatShort, cnBufferSize);
  1571. ::GetDateFormat(lcidLocale, DATE_LONGDATE, &stNow, NULL, szDateFormatLong, cnBufferSize);
  1573. ::GetTimeFormat(lcidLocale, 0, &stNow, NULL, szTimeFormat, cnBufferSize);
  1574. DWORD dwFlags24h = TIME_FORCE24HOURFORMAT | TIME_NOTIMEMARKER;
  1575. ::GetTimeFormat(lcidLocale, dwFlags24h, &stNow, NULL, szTimeFormat24, cnBufferSize);
  1577. REPLACE_S(strFormat, _T("&d"), szDateFormatShort); // &d   Date in short format (as specified by Regional Settings in Control Panel)
  1578. REPLACE_S(strFormat, _T("&D"), szDateFormatLong);  // &D   Date in long format (as specified by Regional Settings in Control Panel)
  1580. REPLACE_S(strFormat, _T("&t"), szTimeFormat);   // &t  Time in the format specified by Regional Settings in Control Panel
  1581. REPLACE_S(strFormat, _T("&T"), szTimeFormat24); // &T  Time in 24-hour format
  1582. }
  1584. void CXTPPrintPageHeaderFooter::_SplitFormatLCR(CString strFormat)
  1585. {
  1586. m_strLeft.Empty();
  1587. m_strCenter.Empty();
  1588. m_strRight.Empty();
  1590. int nAmpBidx = strFormat.Find(_T("&b"));
  1591. if (nAmpBidx < 0)
  1592. {
  1593. m_strLeft = strFormat;
  1594. }
  1595. else if (nAmpBidx >= 0)
  1596. {
  1597. if (nAmpBidx > 0)
  1598. m_strLeft = strFormat.Left(nAmpBidx);
  1600. DELETE_S(strFormat, 0, nAmpBidx + 2);
  1602. nAmpBidx = strFormat.Find(_T("&b"));
  1603. if (nAmpBidx < 0)
  1604. {
  1605. m_strCenter = strFormat;
  1606. }
  1607. else if (nAmpBidx >= 0)
  1608. {
  1609. if (nAmpBidx > 0)
  1610. m_strCenter = strFormat.Left(nAmpBidx);
  1611. DELETE_S(strFormat, 0, nAmpBidx + 2);
  1613. m_strRight = strFormat;
  1614. }
  1615. }
  1616. }
  1618. int CXTPPrintPageHeaderFooter::fnYi(int Xi, int Wi)
  1619. {
  1620. int nYi = Wi / Xi;
  1621. int nYi_ = Wi % Xi;
  1622. return nYi + (nYi_ ? 1 : 0);
  1623. }
  1626. int CXTPPrintPageHeaderFooter::_Calc3ColSizesIfSingleCol(CDC* pDC, int nW,
  1627.   const CString& str1, const CString& str2, const CString& str3,
  1628.   CSize& rsz1, CSize& rsz2, CSize& rsz3)
  1629. {
  1630. CString str1trim = str1;
  1631. CString str2trim = str2;
  1632. CString str3trim = str3;
  1634. str1trim.TrimLeft();
  1635. str2trim.TrimLeft();
  1636. str3trim.TrimLeft();
  1638. UINT uFlags = DT_TOP | DT_WORDBREAK | DT_CALCRECT;
  1639. rsz1 = rsz2 = rsz3 = CSize(0, 0);
  1641. if (!str1trim.IsEmpty() && str2trim.IsEmpty() && str3trim.IsEmpty())
  1642. {
  1643. CRect rcText1(0, 0, nW, 32000);
  1644. rsz1.cx = nW;
  1645. return rsz1.cy = pDC->DrawText(str1, &rcText1, uFlags | DT_LEFT);
  1647. }
  1649. if (str1trim.IsEmpty() && !str2trim.IsEmpty() && str3trim.IsEmpty())
  1650. {
  1651. CRect rcText2(0, 0, nW, 32000);
  1652. rsz2.cx = nW;
  1653. return rsz2.cy = pDC->DrawText(str2, &rcText2, uFlags | DT_CENTER);
  1654. }
  1656. if (str1trim.IsEmpty() && str2trim.IsEmpty() && !str3trim.IsEmpty())
  1657. {
  1658. CRect rcText3(0, 0, nW, 32000);
  1659. rsz3.cx = nW;
  1660. return rsz3.cy = pDC->DrawText(str3, &rcText3, uFlags | DT_RIGHT);
  1661. }
  1663. return -1;
  1664. }
  1666. int CXTPPrintPageHeaderFooter::Calc3ColSizes(CDC* pDC, int nW,
  1667.   const CString& str1, const CString& str2, const CString& str3,
  1668.   CSize& rsz1, CSize& rsz2, CSize& rsz3)
  1669. {
  1670. ASSERT(pDC);
  1671. if (!pDC)
  1672. return 0;
  1674. int nIfSingleCol = _Calc3ColSizesIfSingleCol(pDC, nW, str1, str2, str3, rsz1, rsz2, rsz3);
  1675. if (nIfSingleCol >= 0)
  1676. return nIfSingleCol;
  1678. int nW1 = pDC->GetTextExtent(str1).cx;
  1679. int nW2 = pDC->GetTextExtent(str2).cx;
  1680. int nW3 = pDC->GetTextExtent(str3).cx;
  1682. if (!nW || !nW1 && !nW2 && !nW3)
  1683. return 0;
  1685. nW1 = max(nW1, 1);
  1686. nW2 = max(nW2, 1);
  1687. nW3 = max(nW3, 1);
  1689. int nYmin = INT_MAX;
  1690. int nYminMetric = INT_MAX;
  1691. int nXforYmin[4] = {0, 1, 1, 1};
  1693. int nX[4] = {0, 0, 0, 0};
  1694. int nX_step = 15; //nW/50;
  1696. int nX_start = nW/9;
  1697. int nX_stop = nW/2 - nW/9;
  1698. for (nX[1] = nX_start; nX[1] <= nX_stop; nX[1] += nX_step)
  1699. {
  1700. int nY[4];
  1701. //************************
  1702. nY[1] = fnYi(nX[1], nW1);
  1704. int nX2_stop = nW - nX[1] - nW/9;
  1705. for (nX[2] = nX_start; nX[2] <= nX2_stop; nX[2] += nX_step)
  1706. {
  1707. nX[3] = nW - nX[1] - nX[2];
  1709. //************************
  1710. nY[2] = fnYi(nX[2], nW2);
  1711. if (nY[2] > nYmin)
  1712. continue;
  1714. nY[3] = fnYi(nX[3], nW3);
  1715. if (nY[3] > nYmin)
  1716. break;
  1718. int nY123 = max( max(nY[1], nY[2]), max(nY[1], nY[3]) );
  1720. int nM = nW / 3;
  1721. int nY123Metric = abs(nM - nX[1]) + abs(nM - nX[2]) + abs(nM - nX[3]);
  1723. if (nY123 < nYmin || nY123 == nYmin && nY123Metric < nYminMetric)
  1724. {
  1725. //TRACE(_T("-- =*=   %d <= %d, metrics(cur: %d, min: %d) n"), nY123, nYmin, nY123Metric, nYminMetric);
  1726. //TRACE(_T("-- prev (%d, %d, %d) n"), nXforYmin[1], nXforYmin[2], nXforYmin[3]);
  1727. //TRACE(_T("-- new  (%d, %d, %d) n"), nX[1], nX[2], nX[3]);
  1729. nYmin = nY123;
  1730. nYminMetric = nY123Metric;
  1732. nXforYmin[1] = nX[1];
  1733. nXforYmin[2] = nX[2];
  1734. nXforYmin[3] = nX[3];
  1735. }
  1736. }
  1737. }
  1739. ASSERT(nXforYmin[1] + nXforYmin[2] + nXforYmin[3] <= nW);
  1741. UINT uFlags = DT_TOP | DT_WORDBREAK | DT_CALCRECT;
  1742. CRect rcText1(0, 0, nXforYmin[1], 32000);
  1744. rsz1.cx = nXforYmin[1];
  1745. rsz1.cy = pDC->DrawText(str1, &rcText1, uFlags | DT_LEFT);
  1747. CRect rcText2(0, 0, nXforYmin[2], 32000);
  1748. rsz2.cx = nXforYmin[2];
  1749. rsz2.cy = pDC->DrawText(str2, &rcText2, uFlags | DT_CENTER);
  1751. CRect rcText3(0, 0, nXforYmin[3], 32000);
  1752. rsz3.cx = nXforYmin[3];
  1753. rsz3.cy = pDC->DrawText(str3, &rcText3, uFlags | DT_RIGHT);
  1755. return max( max(rsz1.cy, rsz2.cy), max(rsz1.cy, rsz3.cy) );
  1756. }
  1758. void CXTPPrintPageHeaderFooter::Draw(CDC* pDC, CRect& rcRect, BOOL bCalculateOnly)
  1759. {
  1760. CFont fntHF;
  1761. VERIFY(fntHF.CreateFontIndirect(&m_lfFont));
  1762. CXTPFontDC autoFont(pDC, &fntHF, m_clrColor);
  1764. int nWidth = rcRect.Width();
  1766. CSize szLeft2, szCenter2, szRight2;
  1768. int nHeight = Calc3ColSizes(pDC, nWidth, m_strLeft, m_strCenter, m_strRight,
  1769. szLeft2, szCenter2, szRight2);
  1771. int nBorderH = nHeight ? 3 : 0;
  1772. if (m_bHeader)
  1773. {
  1774. rcRect.bottom = rcRect.top + nHeight + nBorderH;
  1775. }
  1776. else
  1777. {
  1778. rcRect.top = rcRect.bottom - nHeight - nBorderH;
  1779. }
  1781. if (bCalculateOnly)
  1782. {
  1783. return;
  1784. }
  1786. int nBkModePrev = pDC->SetBkMode(TRANSPARENT);
  1788. UINT uFlags = DT_TOP | DT_WORDBREAK | DT_NOPREFIX;
  1790. CRect rcLeft = rcRect;
  1791. rcLeft.right = rcLeft.left + szLeft2.cx;
  1792. pDC->DrawText(m_strLeft, &rcLeft, uFlags | DT_LEFT);
  1794. CRect rcCenter = rcRect;
  1795. rcCenter.left = rcLeft.right;
  1796. rcCenter.right = rcCenter.left + szCenter2.cx;
  1797. pDC->DrawText(m_strCenter, &rcCenter, uFlags | DT_CENTER);
  1799. CRect rcRight = rcRect;
  1800. rcRight.left = rcRight.right - szRight2.cx;
  1801. pDC->DrawText(m_strRight, &rcRight, uFlags | DT_RIGHT);
  1803. pDC->SetBkMode(nBkModePrev);
  1804. }
  1806. //*************************************************************
  1807. IMPLEMENT_DYNAMIC(CXTPPrintOptions, CCmdTarget)
  1809. LCID CXTPPrintOptions::GetActiveLCID()
  1810. {
  1811. return LOCALE_USER_DEFAULT;
  1812. }
  1814. BOOL CXTPPrintOptions::IsMarginsMeasureInches()
  1815. {
  1816. TCHAR szResult[5];
  1818. int nResult = ::GetLocaleInfo(GetActiveLCID(), LOCALE_IMEASURE, szResult, 4);
  1819. ASSERT(nResult == 2);
  1820. long nIsInches = _ttoi(szResult);
  1822. return nIsInches != 0;
  1823. }
  1825. CXTPPrintOptions::CXTPPrintOptions()
  1826. {
  1827. BOOL bIsInches = IsMarginsMeasureInches();
  1828. int nMargin = bIsInches ? (1000 * 1/2  ) : (10 * 100);
  1829. m_rcMargins.SetRect(nMargin, nMargin, nMargin, nMargin);
  1831. m_pPageHeader = new CXTPPrintPageHeaderFooter(this, TRUE);
  1832. m_pPageFooter = new CXTPPrintPageHeaderFooter(this, FALSE);
  1834. m_bBlackWhitePrinting = FALSE;
  1835. m_nBlackWhiteContrast = 0;
  1837. //#ifdef _XTP_ACTIVEX
  1838. //  EnableAutomation();
  1839. //  EnableTypeLib();
  1840. //#endif
  1841. }
  1843. CXTPPrintOptions::~CXTPPrintOptions()
  1844. {
  1845. CMDTARGET_RELEASE(m_pPageHeader);
  1846. CMDTARGET_RELEASE(m_pPageFooter);
  1847. }
  1849. void CXTPPrintOptions::Set(const CXTPPrintOptions* pSrc)
  1850. {
  1851. ASSERT(pSrc);
  1852. if (!pSrc)
  1853. return;
  1855. m_rcMargins = pSrc->m_rcMargins;
  1857. if (m_pPageHeader)
  1858. m_pPageHeader->Set(pSrc->m_pPageHeader);
  1860. if (m_pPageFooter)
  1861. m_pPageFooter->Set(pSrc->m_pPageFooter);
  1863. m_bBlackWhitePrinting = pSrc->m_bBlackWhitePrinting;
  1864. m_nBlackWhiteContrast = pSrc->m_nBlackWhiteContrast;
  1865. }
  1867. CRect CXTPPrintOptions::GetMarginsHimetric()
  1868. {
  1869. BOOL bIsInches = IsMarginsMeasureInches();
  1871. if (!bIsInches)
  1872. {
  1873. return m_rcMargins;
  1874. }
  1876. int nMul_i2m = 254;
  1877. int nDiv_i2m = 100;
  1879. CRect rcMarginsHimetric;
  1880. rcMarginsHimetric.left = m_rcMargins.left * nMul_i2m / nDiv_i2m;
  1881. rcMarginsHimetric.top = m_rcMargins.top * nMul_i2m / nDiv_i2m;
  1882. rcMarginsHimetric.right = m_rcMargins.right * nMul_i2m / nDiv_i2m;
  1883. rcMarginsHimetric.bottom = m_rcMargins.bottom * nMul_i2m / nDiv_i2m;
  1885. return rcMarginsHimetric;
  1886. }
  1888. CRect CXTPPrintOptions::GetMarginsLP(CDC* pDC)
  1889. {
  1890. ASSERT(pDC);
  1891. if (!pDC)
  1892. return CRect(0, 0, 0, 0);
  1894. CRect rcMarginsHI = GetMarginsHimetric();
  1896. CSize szLT(rcMarginsHI.left, rcMarginsHI.top);
  1897. CSize szRB(rcMarginsHI.right, rcMarginsHI.bottom);
  1899. pDC->HIMETRICtoLP(&szLT);
  1900. pDC->HIMETRICtoLP(&szRB);
  1902. CRect rcLP(szLT.cx, szLT.cy, szRB.cx, szRB.cy);
  1904. return rcLP;
  1905. }
  1907. CXTPPrintPageHeaderFooter* CXTPPrintOptions::GetPageHeader()
  1908. {
  1909. return m_pPageHeader;
  1910. }
  1912. CXTPPrintPageHeaderFooter* CXTPPrintOptions::GetPageFooter()
  1913. {
  1914. return m_pPageFooter;
  1915. }
  1918. /////////////////////////////////////////////////////////////////////////////
  1919. // Printing Dialog
  1922. class XTP_PRINT_STATE : public CNoTrackObject
  1923. {
  1924. public:
  1925. // printing abort
  1926. BOOL m_bUserAbort;
  1927. };
  1929. PROCESS_LOCAL(XTP_PRINT_STATE, g_xtpPrintState)
  1931. BOOL CALLBACK _XTPAbortProc(HDC, int)
  1932. {
  1933. XTP_PRINT_STATE* pState = g_xtpPrintState;
  1934. MSG msg;
  1935. while (!pState->m_bUserAbort &&
  1936. ::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE))
  1937. {
  1938. if (!AfxGetThread()->PumpMessage())
  1939. return FALSE;   // terminate if WM_QUIT received
  1940. }
  1941. return !pState->m_bUserAbort;
  1942. }
  1944. CXTPPrintingDialog::CXTPPrintingDialog(CWnd* pParent)
  1945. {
  1946. Create(CXTPPrintingDialog::IDD, pParent);      // modeless !
  1947. g_xtpPrintState->m_bUserAbort = FALSE;
  1948. }
  1950. BOOL CXTPPrintingDialog::OnInitDialog()
  1951. {
  1952. //SetWindowText(AfxGetAppName());
  1953. CenterWindow();
  1954. return CDialog::OnInitDialog();
  1955. }
  1957. void CXTPPrintingDialog::OnCancel()
  1958. {
  1959. g_xtpPrintState->m_bUserAbort = TRUE;  // flag that user aborted print
  1960. CDialog::OnCancel();
  1961. }
  1963. void CXTPPrintPageHeaderFooter::DoInsertHFFormatSpecifierViaMenu(
  1964. CWnd* pParent, CEdit* pEdit, CButton* pButton)
  1965. {
  1966. CMap<UINT, UINT, CString, CString&> menuData;
  1967. menuData[XTP_ID_HF_FORMAT_D1]   = _T("&d");
  1968. menuData[XTP_ID_HF_FORMAT_D2]   = _T("&D");
  1969. menuData[XTP_ID_HF_FORMAT_T1]   = _T("&t");
  1970. menuData[XTP_ID_HF_FORMAT_T2]   = _T("&T");
  1971. menuData[XTP_ID_HF_FORMAT_P1]   = _T("&p");
  1972. menuData[XTP_ID_HF_FORMAT_P2]   = _T("&P");
  1973. menuData[XTP_ID_HF_FORMAT_B]    = _T("&b");
  1974. menuData[XTP_ID_HF_FORMAT_W]    = _T("&w");
  1975. menuData[XTP_ID_HF_FORMAT_UMP]  = _T("&&");
  1976. menuData[XTP_ID_HF_FORMAT_N]    = _T("\n");
  1978. if (!pParent || !pEdit || !pButton)
  1979. {
  1980. ASSERT(FALSE);
  1981. return;
  1982. }
  1983. CRect rcButton;
  1984. pButton->GetWindowRect(&rcButton);
  1986. CPoint ptMenu(rcButton.left, rcButton.bottom + 1);
  1988. CMenu menu;
  1989. VERIFY(XTPResourceManager()->LoadMenu(&menu, XTP_IDR_MENU_HEADERFOOTER_FORMATS));
  1991. // track menu
  1992. int nMenuResult = menu.GetSubMenu(0)->TrackPopupMenu(
  1993. TPM_RETURNCMD | TPM_LEFTALIGN |TPM_RIGHTBUTTON,
  1994. ptMenu.x, ptMenu.y, pParent, NULL);
  1996. pEdit->SetFocus();
  1998. CString strItem = menuData[nMenuResult];
  1999. if (!strItem.IsEmpty())
  2000. {
  2001. pEdit->ReplaceSel(strItem, TRUE);
  2002. }
  2004. }
  2006. //////////////////////////////////////////////////////////////////////////