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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
RULER.CPP
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：21k
源码类别：

Windows编程

开发平台：

Visual C++

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