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

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

对话框与窗口

开发平台：

Visual C++

drawobj.cpp：源码内容
  1. // drawobj.cpp - implementation for drawing objects
  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 "drawcli.h"
  24. #include "drawdoc.h"
  25. #include "drawvw.h"
  26. #include "drawobj.h"
  28. #include "cntritem.h"
  29. #include "rectdlg.h"
  31. IMPLEMENT_SERIAL(CDrawObj, CObject, 0)
  33. CDrawObj::CDrawObj()
  34. {
  35. }
  37. CDrawObj::~CDrawObj()
  38. {
  39. }
  41. CDrawObj::CDrawObj(const CRect& position)
  42. {
  43. m_position = position;
  44. m_pDocument = NULL;
  46. m_bPen = TRUE;
  47. m_logpen.lopnStyle = PS_INSIDEFRAME;
  48. m_logpen.lopnWidth.x = 1;
  49. m_logpen.lopnWidth.y = 1;
  50. m_logpen.lopnColor = RGB(0, 0, 0);
  52. m_bBrush = TRUE;
  53. m_logbrush.lbStyle = BS_SOLID;
  54. m_logbrush.lbColor = RGB(192, 192, 192);
  55. m_logbrush.lbHatch = HS_HORIZONTAL;
  56. }
  58. void CDrawObj::Serialize(CArchive& ar)
  59. {
  60. CObject::Serialize(ar);
  61. if (ar.IsStoring())
  62. {
  63. ar << m_position;
  64. ar << (WORD)m_bPen;
  65. ar.Write(&m_logpen, sizeof(LOGPEN));
  66. ar << (WORD)m_bBrush;
  67. ar.Write(&m_logbrush, sizeof(LOGBRUSH));
  68. }
  69. else
  70. {
  71. // get the document back pointer from the archive
  72. m_pDocument = (CDrawDoc*)ar.m_pDocument;
  73. ASSERT_VALID(m_pDocument);
  74. ASSERT_KINDOF(CDrawDoc, m_pDocument);
  76. WORD wTemp;
  77. ar >> m_position;
  78. ar >> wTemp; m_bPen = (BOOL)wTemp;
  79. ar.Read(&m_logpen,sizeof(LOGPEN));
  80. ar >> wTemp; m_bBrush = (BOOL)wTemp;
  81. ar.Read(&m_logbrush, sizeof(LOGBRUSH));
  82. }
  83. }
  85. void CDrawObj::Remove()
  86. {
  87. delete this;
  88. }
  90. void CDrawObj::Draw(CDC*)
  91. {
  92. }
  94. void CDrawObj::DrawTracker(CDC* pDC, TrackerState state)
  95. {
  96. ASSERT_VALID(this);
  98. switch (state)
  99. {
  100. case normal:
  101. break;
  103. case selected:
  104. case active:
  105. {
  106. int nHandleCount = GetHandleCount();
  107. for (int nHandle = 1; nHandle <= nHandleCount; nHandle += 1)
  108. {
  109. CPoint handle = GetHandle(nHandle);
  110. pDC->PatBlt(handle.x - 3, handle.y - 3, 7, 7, DSTINVERT);
  111. }
  112. }
  113. break;
  114. }
  115. }
  117. // position is in logical
  118. void CDrawObj::MoveTo(const CRect& position, CDrawView* pView)
  119. {
  120. ASSERT_VALID(this);
  122. if (position == m_position)
  123. return;
  125. if (pView == NULL)
  126. {
  127. Invalidate();
  128. m_position = position;
  129. Invalidate();
  130. }
  131. else
  132. {
  133. pView->InvalObj(this);
  134. m_position = position;
  135. pView->InvalObj(this);
  136. }
  137. m_pDocument->SetModifiedFlag();
  138. }
  140. // Note: if bSelected, hit-codes start at one for the top-left
  141. // and increment clockwise, 0 means no hit.
  142. // If !bSelected, 0 = no hit, 1 = hit (anywhere)
  144. // point is in logical coordinates
  145. int CDrawObj::HitTest(CPoint point, CDrawView* pView, BOOL bSelected)
  146. {
  147. ASSERT_VALID(this);
  148. ASSERT(pView != NULL);
  150. if (bSelected)
  151. {
  152. int nHandleCount = GetHandleCount();
  153. for (int nHandle = 1; nHandle <= nHandleCount; nHandle += 1)
  154. {
  155. // GetHandleRect returns in logical coords
  156. CRect rc = GetHandleRect(nHandle,pView);
  157. if (point.x >= rc.left && point.x < rc.right &&
  158. point.y <= rc.top && point.y > rc.bottom)
  159. return nHandle;
  160. }
  161. }
  162. else
  163. {
  164. if (point.x >= m_position.left && point.x < m_position.right &&
  165. point.y <= m_position.top && point.y > m_position.bottom)
  166. return 1;
  167. }
  168. return 0;
  169. }
  171. // rect must be in logical coordinates
  172. BOOL CDrawObj::Intersects(const CRect& rect)
  173. {
  174. ASSERT_VALID(this);
  176. CRect fixed = m_position;
  177. fixed.NormalizeRect();
  178. CRect rectT = rect;
  179. rectT.NormalizeRect();
  180. return !(rectT & fixed).IsRectEmpty();
  181. }
  183. int CDrawObj::GetHandleCount()
  184. {
  185. ASSERT_VALID(this);
  186. return 8;
  187. }
  189. // returns logical coords of center of handle
  190. CPoint CDrawObj::GetHandle(int nHandle)
  191. {
  192. ASSERT_VALID(this);
  193. int x, y, xCenter, yCenter;
  195. // this gets the center regardless of left/right and top/bottom ordering
  196. xCenter = m_position.left + m_position.Width() / 2;
  197. yCenter = m_position.top + m_position.Height() / 2;
  199. switch (nHandle)
  200. {
  201. default:
  202. ASSERT(FALSE);
  204. case 1:
  205. x = m_position.left;
  206. y = m_position.top;
  207. break;
  209. case 2:
  210. x = xCenter;
  211. y = m_position.top;
  212. break;
  214. case 3:
  215. x = m_position.right;
  216. y = m_position.top;
  217. break;
  219. case 4:
  220. x = m_position.right;
  221. y = yCenter;
  222. break;
  224. case 5:
  225. x = m_position.right;
  226. y = m_position.bottom;
  227. break;
  229. case 6:
  230. x = xCenter;
  231. y = m_position.bottom;
  232. break;
  234. case 7:
  235. x = m_position.left;
  236. y = m_position.bottom;
  237. break;
  239. case 8:
  240. x = m_position.left;
  241. y = yCenter;
  242. break;
  243. }
  245. return CPoint(x, y);
  246. }
  248. // return rectange of handle in logical coords
  249. CRect CDrawObj::GetHandleRect(int nHandleID, CDrawView* pView)
  250. {
  251. ASSERT_VALID(this);
  252. ASSERT(pView != NULL);
  254. CRect rect;
  255. // get the center of the handle in logical coords
  256. CPoint point = GetHandle(nHandleID);
  257. // convert to client/device coords
  258. pView->DocToClient(point);
  259. // return CRect of handle in device coords
  260. rect.SetRect(point.x-3, point.y-3, point.x+3, point.y+3);
  261. pView->ClientToDoc(rect);
  263. return rect;
  264. }
  266. HCURSOR CDrawObj::GetHandleCursor(int nHandle)
  267. {
  268. ASSERT_VALID(this);
  270. LPCTSTR id;
  271. switch (nHandle)
  272. {
  273. default:
  274. ASSERT(FALSE);
  276. case 1:
  277. case 5:
  278. id = IDC_SIZENWSE;
  279. break;
  281. case 2:
  282. case 6:
  283. id = IDC_SIZENS;
  284. break;
  286. case 3:
  287. case 7:
  288. id = IDC_SIZENESW;
  289. break;
  291. case 4:
  292. case 8:
  293. id = IDC_SIZEWE;
  294. break;
  295. }
  297. return AfxGetApp()->LoadStandardCursor(id);
  298. }
  300. // point must be in logical
  301. void CDrawObj::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  302. {
  303. ASSERT_VALID(this);
  305. CRect position = m_position;
  306. switch (nHandle)
  307. {
  308. default:
  309. ASSERT(FALSE);
  311. case 1:
  312. position.left = point.x;
  313. position.top = point.y;
  314. break;
  316. case 2:
  317. position.top = point.y;
  318. break;
  320. case 3:
  321. position.right = point.x;
  322. position.top = point.y;
  323. break;
  325. case 4:
  326. position.right = point.x;
  327. break;
  329. case 5:
  330. position.right = point.x;
  331. position.bottom = point.y;
  332. break;
  334. case 6:
  335. position.bottom = point.y;
  336. break;
  338. case 7:
  339. position.left = point.x;
  340. position.bottom = point.y;
  341. break;
  343. case 8:
  344. position.left = point.x;
  345. break;
  346. }
  348. MoveTo(position, pView);
  349. }
  351. void CDrawObj::Invalidate()
  352. {
  353. ASSERT_VALID(this);
  354. m_pDocument->UpdateAllViews(NULL, HINT_UPDATE_DRAWOBJ, this);
  355. }
  357. CDrawObj* CDrawObj::Clone(CDrawDoc* pDoc)
  358. {
  359. ASSERT_VALID(this);
  361. CDrawObj* pClone = new CDrawObj(m_position);
  362. pClone->m_bPen = m_bPen;
  363. pClone->m_logpen = m_logpen;
  364. pClone->m_bBrush = m_bBrush;
  365. pClone->m_logbrush = m_logbrush;
  366. ASSERT_VALID(pClone);
  368. if (pDoc != NULL)
  369. pDoc->Add(pClone);
  371. return pClone;
  372. }
  374. void CDrawObj::OnEditProperties()
  375. {
  376. ASSERT_VALID(this);
  378. CPropertySheet sheet( _T("Shape Properties") );
  379. CRectDlg dlg;
  380. dlg.m_bNoFill = !m_bBrush;
  381. dlg.m_penSize = m_bPen ? m_logpen.lopnWidth.x : 0;
  382. sheet.AddPage( &dlg );
  384. if (sheet.DoModal() != IDOK)
  385. return;
  387. m_bBrush = !dlg.m_bNoFill;
  388. m_bPen = dlg.m_penSize > 0;
  389. if (m_bPen)
  390. {
  391. m_logpen.lopnWidth.x = dlg.m_penSize;
  392. m_logpen.lopnWidth.y = dlg.m_penSize;
  393. }
  395. Invalidate();
  396. m_pDocument->SetModifiedFlag();
  397. }
  399. void CDrawObj::OnOpen(CDrawView* /*pView*/ )
  400. {
  401. OnEditProperties();
  402. }
  404. void CDrawObj::SetLineColor(COLORREF color)
  405. {
  406. ASSERT_VALID(this);
  408. m_logpen.lopnColor = color;
  409. Invalidate();
  410. m_pDocument->SetModifiedFlag();
  411. }
  413. void CDrawObj::SetFillColor(COLORREF color)
  414. {
  415. ASSERT_VALID(this);
  417. m_logbrush.lbColor = color;
  418. Invalidate();
  419. m_pDocument->SetModifiedFlag();
  420. }
  422. #ifdef _DEBUG
  423. void CDrawObj::AssertValid()
  424. {
  425. ASSERT(m_position.left <= m_position.right);
  426. ASSERT(m_position.bottom <= m_position.top);
  427. }
  428. #endif
  430. ////////////////////////////////////////////////////////////////////////////
  431. // CDrawRect
  433. IMPLEMENT_SERIAL(CDrawRect, CDrawObj, 0)
  435. CDrawRect::CDrawRect()
  436. {
  437. }
  439. CDrawRect::CDrawRect(const CRect& position)
  440. : CDrawObj(position)
  441. {
  442. ASSERT_VALID(this);
  444. m_nShape = rectangle;
  445. m_roundness.x = 16;
  446. m_roundness.y = 16;
  447. }
  449. void CDrawRect::Serialize(CArchive& ar)
  450. {
  451. ASSERT_VALID(this);
  453. CDrawObj::Serialize(ar);
  454. if (ar.IsStoring())
  455. {
  456. ar << (WORD) m_nShape;
  457. ar << m_roundness;
  458. }
  459. else
  460. {
  461. WORD wTemp;
  462. ar >> wTemp; m_nShape = (Shape)wTemp;
  463. ar >> m_roundness;
  464. }
  465. }
  467. void CDrawRect::Draw(CDC* pDC)
  468. {
  469. ASSERT_VALID(this);
  471. CBrush brush;
  472. if (!brush.CreateBrushIndirect(&m_logbrush))
  473. return;
  474. CPen pen;
  475. if (!pen.CreatePenIndirect(&m_logpen))
  476. return;
  478. CBrush* pOldBrush;
  479. CPen* pOldPen;
  481. if (m_bBrush)
  482. pOldBrush = pDC->SelectObject(&brush);
  483. else
  484. pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
  486. if (m_bPen)
  487. pOldPen = pDC->SelectObject(&pen);
  488. else
  489. pOldPen = (CPen*)pDC->SelectStockObject(NULL_PEN);
  491. CRect rect = m_position;
  492. switch (m_nShape)
  493. {
  494. case rectangle:
  495. pDC->Rectangle(rect);
  496. break;
  498. case roundRectangle:
  499. pDC->RoundRect(rect, m_roundness);
  500. break;
  502. case ellipse:
  503. pDC->Ellipse(rect);
  504. break;
  506. case line:
  507. if (rect.top > rect.bottom)
  508. {
  509. rect.top -= m_logpen.lopnWidth.y / 2;
  510. rect.bottom += (m_logpen.lopnWidth.y + 1) / 2;
  511. }
  512. else
  513. {
  514. rect.top += (m_logpen.lopnWidth.y + 1) / 2;
  515. rect.bottom -= m_logpen.lopnWidth.y / 2;
  516. }
  518. if (rect.left > rect.right)
  519. {
  520. rect.left -= m_logpen.lopnWidth.x / 2;
  521. rect.right += (m_logpen.lopnWidth.x + 1) / 2;
  522. }
  523. else
  524. {
  525. rect.left += (m_logpen.lopnWidth.x + 1) / 2;
  526. rect.right -= m_logpen.lopnWidth.x / 2;
  527. }
  529. pDC->MoveTo(rect.TopLeft());
  530. pDC->LineTo(rect.BottomRight());
  531. break;
  532. }
  534. pDC->SelectObject(pOldBrush);
  535. pDC->SelectObject(pOldPen);
  536. }
  539. int CDrawRect::GetHandleCount()
  540. {
  541. ASSERT_VALID(this);
  543. return m_nShape == line ? 2 :
  544. CDrawObj::GetHandleCount() + (m_nShape == roundRectangle);
  545. }
  547. // returns center of handle in logical coordinates
  548. CPoint CDrawRect::GetHandle(int nHandle)
  549. {
  550. ASSERT_VALID(this);
  552. if (m_nShape == line && nHandle == 2)
  553. nHandle = 5;
  554. else if (m_nShape == roundRectangle && nHandle == 9)
  555. {
  556. CRect rect = m_position;
  557. rect.NormalizeRect();
  558. CPoint point = rect.BottomRight();
  559. point.x -= m_roundness.x / 2;
  560. point.y -= m_roundness.y / 2;
  561. return point;
  562. }
  564. return CDrawObj::GetHandle(nHandle);
  565. }
  567. HCURSOR CDrawRect::GetHandleCursor(int nHandle)
  568. {
  569. ASSERT_VALID(this);
  571. if (m_nShape == line && nHandle == 2)
  572. nHandle = 5;
  573. else if (m_nShape == roundRectangle && nHandle == 9)
  574. return AfxGetApp()->LoadStandardCursor(IDC_SIZEALL);
  575. return CDrawObj::GetHandleCursor(nHandle);
  576. }
  578. // point is in logical coordinates
  579. void CDrawRect::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  580. {
  581. ASSERT_VALID(this);
  583. if (m_nShape == line && nHandle == 2)
  584. nHandle = 5;
  585. else if (m_nShape == roundRectangle && nHandle == 9)
  586. {
  587. CRect rect = m_position;
  588. rect.NormalizeRect();
  589. if (point.x > rect.right - 1)
  590. point.x = rect.right - 1;
  591. else if (point.x < rect.left + rect.Width() / 2)
  592. point.x = rect.left + rect.Width() / 2;
  593. if (point.y > rect.bottom - 1)
  594. point.y = rect.bottom - 1;
  595. else if (point.y < rect.top + rect.Height() / 2)
  596. point.y = rect.top + rect.Height() / 2;
  597. m_roundness.x = 2 * (rect.right - point.x);
  598. m_roundness.y = 2 * (rect.bottom - point.y);
  599. m_pDocument->SetModifiedFlag();
  600. if (pView == NULL)
  601. Invalidate();
  602. else
  603. pView->InvalObj(this);
  604. return;
  605. }
  607. CDrawObj::MoveHandleTo(nHandle, point, pView);
  608. }
  610. // rect must be in logical coordinates
  611. BOOL CDrawRect::Intersects(const CRect& rect)
  612. {
  613. ASSERT_VALID(this);
  615. CRect rectT = rect;
  616. rectT.NormalizeRect();
  618. CRect fixed = m_position;
  619. fixed.NormalizeRect();
  620. if ((rectT & fixed).IsRectEmpty())
  621. return FALSE;
  623. CRgn rgn;
  624. switch (m_nShape)
  625. {
  626. case rectangle:
  627. return TRUE;
  629. case roundRectangle:
  630. rgn.CreateRoundRectRgn(fixed.left, fixed.top, fixed.right, fixed.bottom,
  631. m_roundness.x, m_roundness.y);
  632. break;
  634. case ellipse:
  635. rgn.CreateEllipticRgnIndirect(fixed);
  636. break;
  638. case line:
  639. {
  640. int x = (m_logpen.lopnWidth.x + 5) / 2;
  641. int y = (m_logpen.lopnWidth.y + 5) / 2;
  642. POINT points[4];
  643. points[0].x = fixed.left;
  644. points[0].y = fixed.top;
  645. points[1].x = fixed.left;
  646. points[1].y = fixed.top;
  647. points[2].x = fixed.right;
  648. points[2].y = fixed.bottom;
  649. points[3].x = fixed.right;
  650. points[3].y = fixed.bottom;
  652. if (fixed.left < fixed.right)
  653. {
  654. points[0].x -= x;
  655. points[1].x += x;
  656. points[2].x += x;
  657. points[3].x -= x;
  658. }
  659. else
  660. {
  661. points[0].x += x;
  662. points[1].x -= x;
  663. points[2].x -= x;
  664. points[3].x += x;
  665. }
  667. if (fixed.top < fixed.bottom)
  668. {
  669. points[0].y -= y;
  670. points[1].y += y;
  671. points[2].y += y;
  672. points[3].y -= y;
  673. }
  674. else
  675. {
  676. points[0].y += y;
  677. points[1].y -= y;
  678. points[2].y -= y;
  679. points[3].y += y;
  680. }
  681. rgn.CreatePolygonRgn(points, 4, ALTERNATE);
  682. }
  683. break;
  684. }
  685. return rgn.RectInRegion(fixed);
  686. }
  688. CDrawObj* CDrawRect::Clone(CDrawDoc* pDoc)
  689. {
  690. ASSERT_VALID(this);
  692. CDrawRect* pClone = new CDrawRect(m_position);
  693. pClone->m_bPen = m_bPen;
  694. pClone->m_logpen = m_logpen;
  695. pClone->m_bBrush = m_bBrush;
  696. pClone->m_logbrush = m_logbrush;
  697. pClone->m_nShape = m_nShape;
  698. pClone->m_roundness = m_roundness;
  699. ASSERT_VALID(pClone);
  701. if (pDoc != NULL)
  702. pDoc->Add(pClone);
  704. ASSERT_VALID(pClone);
  705. return pClone;
  706. }
  708. ////////////////////////////////////////////////////////////////////////////
  709. // CDrawPoly
  711. IMPLEMENT_SERIAL(CDrawPoly, CDrawObj, 0)
  713. CDrawPoly::CDrawPoly()
  714. {
  715. m_points = NULL;
  716. m_nPoints = 0;
  717. m_nAllocPoints = 0;
  718. }
  720. CDrawPoly::CDrawPoly(const CRect& position)
  721. : CDrawObj(position)
  722. {
  723. m_points = NULL;
  724. m_nPoints = 0;
  725. m_nAllocPoints = 0;
  726. m_bPen = TRUE;
  727. m_bBrush = FALSE;
  728. }
  730. CDrawPoly::~CDrawPoly()
  731. {
  732. if (m_points != NULL)
  733. delete[] m_points;
  734. }
  736. void CDrawPoly::Serialize( CArchive& ar )
  737. {
  738. int i;
  739. CDrawObj::Serialize( ar );
  740. if( ar.IsStoring() )
  741. {
  742. ar << (WORD) m_nPoints;
  743. ar << (WORD) m_nAllocPoints;
  744. for (i = 0;i< m_nPoints; i++)
  745. ar << m_points[i];
  746. }
  747. else
  748. {
  749. WORD wTemp;
  750. ar >> wTemp; m_nPoints = wTemp;
  751. ar >> wTemp; m_nAllocPoints = wTemp;
  752. m_points = new CPoint[m_nAllocPoints];
  753. for (i = 0;i < m_nPoints; i++)
  754. ar >> m_points[i];
  755. }
  756. }
  758. void CDrawPoly::Draw(CDC* pDC)
  759. {
  760. ASSERT_VALID(this);
  762. CBrush brush;
  763. if (!brush.CreateBrushIndirect(&m_logbrush))
  764. return;
  765. CPen pen;
  766. if (!pen.CreatePenIndirect(&m_logpen))
  767. return;
  769. CBrush* pOldBrush;
  770. CPen* pOldPen;
  772. if (m_bBrush)
  773. pOldBrush = pDC->SelectObject(&brush);
  774. else
  775. pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
  777. if (m_bPen)
  778. pOldPen = pDC->SelectObject(&pen);
  779. else
  780. pOldPen = (CPen*)pDC->SelectStockObject(NULL_PEN);
  782. pDC->Polygon(m_points, m_nPoints);
  784. pDC->SelectObject(pOldBrush);
  785. pDC->SelectObject(pOldPen);
  786. }
  788. // position must be in logical coordinates
  789. void CDrawPoly::MoveTo(const CRect& position, CDrawView* pView)
  790. {
  791. ASSERT_VALID(this);
  792. if (position == m_position)
  793. return;
  795. if (pView == NULL)
  796. Invalidate();
  797. else
  798. pView->InvalObj(this);
  800. for (int i = 0; i < m_nPoints; i += 1)
  801. {
  802. m_points[i].x += position.left - m_position.left;
  803. m_points[i].y += position.top - m_position.top;
  804. }
  806. m_position = position;
  808. if (pView == NULL)
  809. Invalidate();
  810. else
  811. pView->InvalObj(this);
  812. m_pDocument->SetModifiedFlag();
  813. }
  815. int CDrawPoly::GetHandleCount()
  816. {
  817. return m_nPoints;
  818. }
  820. CPoint CDrawPoly::GetHandle(int nHandle)
  821. {
  822. ASSERT_VALID(this);
  824. ASSERT(nHandle >= 1 && nHandle <= m_nPoints);
  825. return m_points[nHandle - 1];
  826. }
  828. HCURSOR CDrawPoly::GetHandleCursor(int )
  829. {
  830. return AfxGetApp()->LoadStandardCursor(IDC_ARROW);
  831. }
  833. // point is in logical coordinates
  834. void CDrawPoly::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  835. {
  836. ASSERT_VALID(this);
  837. ASSERT(nHandle >= 1 && nHandle <= m_nPoints);
  838. if (m_points[nHandle - 1] == point)
  839. return;
  841. m_points[nHandle - 1] = point;
  842. RecalcBounds(pView);
  844. if (pView == NULL)
  845. Invalidate();
  846. else
  847. pView->InvalObj(this);
  848. m_pDocument->SetModifiedFlag();
  849. }
  851. // rect must be in logical coordinates
  852. BOOL CDrawPoly::Intersects(const CRect& rect)
  853. {
  854. ASSERT_VALID(this);
  855. CRgn rgn;
  856. rgn.CreatePolygonRgn(m_points, m_nPoints, ALTERNATE);
  857. return rgn.RectInRegion(rect);
  858. }
  860. CDrawObj* CDrawPoly::Clone(CDrawDoc* pDoc)
  861. {
  862. ASSERT_VALID(this);
  864. CDrawPoly* pClone = new CDrawPoly(m_position);
  865. pClone->m_bPen = m_bPen;
  866. pClone->m_logpen = m_logpen;
  867. pClone->m_bBrush = m_bBrush;
  868. pClone->m_logbrush = m_logbrush;
  869. pClone->m_points = new CPoint[m_nAllocPoints];
  870. MEMCPY_S(pClone->m_points, m_points, sizeof(CPoint) * m_nPoints);
  871. pClone->m_nAllocPoints = m_nAllocPoints;
  872. pClone->m_nPoints = m_nPoints;
  873. ASSERT_VALID(pClone);
  875. if (pDoc != NULL)
  876. pDoc->Add(pClone);
  878. ASSERT_VALID(pClone);
  879. return pClone;
  880. }
  882. // point is in logical coordinates
  883. void CDrawPoly::AddPoint(const CPoint& point, CDrawView* pView)
  884. {
  885. ASSERT_VALID(this);
  886. if (m_nPoints == m_nAllocPoints)
  887. {
  888. CPoint* newPoints = new CPoint[m_nAllocPoints + 10];
  889. if (m_points != NULL)
  890. {
  891. MEMCPY_S(newPoints, m_points, sizeof(CPoint) * m_nAllocPoints);
  892. delete[] m_points;
  893. }
  894. m_points = newPoints;
  895. m_nAllocPoints += 10;
  896. }
  898. if (m_nPoints == 0 || m_points[m_nPoints - 1] != point)
  899. {
  900. m_points[m_nPoints++] = point;
  901. if (!RecalcBounds(pView))
  902. {
  903. if (pView == NULL)
  904. Invalidate();
  905. else
  906. pView->InvalObj(this);
  907. }
  908. m_pDocument->SetModifiedFlag();
  909. }
  910. }
  912. BOOL CDrawPoly::RecalcBounds(CDrawView* pView)
  913. {
  914. ASSERT_VALID(this);
  916. if (m_nPoints == 0)
  917. return FALSE;
  919. CRect bounds(m_points[0], CSize(0, 0));
  920. for (int i = 1; i < m_nPoints; ++i)
  921. {
  922. if (m_points[i].x < bounds.left)
  923. bounds.left = m_points[i].x;
  924. if (m_points[i].x > bounds.right)
  925. bounds.right = m_points[i].x;
  926. if (m_points[i].y < bounds.top)
  927. bounds.top = m_points[i].y;
  928. if (m_points[i].y > bounds.bottom)
  929. bounds.bottom = m_points[i].y;
  930. }
  932. if (bounds == m_position)
  933. return FALSE;
  935. if (pView == NULL)
  936. Invalidate();
  937. else
  938. pView->InvalObj(this);
  940. m_position = bounds;
  942. if (pView == NULL)
  943. Invalidate();
  944. else
  945. pView->InvalObj(this);
  947. return TRUE;
  948. }
  950. ////////////////////////////////////////////////////////////////////////////
  952. IMPLEMENT_SERIAL(CDrawOleObj, CDrawObj, 0)
  954. BOOL CDrawOleObj::c_bShowItems = TRUE;
  956. CDrawOleObj::CDrawOleObj() : m_extent(0,0)
  957. {
  958. m_pClientItem = NULL;
  959. }
  961. CDrawOleObj::CDrawOleObj(const CRect& position)
  962. : CDrawObj(position), m_extent(0, 0)
  963. {
  964. m_pClientItem = NULL;
  965. }
  967. CDrawOleObj::~CDrawOleObj()
  968. {
  969. if (m_pClientItem != NULL)
  970. {
  971. m_pClientItem->Release();
  972. m_pClientItem = NULL;
  973. }
  974. }
  976. void CDrawOleObj::Remove()
  977. {
  978. if (m_pClientItem != NULL)
  979. {
  980. m_pClientItem->Delete();
  981. m_pClientItem = NULL;
  982. }
  983. CDrawObj::Remove();
  984. }
  986. void CDrawOleObj::Serialize( CArchive& ar )
  987. {
  988. ASSERT_VALID(this);
  990. CDrawObj::Serialize(ar);
  992. if (ar.IsStoring())
  993. {
  994. ar << m_extent;
  995. ar << m_pClientItem;
  996. }
  997. else
  998. {
  999. ar >> m_extent;
  1000. ar >> m_pClientItem;
  1001. m_pClientItem->m_pDrawObj = this;
  1002. }
  1003. }
  1005. CDrawObj* CDrawOleObj::Clone(CDrawDoc* pDoc)
  1006. {
  1007. ASSERT_VALID(this);
  1009. AfxGetApp()->BeginWaitCursor();
  1011. CDrawOleObj* pClone = NULL;
  1012. CDrawItem* pItem = NULL;
  1013. TRY
  1014. {
  1015. // perform a "deep copy" -- need to copy CDrawOleObj and the CDrawItem
  1016. //  that it points to.
  1017. CDrawOleObj* pClone = new CDrawOleObj(m_position);
  1018. CDrawItem* pItem = new CDrawItem(m_pDocument, pClone);
  1019. if (!pItem->CreateCloneFrom(m_pClientItem))
  1020. AfxThrowMemoryException();
  1022. pClone->m_pClientItem = pItem;
  1023. pClone->m_bPen = m_bPen;
  1024. pClone->m_logpen = m_logpen;
  1025. pClone->m_bBrush = m_bBrush;
  1026. pClone->m_logbrush = m_logbrush;
  1027. ASSERT_VALID(pClone);
  1029. if (pDoc != NULL)
  1030. pDoc->Add(pClone);
  1031. }
  1032. CATCH_ALL(e)
  1033. {
  1034. pItem->Delete();
  1035. pClone->m_pClientItem = NULL;
  1036. pClone->Remove();
  1037. AfxGetApp()->EndWaitCursor();
  1039. THROW_LAST();
  1040. }
  1041. END_CATCH_ALL
  1043. AfxGetApp()->EndWaitCursor();
  1044. return pClone;
  1045. }
  1047. void CDrawOleObj::Draw(CDC* pDC)
  1048. {
  1049. ASSERT_VALID(this);
  1051. CDrawItem* pItem = m_pClientItem;
  1052. if (pItem != NULL)
  1053. {
  1054. // draw the OLE item itself
  1055. pItem->Draw(pDC, m_position);
  1057. // don't draw tracker in print preview or on printer
  1058. if (!pDC->IsPrinting())
  1059. {
  1060. // use a CRectTracker to draw the standard effects
  1061. CRectTracker tracker;
  1062. tracker.m_rect = m_position;
  1063. pDC->LPtoDP(tracker.m_rect);
  1065. if (c_bShowItems)
  1066. {
  1067. // put correct border depending on item type
  1068. if (pItem->GetType() == OT_LINK)
  1069. tracker.m_nStyle |= CRectTracker::dottedLine;
  1070. else
  1071. tracker.m_nStyle |= CRectTracker::solidLine;
  1072. }
  1074. // put hatching over the item if it is currently open
  1075. if (pItem->GetItemState() == COleClientItem::openState ||
  1076. pItem->GetItemState() == COleClientItem::activeUIState)
  1077. {
  1078. tracker.m_nStyle |= CRectTracker::hatchInside;
  1079. }
  1080. tracker.Draw(pDC);
  1081. }
  1082. }
  1083. }
  1085. void CDrawOleObj::OnOpen(CDrawView* pView)
  1086. {
  1087. AfxGetApp()->BeginWaitCursor();
  1088. m_pClientItem->DoVerb(
  1089. GetKeyState(VK_CONTROL) < 0 ? OLEIVERB_OPEN : OLEIVERB_PRIMARY,
  1090. pView);
  1091. AfxGetApp()->EndWaitCursor();
  1092. }
  1094. void CDrawOleObj::OnEditProperties()
  1095. {
  1096. // using COlePropertiesDialog directly means no scaling
  1097. COlePropertiesDialog dlg(m_pClientItem, 100, 100, NULL);
  1099. dlg.DoModal();
  1100. }
  1102. // position is in logical
  1103. void CDrawOleObj::MoveTo(const CRect& position, CDrawView* pView)
  1104. {
  1105. ASSERT_VALID(this);
  1107. if (position == m_position)
  1108. return;
  1110. // call base class to update position
  1111. CDrawObj::MoveTo(position, pView);
  1113. // update position of in-place editing session on position change
  1114. if (m_pClientItem->IsInPlaceActive())
  1115. m_pClientItem->SetItemRects();
  1116. }
  1118. /////////////////////////////////////////////////////////////////////////////