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

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

Windows编程

开发平台：

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::Remove()
  79. {
  80. delete this;
  81. }
  83. void CDrawObj::Draw(CDC*)
  84. {
  85. }
  87. void CDrawObj::DrawTracker(CDC* pDC, TrackerState state)
  88. {
  89. ASSERT_VALID(this);
  91. switch (state)
  92. {
  93. case normal:
  94. break;
  96. case selected:
  97. case active:
  98. {
  99. int nHandleCount = GetHandleCount();
  100. for (int nHandle = 1; nHandle <= nHandleCount; nHandle += 1)
  101. {
  102. CPoint handle = GetHandle(nHandle);
  103. pDC->PatBlt(handle.x - 3, handle.y - 3, 7, 7, DSTINVERT);
  104. }
  105. }
  106. break;
  107. }
  108. }
  110. // position is in logical
  111. void CDrawObj::MoveTo(const CRect& position, CDrawView* pView)
  112. {
  113. ASSERT_VALID(this);
  115. if (position == m_position)
  116. return;
  118. if (pView == NULL)
  119. {
  120. Invalidate();
  121. m_position = position;
  122. Invalidate();
  123. }
  124. else
  125. {
  126. pView->InvalObj(this);
  127. m_position = position;
  128. pView->InvalObj(this);
  129. }
  130. m_pDocument->SetModifiedFlag();
  131. }
  133. // Note: if bSelected, hit-codes start at one for the top-left
  134. // and increment clockwise, 0 means no hit.
  135. // If !bSelected, 0 = no hit, 1 = hit (anywhere)
  137. // point is in logical coordinates
  138. int CDrawObj::HitTest(CPoint point, CDrawView* pView, BOOL bSelected)
  139. {
  140. ASSERT_VALID(this);
  141. ASSERT(pView != NULL);
  143. if (bSelected)
  144. {
  145. int nHandleCount = GetHandleCount();
  146. for (int nHandle = 1; nHandle <= nHandleCount; nHandle += 1)
  147. {
  148. // GetHandleRect returns in logical coords
  149. CRect rc = GetHandleRect(nHandle,pView);
  150. if (point.x >= rc.left && point.x < rc.right &&
  151. point.y <= rc.top && point.y > rc.bottom)
  152. return nHandle;
  153. }
  154. }
  155. else
  156. {
  157. if (point.x >= m_position.left && point.x < m_position.right &&
  158. point.y <= m_position.top && point.y > m_position.bottom)
  159. return 1;
  160. }
  161. return 0;
  162. }
  164. // rect must be in logical coordinates
  165. BOOL CDrawObj::Intersects(const CRect& rect)
  166. {
  167. ASSERT_VALID(this);
  169. CRect fixed = m_position;
  170. fixed.NormalizeRect();
  171. CRect rectT = rect;
  172. rectT.NormalizeRect();
  173. return !(rectT & fixed).IsRectEmpty();
  174. }
  176. int CDrawObj::GetHandleCount()
  177. {
  178. ASSERT_VALID(this);
  179. return 8;
  180. }
  182. // returns logical coords of center of handle
  183. CPoint CDrawObj::GetHandle(int nHandle)
  184. {
  185. ASSERT_VALID(this);
  186. int x, y, xCenter, yCenter;
  188. // this gets the center regardless of left/right and top/bottom ordering
  189. xCenter = m_position.left + m_position.Width() / 2;
  190. yCenter = m_position.top + m_position.Height() / 2;
  192. switch (nHandle)
  193. {
  194. default:
  195. ASSERT(FALSE);
  197. case 1:
  198. x = m_position.left;
  199. y = m_position.top;
  200. break;
  202. case 2:
  203. x = xCenter;
  204. y = m_position.top;
  205. break;
  207. case 3:
  208. x = m_position.right;
  209. y = m_position.top;
  210. break;
  212. case 4:
  213. x = m_position.right;
  214. y = yCenter;
  215. break;
  217. case 5:
  218. x = m_position.right;
  219. y = m_position.bottom;
  220. break;
  222. case 6:
  223. x = xCenter;
  224. y = m_position.bottom;
  225. break;
  227. case 7:
  228. x = m_position.left;
  229. y = m_position.bottom;
  230. break;
  232. case 8:
  233. x = m_position.left;
  234. y = yCenter;
  235. break;
  236. }
  238. return CPoint(x, y);
  239. }
  241. // return rectange of handle in logical coords
  242. CRect CDrawObj::GetHandleRect(int nHandleID, CDrawView* pView)
  243. {
  244. ASSERT_VALID(this);
  245. ASSERT(pView != NULL);
  247. CRect rect;
  248. // get the center of the handle in logical coords
  249. CPoint point = GetHandle(nHandleID);
  250. // convert to client/device coords
  251. pView->DocToClient(point);
  252. // return CRect of handle in device coords
  253. rect.SetRect(point.x-3, point.y-3, point.x+3, point.y+3);
  254. pView->ClientToDoc(rect);
  256. return rect;
  257. }
  259. HCURSOR CDrawObj::GetHandleCursor(int nHandle)
  260. {
  261. ASSERT_VALID(this);
  263. LPCTSTR id;
  264. switch (nHandle)
  265. {
  266. default:
  267. ASSERT(FALSE);
  269. case 1:
  270. case 5:
  271. id = IDC_SIZENWSE;
  272. break;
  274. case 2:
  275. case 6:
  276. id = IDC_SIZENS;
  277. break;
  279. case 3:
  280. case 7:
  281. id = IDC_SIZENESW;
  282. break;
  284. case 4:
  285. case 8:
  286. id = IDC_SIZEWE;
  287. break;
  288. }
  290. return AfxGetApp()->LoadStandardCursor(id);
  291. }
  293. // point must be in logical
  294. void CDrawObj::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  295. {
  296. ASSERT_VALID(this);
  298. CRect position = m_position;
  299. switch (nHandle)
  300. {
  301. default:
  302. ASSERT(FALSE);
  304. case 1:
  305. position.left = point.x;
  306. position.top = point.y;
  307. break;
  309. case 2:
  310. position.top = point.y;
  311. break;
  313. case 3:
  314. position.right = point.x;
  315. position.top = point.y;
  316. break;
  318. case 4:
  319. position.right = point.x;
  320. break;
  322. case 5:
  323. position.right = point.x;
  324. position.bottom = point.y;
  325. break;
  327. case 6:
  328. position.bottom = point.y;
  329. break;
  331. case 7:
  332. position.left = point.x;
  333. position.bottom = point.y;
  334. break;
  336. case 8:
  337. position.left = point.x;
  338. break;
  339. }
  341. MoveTo(position, pView);
  342. }
  344. void CDrawObj::Invalidate()
  345. {
  346. ASSERT_VALID(this);
  347. m_pDocument->UpdateAllViews(NULL, HINT_UPDATE_DRAWOBJ, this);
  348. }
  350. CDrawObj* CDrawObj::Clone(CDrawDoc* pDoc)
  351. {
  352. ASSERT_VALID(this);
  354. CDrawObj* pClone = new CDrawObj(m_position);
  355. pClone->m_bPen = m_bPen;
  356. pClone->m_logpen = m_logpen;
  357. pClone->m_bBrush = m_bBrush;
  358. pClone->m_logbrush = m_logbrush;
  359. ASSERT_VALID(pClone);
  361. if (pDoc != NULL)
  362. pDoc->Add(pClone);
  364. return pClone;
  365. }
  367. void CDrawObj::OnEditProperties()
  368. {
  369. ASSERT_VALID(this);
  371. CPropertySheet sheet( _T("Shape Properties") );
  372. CRectDlg dlg;
  373. dlg.m_bNoFill = !m_bBrush;
  374. dlg.m_penSize = m_bPen ? m_logpen.lopnWidth.x : 0;
  375. sheet.AddPage( &dlg );
  377. if (sheet.DoModal() != IDOK)
  378. return;
  380. m_bBrush = !dlg.m_bNoFill;
  381. m_bPen = dlg.m_penSize > 0;
  382. if (m_bPen)
  383. {
  384. m_logpen.lopnWidth.x = dlg.m_penSize;
  385. m_logpen.lopnWidth.y = dlg.m_penSize;
  386. }
  388. Invalidate();
  389. m_pDocument->SetModifiedFlag();
  390. }
  392. void CDrawObj::OnOpen(CDrawView* /*pView*/ )
  393. {
  394. OnEditProperties();
  395. }
  397. void CDrawObj::SetLineColor(COLORREF color)
  398. {
  399. ASSERT_VALID(this);
  401. m_logpen.lopnColor = color;
  402. Invalidate();
  403. m_pDocument->SetModifiedFlag();
  404. }
  406. void CDrawObj::SetFillColor(COLORREF color)
  407. {
  408. ASSERT_VALID(this);
  410. m_logbrush.lbColor = color;
  411. Invalidate();
  412. m_pDocument->SetModifiedFlag();
  413. }
  415. #ifdef _DEBUG
  416. void CDrawObj::AssertValid()
  417. {
  418. ASSERT(m_position.left <= m_position.right);
  419. ASSERT(m_position.bottom <= m_position.top);
  420. }
  421. #endif
  423. ////////////////////////////////////////////////////////////////////////////
  424. // CDrawRect
  426. IMPLEMENT_SERIAL(CDrawRect, CDrawObj, 0)
  428. CDrawRect::CDrawRect()
  429. {
  430. }
  432. CDrawRect::CDrawRect(const CRect& position)
  433. : CDrawObj(position)
  434. {
  435. ASSERT_VALID(this);
  437. m_nShape = rectangle;
  438. m_roundness.x = 16;
  439. m_roundness.y = 16;
  440. }
  442. void CDrawRect::Serialize(CArchive& ar)
  443. {
  444. ASSERT_VALID(this);
  446. CDrawObj::Serialize(ar);
  447. if (ar.IsStoring())
  448. {
  449. ar << (WORD) m_nShape;
  450. ar << m_roundness;
  451. }
  452. else
  453. {
  454. WORD wTemp;
  455. ar >> wTemp; m_nShape = (Shape)wTemp;
  456. ar >> m_roundness;
  457. }
  458. }
  460. void CDrawRect::Draw(CDC* pDC)
  461. {
  462. ASSERT_VALID(this);
  464. CBrush brush;
  465. if (!brush.CreateBrushIndirect(&m_logbrush))
  466. return;
  467. CPen pen;
  468. if (!pen.CreatePenIndirect(&m_logpen))
  469. return;
  471. CBrush* pOldBrush;
  472. CPen* pOldPen;
  474. if (m_bBrush)
  475. pOldBrush = pDC->SelectObject(&brush);
  476. else
  477. pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
  479. if (m_bPen)
  480. pOldPen = pDC->SelectObject(&pen);
  481. else
  482. pOldPen = (CPen*)pDC->SelectStockObject(NULL_PEN);
  484. CRect rect = m_position;
  485. switch (m_nShape)
  486. {
  487. case rectangle:
  488. pDC->Rectangle(rect);
  489. break;
  491. case roundRectangle:
  492. pDC->RoundRect(rect, m_roundness);
  493. break;
  495. case ellipse:
  496. pDC->Ellipse(rect);
  497. break;
  499. case line:
  500. if (rect.top > rect.bottom)
  501. {
  502. rect.top -= m_logpen.lopnWidth.y / 2;
  503. rect.bottom += (m_logpen.lopnWidth.y + 1) / 2;
  504. }
  505. else
  506. {
  507. rect.top += (m_logpen.lopnWidth.y + 1) / 2;
  508. rect.bottom -= m_logpen.lopnWidth.y / 2;
  509. }
  511. if (rect.left > rect.right)
  512. {
  513. rect.left -= m_logpen.lopnWidth.x / 2;
  514. rect.right += (m_logpen.lopnWidth.x + 1) / 2;
  515. }
  516. else
  517. {
  518. rect.left += (m_logpen.lopnWidth.x + 1) / 2;
  519. rect.right -= m_logpen.lopnWidth.x / 2;
  520. }
  522. pDC->MoveTo(rect.TopLeft());
  523. pDC->LineTo(rect.BottomRight());
  524. break;
  525. }
  527. pDC->SelectObject(pOldBrush);
  528. pDC->SelectObject(pOldPen);
  529. }
  532. int CDrawRect::GetHandleCount()
  533. {
  534. ASSERT_VALID(this);
  536. return m_nShape == line ? 2 :
  537. CDrawObj::GetHandleCount() + (m_nShape == roundRectangle);
  538. }
  540. // returns center of handle in logical coordinates
  541. CPoint CDrawRect::GetHandle(int nHandle)
  542. {
  543. ASSERT_VALID(this);
  545. if (m_nShape == line && nHandle == 2)
  546. nHandle = 5;
  547. else if (m_nShape == roundRectangle && nHandle == 9)
  548. {
  549. CRect rect = m_position;
  550. rect.NormalizeRect();
  551. CPoint point = rect.BottomRight();
  552. point.x -= m_roundness.x / 2;
  553. point.y -= m_roundness.y / 2;
  554. return point;
  555. }
  557. return CDrawObj::GetHandle(nHandle);
  558. }
  560. HCURSOR CDrawRect::GetHandleCursor(int nHandle)
  561. {
  562. ASSERT_VALID(this);
  564. if (m_nShape == line && nHandle == 2)
  565. nHandle = 5;
  566. else if (m_nShape == roundRectangle && nHandle == 9)
  567. return AfxGetApp()->LoadStandardCursor(IDC_SIZEALL);
  568. return CDrawObj::GetHandleCursor(nHandle);
  569. }
  571. // point is in logical coordinates
  572. void CDrawRect::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  573. {
  574. ASSERT_VALID(this);
  576. if (m_nShape == line && nHandle == 2)
  577. nHandle = 5;
  578. else if (m_nShape == roundRectangle && nHandle == 9)
  579. {
  580. CRect rect = m_position;
  581. rect.NormalizeRect();
  582. if (point.x > rect.right - 1)
  583. point.x = rect.right - 1;
  584. else if (point.x < rect.left + rect.Width() / 2)
  585. point.x = rect.left + rect.Width() / 2;
  586. if (point.y > rect.bottom - 1)
  587. point.y = rect.bottom - 1;
  588. else if (point.y < rect.top + rect.Height() / 2)
  589. point.y = rect.top + rect.Height() / 2;
  590. m_roundness.x = 2 * (rect.right - point.x);
  591. m_roundness.y = 2 * (rect.bottom - point.y);
  592. m_pDocument->SetModifiedFlag();
  593. if (pView == NULL)
  594. Invalidate();
  595. else
  596. pView->InvalObj(this);
  597. return;
  598. }
  600. CDrawObj::MoveHandleTo(nHandle, point, pView);
  601. }
  603. // rect must be in logical coordinates
  604. BOOL CDrawRect::Intersects(const CRect& rect)
  605. {
  606. ASSERT_VALID(this);
  608. CRect rectT = rect;
  609. rectT.NormalizeRect();
  611. CRect fixed = m_position;
  612. fixed.NormalizeRect();
  613. if ((rectT & fixed).IsRectEmpty())
  614. return FALSE;
  616. CRgn rgn;
  617. switch (m_nShape)
  618. {
  619. case rectangle:
  620. return TRUE;
  622. case roundRectangle:
  623. rgn.CreateRoundRectRgn(fixed.left, fixed.top, fixed.right, fixed.bottom,
  624. m_roundness.x, m_roundness.y);
  625. break;
  627. case ellipse:
  628. rgn.CreateEllipticRgnIndirect(fixed);
  629. break;
  631. case line:
  632. {
  633. int x = (m_logpen.lopnWidth.x + 5) / 2;
  634. int y = (m_logpen.lopnWidth.y + 5) / 2;
  635. POINT points[4];
  636. points[0].x = fixed.left;
  637. points[0].y = fixed.top;
  638. points[1].x = fixed.left;
  639. points[1].y = fixed.top;
  640. points[2].x = fixed.right;
  641. points[2].y = fixed.bottom;
  642. points[3].x = fixed.right;
  643. points[3].y = fixed.bottom;
  645. if (fixed.left < fixed.right)
  646. {
  647. points[0].x -= x;
  648. points[1].x += x;
  649. points[2].x += x;
  650. points[3].x -= x;
  651. }
  652. else
  653. {
  654. points[0].x += x;
  655. points[1].x -= x;
  656. points[2].x -= x;
  657. points[3].x += x;
  658. }
  660. if (fixed.top < fixed.bottom)
  661. {
  662. points[0].y -= y;
  663. points[1].y += y;
  664. points[2].y += y;
  665. points[3].y -= y;
  666. }
  667. else
  668. {
  669. points[0].y += y;
  670. points[1].y -= y;
  671. points[2].y -= y;
  672. points[3].y += y;
  673. }
  674. rgn.CreatePolygonRgn(points, 4, ALTERNATE);
  675. }
  676. break;
  677. }
  678. return rgn.RectInRegion(fixed);
  679. }
  681. CDrawObj* CDrawRect::Clone(CDrawDoc* pDoc)
  682. {
  683. ASSERT_VALID(this);
  685. CDrawRect* pClone = new CDrawRect(m_position);
  686. pClone->m_bPen = m_bPen;
  687. pClone->m_logpen = m_logpen;
  688. pClone->m_bBrush = m_bBrush;
  689. pClone->m_logbrush = m_logbrush;
  690. pClone->m_nShape = m_nShape;
  691. pClone->m_roundness = m_roundness;
  692. ASSERT_VALID(pClone);
  694. if (pDoc != NULL)
  695. pDoc->Add(pClone);
  697. ASSERT_VALID(pClone);
  698. return pClone;
  699. }
  701. ////////////////////////////////////////////////////////////////////////////
  702. // CDrawPoly
  704. IMPLEMENT_SERIAL(CDrawPoly, CDrawObj, 0)
  706. CDrawPoly::CDrawPoly()
  707. {
  708. m_points = NULL;
  709. m_nPoints = 0;
  710. m_nAllocPoints = 0;
  711. }
  713. CDrawPoly::CDrawPoly(const CRect& position)
  714. : CDrawObj(position)
  715. {
  716. m_points = NULL;
  717. m_nPoints = 0;
  718. m_nAllocPoints = 0;
  719. m_bPen = TRUE;
  720. m_bBrush = FALSE;
  721. }
  723. CDrawPoly::~CDrawPoly()
  724. {
  725. if (m_points != NULL)
  726. delete[] m_points;
  727. }
  729. void CDrawPoly::Serialize( CArchive& ar )
  730. {
  731. int i;
  732. CDrawObj::Serialize( ar );
  733. if( ar.IsStoring() )
  734. {
  735. ar << (WORD) m_nPoints;
  736. ar << (WORD) m_nAllocPoints;
  737. for (i = 0;i< m_nPoints; i++)
  738. ar << m_points[i];
  739. }
  740. else
  741. {
  742. WORD wTemp;
  743. ar >> wTemp; m_nPoints = wTemp;
  744. ar >> wTemp; m_nAllocPoints = wTemp;
  745. m_points = new CPoint[m_nAllocPoints];
  746. for (i = 0;i < m_nPoints; i++)
  747. ar >> m_points[i];
  748. }
  749. }
  751. void CDrawPoly::Draw(CDC* pDC)
  752. {
  753. ASSERT_VALID(this);
  755. CBrush brush;
  756. if (!brush.CreateBrushIndirect(&m_logbrush))
  757. return;
  758. CPen pen;
  759. if (!pen.CreatePenIndirect(&m_logpen))
  760. return;
  762. CBrush* pOldBrush;
  763. CPen* pOldPen;
  765. if (m_bBrush)
  766. pOldBrush = pDC->SelectObject(&brush);
  767. else
  768. pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
  770. if (m_bPen)
  771. pOldPen = pDC->SelectObject(&pen);
  772. else
  773. pOldPen = (CPen*)pDC->SelectStockObject(NULL_PEN);
  775. pDC->Polygon(m_points, m_nPoints);
  777. pDC->SelectObject(pOldBrush);
  778. pDC->SelectObject(pOldPen);
  779. }
  781. // position must be in logical coordinates
  782. void CDrawPoly::MoveTo(const CRect& position, CDrawView* pView)
  783. {
  784. ASSERT_VALID(this);
  785. if (position == m_position)
  786. return;
  788. if (pView == NULL)
  789. Invalidate();
  790. else
  791. pView->InvalObj(this);
  793. for (int i = 0; i < m_nPoints; i += 1)
  794. {
  795. m_points[i].x += position.left - m_position.left;
  796. m_points[i].y += position.top - m_position.top;
  797. }
  799. m_position = position;
  801. if (pView == NULL)
  802. Invalidate();
  803. else
  804. pView->InvalObj(this);
  805. m_pDocument->SetModifiedFlag();
  806. }
  808. int CDrawPoly::GetHandleCount()
  809. {
  810. return m_nPoints;
  811. }
  813. CPoint CDrawPoly::GetHandle(int nHandle)
  814. {
  815. ASSERT_VALID(this);
  817. ASSERT(nHandle >= 1 && nHandle <= m_nPoints);
  818. return m_points[nHandle - 1];
  819. }
  821. HCURSOR CDrawPoly::GetHandleCursor(int )
  822. {
  823. return AfxGetApp()->LoadStandardCursor(IDC_ARROW);
  824. }
  826. // point is in logical coordinates
  827. void CDrawPoly::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  828. {
  829. ASSERT_VALID(this);
  830. ASSERT(nHandle >= 1 && nHandle <= m_nPoints);
  831. if (m_points[nHandle - 1] == point)
  832. return;
  834. m_points[nHandle - 1] = point;
  835. RecalcBounds(pView);
  837. if (pView == NULL)
  838. Invalidate();
  839. else
  840. pView->InvalObj(this);
  841. m_pDocument->SetModifiedFlag();
  842. }
  844. // rect must be in logical coordinates
  845. BOOL CDrawPoly::Intersects(const CRect& rect)
  846. {
  847. ASSERT_VALID(this);
  848. CRgn rgn;
  849. rgn.CreatePolygonRgn(m_points, m_nPoints, ALTERNATE);
  850. return rgn.RectInRegion(rect);
  851. }
  853. CDrawObj* CDrawPoly::Clone(CDrawDoc* pDoc)
  854. {
  855. ASSERT_VALID(this);
  857. CDrawPoly* pClone = new CDrawPoly(m_position);
  858. pClone->m_bPen = m_bPen;
  859. pClone->m_logpen = m_logpen;
  860. pClone->m_bBrush = m_bBrush;
  861. pClone->m_logbrush = m_logbrush;
  862. pClone->m_points = new CPoint[m_nAllocPoints];
  863. memcpy(pClone->m_points, m_points, sizeof(CPoint) * m_nPoints);
  864. pClone->m_nAllocPoints = m_nAllocPoints;
  865. pClone->m_nPoints = m_nPoints;
  866. ASSERT_VALID(pClone);
  868. if (pDoc != NULL)
  869. pDoc->Add(pClone);
  871. ASSERT_VALID(pClone);
  872. return pClone;
  873. }
  875. // point is in logical coordinates
  876. void CDrawPoly::AddPoint(const CPoint& point, CDrawView* pView)
  877. {
  878. ASSERT_VALID(this);
  879. if (m_nPoints == m_nAllocPoints)
  880. {
  881. CPoint* newPoints = new CPoint[m_nAllocPoints + 10];
  882. if (m_points != NULL)
  883. {
  884. memcpy(newPoints, m_points, sizeof(CPoint) * m_nAllocPoints);
  885. delete[] m_points;
  886. }
  887. m_points = newPoints;
  888. m_nAllocPoints += 10;
  889. }
  891. if (m_nPoints == 0 || m_points[m_nPoints - 1] != point)
  892. {
  893. m_points[m_nPoints++] = point;
  894. if (!RecalcBounds(pView))
  895. {
  896. if (pView == NULL)
  897. Invalidate();
  898. else
  899. pView->InvalObj(this);
  900. }
  901. m_pDocument->SetModifiedFlag();
  902. }
  903. }
  905. BOOL CDrawPoly::RecalcBounds(CDrawView* pView)
  906. {
  907. ASSERT_VALID(this);
  909. if (m_nPoints == 0)
  910. return FALSE;
  912. CRect bounds(m_points[0], CSize(0, 0));
  913. for (int i = 1; i < m_nPoints; ++i)
  914. {
  915. if (m_points[i].x < bounds.left)
  916. bounds.left = m_points[i].x;
  917. if (m_points[i].x > bounds.right)
  918. bounds.right = m_points[i].x;
  919. if (m_points[i].y < bounds.top)
  920. bounds.top = m_points[i].y;
  921. if (m_points[i].y > bounds.bottom)
  922. bounds.bottom = m_points[i].y;
  923. }
  925. if (bounds == m_position)
  926. return FALSE;
  928. if (pView == NULL)
  929. Invalidate();
  930. else
  931. pView->InvalObj(this);
  933. m_position = bounds;
  935. if (pView == NULL)
  936. Invalidate();
  937. else
  938. pView->InvalObj(this);
  940. return TRUE;
  941. }
  943. ////////////////////////////////////////////////////////////////////////////
  945. IMPLEMENT_SERIAL(CDrawOleObj, CDrawObj, 0)
  947. BOOL CDrawOleObj::c_bShowItems = TRUE;
  949. CDrawOleObj::CDrawOleObj() : m_extent(0,0)
  950. {
  951. m_pClientItem = NULL;
  952. }
  954. CDrawOleObj::CDrawOleObj(const CRect& position)
  955. : CDrawObj(position), m_extent(0, 0)
  956. {
  957. m_pClientItem = NULL;
  958. }
  960. CDrawOleObj::~CDrawOleObj()
  961. {
  962. if (m_pClientItem != NULL)
  963. {
  964. m_pClientItem->Release();
  965. m_pClientItem = NULL;
  966. }
  967. }
  969. void CDrawOleObj::Remove()
  970. {
  971. if (m_pClientItem != NULL)
  972. {
  973. m_pClientItem->Delete();
  974. m_pClientItem = NULL;
  975. }
  976. CDrawObj::Remove();
  977. }
  979. void CDrawOleObj::Serialize( CArchive& ar )
  980. {
  981. ASSERT_VALID(this);
  983. CDrawObj::Serialize(ar);
  985. if (ar.IsStoring())
  986. {
  987. ar << m_extent;
  988. ar << m_pClientItem;
  989. }
  990. else
  991. {
  992. ar >> m_extent;
  993. ar >> m_pClientItem;
  994. m_pClientItem->m_pDrawObj = this;
  995. }
  996. }
  998. CDrawObj* CDrawOleObj::Clone(CDrawDoc* pDoc)
  999. {
  1000. ASSERT_VALID(this);
  1002. AfxGetApp()->BeginWaitCursor();
  1004. CDrawOleObj* pClone = NULL;
  1005. CDrawItem* pItem = NULL;
  1006. TRY
  1007. {
  1008. // perform a "deep copy" -- need to copy CDrawOleObj and the CDrawItem
  1009. //  that it points to.
  1010. CDrawOleObj* pClone = new CDrawOleObj(m_position);
  1011. CDrawItem* pItem = new CDrawItem(m_pDocument, pClone);
  1012. if (!pItem->CreateCloneFrom(m_pClientItem))
  1013. AfxThrowMemoryException();
  1015. pClone->m_pClientItem = pItem;
  1016. pClone->m_bPen = m_bPen;
  1017. pClone->m_logpen = m_logpen;
  1018. pClone->m_bBrush = m_bBrush;
  1019. pClone->m_logbrush = m_logbrush;
  1020. ASSERT_VALID(pClone);
  1022. if (pDoc != NULL)
  1023. pDoc->Add(pClone);
  1024. }
  1025. CATCH_ALL(e)
  1026. {
  1027. pItem->Delete();
  1028. pClone->m_pClientItem = NULL;
  1029. pClone->Remove();
  1030. AfxGetApp()->EndWaitCursor();
  1032. THROW_LAST();
  1033. }
  1034. END_CATCH_ALL
  1036. AfxGetApp()->EndWaitCursor();
  1037. return pClone;
  1038. }
  1040. void CDrawOleObj::Draw(CDC* pDC)
  1041. {
  1042. ASSERT_VALID(this);
  1044. CDrawItem* pItem = m_pClientItem;
  1045. if (pItem != NULL)
  1046. {
  1047. // draw the OLE item itself
  1048. pItem->Draw(pDC, m_position);
  1050. // don't draw tracker in print preview or on printer
  1051. if (!pDC->IsPrinting())
  1052. {
  1053. // use a CRectTracker to draw the standard effects
  1054. CRectTracker tracker;
  1055. tracker.m_rect = m_position;
  1056. pDC->LPtoDP(tracker.m_rect);
  1058. if (c_bShowItems)
  1059. {
  1060. // put correct border depending on item type
  1061. if (pItem->GetType() == OT_LINK)
  1062. tracker.m_nStyle |= CRectTracker::dottedLine;
  1063. else
  1064. tracker.m_nStyle |= CRectTracker::solidLine;
  1065. }
  1067. // put hatching over the item if it is currently open
  1068. if (pItem->GetItemState() == COleClientItem::openState ||
  1069. pItem->GetItemState() == COleClientItem::activeUIState)
  1070. {
  1071. tracker.m_nStyle |= CRectTracker::hatchInside;
  1072. }
  1073. tracker.Draw(pDC);
  1074. }
  1075. }
  1076. }
  1078. void CDrawOleObj::OnOpen(CDrawView* pView)
  1079. {
  1080. AfxGetApp()->BeginWaitCursor();
  1081. m_pClientItem->DoVerb(
  1082. GetKeyState(VK_CONTROL) < 0 ? OLEIVERB_OPEN : OLEIVERB_PRIMARY,
  1083. pView);
  1084. AfxGetApp()->EndWaitCursor();
  1085. }
  1087. void CDrawOleObj::OnEditProperties()
  1088. {
  1089. // using COlePropertiesDialog directly means no scaling
  1090. COlePropertiesDialog dlg(m_pClientItem, 100, 100, NULL);
  1092. dlg.DoModal();
  1093. }
  1095. // position is in logical
  1096. void CDrawOleObj::MoveTo(const CRect& position, CDrawView* pView)
  1097. {
  1098. ASSERT_VALID(this);
  1100. if (position == m_position)
  1101. return;
  1103. // call base class to update position
  1104. CDrawObj::MoveTo(position, pView);
  1106. // update position of in-place editing session on position change
  1107. if (m_pClientItem->IsInPlaceActive())
  1108. m_pClientItem->SetItemRects();
  1109. }
  1111. /////////////////////////////////////////////////////////////////////////////