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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 其他行业 > 查看源码
DrawObj.cpp
资源名称：组态王6.5源代码.rar　[点击查看]
上传用户：seaboy_04
上传日期：2013-02-24
资源大小：284k
文件大小：18k
源码类别：

其他行业

开发平台：

Visual C++

DrawObj.cpp：源码内容
  1. // DrawObj.cpp: implementation of the CDrawObj class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "DrawCli.h"
  7. #include "DrawObj.h"
  9. #include "drawdoc.h"
  10. #include "drawvw.h"
  11. #include "cntritem.h"
  12. #include "rectdlg.h"
  14. #ifdef _DEBUG
  15. #undef THIS_FILE
  16. static char THIS_FILE[]=__FILE__;
  17. #define new DEBUG_NEW
  18. #endif
  20. //////////////////////////////////////////////////////////////////////
  21. // Construction/Destruction
  22. //////////////////////////////////////////////////////////////////////
  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 = 2;
  42. m_logpen.lopnWidth.y = 2;
  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;
  50. m_nOrder=0;
  51. m_nType=0;
  52. }
  54. void CDrawObj::Serialize(CArchive& ar)
  55. {
  56. CObject::Serialize(ar);
  57. if (ar.IsStoring())
  58. {
  59. ar << m_position;
  60. ar << (WORD)m_bPen;
  61. ar.Write(&m_logpen, sizeof(LOGPEN));
  62. ar << (WORD)m_bBrush;
  63. ar.Write(&m_logbrush, sizeof(LOGBRUSH));
  64. ar << m_nOrder;
  65. ar << m_nType;
  66. }
  67. else
  68. {
  69. // get the document back pointer from the archive
  70. m_pDocument = (CDrawDoc*)ar.m_pDocument;
  71. ASSERT_VALID(m_pDocument);
  72. ASSERT_KINDOF(CDrawDoc, m_pDocument);
  74. WORD wTemp;
  75. ar >> m_position;
  76. ar >> wTemp; m_bPen = (BOOL)wTemp;
  77. ar.Read(&m_logpen,sizeof(LOGPEN));
  78. ar >> wTemp; m_bBrush = (BOOL)wTemp;
  79. ar.Read(&m_logbrush, sizeof(LOGBRUSH));
  80. ar >> m_nOrder;
  81. ar >> m_nType;
  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);
  121.  
  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);
  360.  
  361. CDrawObj* pClone = new CDrawObj(m_position);
  363. pClone->m_bPen = m_bPen;
  364. pClone->m_logpen = m_logpen;
  365. pClone->m_bBrush = m_bBrush;
  366. pClone->m_logbrush = m_logbrush;
  367. pClone->m_nOrder = m_nOrder;
  368. pClone->m_nType = m_nType;
  370. ASSERT_VALID(pClone);
  372. if (pDoc != NULL)
  373. pDoc->Add(pClone);
  375. return pClone;
  377. }
  379. void CDrawObj::OnEditProperties()
  380. {
  381. ASSERT_VALID(this);
  382.    
  383. CPropertySheet sheet( _T("对象显示属性") );
  384. CRectDlg dlg;
  385. dlg.m_bNoFill = !m_bBrush;
  386. dlg.m_penSize = m_bPen ? m_logpen.lopnWidth.x : 0;
  387. dlg.m_LineColor = m_logpen.lopnColor;   
  388.     dlg.m_FillColor = m_logbrush.lbColor;   
  389.     dlg.m_nOrd=m_nOrder;
  390.     dlg.m_nTyp=m_nType;
  392. sheet.AddPage( &dlg );
  394. if (sheet.DoModal() != IDOK)
  395. return;
  396.   
  398. m_bBrush = !dlg.m_bNoFill;
  399. m_bPen = dlg.m_penSize > 0;
  400. m_logbrush.lbColor = dlg.m_FillColor;   
  401. if (m_bPen)
  402. {
  403.     m_logpen.lopnWidth.x = dlg.m_penSize;
  404. m_logpen.lopnWidth.y = dlg.m_penSize;
  405. m_logpen.lopnColor = dlg.m_LineColor;   
  407.   }
  409.     m_nOrder=dlg.m_nOrd;
  410.     m_nType=dlg.m_nTyp;
  412. Invalidate();
  413. m_pDocument->SetModifiedFlag(); 
  414. }
  416. void CDrawObj::OnOpen(CDrawView* /*pView*/ )
  417. {
  418. OnEditProperties();
  419. }
  421. void CDrawObj::SetLineColor(COLORREF color)
  422. {
  423. ASSERT_VALID(this);
  425. m_logpen.lopnColor = color;
  426. Invalidate();
  427. m_pDocument->SetModifiedFlag();
  428. }
  430. void CDrawObj::SetFillColor(COLORREF color)
  431. {
  432. ASSERT_VALID(this);
  434. m_logbrush.lbColor = color;
  435. Invalidate();
  436. m_pDocument->SetModifiedFlag();
  437. }
  439. #ifdef _DEBUG
  440. void CDrawObj::AssertValid()
  441. {
  442. ASSERT(m_position.left <= m_position.right);
  443. ASSERT(m_position.bottom <= m_position.top);
  444. }
  445. #endif
  447. ////////////////////////////////////////////////////////////////////////////
  448. // CDrawRect
  450. IMPLEMENT_SERIAL(CDrawRect, CDrawObj, 0)
  452. CDrawRect::CDrawRect()
  453. {
  454. }
  456. CDrawRect::CDrawRect(const CRect& position)
  457. : CDrawObj(position)
  458. {
  459. ASSERT_VALID(this);
  461. m_nShape = rectangle;
  462. m_roundness.x = 16;
  463. m_roundness.y = 16;
  464. }
  466. void CDrawRect::Serialize(CArchive& ar)
  467. {
  468. ASSERT_VALID(this);
  470. CDrawObj::Serialize(ar);
  471. if (ar.IsStoring())
  472. {
  473. ar << (WORD) m_nShape;
  474. ar << m_roundness;
  475. }
  476. else
  477. {
  478. WORD wTemp;
  479. ar >> wTemp; m_nShape = (Shape)wTemp;
  480. ar >> m_roundness;
  481. }
  482. }
  484. /**/
  485. void CDrawRect::DrawCircle(CDC* pDC,CRect rect)
  486. {
  487. ASSERT_VALID(this);
  489. int cx,cy;
  490. if (rect.right < rect.left)
  491. {
  492. cx = rect.left;
  493. rect.left = rect.right;
  494. rect.right = cx;
  495. }
  496. if (rect.bottom < rect.top)
  497. {
  498. cy = rect.top;
  499. rect.top = rect.bottom;
  500. rect.bottom = cy;
  501. }
  502. cx = rect.right - rect.left;
  503.     cy = rect.bottom - rect.top;
  504. if (cx > cy)
  505. {
  506. rect.left += (cx-cy) / 2;
  507. rect.right = rect.left + cy;
  508. }
  509. else
  510. {
  511.             rect.top += (cy-cx) / 2;
  512. rect.bottom = rect.top + cx;
  513. }
  514. //pDC->TextOut(rect.left,rect.bottom,"123",3);
  515. pDC->Ellipse(rect);
  516. }
  517. /**/
  519. void CDrawRect::Draw(CDC* pDC)
  520. {
  521. ASSERT_VALID(this);
  523. CBrush brush;
  524. if (!brush.CreateBrushIndirect(&m_logbrush))
  525. return;
  526. CPen pen;
  527. if (!pen.CreatePenIndirect(&m_logpen))
  528. return;
  530. CBrush* pOldBrush;
  531. CPen* pOldPen;
  533. if (m_bBrush)
  534. pOldBrush = pDC->SelectObject(&brush);
  535. else
  536. pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
  538. if (m_bPen)
  539. pOldPen = pDC->SelectObject(&pen);
  540. else
  541. pOldPen = (CPen*)pDC->SelectStockObject(NULL_PEN);
  543. CRect rect = m_position;
  544. switch (m_nShape)
  545. {
  546. case rectangle:
  547. pDC->Rectangle(rect);
  548. break;
  550. case roundRectangle:
  551. pDC->RoundRect(rect, m_roundness);
  552. break;
  554. case ellipse:
  555. pDC->Ellipse(rect);
  556. break;
  558. case circle:
  559. DrawCircle(pDC,rect);
  560. //pDC->Circle(rect);
  561. break;
  563. case line:
  564. if (rect.top > rect.bottom)
  565. {
  566. rect.top -= m_logpen.lopnWidth.y / 2;
  567. rect.bottom += (m_logpen.lopnWidth.y + 1) / 2;
  568. }
  569. else
  570. {
  571. rect.top += (m_logpen.lopnWidth.y + 1) / 2;
  572. rect.bottom -= m_logpen.lopnWidth.y / 2;
  573. }
  575. if (rect.left > rect.right)
  576. {
  577. rect.left -= m_logpen.lopnWidth.x / 2;
  578. rect.right += (m_logpen.lopnWidth.x + 1) / 2;
  579. }
  580. else
  581. {
  582. rect.left += (m_logpen.lopnWidth.x + 1) / 2;
  583. rect.right -= m_logpen.lopnWidth.x / 2;
  584. }
  586. pDC->MoveTo(rect.TopLeft());
  587. pDC->LineTo(rect.BottomRight());
  588. break;
  589. }
  591. pDC->SelectObject(pOldBrush);
  592. pDC->SelectObject(pOldPen);
  593. }
  596. int CDrawRect::GetHandleCount()
  597. {
  598. ASSERT_VALID(this);
  600. return m_nShape == line ? 2 :
  601. CDrawObj::GetHandleCount() + (m_nShape == roundRectangle);
  602. }
  604. // returns center of handle in logical coordinates
  605. CPoint CDrawRect::GetHandle(int nHandle)
  606. {
  607. ASSERT_VALID(this);
  609. if (m_nShape == line && nHandle == 2)
  610. nHandle = 5;
  611. else if (m_nShape == roundRectangle && nHandle == 9)
  612. {
  613. CRect rect = m_position;
  614. rect.NormalizeRect();
  615. CPoint point = rect.BottomRight();
  616. point.x -= m_roundness.x / 2;
  617. point.y -= m_roundness.y / 2;
  618. return point;
  619. }
  621. return CDrawObj::GetHandle(nHandle);
  622. }
  624. HCURSOR CDrawRect::GetHandleCursor(int nHandle)
  625. {
  626. ASSERT_VALID(this);
  628. if (m_nShape == line && nHandle == 2)
  629. nHandle = 5;
  630. else if (m_nShape == roundRectangle && nHandle == 9)
  631. return AfxGetApp()->LoadStandardCursor(IDC_SIZEALL);
  632. return CDrawObj::GetHandleCursor(nHandle);
  633. }
  635. // point is in logical coordinates
  636. void CDrawRect::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  637. {
  638. ASSERT_VALID(this);
  640. if (m_nShape == line && nHandle == 2)
  641. nHandle = 5;
  642. else if (m_nShape == roundRectangle && nHandle == 9)
  643. {
  644. CRect rect = m_position;
  645. rect.NormalizeRect();
  646. if (point.x > rect.right - 1)
  647. point.x = rect.right - 1;
  648. else if (point.x < rect.left + rect.Width() / 2)
  649. point.x = rect.left + rect.Width() / 2;
  650. if (point.y > rect.bottom - 1)
  651. point.y = rect.bottom - 1;
  652. else if (point.y < rect.top + rect.Height() / 2)
  653. point.y = rect.top + rect.Height() / 2;
  654. m_roundness.x = 2 * (rect.right - point.x);
  655. m_roundness.y = 2 * (rect.bottom - point.y);
  656. m_pDocument->SetModifiedFlag();
  657. if (pView == NULL)
  658. Invalidate();
  659. else
  660. pView->InvalObj(this);
  661. return;
  662. }
  664. CDrawObj::MoveHandleTo(nHandle, point, pView);
  665. }
  667. // rect must be in logical coordinates
  668. BOOL CDrawRect::Intersects(const CRect& rect)
  669. {
  670. ASSERT_VALID(this);
  672. CRect rectT = rect;
  673. rectT.NormalizeRect();
  675. CRect fixed = m_position;
  676. fixed.NormalizeRect();
  677. if ((rectT & fixed).IsRectEmpty())
  678. return FALSE;
  680. CRgn rgn;
  681. switch (m_nShape)
  682. {
  683. case rectangle:
  684. return TRUE;
  686. case roundRectangle:
  687. rgn.CreateRoundRectRgn(fixed.left, fixed.top, fixed.right, fixed.bottom,
  688. m_roundness.x, m_roundness.y);
  689. break;
  691. case ellipse:
  692. rgn.CreateEllipticRgnIndirect(fixed);
  693. break;
  695. case line:
  696. {
  697. int x = (m_logpen.lopnWidth.x + 5) / 2;
  698. int y = (m_logpen.lopnWidth.y + 5) / 2;
  699. POINT points[4];
  700. points[0].x = fixed.left;
  701. points[0].y = fixed.top;
  702. points[1].x = fixed.left;
  703. points[1].y = fixed.top;
  704. points[2].x = fixed.right;
  705. points[2].y = fixed.bottom;
  706. points[3].x = fixed.right;
  707. points[3].y = fixed.bottom;
  709. if (fixed.left < fixed.right)
  710. {
  711. points[0].x -= x;
  712. points[1].x += x;
  713. points[2].x += x;
  714. points[3].x -= x;
  715. }
  716. else
  717. {
  718. points[0].x += x;
  719. points[1].x -= x;
  720. points[2].x -= x;
  721. points[3].x += x;
  722. }
  724. if (fixed.top < fixed.bottom)
  725. {
  726. points[0].y -= y;
  727. points[1].y += y;
  728. points[2].y += y;
  729. points[3].y -= y;
  730. }
  731. else
  732. {
  733. points[0].y += y;
  734. points[1].y -= y;
  735. points[2].y -= y;
  736. points[3].y += y;
  737. }
  738. rgn.CreatePolygonRgn(points, 4, ALTERNATE);
  739. }
  740. break;
  741. case circle:
  742. rgn.CreateEllipticRgnIndirect(fixed);
  743. break;
  744. }
  745. return rgn.RectInRegion(fixed);
  746. }
  748. CDrawObj* CDrawRect::Clone(CDrawDoc* pDoc)
  749. {
  750. ASSERT_VALID(this);
  752. CDrawRect* pClone = new CDrawRect(m_position);
  754. pClone->m_bPen = m_bPen;
  755. pClone->m_logpen = m_logpen;
  756. pClone->m_bBrush = m_bBrush;
  757. pClone->m_logbrush = m_logbrush;
  758. pClone->m_nShape = m_nShape;
  759. pClone->m_roundness = m_roundness;
  761. pClone->m_nOrder = m_nOrder;
  762. pClone->m_nType = m_nType;
  764. ASSERT_VALID(pClone);
  766. if (pDoc != NULL)
  767. pDoc->Add(pClone);
  769. ASSERT_VALID(pClone);
  771. return pClone;
  772. }
  773. ////////////////////////////////////////////////////////////////////////////
  775. IMPLEMENT_SERIAL(CDrawOleObj, CDrawObj, 0)
  777. BOOL CDrawOleObj::c_bShowItems = TRUE;
  779. CDrawOleObj::CDrawOleObj() : m_extent(0,0)
  780. {
  781. m_pClientItem = NULL;
  782. }
  784. CDrawOleObj::CDrawOleObj(const CRect& position)
  785. : CDrawObj(position), m_extent(0, 0)
  786. {
  787. m_pClientItem = NULL;
  788. }
  790. CDrawOleObj::~CDrawOleObj()
  791. {
  792. if (m_pClientItem != NULL)
  793. {
  794. m_pClientItem->Release();
  795. m_pClientItem = NULL;
  796. }
  797. }
  799. void CDrawOleObj::Remove()
  800. {
  801. if (m_pClientItem != NULL)
  802. {
  803. m_pClientItem->Delete();
  804. m_pClientItem = NULL;
  805. }
  806. CDrawObj::Remove();
  807. }
  809. void CDrawOleObj::Serialize( CArchive& ar )
  810. {
  811. ASSERT_VALID(this);
  813. CDrawObj::Serialize(ar);
  815. if (ar.IsStoring())
  816. {
  817. ar << m_extent;
  818. ar << m_pClientItem;
  819. }
  820. else
  821. {
  822. ar >> m_extent;
  823. ar >> m_pClientItem;
  824. m_pClientItem->m_pDrawObj = this;
  825. }
  826.  }
  828. CDrawObj* CDrawOleObj::Clone(CDrawDoc* pDoc)
  829. {
  830. ASSERT_VALID(this);
  831.  
  832. AfxGetApp()->BeginWaitCursor();
  834. CDrawOleObj* pClone = NULL;
  835. CDrawItem* pItem = NULL;
  836.  
  837. TRY
  838. {
  839. // perform a "deep copy" -- need to copy CDrawOleObj and the CDrawItem
  840. //  that it points to.
  841. CDrawOleObj* pClone = new CDrawOleObj(m_position);
  842. CDrawItem* pItem = new CDrawItem(m_pDocument, pClone);
  843. if (!pItem->CreateCloneFrom(m_pClientItem))
  844. AfxThrowMemoryException();
  846. pClone->m_pClientItem = pItem;
  847. pClone->m_bPen = m_bPen;
  848. pClone->m_logpen = m_logpen;
  849. pClone->m_bBrush = m_bBrush;
  850. pClone->m_logbrush = m_logbrush;
  852. pClone->m_nOrder = m_nOrder;
  853.     pClone->m_nType = m_nType;
  855. ASSERT_VALID(pClone);
  857. if (pDoc != NULL)
  858. pDoc->Add(pClone);
  859. }
  860. CATCH_ALL(e)
  861. {
  862. pItem->Delete();
  863. pClone->m_pClientItem = NULL;
  864. pClone->Remove();
  865. AfxGetApp()->EndWaitCursor();
  867. THROW_LAST();
  868. }
  869. END_CATCH_ALL
  871. AfxGetApp()->EndWaitCursor();
  873. return pClone;
  874. }
  876. void CDrawOleObj::Draw(CDC* pDC)
  877. {
  878. ASSERT_VALID(this);
  880. CDrawItem* pItem = m_pClientItem;
  881. if (pItem != NULL)
  882. {
  883. // draw the OLE item itself
  884. pItem->Draw(pDC, m_position);
  886. // don't draw tracker in print preview or on printer
  887. if (!pDC->IsPrinting())
  888. {
  889. // use a CRectTracker to draw the standard effects
  890. CRectTracker tracker;
  891. tracker.m_rect = m_position;
  892. pDC->LPtoDP(tracker.m_rect);
  894. if (c_bShowItems)
  895. {
  896. // put correct border depending on item type
  897. if (pItem->GetType() == OT_LINK)
  898. tracker.m_nStyle |= CRectTracker::dottedLine;
  899. else
  900. tracker.m_nStyle |= CRectTracker::solidLine;
  901. }
  903. // put hatching over the item if it is currently open
  904. if (pItem->GetItemState() == COleClientItem::openState ||
  905. pItem->GetItemState() == COleClientItem::activeUIState)
  906. {
  907. tracker.m_nStyle |= CRectTracker::hatchInside;
  908. }
  909. tracker.Draw(pDC);
  910. }
  911. }
  912. }
  914. void CDrawOleObj::OnOpen(CDrawView* pView)
  915. {
  916. AfxGetApp()->BeginWaitCursor();
  917. m_pClientItem->DoVerb(
  918. #ifndef _MAC
  919. GetKeyState(VK_CONTROL) < 0 ? OLEIVERB_OPEN : OLEIVERB_PRIMARY,
  920. #else
  921. GetKeyState(VK_OPTION) < 0 ? OLEIVERB_OPEN : OLEIVERB_PRIMARY,
  922. #endif
  923. pView);
  924. AfxGetApp()->EndWaitCursor();
  925. }
  927. void CDrawOleObj::OnEditProperties()
  928. {
  929. // using COlePropertiesDialog directly means no scaling
  930. COlePropertiesDialog dlg(m_pClientItem, 100, 100, NULL);
  932. dlg.DoModal();
  933. }
  935. // position is in logical
  936. void CDrawOleObj::MoveTo(const CRect& position, CDrawView* pView)
  937. {
  938. ASSERT_VALID(this);
  940. if (position == m_position)
  941. return;
  943. // call base class to update position
  944. CDrawObj::MoveTo(position, pView);
  946. // update position of in-place editing session on position change
  947. if (m_pClientItem->IsInPlaceActive())
  948. m_pClientItem->SetItemRects();
  949. }
  951. /////////////////////////////////////////////////////////////////////////////