RULER.CPP
上传用户:aakk678
上传日期:2022-07-09
资源大小:406k
文件大小:21k
源码类别:

界面编程

开发平台:

Visual C++

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