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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
DRAWOBJ.CPP
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：23k
源码类别：

界面编程

开发平台：

Visual C++

DRAWOBJ.CPP：源码内容
  1. // drawobj.cpp - implementation for drawing objects
  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.
  14. #include "stdafx.h"
  15. #include "drawcli.h"
  17. #include "drawdoc.h"
  18. #include "drawvw.h"
  19. #include "drawobj.h"
  21. #include "cntritem.h"
  22. #include "rectdlg.h"
  24. IMPLEMENT_SERIAL(CDrawObj, CObject, 0)
  26. CDrawObj::CDrawObj()
  27. {
  28. }
  30. CDrawObj::~CDrawObj()
  31. {
  32. }
  34. CDrawObj::CDrawObj(const CRect& position)
  35. {
  36. m_position = position;
  37. m_pDocument = NULL;
  39. m_bPen = TRUE;
  40. m_logpen.lopnStyle = PS_INSIDEFRAME;
  41. m_logpen.lopnWidth.x = 1;
  42. m_logpen.lopnWidth.y = 1;
  43. m_logpen.lopnColor = RGB(0, 0, 0);
  45. m_bBrush = TRUE;
  46. m_logbrush.lbStyle = BS_SOLID;
  47. m_logbrush.lbColor = RGB(192, 192, 192);
  48. m_logbrush.lbHatch = HS_HORIZONTAL;
  49. }
  51. void CDrawObj::Serialize(CArchive& ar)
  52. {
  53. CObject::Serialize(ar);
  54. if (ar.IsStoring())
  55. {
  56. ar << m_position;
  57. ar << (WORD)m_bPen;
  58. ar.Write(&m_logpen, sizeof(LOGPEN));
  59. ar << (WORD)m_bBrush;
  60. ar.Write(&m_logbrush, sizeof(LOGBRUSH));
  61. }
  62. else
  63. {
  64. // get the document back pointer from the archive
  65. m_pDocument = (CDrawDoc*)ar.m_pDocument;
  66. ASSERT_VALID(m_pDocument);
  67. ASSERT_KINDOF(CDrawDoc, m_pDocument);
  69. WORD wTemp;
  70. ar >> m_position;
  71. ar >> wTemp; m_bPen = (BOOL)wTemp;
  72. ar.Read(&m_logpen,sizeof(LOGPEN));
  73. ar >> wTemp; m_bBrush = (BOOL)wTemp;
  74. ar.Read(&m_logbrush, sizeof(LOGBRUSH));
  75. }
  76. }
  78. void CDrawObj::SetLineColor(COLORREF color)
  79. {
  80. ASSERT_VALID(this);
  82. m_logpen.lopnColor = color;
  83. Invalidate();
  84. m_pDocument->SetModifiedFlag();
  85. }
  87. void CDrawObj::SetFillColor(COLORREF color)
  88. {
  89. ASSERT_VALID(this);
  91. m_logbrush.lbColor = color;
  92. Invalidate();
  93. m_pDocument->SetModifiedFlag();
  94. }
  96. COLORREF CDrawObj::GetLineColor()
  97. {
  98. return m_logpen.lopnColor;
  99. }
  101. COLORREF CDrawObj::GetFillColor()
  102. {
  103. return m_logbrush.lbColor;
  104. }
  106. BOOL CDrawObj::IsNoFill()
  107. {
  108. return !m_bBrush;
  109. }
  111. BOOL CDrawObj::IsNoOutline()
  112. {
  113. return !m_bPen;
  114. }
  116. BOOL CDrawObj::SetNoFill( BOOL bSet /*= TRUE*/ )
  117. {
  118. BOOL bPrev = !m_bBrush;
  119. m_bBrush = !bSet;
  120. return bPrev;
  121. }
  123. BOOL CDrawObj::SetNoOutline( BOOL bSet /*= TRUE*/ )
  124. {
  125. BOOL bPrev = !m_bPen;
  126. m_bPen = !bSet;
  127. if( bSet )
  128. {
  129. m_logpen.lopnWidth.x = 0;
  130. m_logpen.lopnWidth.y = 0;
  131. }
  132. else
  133. {
  134. if( m_logpen.lopnWidth.x == 0
  135. || m_logpen.lopnWidth.y == 0
  136. )
  137. m_logpen.lopnWidth.x
  138. = m_logpen.lopnWidth.y
  139. = 1;
  140.   }
  141. return bPrev;
  142. }
  144. void CDrawObj::Remove()
  145. {
  146. delete this;
  147. }
  149. void CDrawObj::Draw(CDC*)
  150. {
  151. }
  153. void CDrawObj::DrawTracker(CDC* pDC, TrackerState state)
  154. {
  155. ASSERT_VALID(this);
  157. switch (state)
  158. {
  159. case normal:
  160. break;
  162. case selected:
  163. case active:
  164. {
  165. int nHandleCount = GetHandleCount();
  166. for (int nHandle = 1; nHandle <= nHandleCount; nHandle += 1)
  167. {
  168. CPoint handle = GetHandle(nHandle);
  169. pDC->PatBlt(handle.x - 3, handle.y - 3, 7, 7, DSTINVERT);
  170. }
  171. }
  172. break;
  173. }
  174. }
  176. // position is in logical
  177. void CDrawObj::MoveTo(const CRect& position, CDrawView* pView)
  178. {
  179. ASSERT_VALID(this);
  181. if (position == m_position)
  182. return;
  184. if (pView == NULL)
  185. {
  186. Invalidate();
  187. m_position = position;
  188. Invalidate();
  189. }
  190. else
  191. {
  192. pView->InvalObj(this);
  193. m_position = position;
  194. pView->InvalObj(this);
  195. }
  196. m_pDocument->SetModifiedFlag();
  197. }
  199. // Note: if bSelected, hit-codes start at one for the top-left
  200. // and increment clockwise, 0 means no hit.
  201. // If !bSelected, 0 = no hit, 1 = hit (anywhere)
  203. // point is in logical coordinates
  204. int CDrawObj::HitTest(CPoint point, CDrawView* pView, BOOL bSelected)
  205. {
  206. ASSERT_VALID(this);
  207. ASSERT(pView != NULL);
  209. if (bSelected)
  210. {
  211. int nHandleCount = GetHandleCount();
  212. for (int nHandle = 1; nHandle <= nHandleCount; nHandle += 1)
  213. {
  214. // GetHandleRect returns in logical coords
  215. CRect rc = GetHandleRect(nHandle,pView);
  216. if (point.x >= rc.left && point.x < rc.right &&
  217. point.y <= rc.top && point.y > rc.bottom)
  218. return nHandle;
  219. }
  220. }
  221. else
  222. {
  223. if (point.x >= m_position.left && point.x < m_position.right &&
  224. point.y <= m_position.top && point.y > m_position.bottom)
  225. return 1;
  226. }
  227. return 0;
  228. }
  230. // rect must be in logical coordinates
  231. BOOL CDrawObj::Intersects(const CRect& rect)
  232. {
  233. ASSERT_VALID(this);
  235. CRect fixed = m_position;
  236. fixed.NormalizeRect();
  237. CRect rectT = rect;
  238. rectT.NormalizeRect();
  239. return !(rectT & fixed).IsRectEmpty();
  240. }
  242. int CDrawObj::GetHandleCount()
  243. {
  244. ASSERT_VALID(this);
  245. return 8;
  246. }
  248. // returns logical coords of center of handle
  249. CPoint CDrawObj::GetHandle(int nHandle)
  250. {
  251. ASSERT_VALID(this);
  252. int x, y, xCenter, yCenter;
  254. // this gets the center regardless of left/right and top/bottom ordering
  255. xCenter = m_position.left + m_position.Width() / 2;
  256. yCenter = m_position.top + m_position.Height() / 2;
  258. switch (nHandle)
  259. {
  260. default:
  261. ASSERT(FALSE);
  263. case 1:
  264. x = m_position.left;
  265. y = m_position.top;
  266. break;
  268. case 2:
  269. x = xCenter;
  270. y = m_position.top;
  271. break;
  273. case 3:
  274. x = m_position.right;
  275. y = m_position.top;
  276. break;
  278. case 4:
  279. x = m_position.right;
  280. y = yCenter;
  281. break;
  283. case 5:
  284. x = m_position.right;
  285. y = m_position.bottom;
  286. break;
  288. case 6:
  289. x = xCenter;
  290. y = m_position.bottom;
  291. break;
  293. case 7:
  294. x = m_position.left;
  295. y = m_position.bottom;
  296. break;
  298. case 8:
  299. x = m_position.left;
  300. y = yCenter;
  301. break;
  302. }
  304. return CPoint(x, y);
  305. }
  307. // return rectange of handle in logical coords
  308. CRect CDrawObj::GetHandleRect(int nHandleID, CDrawView* pView)
  309. {
  310. ASSERT_VALID(this);
  311. ASSERT(pView != NULL);
  313. CRect rect;
  314. // get the center of the handle in logical coords
  315. CPoint point = GetHandle(nHandleID);
  316. // convert to client/device coords
  317. pView->DocToClient(point);
  318. // return CRect of handle in device coords
  319. rect.SetRect(point.x-3, point.y-3, point.x+3, point.y+3);
  320. pView->ClientToDoc(rect);
  322. return rect;
  323. }
  325. HCURSOR CDrawObj::GetHandleCursor(int nHandle)
  326. {
  327. ASSERT_VALID(this);
  329. LPCTSTR id;
  330. switch (nHandle)
  331. {
  332. default:
  333. ASSERT(FALSE);
  335. case 1:
  336. case 5:
  337. id = IDC_SIZENWSE;
  338. break;
  340. case 2:
  341. case 6:
  342. id = IDC_SIZENS;
  343. break;
  345. case 3:
  346. case 7:
  347. id = IDC_SIZENESW;
  348. break;
  350. case 4:
  351. case 8:
  352. id = IDC_SIZEWE;
  353. break;
  354. }
  356. return AfxGetApp()->LoadStandardCursor(id);
  357. }
  359. // point must be in logical
  360. void CDrawObj::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  361. {
  362. ASSERT_VALID(this);
  364. CRect position = m_position;
  365. switch (nHandle)
  366. {
  367. default:
  368. ASSERT(FALSE);
  370. case 1:
  371. position.left = point.x;
  372. position.top = point.y;
  373. break;
  375. case 2:
  376. position.top = point.y;
  377. break;
  379. case 3:
  380. position.right = point.x;
  381. position.top = point.y;
  382. break;
  384. case 4:
  385. position.right = point.x;
  386. break;
  388. case 5:
  389. position.right = point.x;
  390. position.bottom = point.y;
  391. break;
  393. case 6:
  394. position.bottom = point.y;
  395. break;
  397. case 7:
  398. position.left = point.x;
  399. position.bottom = point.y;
  400. break;
  402. case 8:
  403. position.left = point.x;
  404. break;
  405. }
  407. MoveTo(position, pView);
  408. }
  410. void CDrawObj::Invalidate()
  411. {
  412. ASSERT_VALID(this);
  413. m_pDocument->UpdateAllViews(NULL, HINT_UPDATE_DRAWOBJ, this);
  414. }
  416. CDrawObj* CDrawObj::Clone(CDrawDoc* pDoc)
  417. {
  418. ASSERT_VALID(this);
  420. CDrawObj* pClone = new CDrawObj(m_position);
  421. pClone->m_bPen = m_bPen;
  422. pClone->m_logpen = m_logpen;
  423. pClone->m_bBrush = m_bBrush;
  424. pClone->m_logbrush = m_logbrush;
  425. ASSERT_VALID(pClone);
  427. if (pDoc != NULL)
  428. pDoc->Add(pClone);
  430. return pClone;
  431. }
  433. void CDrawObj::OnEditProperties()
  434. {
  435. ASSERT_VALID(this);
  437. CPropertySheet sheet( _T("Shape Properties") );
  438. CRectDlg dlgRect;
  439. dlgRect.m_bNoFill = IsNoFill(); // !m_bBrush;
  440. dlgRect.m_nPenSize = IsNoOutline() ? 0 : m_logpen.lopnWidth.x; // m_bPen ? m_logpen.lopnWidth.x : 0;
  441. dlgRect.m_clrFill = IsNoFill() ? CRectDlg::g_clrTransparent : GetFillColor();
  442. dlgRect.m_clrOutline = IsNoOutline() ? CRectDlg::g_clrTransparent : GetLineColor();
  443. sheet.AddPage( &dlgRect );
  445. if (sheet.DoModal() != IDOK)
  446. return;
  448. //m_bBrush = !dlgRect.m_bNoFill;
  449. SetNoFill( dlgRect.m_bNoFill );
  450. if( !IsNoFill() )
  451. SetFillColor( dlgRect.m_clrFill );
  453. if( dlgRect.m_nPenSize == 0 )
  454. SetNoOutline();
  455. else
  456. {
  457. SetNoOutline( FALSE );
  458. m_logpen.lopnWidth.x = dlgRect.m_nPenSize;
  459. m_logpen.lopnWidth.y = dlgRect.m_nPenSize;
  460. SetLineColor( dlgRect.m_clrOutline );
  461. }
  463. Invalidate();
  464. m_pDocument->SetModifiedFlag();
  465. m_pDocument->UpdateAllViews( NULL, HINT_UPDATE_TOOLBAR_COLOR_BUTTONS);
  466. }
  468. void CDrawObj::OnOpen(CDrawView* /*pView*/ )
  469. {
  470. OnEditProperties();
  471. }
  473. #ifdef _DEBUG
  474. void CDrawObj::AssertValid()
  475. {
  476. ASSERT(m_position.left <= m_position.right);
  477. ASSERT(m_position.bottom <= m_position.top);
  478. }
  479. #endif
  481. ////////////////////////////////////////////////////////////////////////////
  482. // CDrawRect
  484. IMPLEMENT_SERIAL(CDrawRect, CDrawObj, 0)
  486. CDrawRect::CDrawRect()
  487. {
  488. }
  490. CDrawRect::CDrawRect(const CRect& position)
  491. : CDrawObj(position)
  492. {
  493. ASSERT_VALID(this);
  495. m_nShape = rectangle;
  496. m_roundness.x = 16;
  497. m_roundness.y = 16;
  498. }
  500. void CDrawRect::Serialize(CArchive& ar)
  501. {
  502. ASSERT_VALID(this);
  504. CDrawObj::Serialize(ar);
  505. if (ar.IsStoring())
  506. {
  507. ar << (WORD) m_nShape;
  508. ar << m_roundness;
  509. }
  510. else
  511. {
  512. WORD wTemp;
  513. ar >> wTemp; m_nShape = (Shape)wTemp;
  514. ar >> m_roundness;
  515. }
  516. }
  518. void CDrawRect::Draw(CDC* pDC)
  519. {
  520. ASSERT_VALID(this);
  522. CBrush brush;
  523. if (!brush.CreateBrushIndirect(&m_logbrush))
  524. return;
  525. CPen pen;
  526. if (!pen.CreatePenIndirect(&m_logpen))
  527. return;
  529. CBrush* pOldBrush;
  530. CPen* pOldPen;
  532. if (m_bBrush)
  533. pOldBrush = pDC->SelectObject(&brush);
  534. else
  535. pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
  537. if (m_bPen)
  538. pOldPen = pDC->SelectObject(&pen);
  539. else
  540. pOldPen = (CPen*)pDC->SelectStockObject(NULL_PEN);
  542. CRect rect = m_position;
  543. switch (m_nShape)
  544. {
  545. case rectangle:
  546. pDC->Rectangle(rect);
  547. break;
  549. case roundRectangle:
  550. pDC->RoundRect(rect, m_roundness);
  551. break;
  553. case ellipse:
  554. pDC->Ellipse(rect);
  555. break;
  557. case line:
  558. if (rect.top > rect.bottom)
  559. {
  560. rect.top -= m_logpen.lopnWidth.y / 2;
  561. rect.bottom += (m_logpen.lopnWidth.y + 1) / 2;
  562. }
  563. else
  564. {
  565. rect.top += (m_logpen.lopnWidth.y + 1) / 2;
  566. rect.bottom -= m_logpen.lopnWidth.y / 2;
  567. }
  569. if (rect.left > rect.right)
  570. {
  571. rect.left -= m_logpen.lopnWidth.x / 2;
  572. rect.right += (m_logpen.lopnWidth.x + 1) / 2;
  573. }
  574. else
  575. {
  576. rect.left += (m_logpen.lopnWidth.x + 1) / 2;
  577. rect.right -= m_logpen.lopnWidth.x / 2;
  578. }
  580. pDC->MoveTo(rect.TopLeft());
  581. pDC->LineTo(rect.BottomRight());
  582. break;
  583. }
  585. pDC->SelectObject(pOldBrush);
  586. pDC->SelectObject(pOldPen);
  587. }
  590. int CDrawRect::GetHandleCount()
  591. {
  592. ASSERT_VALID(this);
  594. return m_nShape == line ? 2 :
  595. CDrawObj::GetHandleCount() + (m_nShape == roundRectangle);
  596. }
  598. // returns center of handle in logical coordinates
  599. CPoint CDrawRect::GetHandle(int nHandle)
  600. {
  601. ASSERT_VALID(this);
  603. if (m_nShape == line && nHandle == 2)
  604. nHandle = 5;
  605. else if (m_nShape == roundRectangle && nHandle == 9)
  606. {
  607. CRect rect = m_position;
  608. rect.NormalizeRect();
  609. CPoint point = rect.BottomRight();
  610. point.x -= m_roundness.x / 2;
  611. point.y -= m_roundness.y / 2;
  612. return point;
  613. }
  615. return CDrawObj::GetHandle(nHandle);
  616. }
  618. HCURSOR CDrawRect::GetHandleCursor(int nHandle)
  619. {
  620. ASSERT_VALID(this);
  622. if (m_nShape == line && nHandle == 2)
  623. nHandle = 5;
  624. else if (m_nShape == roundRectangle && nHandle == 9)
  625. return AfxGetApp()->LoadStandardCursor(IDC_SIZEALL);
  626. return CDrawObj::GetHandleCursor(nHandle);
  627. }
  629. // point is in logical coordinates
  630. void CDrawRect::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  631. {
  632. ASSERT_VALID(this);
  634. if (m_nShape == line && nHandle == 2)
  635. nHandle = 5;
  636. else if (m_nShape == roundRectangle && nHandle == 9)
  637. {
  638. CRect rect = m_position;
  639. rect.NormalizeRect();
  640. if (point.x > rect.right - 1)
  641. point.x = rect.right - 1;
  642. else if (point.x < rect.left + rect.Width() / 2)
  643. point.x = rect.left + rect.Width() / 2;
  644. if (point.y > rect.bottom - 1)
  645. point.y = rect.bottom - 1;
  646. else if (point.y < rect.top + rect.Height() / 2)
  647. point.y = rect.top + rect.Height() / 2;
  648. m_roundness.x = 2 * (rect.right - point.x);
  649. m_roundness.y = 2 * (rect.bottom - point.y);
  650. m_pDocument->SetModifiedFlag();
  651. if (pView == NULL)
  652. Invalidate();
  653. else
  654. pView->InvalObj(this);
  655. return;
  656. }
  658. CDrawObj::MoveHandleTo(nHandle, point, pView);
  659. }
  661. // rect must be in logical coordinates
  662. BOOL CDrawRect::Intersects(const CRect& rect)
  663. {
  664. ASSERT_VALID(this);
  666. CRect rectT = rect;
  667. rectT.NormalizeRect();
  669. CRect fixed = m_position;
  670. fixed.NormalizeRect();
  671. if ((rectT & fixed).IsRectEmpty())
  672. return FALSE;
  674. CRgn rgn;
  675. switch (m_nShape)
  676. {
  677. case rectangle:
  678. return TRUE;
  680. case roundRectangle:
  681. rgn.CreateRoundRectRgn(fixed.left, fixed.top, fixed.right, fixed.bottom,
  682. m_roundness.x, m_roundness.y);
  683. break;
  685. case ellipse:
  686. rgn.CreateEllipticRgnIndirect(fixed);
  687. break;
  689. case line:
  690. {
  691. int x = (m_logpen.lopnWidth.x + 5) / 2;
  692. int y = (m_logpen.lopnWidth.y + 5) / 2;
  693. POINT points[4];
  694. points[0].x = fixed.left;
  695. points[0].y = fixed.top;
  696. points[1].x = fixed.left;
  697. points[1].y = fixed.top;
  698. points[2].x = fixed.right;
  699. points[2].y = fixed.bottom;
  700. points[3].x = fixed.right;
  701. points[3].y = fixed.bottom;
  703. if (fixed.left < fixed.right)
  704. {
  705. points[0].x -= x;
  706. points[1].x += x;
  707. points[2].x += x;
  708. points[3].x -= x;
  709. }
  710. else
  711. {
  712. points[0].x += x;
  713. points[1].x -= x;
  714. points[2].x -= x;
  715. points[3].x += x;
  716. }
  718. if (fixed.top < fixed.bottom)
  719. {
  720. points[0].y -= y;
  721. points[1].y += y;
  722. points[2].y += y;
  723. points[3].y -= y;
  724. }
  725. else
  726. {
  727. points[0].y += y;
  728. points[1].y -= y;
  729. points[2].y -= y;
  730. points[3].y += y;
  731. }
  732. rgn.CreatePolygonRgn(points, 4, ALTERNATE);
  733. }
  734. break;
  735. }
  736. return rgn.RectInRegion(fixed);
  737. }
  739. CDrawObj* CDrawRect::Clone(CDrawDoc* pDoc)
  740. {
  741. ASSERT_VALID(this);
  743. CDrawRect* pClone = new CDrawRect(m_position);
  744. pClone->m_bPen = m_bPen;
  745. pClone->m_logpen = m_logpen;
  746. pClone->m_bBrush = m_bBrush;
  747. pClone->m_logbrush = m_logbrush;
  748. pClone->m_nShape = m_nShape;
  749. pClone->m_roundness = m_roundness;
  750. ASSERT_VALID(pClone);
  752. if (pDoc != NULL)
  753. pDoc->Add(pClone);
  755. ASSERT_VALID(pClone);
  756. return pClone;
  757. }
  759. ////////////////////////////////////////////////////////////////////////////
  760. // CDrawPoly
  762. IMPLEMENT_SERIAL(CDrawPoly, CDrawObj, 0)
  764. CDrawPoly::CDrawPoly()
  765. {
  766. m_points = NULL;
  767. m_nPoints = 0;
  768. m_nAllocPoints = 0;
  769. }
  771. CDrawPoly::CDrawPoly(const CRect& position)
  772. : CDrawObj(position)
  773. {
  774. m_points = NULL;
  775. m_nPoints = 0;
  776. m_nAllocPoints = 0;
  777. m_bPen = TRUE;
  778. m_bBrush = FALSE;
  779. }
  781. CDrawPoly::~CDrawPoly()
  782. {
  783. if (m_points != NULL)
  784. delete[] m_points;
  785. }
  787. void CDrawPoly::Serialize( CArchive& ar )
  788. {
  789. int i;
  790. CDrawObj::Serialize( ar );
  791. if( ar.IsStoring() )
  792. {
  793. ar << (WORD) m_nPoints;
  794. ar << (WORD) m_nAllocPoints;
  795. for (i = 0;i< m_nPoints; i++)
  796. ar << m_points[i];
  797. }
  798. else
  799. {
  800. WORD wTemp;
  801. ar >> wTemp; m_nPoints = wTemp;
  802. ar >> wTemp; m_nAllocPoints = wTemp;
  803. m_points = new CPoint[m_nAllocPoints];
  804. for (i = 0;i < m_nPoints; i++)
  805. ar >> m_points[i];
  806. }
  807. }
  809. void CDrawPoly::Draw(CDC* pDC)
  810. {
  811. ASSERT_VALID(this);
  813. CBrush brush;
  814. if (!brush.CreateBrushIndirect(&m_logbrush))
  815. return;
  816. CPen pen;
  817. if (!pen.CreatePenIndirect(&m_logpen))
  818. return;
  820. CBrush* pOldBrush;
  821. CPen* pOldPen;
  823. if (m_bBrush)
  824. pOldBrush = pDC->SelectObject(&brush);
  825. else
  826. pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
  828. if (m_bPen)
  829. pOldPen = pDC->SelectObject(&pen);
  830. else
  831. pOldPen = (CPen*)pDC->SelectStockObject(NULL_PEN);
  833. pDC->Polygon(m_points, m_nPoints);
  835. pDC->SelectObject(pOldBrush);
  836. pDC->SelectObject(pOldPen);
  837. }
  839. // position must be in logical coordinates
  840. void CDrawPoly::MoveTo(const CRect& position, CDrawView* pView)
  841. {
  842. ASSERT_VALID(this);
  843. if (position == m_position)
  844. return;
  846. if (pView == NULL)
  847. Invalidate();
  848. else
  849. pView->InvalObj(this);
  851. for (int i = 0; i < m_nPoints; i += 1)
  852. {
  853. m_points[i].x += position.left - m_position.left;
  854. m_points[i].y += position.top - m_position.top;
  855. }
  857. m_position = position;
  859. if (pView == NULL)
  860. Invalidate();
  861. else
  862. pView->InvalObj(this);
  863. m_pDocument->SetModifiedFlag();
  864. }
  866. int CDrawPoly::GetHandleCount()
  867. {
  868. return m_nPoints;
  869. }
  871. CPoint CDrawPoly::GetHandle(int nHandle)
  872. {
  873. ASSERT_VALID(this);
  875. ASSERT(nHandle >= 1 && nHandle <= m_nPoints);
  876. return m_points[nHandle - 1];
  877. }
  879. HCURSOR CDrawPoly::GetHandleCursor(int )
  880. {
  881. return AfxGetApp()->LoadStandardCursor(IDC_ARROW);
  882. }
  884. // point is in logical coordinates
  885. void CDrawPoly::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  886. {
  887. ASSERT_VALID(this);
  888. ASSERT(nHandle >= 1 && nHandle <= m_nPoints);
  889. if (m_points[nHandle - 1] == point)
  890. return;
  892. m_points[nHandle - 1] = point;
  893. RecalcBounds(pView);
  895. if (pView == NULL)
  896. Invalidate();
  897. else
  898. pView->InvalObj(this);
  899. m_pDocument->SetModifiedFlag();
  900. }
  902. // rect must be in logical coordinates
  903. BOOL CDrawPoly::Intersects(const CRect& rect)
  904. {
  905. ASSERT_VALID(this);
  906. CRgn rgn;
  907. rgn.CreatePolygonRgn(m_points, m_nPoints, ALTERNATE);
  908. return rgn.RectInRegion(rect);
  909. }
  911. CDrawObj* CDrawPoly::Clone(CDrawDoc* pDoc)
  912. {
  913. ASSERT_VALID(this);
  915. CDrawPoly* pClone = new CDrawPoly(m_position);
  916. pClone->m_bPen = m_bPen;
  917. pClone->m_logpen = m_logpen;
  918. pClone->m_bBrush = m_bBrush;
  919. pClone->m_logbrush = m_logbrush;
  920. pClone->m_points = new CPoint[m_nAllocPoints];
  921. memcpy(pClone->m_points, m_points, sizeof(CPoint) * m_nPoints);
  922. pClone->m_nAllocPoints = m_nAllocPoints;
  923. pClone->m_nPoints = m_nPoints;
  924. ASSERT_VALID(pClone);
  926. if (pDoc != NULL)
  927. pDoc->Add(pClone);
  929. ASSERT_VALID(pClone);
  930. return pClone;
  931. }
  933. // point is in logical coordinates
  934. void CDrawPoly::AddPoint(const CPoint& point, CDrawView* pView)
  935. {
  936. ASSERT_VALID(this);
  937. if (m_nPoints == m_nAllocPoints)
  938. {
  939. CPoint* newPoints = new CPoint[m_nAllocPoints + 10];
  940. if (m_points != NULL)
  941. {
  942. memcpy(newPoints, m_points, sizeof(CPoint) * m_nAllocPoints);
  943. delete[] m_points;
  944. }
  945. m_points = newPoints;
  946. m_nAllocPoints += 10;
  947. }
  949. if (m_nPoints == 0 || m_points[m_nPoints - 1] != point)
  950. {
  951. m_points[m_nPoints++] = point;
  952. if (!RecalcBounds(pView))
  953. {
  954. if (pView == NULL)
  955. Invalidate();
  956. else
  957. pView->InvalObj(this);
  958. }
  959. m_pDocument->SetModifiedFlag();
  960. }
  961. }
  963. BOOL CDrawPoly::RecalcBounds(CDrawView* pView)
  964. {
  965. ASSERT_VALID(this);
  967. if (m_nPoints == 0)
  968. return FALSE;
  970. CRect bounds(m_points[0], CSize(0, 0));
  971. for (int i = 1; i < m_nPoints; ++i)
  972. {
  973. if (m_points[i].x < bounds.left)
  974. bounds.left = m_points[i].x;
  975. if (m_points[i].x > bounds.right)
  976. bounds.right = m_points[i].x;
  977. if (m_points[i].y < bounds.top)
  978. bounds.top = m_points[i].y;
  979. if (m_points[i].y > bounds.bottom)
  980. bounds.bottom = m_points[i].y;
  981. }
  983. if (bounds == m_position)
  984. return FALSE;
  986. if (pView == NULL)
  987. Invalidate();
  988. else
  989. pView->InvalObj(this);
  991. m_position = bounds;
  993. if (pView == NULL)
  994. Invalidate();
  995. else
  996. pView->InvalObj(this);
  998. return TRUE;
  999. }
  1001. ////////////////////////////////////////////////////////////////////////////
  1003. IMPLEMENT_SERIAL(CDrawOleObj, CDrawObj, 0)
  1005. BOOL CDrawOleObj::c_bShowItems = TRUE;
  1007. CDrawOleObj::CDrawOleObj() : m_extent(0,0)
  1008. {
  1009. m_pClientItem = NULL;
  1010. }
  1012. CDrawOleObj::CDrawOleObj(const CRect& position)
  1013. : CDrawObj(position), m_extent(0, 0)
  1014. {
  1015. m_pClientItem = NULL;
  1016. }
  1018. CDrawOleObj::~CDrawOleObj()
  1019. {
  1020. if (m_pClientItem != NULL)
  1021. {
  1022. m_pClientItem->Release();
  1023. m_pClientItem = NULL;
  1024. }
  1025. }
  1027. void CDrawOleObj::Remove()
  1028. {
  1029. if (m_pClientItem != NULL)
  1030. {
  1031. m_pClientItem->Delete();
  1032. m_pClientItem = NULL;
  1033. }
  1034. CDrawObj::Remove();
  1035. }
  1037. void CDrawOleObj::Serialize( CArchive& ar )
  1038. {
  1039. ASSERT_VALID(this);
  1041. CDrawObj::Serialize(ar);
  1043. if (ar.IsStoring())
  1044. {
  1045. ar << m_extent;
  1046. ar << m_pClientItem;
  1047. }
  1048. else
  1049. {
  1050. ar >> m_extent;
  1051. ar >> m_pClientItem;
  1052. m_pClientItem->m_pDrawObj = this;
  1053. }
  1054. }
  1056. CDrawObj* CDrawOleObj::Clone(CDrawDoc* pDoc)
  1057. {
  1058. ASSERT_VALID(this);
  1060. AfxGetApp()->BeginWaitCursor();
  1062. CDrawOleObj* pClone = NULL;
  1063. CDrawItem* pItem = NULL;
  1064. TRY
  1065. {
  1066. // perform a "deep copy" -- need to copy CDrawOleObj and the CDrawItem
  1067. //  that it points to.
  1068. CDrawOleObj* pClone = new CDrawOleObj(m_position);
  1069. CDrawItem* pItem = new CDrawItem(m_pDocument, pClone);
  1070. if (!pItem->CreateCloneFrom(m_pClientItem))
  1071. AfxThrowMemoryException();
  1073. pClone->m_pClientItem = pItem;
  1074. pClone->m_bPen = m_bPen;
  1075. pClone->m_logpen = m_logpen;
  1076. pClone->m_bBrush = m_bBrush;
  1077. pClone->m_logbrush = m_logbrush;
  1078. ASSERT_VALID(pClone);
  1080. if (pDoc != NULL)
  1081. pDoc->Add(pClone);
  1082. }
  1083. CATCH_ALL(e)
  1084. {
  1085. pItem->Delete();
  1086. pClone->m_pClientItem = NULL;
  1087. pClone->Remove();
  1088. AfxGetApp()->EndWaitCursor();
  1090. THROW_LAST();
  1091. }
  1092. END_CATCH_ALL
  1094. AfxGetApp()->EndWaitCursor();
  1095. return pClone;
  1096. }
  1098. void CDrawOleObj::Draw(CDC* pDC)
  1099. {
  1100. ASSERT_VALID(this);
  1102. CDrawItem* pItem = m_pClientItem;
  1103. if (pItem != NULL)
  1104. {
  1105. // draw the OLE item itself
  1106. pItem->Draw(pDC, m_position);
  1108. // don't draw tracker in print preview or on printer
  1109. if (!pDC->IsPrinting())
  1110. {
  1111. // use a CRectTracker to draw the standard effects
  1112. CRectTracker tracker;
  1113. tracker.m_rect = m_position;
  1114. pDC->LPtoDP(tracker.m_rect);
  1116. if (c_bShowItems)
  1117. {
  1118. // put correct border depending on item type
  1119. if (pItem->GetType() == OT_LINK)
  1120. tracker.m_nStyle |= CRectTracker::dottedLine;
  1121. else
  1122. tracker.m_nStyle |= CRectTracker::solidLine;
  1123. }
  1125. // put hatching over the item if it is currently open
  1126. if (pItem->GetItemState() == COleClientItem::openState ||
  1127. pItem->GetItemState() == COleClientItem::activeUIState)
  1128. {
  1129. tracker.m_nStyle |= CRectTracker::hatchInside;
  1130. }
  1131. tracker.Draw(pDC);
  1132. }
  1133. }
  1134. }
  1136. void CDrawOleObj::OnOpen(CDrawView* pView)
  1137. {
  1138. AfxGetApp()->BeginWaitCursor();
  1139. m_pClientItem->DoVerb(
  1140. GetKeyState(VK_CONTROL) < 0 ? OLEIVERB_OPEN : OLEIVERB_PRIMARY,
  1141. pView);
  1142. AfxGetApp()->EndWaitCursor();
  1143. }
  1145. void CDrawOleObj::OnEditProperties()
  1146. {
  1147. // using COlePropertiesDialog directly means no scaling
  1148. COlePropertiesDialog dlgOleProperties(m_pClientItem, 100, 100, NULL);
  1149. dlgOleProperties.DoModal();
  1150. }
  1152. // position is in logical
  1153. void CDrawOleObj::MoveTo(const CRect& position, CDrawView* pView)
  1154. {
  1155. ASSERT_VALID(this);
  1157. if (position == m_position)
  1158. return;
  1160. // call base class to update position
  1161. CDrawObj::MoveTo(position, pView);
  1163. // update position of in-place editing session on position change
  1164. if (m_pClientItem->IsInPlaceActive())
  1165. m_pClientItem->SetItemRects();
  1166. }
  1168. /////////////////////////////////////////////////////////////////////////////