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

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

对话框与窗口

开发平台：

Visual C++

ruler.cpp：源码内容
  1. // ruler.cpp : implementation file
  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 "wordpad.h"
  23. #include "ruler.h"
  24. #include "wordpvw.h"
  25. #include "wordpdoc.h"
  26. #include "strings.h"
  27. #include <memory.h>
  30. #ifdef _DEBUG
  31. #undef THIS_FILE
  32. static char BASED_CODE THIS_FILE[] = __FILE__;
  33. #endif
  35. #define HEIGHT 17
  36. #define RULERBARHEIGHT 17
  38. CRulerItem::CRulerItem(UINT nBitmapID)
  39. {
  40. m_nAlignment = TA_CENTER;
  41. m_pDC = NULL;
  42. m_bTrack = FALSE;
  43. m_hbm = NULL;
  44. m_hbmMask = NULL;
  45. if (nBitmapID != 0)
  46. {
  47. m_hbmMask = ::LoadBitmap(
  48. AfxFindResourceHandle(MAKEINTRESOURCE(nBitmapID+1), RT_BITMAP),
  49. MAKEINTRESOURCE(nBitmapID+1));
  50. ASSERT(m_hbmMask != NULL);
  51. VERIFY(LoadMaskedBitmap(MAKEINTRESOURCE(nBitmapID)));
  52. BITMAP bm;
  53. ::GetObject(m_hbm, sizeof(BITMAP), &bm);
  54. m_size = CSize(bm.bmWidth, bm.bmHeight);
  55. }
  56. }
  58. CRulerItem::~CRulerItem()
  59. {
  60. if (m_hbm != NULL)
  61. ::DeleteObject(m_hbm);
  62. if (m_hbmMask != NULL)
  63. ::DeleteObject(m_hbmMask);
  64. }
  66. BOOL CRulerItem::LoadMaskedBitmap(LPCTSTR lpszResourceName)
  67. {
  68. ASSERT(lpszResourceName != NULL);
  70. if (m_hbm != NULL)
  71. ::DeleteObject(m_hbm);
  73. HINSTANCE hInst = AfxFindResourceHandle(lpszResourceName, RT_BITMAP);
  74. HRSRC hRsrc = ::FindResource(hInst, lpszResourceName, RT_BITMAP);
  75. if (hRsrc == NULL)
  76. return FALSE;
  78. m_hbm = AfxLoadSysColorBitmap(hInst, hRsrc);
  79. return (m_hbm != NULL);
  80. }
  82. void CRulerItem::SetHorzPosTwips(int nXPos)
  83. {
  84. if (GetHorzPosTwips() != nXPos)
  85. {
  86. if (m_bTrack)
  87. DrawFocusLine();
  88. Invalidate();
  89. m_nXPosTwips = nXPos;
  90. Invalidate();
  91. if (m_bTrack)
  92. DrawFocusLine();
  93. }
  94. }
  96. void CRulerItem::TrackHorzPosTwips(int nXPos, BOOL /*bOnRuler*/)
  97. {
  98. int nMin = GetMin();
  99. int nMax = GetMax();
  100. if (nXPos < nMin)
  101. nXPos = nMin;
  102. if (nXPos > nMax)
  103. nXPos = nMax;
  104. SetHorzPosTwips(nXPos);
  105. }
  107. void CRulerItem::DrawFocusLine()
  108. {
  109. if (GetHorzPosTwips() != 0)
  110. {
  111. m_rcTrack.left = m_rcTrack.right = GetHorzPosPix();
  112. ASSERT(m_pDC != NULL);
  113. int nLeft = m_pRuler->XRulerToClient(m_rcTrack.left);
  114. m_pDC->MoveTo(nLeft, m_rcTrack.top);
  115. m_pDC->LineTo(nLeft, m_rcTrack.bottom);
  116. }
  117. }
  119. void CRulerItem::SetTrack(BOOL b)
  120. {
  121. m_bTrack = b;
  123. if (m_pDC != NULL) // just in case we lost focus Capture somewhere
  124. {
  125. DrawFocusLine();
  126. m_pDC->RestoreDC(-1);
  127. delete m_pDC ;
  128. m_pDC = NULL;
  129. }
  130. if (m_bTrack)
  131. {
  132. CWordPadView* pView = (CWordPadView*)m_pRuler->GetView();
  133. ASSERT(pView != NULL);
  134. pView->GetClientRect(&m_rcTrack);
  135. m_pDC = new CWindowDC(pView);
  136. m_pDC->SaveDC();
  137. m_pDC->SelectObject(&m_pRuler->penFocusLine);
  138. m_pDC->SetROP2(R2_XORPEN);
  139. DrawFocusLine();
  140. }
  141. }
  143. void CRulerItem::Invalidate()
  144. {
  145. CRect rc = GetHitRectPix();
  146. m_pRuler->RulerToClient(rc.TopLeft());
  147. m_pRuler->RulerToClient(rc.BottomRight());
  148. m_pRuler->InvalidateRect(rc);
  149. }
  151. CRect CRulerItem::GetHitRectPix()
  152. {
  153. int nx = GetHorzPosPix();
  154. return CRect(
  155. CPoint(
  156. (m_nAlignment == TA_CENTER) ? (nx - m_size.cx/2) :
  157. (m_nAlignment == TA_LEFT) ? nx : nx - m_size.cx
  158. , m_nYPosPix
  159. ),
  160. m_size);
  161. }
  163. void CRulerItem::Draw(CDC& dc)
  164. {
  165. CDC dcBitmap;
  166. dcBitmap.CreateCompatibleDC(&dc);
  167. CPoint pt(GetHorzPosPix(), GetVertPosPix());
  169. HGDIOBJ hbm = ::SelectObject(dcBitmap.m_hDC, m_hbmMask);
  171. // do mask part
  172. if (m_nAlignment == TA_CENTER)
  173. dc.BitBlt(pt.x - m_size.cx/2, pt.y, m_size.cx, m_size.cy, &dcBitmap, 0, 0, SRCAND);
  174. else if (m_nAlignment == TA_LEFT)
  175. dc.BitBlt(pt.x, pt.y, m_size.cx, m_size.cy, &dcBitmap, 0, 0, SRCAND);
  176. else // TA_RIGHT
  177. dc.BitBlt(pt.x - m_size.cx, pt.y, m_size.cx, m_size.cy, &dcBitmap, 0, 0, SRCAND);
  179. // do image part
  180. ::SelectObject(dcBitmap.m_hDC, m_hbm);
  182. if (m_nAlignment == TA_CENTER)
  183. dc.BitBlt(pt.x - m_size.cx/2, pt.y, m_size.cx, m_size.cy, &dcBitmap, 0, 0, SRCINVERT);
  184. else if (m_nAlignment == TA_LEFT)
  185. dc.BitBlt(pt.x, pt.y, m_size.cx, m_size.cy, &dcBitmap, 0, 0, SRCINVERT);
  186. else // TA_RIGHT
  187. dc.BitBlt(pt.x - m_size.cx, pt.y, m_size.cx, m_size.cy, &dcBitmap, 0, 0, SRCINVERT);
  189. ::SelectObject(dcBitmap.m_hDC, hbm);
  190. }
  192. CComboRulerItem::CComboRulerItem(UINT nBitmapID1, UINT nBitmapID2, CRulerItem& item)
  193. : CRulerItem(nBitmapID1), m_secondary(nBitmapID2) , m_link(item)
  194. {
  195. m_bHitPrimary = TRUE;
  196. }
  198. BOOL CComboRulerItem::HitTestPix(CPoint pt)
  199. {
  200. m_bHitPrimary = FALSE;
  201. if (CRulerItem::GetHitRectPix().PtInRect(pt))
  202. m_bHitPrimary = TRUE;
  203. else
  204. return m_secondary.HitTestPix(pt);
  205. return TRUE;
  206. }
  208. void CComboRulerItem::Draw(CDC& dc)
  209. {
  210. CRulerItem::Draw(dc);
  211. m_secondary.Draw(dc);
  212. }
  214. void CComboRulerItem::SetHorzPosTwips(int nXPos)
  215. {
  216. if (m_bHitPrimary) // only change linked items by delta
  217. m_link.SetHorzPosTwips(m_link.GetHorzPosTwips() + nXPos - GetHorzPosTwips());
  218. CRulerItem::SetHorzPosTwips(nXPos);
  219. m_secondary.SetHorzPosTwips(nXPos);
  220. }
  222. void CComboRulerItem::TrackHorzPosTwips(int nXPos, BOOL /*bOnRuler*/)
  223. {
  224. int nMin = GetMin();
  225. int nMax = GetMax();
  226. if (nXPos < nMin)
  227. nXPos = nMin;
  228. if (nXPos > nMax)
  229. nXPos = nMax;
  230. SetHorzPosTwips(nXPos);
  231. }
  233. void CComboRulerItem::SetVertPos(int nYPos)
  234. {
  235. m_secondary.SetVertPos(nYPos);
  236. nYPos += m_secondary.GetHitRectPix().Height();
  237. CRulerItem::SetVertPos(nYPos);
  238. }
  240. void CComboRulerItem::SetAlignment(int nAlign)
  241. {
  242. CRulerItem::SetAlignment(nAlign);
  243. m_secondary.SetAlignment(nAlign);
  244. }
  246. void CComboRulerItem::SetRuler(CRulerBar* pRuler)
  247. {
  248. m_pRuler = pRuler;
  249. m_secondary.SetRuler(pRuler);
  250. }
  252. void CComboRulerItem::SetBounds(int nMin, int nMax)
  253. {
  254. CRulerItem::SetBounds(nMin, nMax);
  255. m_secondary.SetBounds(nMin, nMax);
  256. }
  258. int CComboRulerItem::GetMin()
  259. {
  260. if (m_bHitPrimary)
  261. {
  262. int nPDist = GetHorzPosTwips() - CRulerItem::GetMin();
  263. int nLDist = m_link.GetHorzPosTwips() - m_link.GetMin();
  264. return GetHorzPosTwips() - min(nPDist, nLDist);
  265. }
  266. else
  267. return CRulerItem::GetMin();
  268. }
  270. int CComboRulerItem::GetMax()
  271. {
  272. if (m_bHitPrimary)
  273. {
  274. int nPDist = CRulerItem::GetMax() - GetHorzPosTwips();
  275. int nLDist = m_link.GetMax() - m_link.GetHorzPosTwips();
  276. int nMinDist = (nPDist < nLDist) ? nPDist : nLDist;
  277. return GetHorzPosTwips() + nMinDist;
  278. }
  279. else
  280. return CRulerItem::GetMax();
  281. }
  283. void CTabRulerItem::TrackHorzPosTwips(int nXPos, BOOL bOnRuler)
  284. {
  285. if (bOnRuler)
  286. CRulerItem::TrackHorzPosTwips(nXPos, bOnRuler);
  287. else
  288. CRulerItem::TrackHorzPosTwips(0, bOnRuler);
  289. }
  292. BEGIN_MESSAGE_MAP(CRulerBar, CControlBar)
  293. //{{AFX_MSG_MAP(CRulerBar)
  294. ON_WM_LBUTTONDOWN()
  295. ON_WM_LBUTTONUP()
  296. ON_WM_MOUSEMOVE()
  297. ON_WM_SYSCOLORCHANGE()
  298. ON_WM_WINDOWPOSCHANGING()
  299. ON_WM_SHOWWINDOW()
  300. ON_WM_WINDOWPOSCHANGED()
  301. //}}AFX_MSG_MAP
  302. ON_MESSAGE(WM_SIZEPARENT, OnSizeParent)
  303. // Global help commands
  304. END_MESSAGE_MAP()
  306. CRulerBar::CRulerBar(BOOL b3DExt) :
  307. m_leftmargin(IDB_RULER_BLOCK, IDB_RULER_UP, m_indent),
  308. m_indent(IDB_RULER_DOWN),
  309. m_rightmargin(IDB_RULER_UP),
  310. m_tabItem(IDB_RULER_TAB)
  311. {
  312. m_bDeferInProgress = FALSE;
  313. m_leftmargin.SetRuler(this);
  314. m_indent.SetRuler(this);
  315. m_rightmargin.SetRuler(this);
  317. // all of the tab stops share handles
  318. for (int i=0;i<MAX_TAB_STOPS;i++)
  319. {
  320. m_pTabItems[i].m_hbm = m_tabItem.m_hbm;
  321. m_pTabItems[i].m_hbmMask = m_tabItem.m_hbmMask;
  322. m_pTabItems[i].m_size = m_tabItem.m_size;
  323. }
  325. m_unit.m_nTPU = 0;
  326. m_nScroll = 0;
  328. LOGFONT lf;
  329. MEMCPY_S(&lf, &theApp.m_lf, sizeof(LOGFONT));
  330. lf.lfHeight = -8;
  331. lf.lfWidth = 0;
  332. VERIFY(fnt.CreateFontIndirect(&lf));
  334. m_nTabs = 0;
  335. m_leftmargin.SetVertPos(9);
  336. m_indent.SetVertPos(-1);
  337. m_rightmargin.SetVertPos(9);
  339. m_cxLeftBorder = 0;
  340. if (!theApp.m_bWin4)
  341. m_bDraw3DExt = FALSE;
  342. else
  343. m_bDraw3DExt = b3DExt;
  345. m_cyTopBorder = 4;
  346. m_cyBottomBorder = 6;
  348. m_pSelItem = NULL;
  350. m_logx = theApp.m_dcScreen.GetDeviceCaps(LOGPIXELSX);
  352. CreateGDIObjects();
  353. }
  355. CRulerBar::~CRulerBar()
  356. {
  357. // set handles to NULL to avoid deleting twice
  358. for (int i=0;i<MAX_TAB_STOPS;i++)
  359. {
  360. m_pTabItems[i].m_hbm = NULL;
  361. m_pTabItems[i].m_hbmMask = NULL;
  362. }
  363. }
  365. void CRulerBar::CreateGDIObjects()
  366. {
  367. penFocusLine.DeleteObject();
  368. penBtnHighLight.DeleteObject();
  369. penBtnShadow.DeleteObject();
  370. penWindowFrame.DeleteObject();
  371. penBtnText.DeleteObject();
  372. penBtnFace.DeleteObject();
  373. penWindowText.DeleteObject();
  374. penWindow.DeleteObject();
  375. brushWindow.DeleteObject();
  376. brushBtnFace.DeleteObject();
  378. penFocusLine.CreatePen(PS_DOT, 1,GetSysColor(COLOR_WINDOWTEXT));
  379. penBtnHighLight.CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNHIGHLIGHT));
  380. penBtnShadow.CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW));
  381. penWindowFrame.CreatePen(PS_SOLID, 0, GetSysColor(COLOR_WINDOWFRAME));
  382. penBtnText.CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNTEXT));
  383. penBtnFace.CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNFACE));
  384. penWindowText.CreatePen(PS_SOLID, 0, GetSysColor(COLOR_WINDOWTEXT));
  385. penWindow.CreatePen(PS_SOLID, 0, GetSysColor(COLOR_WINDOW));
  386. brushWindow.CreateSolidBrush(GetSysColor(COLOR_WINDOW));
  387. brushBtnFace.CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
  389. }
  391. void CRulerBar::OnUpdateCmdUI(CFrameWnd* /*pTarget*/, BOOL /*bDisableIfNoHndler*/)
  392. {
  393. ASSERT_VALID(this);
  394. //Get the page size and see if changed -- from document
  395. //get margins and tabs and see if changed -- from view
  396. if (m_pSelItem == NULL) // only update if not in middle of dragging
  397. {
  398. CWordPadView* pView = (CWordPadView*)GetView();
  399. ASSERT(pView != NULL);
  400. Update(pView->GetPaperSize(), pView->GetMargins());
  401. Update(pView->GetParaFormatSelection());
  402. CRect rect;
  403. pView->GetRichEditCtrl().GetRect(&rect);
  404. CPoint pt = rect.TopLeft();
  405. pView->ClientToScreen(&pt);
  406. ScreenToClient(&pt);
  407. if (m_cxLeftBorder != pt.x)
  408. {
  409. m_cxLeftBorder = pt.x;
  410. Invalidate();
  411. }
  412. int nScroll = pView->GetScrollPos(SB_HORZ);
  413. if (nScroll != m_nScroll)
  414. {
  415. m_nScroll = nScroll;
  416. Invalidate();
  417. }
  418. }
  419. }
  421. CSize CRulerBar::GetBaseUnits()
  422. {
  423. ASSERT(fnt.GetSafeHandle() != NULL);
  424. CFont* pFont = theApp.m_dcScreen.SelectObject(&fnt);
  425. TEXTMETRIC tm;
  426. VERIFY(theApp.m_dcScreen.GetTextMetrics(&tm) == TRUE);
  427. theApp.m_dcScreen.SelectObject(pFont);
  428. //  return CSize(tm.tmAveCharWidth, tm.tmHeight+tm.tmDescent);
  429. return CSize(tm.tmAveCharWidth, tm.tmHeight);
  430. }
  432. BOOL CRulerBar::Create(CWnd* pParentWnd, DWORD dwStyle, UINT nID)
  433. {
  434. ASSERT_VALID(pParentWnd);   // must have a parent
  436. dwStyle |= WS_CLIPSIBLINGS;
  437. // force WS_CLIPSIBLINGS (avoids SetWindowPos bugs)
  438. m_dwStyle = (dwStyle & CBRS_ALL);
  440. // create the HWND
  441. CRect rect;
  442. rect.SetRectEmpty();
  443. LPCTSTR lpszClass = AfxRegisterWndClass(0, ::LoadCursor(NULL, IDC_ARROW),
  444. (HBRUSH)(COLOR_BTNFACE+1), NULL);
  446. if (!CWnd::Create(lpszClass, NULL, dwStyle, rect, pParentWnd, nID))
  447. return FALSE;
  448. // NOTE: Parent must resize itself for control bar to be resized
  450. int i;
  451. int nMax = 100;
  452. for (i=0;i<MAX_TAB_STOPS;i++)
  453. {
  454. m_pTabItems[i].SetRuler(this);
  455. m_pTabItems[i].SetVertPos(8);
  456. m_pTabItems[i].SetHorzPosTwips(0);
  457. m_pTabItems[i].SetBounds(0, nMax);
  458. }
  459. return TRUE;
  460. }
  462. CSize CRulerBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  463. {
  464. ASSERT(bHorz);
  465. CSize m_size = CControlBar::CalcFixedLayout(bStretch, bHorz);
  466. CRect rectSize;
  467. rectSize.SetRectEmpty();
  468. CalcInsideRect(rectSize, bHorz);       // will be negative size
  469. m_size.cy = RULERBARHEIGHT - rectSize.Height();
  470. return m_size;
  471. }
  473. void CRulerBar::Update(const PARAFORMAT& pf)
  474. {
  475. ASSERT(pf.cTabCount <= MAX_TAB_STOPS);
  477. m_leftmargin.SetHorzPosTwips((int)(pf.dxStartIndent + pf.dxOffset));
  478. m_indent.SetHorzPosTwips((int)pf.dxStartIndent);
  479. m_rightmargin.SetHorzPosTwips(PrintWidth() - (int) pf.dxRightIndent);
  481. int i = 0;
  482. for (i=0;i<pf.cTabCount;i++)
  483. m_pTabItems[i].SetHorzPosTwips((int)pf.rgxTabs[i]);
  484. for ( ;i<MAX_TAB_STOPS; i++)
  485. m_pTabItems[i].SetHorzPosTwips(0);
  486. }
  488. void CRulerBar::Update(CSize sizePaper, const CRect& rectMargins)
  489. {
  490. if ((sizePaper != m_sizePaper) || (rectMargins != m_rectMargin))
  491. {
  492. m_sizePaper = sizePaper;
  493. m_rectMargin = rectMargins;
  494. Invalidate();
  495. }
  496. if (m_unit.m_nTPU != theApp.GetTPU())
  497. {
  498. m_unit = theApp.GetUnit();
  499. Invalidate();
  500. }
  501. }
  503. void CRulerBar::FillInParaFormat(PARAFORMAT& pf)
  504. {
  505. pf.dwMask = PFM_STARTINDENT | PFM_RIGHTINDENT | PFM_OFFSET | PFM_TABSTOPS;
  506. pf.dxStartIndent = m_indent.GetHorzPosTwips();
  507. pf.dxOffset = m_leftmargin.GetHorzPosTwips() - pf.dxStartIndent;
  508. pf.dxRightIndent = PrintWidth() - m_rightmargin.GetHorzPosTwips();
  509. pf.cTabCount = 0L;
  510. SortTabs();
  511. int i, nPos = 0;
  512. for (i=0;i<MAX_TAB_STOPS;i++)
  513. {
  514. // get rid of zeroes and multiples
  515. // i.e. if we have 0,0,0,1,2,3,4,4,5
  516. // we will get tabs at 1,2,3,4,5
  517. if (nPos != m_pTabItems[i].GetHorzPosTwips())
  518. {
  519. nPos = m_pTabItems[i].GetHorzPosTwips();
  520. pf.rgxTabs[pf.cTabCount++] = nPos;
  521. }
  522. }
  523. }
  525. // simple bubble sort is adequate for small number of tabs
  526. void CRulerBar::SortTabs()
  527. {
  528. int i,j, nPos;
  529. for (i=0;i<MAX_TAB_STOPS - 1;i++)
  530. {
  531. for (j=i+1; j < MAX_TAB_STOPS;j++)
  532. {
  533. if (m_pTabItems[j].GetHorzPosTwips() < m_pTabItems[i].GetHorzPosTwips())
  534. {
  535. nPos = m_pTabItems[j].GetHorzPosTwips();
  536. m_pTabItems[j].SetHorzPosTwips(m_pTabItems[i].GetHorzPosTwips());
  537. m_pTabItems[i].SetHorzPosTwips(nPos);
  538. }
  539. }
  540. }
  541. }
  543. void CRulerBar::DoPaint(CDC* pDC)
  544. {
  545. pDC->FillSolidRect(CXTPClientRect(this), XTPPaintManager()->GetXtremeColor(XPCOLOR_3DFACE));
  546. CControlBar::DoPaint(pDC); // CControlBar::DoPaint -- draws border
  547. if (m_unit.m_nTPU != 0)
  548. {
  549. pDC->SaveDC();
  550. // offset coordinate system
  551. CPoint pointOffset(0,0);
  552. RulerToClient(pointOffset);
  553. pDC->SetViewportOrg(pointOffset);
  555. DrawFace(*pDC);
  556. DrawTickMarks(*pDC);
  558. DrawTabs(*pDC);
  559. m_leftmargin.Draw(*pDC);
  560. m_indent.Draw(*pDC);
  561. m_rightmargin.Draw(*pDC);
  563. pDC->RestoreDC(-1);
  564. }
  565. // Do not call CControlBar::OnPaint() for painting messages
  566. }
  568. void CRulerBar::DrawTabs(CDC& dc)
  569. {
  570. int i;
  571. int nPos = 0;
  572. for (i=0;i<MAX_TAB_STOPS;i++)
  573. {
  574. if (m_pTabItems[i].GetHorzPosTwips() > nPos)
  575. nPos = (m_pTabItems[i].GetHorzPosTwips());
  576. m_pTabItems[i].Draw(dc);
  577. }
  578. int nPageWidth = PrintWidth();
  579. nPos = nPos - nPos%720 + 720;
  580. dc.SelectObject(&penBtnShadow);
  581. for ( ; nPos < nPageWidth; nPos += 720)
  582. {
  583. int nx = XTwipsToRuler(nPos);
  584. dc.MoveTo(nx, HEIGHT - 1);
  585. dc.LineTo(nx, HEIGHT + 1);
  586. }
  587. }
  589. void CRulerBar::DrawFace(CDC& dc)
  590. {
  591. int nPageWidth = XTwipsToRuler(PrintWidth());
  592. int nPageEdge = XTwipsToRuler(PrintWidth() + m_rectMargin.right);
  594. dc.SaveDC();
  596. dc.SelectObject(&penBtnShadow);
  597. dc.MoveTo(0,0);
  598. dc.LineTo(nPageEdge - 1, 0);
  599. dc.LineTo(nPageEdge - 1, HEIGHT - 2);
  600. dc.LineTo(nPageWidth - 1, HEIGHT - 2);
  601. dc.LineTo(nPageWidth - 1, 1);
  602. dc.LineTo(nPageWidth, 1);
  603. dc.LineTo(nPageWidth, HEIGHT -2);
  605. dc.SelectObject(&penBtnHighLight);
  606. dc.MoveTo(nPageWidth, HEIGHT - 1);
  607. dc.LineTo(nPageEdge, HEIGHT -1);
  608. dc.MoveTo(nPageWidth + 1, HEIGHT - 3);
  609. dc.LineTo(nPageWidth + 1, 1);
  610. dc.LineTo(nPageEdge - 1, 1);
  612. dc.SelectObject(&penWindow);
  613. dc.MoveTo(0, HEIGHT - 1);
  614. dc.LineTo(nPageWidth, HEIGHT -1);
  616. dc.SelectObject(&penBtnFace);
  617. dc.MoveTo(1, HEIGHT - 2);
  618. dc.LineTo(nPageWidth - 1, HEIGHT - 2);
  620. dc.SelectObject(&penWindowFrame);
  621. dc.MoveTo(0, HEIGHT - 2);
  622. dc.LineTo(0, 1);
  623. dc.LineTo(nPageWidth - 1, 1);
  625. dc.FillRect(CRect(1, 2, nPageWidth - 1, HEIGHT-2), &brushWindow);
  626. dc.FillSolidRect(CRect(nPageWidth + 2, 2, nPageEdge - 1, HEIGHT-2), XTPPaintManager()->GetXtremeColor(XPCOLOR_3DSHADOW));
  628. CRect rcClient;
  629. GetClientRect(&rcClient);
  630. ClientToRuler(rcClient);
  631. rcClient.top = HEIGHT;
  632. rcClient.bottom = HEIGHT + 2;
  633. dc.FillSolidRect(rcClient, XTPPaintManager()->GetXtremeColor(XPCOLOR_3DSHADOW));
  635. CRect rectFill(rcClient.left, HEIGHT+4, rcClient.right, HEIGHT+9);
  636. dc.FillRect(rectFill, &brushWindow);
  638. if (m_bDraw3DExt)  // draws the 3D extension into the view
  639. {
  640. dc.SelectObject(&penBtnShadow);
  641. dc.MoveTo(rcClient.left, HEIGHT+8);
  642. dc.LineTo(rcClient.left, HEIGHT+2);
  643. dc.LineTo(rcClient.right-1, HEIGHT+2);
  645. dc.SelectObject(&penWindowFrame);
  646. dc.MoveTo(rcClient.left+1, HEIGHT+8);
  647. dc.LineTo(rcClient.left+1, HEIGHT+3);
  648. dc.LineTo(rcClient.right-2, HEIGHT+3);
  650. dc.SelectObject(&penBtnHighLight);
  651. dc.MoveTo(rcClient.right-1, HEIGHT+2);
  652. dc.LineTo(rcClient.right-1, HEIGHT+8);
  654. dc.SelectObject(&penBtnFace);
  655. dc.MoveTo(rcClient.right-2, HEIGHT+3);
  656. dc.LineTo(rcClient.right-2, HEIGHT+8);
  657. }
  658. else
  659. {
  660. dc.SelectObject(&penBtnShadow);
  661. dc.MoveTo(rcClient.left, HEIGHT+2);
  662. dc.LineTo(rcClient.right, HEIGHT+2);
  664. dc.SelectObject(&penWindowFrame);
  665. dc.MoveTo(rcClient.left, HEIGHT+3);
  666. dc.LineTo(rcClient.right, HEIGHT+3);
  667. }
  669. dc.RestoreDC(-1);
  670. }
  672. void CRulerBar::DrawTickMarks(CDC& dc)
  673. {
  674. dc.SaveDC();
  676. dc.SelectObject(&penWindowText);
  677. dc.SelectObject(&fnt);
  678. dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT));
  679. dc.SetBkMode(TRANSPARENT);
  681. DrawDiv(dc, m_unit.m_nSmallDiv, m_unit.m_nLargeDiv, 2);
  682. DrawDiv(dc, m_unit.m_nMediumDiv, m_unit.m_nLargeDiv, 5);
  683. DrawNumbers(dc, m_unit.m_nLargeDiv, m_unit.m_nTPU);
  685. dc.RestoreDC(-1);
  686. }
  688. void CRulerBar::DrawNumbers(CDC& dc, int nInc, int nTPU)
  689. {
  690. int nPageWidth = PrintWidth();
  691. int nPageEdge = nPageWidth + m_rectMargin.right;
  692. TCHAR buf[10];
  694. int nTwips, nPixel, nLen;
  696. for (nTwips = nInc; nTwips < nPageEdge; nTwips += nInc)
  697. {
  698. if (nTwips == nPageWidth)
  699. continue;
  700. nPixel = XTwipsToRuler(nTwips);
  701. wsprintf(buf, _T("%d"), nTwips/nTPU);
  702. nLen = lstrlen(buf);
  703. CSize sz = dc.GetTextExtent(buf, nLen);
  704. dc.ExtTextOut(nPixel - sz.cx/2, HEIGHT/2 - sz.cy/2, 0, NULL, buf, nLen, NULL);
  705. }
  706. }
  708. void CRulerBar::DrawDiv(CDC& dc, int nInc, int nLargeDiv, int nLength)
  709. {
  710. int nPageWidth = PrintWidth();
  711. int nPageEdge = nPageWidth + m_rectMargin.right;
  713. int nTwips, nPixel;
  715. for (nTwips = nInc; nTwips < nPageEdge; nTwips += nInc)
  716. {
  717. if (nTwips == nPageWidth || nTwips%nLargeDiv == 0)
  718. continue;
  719. nPixel = XTwipsToRuler(nTwips);
  720. dc.MoveTo(nPixel, HEIGHT/2 - nLength/2);
  721. dc.LineTo(nPixel, HEIGHT/2 - nLength/2 + nLength);
  722. }
  723. }
  725. void CRulerBar::OnLButtonDown(UINT nFlags, CPoint point)
  726. {
  727. CPoint pt = point;
  728. ClientToRuler(pt);
  730. m_pSelItem = NULL;
  731. if (m_leftmargin.HitTestPix(pt))
  732. m_pSelItem = &m_leftmargin;
  733. else if (m_indent.HitTestPix(pt))
  734. m_pSelItem = &m_indent;
  735. else if (m_rightmargin.HitTestPix(pt))
  736. m_pSelItem = &m_rightmargin;
  737. else
  738. m_pSelItem = GetHitTabPix(pt);
  739. if (m_pSelItem == NULL)
  740. m_pSelItem = GetFreeTab();
  741. if (m_pSelItem == NULL)
  742. return;
  743. SetCapture();
  745. m_pSelItem->SetTrack(TRUE);
  746. SetMarginBounds();
  747. OnMouseMove(nFlags, point);
  748. }
  750. void CRulerBar::SetMarginBounds()
  751. {
  752. m_leftmargin.SetBounds(0, m_rightmargin.GetHorzPosTwips());
  753. m_indent.SetBounds(0, m_rightmargin.GetHorzPosTwips());
  755. int nMin = (m_leftmargin.GetHorzPosTwips() > m_indent.GetHorzPosTwips()) ?
  756. m_leftmargin.GetHorzPosTwips() : m_indent.GetHorzPosTwips();
  757. int nMax = PrintWidth() + m_rectMargin.right;
  758. m_rightmargin.SetBounds(nMin, nMax);
  760. // tabs can go from zero to the right page edge
  761. for (int i=0;i<MAX_TAB_STOPS;i++)
  762. m_pTabItems[i].SetBounds(0, nMax);
  763. }
  765. CRulerItem* CRulerBar::GetFreeTab()
  766. {
  767. int i;
  768. for (i=0;i<MAX_TAB_STOPS;i++)
  769. {
  770. if (m_pTabItems[i].GetHorzPosTwips() == 0)
  771. return &m_pTabItems[i];
  772. }
  773. return NULL;
  774. }
  776. CTabRulerItem* CRulerBar::GetHitTabPix(CPoint point)
  777. {
  778. int i;
  779. for (i=0;i<MAX_TAB_STOPS;i++)
  780. {
  781. if (m_pTabItems[i].HitTestPix(point))
  782. return &m_pTabItems[i];
  783. }
  784. return NULL;
  785. }
  787. void CRulerBar::OnLButtonUp(UINT nFlags, CPoint point)
  788. {
  789. if (::GetCapture() != m_hWnd)
  790. return;
  791. OnMouseMove(nFlags, point);
  792. m_pSelItem->SetTrack(FALSE);
  793. ReleaseCapture();
  794. CWordPadView* pView = (CWordPadView*)GetView();
  795. ASSERT(pView != NULL);
  796. PARAFORMAT& pf = pView->GetParaFormatSelection();
  797. FillInParaFormat(pf);
  798. pView->SetParaFormat(pf);
  799. m_pSelItem = NULL;
  800. }
  802. void CRulerBar::OnMouseMove(UINT nFlags, CPoint point)
  803. {
  804. CControlBar::OnMouseMove(nFlags, point);
  805. // use ::GetCapture to avoid creating temporaries
  806. if (::GetCapture() != m_hWnd)
  807. return;
  808. ASSERT(m_pSelItem != NULL);
  809. CRect rc(0,0, XTwipsToRuler(PrintWidth() + m_rectMargin.right), HEIGHT);
  810. RulerToClient(rc);
  811. BOOL bOnRuler = rc.PtInRect(point);
  813. // snap to minimum movement
  814. point.x = XClientToTwips(point.x);
  815. point.x += m_unit.m_nMinMove/2;
  816. point.x -= point.x%m_unit.m_nMinMove;
  818. m_pSelItem->TrackHorzPosTwips(point.x, bOnRuler);
  819. UpdateWindow();
  820. }
  822. void CRulerBar::OnSysColorChange()
  823. {
  824. CControlBar::OnSysColorChange();
  825. CreateGDIObjects();
  826. Invalidate();
  827. }
  829. void CRulerBar::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)
  830. {
  831. CControlBar::OnWindowPosChanging(lpwndpos);
  832. CRect rect;
  833. GetClientRect(rect);
  834. int minx = min(rect.Width(), lpwndpos->cx);
  835. int maxx = max(rect.Width(), lpwndpos->cx);
  836. rect.SetRect(minx-2, rect.bottom - 6, minx, rect.bottom);
  837. InvalidateRect(rect);
  838. rect.SetRect(maxx-2, rect.bottom - 6, maxx, rect.bottom);
  839. InvalidateRect(rect);
  840. }
  842. void CRulerBar::OnShowWindow(BOOL bShow, UINT nStatus)
  843. {
  844. CControlBar::OnShowWindow(bShow, nStatus);
  845. m_bDeferInProgress = FALSE;
  846. }
  848. void CRulerBar::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos)
  849. {
  850. CControlBar::OnWindowPosChanged(lpwndpos);
  851. m_bDeferInProgress = FALSE;
  852. }
  854. LRESULT CRulerBar::OnSizeParent(WPARAM wParam, LPARAM lParam)
  855. {
  856. BOOL bVis = GetStyle() & WS_VISIBLE;
  857. if ((bVis && (m_nStateFlags & delayHide)) ||
  858. (!bVis && (m_nStateFlags & delayShow)))
  859. {
  860. m_bDeferInProgress = TRUE;
  861. }
  862. return CControlBar::OnSizeParent(wParam, lParam);
  863. }