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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 其他行业 > 查看源码
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;
  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);
  114.  
  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);
  353.  
  354. CDrawObj* pClone = new CDrawObj(m_position);
  356. pClone->m_bPen = m_bPen;
  357. pClone->m_logpen = m_logpen;
  358. pClone->m_bBrush = m_bBrush;
  359. pClone->m_logbrush = m_logbrush;
  360. ASSERT_VALID(pClone);
  362. if (pDoc != NULL)
  363. pDoc->Add(pClone);
  365. return pClone;
  367. }
  369. void CDrawObj::OnEditProperties()
  370. {
  371. ASSERT_VALID(this);
  372.    
  373. CPropertySheet sheet( _T("对象显示属性") );
  374. CRectDlg dlg;
  375. dlg.m_bNoFill = !m_bBrush;
  376. dlg.m_penSize = m_bPen ? m_logpen.lopnWidth.x : 0;
  377. dlg.m_LineColor = m_logpen.lopnColor;   
  378.     dlg.m_FillColor = m_logbrush.lbColor;   
  380. sheet.AddPage( &dlg );
  382. if (sheet.DoModal() != IDOK)
  383. return;
  386. m_bBrush = !dlg.m_bNoFill;
  387. m_bPen = dlg.m_penSize > 0;
  388. m_logbrush.lbColor = dlg.m_FillColor;   
  389. if (m_bPen)
  390. {
  391.     m_logpen.lopnWidth.x = dlg.m_penSize;
  392. m_logpen.lopnWidth.y = dlg.m_penSize;
  393. m_logpen.lopnColor = dlg.m_LineColor;   
  395.   }
  397. Invalidate();
  398. m_pDocument->SetModifiedFlag(); 
  399. }
  401. void CDrawObj::OnOpen(CDrawView* /*pView*/ )
  402. {
  403. OnEditProperties();
  404. }
  406. void CDrawObj::SetLineColor(COLORREF color)
  407. {
  408. ASSERT_VALID(this);
  410. m_logpen.lopnColor = color;
  411. Invalidate();
  412. m_pDocument->SetModifiedFlag();
  413. }
  415. void CDrawObj::SetFillColor(COLORREF color)
  416. {
  417. ASSERT_VALID(this);
  419. m_logbrush.lbColor = color;
  420. Invalidate();
  421. m_pDocument->SetModifiedFlag();
  422. }
  424. #ifdef _DEBUG
  425. void CDrawObj::AssertValid()
  426. {
  427. ASSERT(m_position.left <= m_position.right);
  428. ASSERT(m_position.bottom <= m_position.top);
  429. }
  430. #endif
  432. ////////////////////////////////////////////////////////////////////////////
  433. // CDrawRect
  435. IMPLEMENT_SERIAL(CDrawRect, CDrawObj, 0)
  437. CDrawRect::CDrawRect()
  438. {
  439. }
  441. CDrawRect::CDrawRect(const CRect& position)
  442. : CDrawObj(position)
  443. {
  444. ASSERT_VALID(this);
  446. m_nShape = rectangle;
  447. m_roundness.x = 16;
  448. m_roundness.y = 16;
  449. }
  451. void CDrawRect::Serialize(CArchive& ar)
  452. {
  453. ASSERT_VALID(this);
  455. CDrawObj::Serialize(ar);
  456. if (ar.IsStoring())
  457. {
  458. ar << (WORD) m_nShape;
  459. ar << m_roundness;
  460. }
  461. else
  462. {
  463. WORD wTemp;
  464. ar >> wTemp; m_nShape = (Shape)wTemp;
  465. ar >> m_roundness;
  466. }
  467. }
  469. /**/
  470. void CDrawRect::DrawCircle(CDC* pDC,CRect rect)
  471. {
  472. ASSERT_VALID(this);
  474. int cx,cy;
  475. if (rect.right < rect.left)
  476. {
  477. cx = rect.left;
  478. rect.left = rect.right;
  479. rect.right = cx;
  480. }
  481. if (rect.bottom < rect.top)
  482. {
  483. cy = rect.top;
  484. rect.top = rect.bottom;
  485. rect.bottom = cy;
  486. }
  487. cx = rect.right - rect.left;
  488.     cy = rect.bottom - rect.top;
  489. if (cx > cy)
  490. {
  491. rect.left += (cx-cy) / 2;
  492. rect.right = rect.left + cy;
  493. }
  494. else
  495. {
  496.             rect.top += (cy-cx) / 2;
  497. rect.bottom = rect.top + cx;
  498. }
  499. //pDC->TextOut(rect.left,rect.bottom,"123",3);
  500. pDC->Ellipse(rect);
  501. }
  502. /**/
  504. void CDrawRect::Draw(CDC* pDC)
  505. {
  506. ASSERT_VALID(this);
  508. CBrush brush;
  509. if (!brush.CreateBrushIndirect(&m_logbrush))
  510. return;
  511. CPen pen;
  512. if (!pen.CreatePenIndirect(&m_logpen))
  513. return;
  515. CBrush* pOldBrush;
  516. CPen* pOldPen;
  518. if (m_bBrush)
  519. pOldBrush = pDC->SelectObject(&brush);
  520. else
  521. pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
  523. if (m_bPen)
  524. pOldPen = pDC->SelectObject(&pen);
  525. else
  526. pOldPen = (CPen*)pDC->SelectStockObject(NULL_PEN);
  528. CRect rect = m_position;
  529. switch (m_nShape)
  530. {
  531. case rectangle:
  532. pDC->Rectangle(rect);
  533. break;
  535. case roundRectangle:
  536. pDC->RoundRect(rect, m_roundness);
  537. break;
  539. case ellipse:
  540. pDC->Ellipse(rect);
  541. break;
  543. case circle:
  544. DrawCircle(pDC,rect);
  545. //pDC->Circle(rect);
  546. break;
  548. case line:
  549. if (rect.top > rect.bottom)
  550. {
  551. rect.top -= m_logpen.lopnWidth.y / 2;
  552. rect.bottom += (m_logpen.lopnWidth.y + 1) / 2;
  553. }
  554. else
  555. {
  556. rect.top += (m_logpen.lopnWidth.y + 1) / 2;
  557. rect.bottom -= m_logpen.lopnWidth.y / 2;
  558. }
  560. if (rect.left > rect.right)
  561. {
  562. rect.left -= m_logpen.lopnWidth.x / 2;
  563. rect.right += (m_logpen.lopnWidth.x + 1) / 2;
  564. }
  565. else
  566. {
  567. rect.left += (m_logpen.lopnWidth.x + 1) / 2;
  568. rect.right -= m_logpen.lopnWidth.x / 2;
  569. }
  571. pDC->MoveTo(rect.TopLeft());
  572. pDC->LineTo(rect.BottomRight());
  573. break;
  574. }
  576. pDC->SelectObject(pOldBrush);
  577. pDC->SelectObject(pOldPen);
  578. }
  581. int CDrawRect::GetHandleCount()
  582. {
  583. ASSERT_VALID(this);
  585. return m_nShape == line ? 2 :
  586. CDrawObj::GetHandleCount() + (m_nShape == roundRectangle);
  587. }
  589. // returns center of handle in logical coordinates
  590. CPoint CDrawRect::GetHandle(int nHandle)
  591. {
  592. ASSERT_VALID(this);
  594. if (m_nShape == line && nHandle == 2)
  595. nHandle = 5;
  596. else if (m_nShape == roundRectangle && nHandle == 9)
  597. {
  598. CRect rect = m_position;
  599. rect.NormalizeRect();
  600. CPoint point = rect.BottomRight();
  601. point.x -= m_roundness.x / 2;
  602. point.y -= m_roundness.y / 2;
  603. return point;
  604. }
  606. return CDrawObj::GetHandle(nHandle);
  607. }
  609. HCURSOR CDrawRect::GetHandleCursor(int nHandle)
  610. {
  611. ASSERT_VALID(this);
  613. if (m_nShape == line && nHandle == 2)
  614. nHandle = 5;
  615. else if (m_nShape == roundRectangle && nHandle == 9)
  616. return AfxGetApp()->LoadStandardCursor(IDC_SIZEALL);
  617. return CDrawObj::GetHandleCursor(nHandle);
  618. }
  620. // point is in logical coordinates
  621. void CDrawRect::MoveHandleTo(int nHandle, CPoint point, CDrawView* pView)
  622. {
  623. ASSERT_VALID(this);
  625. if (m_nShape == line && nHandle == 2)
  626. nHandle = 5;
  627. else if (m_nShape == roundRectangle && nHandle == 9)
  628. {
  629. CRect rect = m_position;
  630. rect.NormalizeRect();
  631. if (point.x > rect.right - 1)
  632. point.x = rect.right - 1;
  633. else if (point.x < rect.left + rect.Width() / 2)
  634. point.x = rect.left + rect.Width() / 2;
  635. if (point.y > rect.bottom - 1)
  636. point.y = rect.bottom - 1;
  637. else if (point.y < rect.top + rect.Height() / 2)
  638. point.y = rect.top + rect.Height() / 2;
  639. m_roundness.x = 2 * (rect.right - point.x);
  640. m_roundness.y = 2 * (rect.bottom - point.y);
  641. m_pDocument->SetModifiedFlag();
  642. if (pView == NULL)
  643. Invalidate();
  644. else
  645. pView->InvalObj(this);
  646. return;
  647. }
  649. CDrawObj::MoveHandleTo(nHandle, point, pView);
  650. }
  652. // rect must be in logical coordinates
  653. BOOL CDrawRect::Intersects(const CRect& rect)
  654. {
  655. ASSERT_VALID(this);
  657. CRect rectT = rect;
  658. rectT.NormalizeRect();
  660. CRect fixed = m_position;
  661. fixed.NormalizeRect();
  662. if ((rectT & fixed).IsRectEmpty())
  663. return FALSE;
  665. CRgn rgn;
  666. switch (m_nShape)
  667. {
  668. case rectangle:
  669. return TRUE;
  671. case roundRectangle:
  672. rgn.CreateRoundRectRgn(fixed.left, fixed.top, fixed.right, fixed.bottom,
  673. m_roundness.x, m_roundness.y);
  674. break;
  676. case ellipse:
  677. rgn.CreateEllipticRgnIndirect(fixed);
  678. break;
  680. case line:
  681. {
  682. int x = (m_logpen.lopnWidth.x + 5) / 2;
  683. int y = (m_logpen.lopnWidth.y + 5) / 2;
  684. POINT points[4];
  685. points[0].x = fixed.left;
  686. points[0].y = fixed.top;
  687. points[1].x = fixed.left;
  688. points[1].y = fixed.top;
  689. points[2].x = fixed.right;
  690. points[2].y = fixed.bottom;
  691. points[3].x = fixed.right;
  692. points[3].y = fixed.bottom;
  694. if (fixed.left < fixed.right)
  695. {
  696. points[0].x -= x;
  697. points[1].x += x;
  698. points[2].x += x;
  699. points[3].x -= x;
  700. }
  701. else
  702. {
  703. points[0].x += x;
  704. points[1].x -= x;
  705. points[2].x -= x;
  706. points[3].x += x;
  707. }
  709. if (fixed.top < fixed.bottom)
  710. {
  711. points[0].y -= y;
  712. points[1].y += y;
  713. points[2].y += y;
  714. points[3].y -= y;
  715. }
  716. else
  717. {
  718. points[0].y += y;
  719. points[1].y -= y;
  720. points[2].y -= y;
  721. points[3].y += y;
  722. }
  723. rgn.CreatePolygonRgn(points, 4, ALTERNATE);
  724. }
  725. break;
  726. case circle:
  727. rgn.CreateEllipticRgnIndirect(fixed);
  728. break;
  729. }
  730. return rgn.RectInRegion(fixed);
  731. }
  733. CDrawObj* CDrawRect::Clone(CDrawDoc* pDoc)
  734. {
  735. ASSERT_VALID(this);
  737. CDrawRect* pClone = new CDrawRect(m_position);
  739. pClone->m_bPen = m_bPen;
  740. pClone->m_logpen = m_logpen;
  741. pClone->m_bBrush = m_bBrush;
  742. pClone->m_logbrush = m_logbrush;
  743. pClone->m_nShape = m_nShape;
  744. pClone->m_roundness = m_roundness;
  745. ASSERT_VALID(pClone);
  747. if (pDoc != NULL)
  748. pDoc->Add(pClone);
  750. ASSERT_VALID(pClone);
  752. return pClone;
  753. }
  754. ////////////////////////////////////////////////////////////////////////////
  756. IMPLEMENT_SERIAL(CDrawOleObj, CDrawObj, 0)
  758. BOOL CDrawOleObj::c_bShowItems = TRUE;
  760. CDrawOleObj::CDrawOleObj() : m_extent(0,0)
  761. {
  762. m_pClientItem = NULL;
  763. }
  765. CDrawOleObj::CDrawOleObj(const CRect& position)
  766. : CDrawObj(position), m_extent(0, 0)
  767. {
  768. m_pClientItem = NULL;
  769. }
  771. CDrawOleObj::~CDrawOleObj()
  772. {
  773. if (m_pClientItem != NULL)
  774. {
  775. m_pClientItem->Release();
  776. m_pClientItem = NULL;
  777. }
  778. }
  780. void CDrawOleObj::Remove()
  781. {
  782. if (m_pClientItem != NULL)
  783. {
  784. m_pClientItem->Delete();
  785. m_pClientItem = NULL;
  786. }
  787. CDrawObj::Remove();
  788. }
  790. void CDrawOleObj::Serialize( CArchive& ar )
  791. {
  792. ASSERT_VALID(this);
  794. CDrawObj::Serialize(ar);
  796. if (ar.IsStoring())
  797. {
  798. ar << m_extent;
  799. ar << m_pClientItem;
  800. }
  801. else
  802. {
  803. ar >> m_extent;
  804. ar >> m_pClientItem;
  805. m_pClientItem->m_pDrawObj = this;
  806. }
  807.  }
  809. CDrawObj* CDrawOleObj::Clone(CDrawDoc* pDoc)
  810. {
  811. ASSERT_VALID(this);
  812.  
  813. AfxGetApp()->BeginWaitCursor();
  815. CDrawOleObj* pClone = NULL;
  816. CDrawItem* pItem = NULL;
  817.  
  818. TRY
  819. {
  820. // perform a "deep copy" -- need to copy CDrawOleObj and the CDrawItem
  821. //  that it points to.
  822. CDrawOleObj* pClone = new CDrawOleObj(m_position);
  823. CDrawItem* pItem = new CDrawItem(m_pDocument, pClone);
  824. if (!pItem->CreateCloneFrom(m_pClientItem))
  825. AfxThrowMemoryException();
  827. pClone->m_pClientItem = pItem;
  828. pClone->m_bPen = m_bPen;
  829. pClone->m_logpen = m_logpen;
  830. pClone->m_bBrush = m_bBrush;
  831. pClone->m_logbrush = m_logbrush;
  832. ASSERT_VALID(pClone);
  834. if (pDoc != NULL)
  835. pDoc->Add(pClone);
  836. }
  837. CATCH_ALL(e)
  838. {
  839. pItem->Delete();
  840. pClone->m_pClientItem = NULL;
  841. pClone->Remove();
  842. AfxGetApp()->EndWaitCursor();
  844. THROW_LAST();
  845. }
  846. END_CATCH_ALL
  848. AfxGetApp()->EndWaitCursor();
  850. return pClone;
  851. }
  853. void CDrawOleObj::Draw(CDC* pDC)
  854. {
  855. ASSERT_VALID(this);
  857. CDrawItem* pItem = m_pClientItem;
  858. if (pItem != NULL)
  859. {
  860. // draw the OLE item itself
  861. pItem->Draw(pDC, m_position);
  863. // don't draw tracker in print preview or on printer
  864. if (!pDC->IsPrinting())
  865. {
  866. // use a CRectTracker to draw the standard effects
  867. CRectTracker tracker;
  868. tracker.m_rect = m_position;
  869. pDC->LPtoDP(tracker.m_rect);
  871. if (c_bShowItems)
  872. {
  873. // put correct border depending on item type
  874. if (pItem->GetType() == OT_LINK)
  875. tracker.m_nStyle |= CRectTracker::dottedLine;
  876. else
  877. tracker.m_nStyle |= CRectTracker::solidLine;
  878. }
  880. // put hatching over the item if it is currently open
  881. if (pItem->GetItemState() == COleClientItem::openState ||
  882. pItem->GetItemState() == COleClientItem::activeUIState)
  883. {
  884. tracker.m_nStyle |= CRectTracker::hatchInside;
  885. }
  886. tracker.Draw(pDC);
  887. }
  888. }
  889. }
  891. void CDrawOleObj::OnOpen(CDrawView* pView)
  892. {
  893. AfxGetApp()->BeginWaitCursor();
  894. m_pClientItem->DoVerb(
  895. #ifndef _MAC
  896. GetKeyState(VK_CONTROL) < 0 ? OLEIVERB_OPEN : OLEIVERB_PRIMARY,
  897. #else
  898. GetKeyState(VK_OPTION) < 0 ? OLEIVERB_OPEN : OLEIVERB_PRIMARY,
  899. #endif
  900. pView);
  901. AfxGetApp()->EndWaitCursor();
  902. }
  904. void CDrawOleObj::OnEditProperties()
  905. {
  906. // using COlePropertiesDialog directly means no scaling
  907. COlePropertiesDialog dlg(m_pClientItem, 100, 100, NULL);
  909. dlg.DoModal();
  910. }
  912. // position is in logical
  913. void CDrawOleObj::MoveTo(const CRect& position, CDrawView* pView)
  914. {
  915. ASSERT_VALID(this);
  917. if (position == m_position)
  918. return;
  920. // call base class to update position
  921. CDrawObj::MoveTo(position, pView);
  923. // update position of in-place editing session on position change
  924. if (m_pClientItem->IsInPlaceActive())
  925. m_pClientItem->SetItemRects();
  926. }
  928. /////////////////////////////////////////////////////////////////////////////