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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DNA > 查看源码
mainview.cpp
资源名称：COM 原理与应用.rar　[点击查看]
上传用户：biuytresa
上传日期：2007-12-07
资源大小：721k
文件大小：33k
源码类别：

DNA

开发平台：

Visual C++

mainview.cpp：源码内容
  1. // mainview.cpp : implementation of the CMainView class
  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 "oclient.h"
  17. #include "maindoc.h"
  18. #include "mainview.h"
  19. #include "rectitem.h"
  21. #ifdef _DEBUG
  22. #undef THIS_FILE
  23. static char BASED_CODE THIS_FILE[] = __FILE__;
  24. #endif
  26. /////////////////////////////////////////////////////////////////////////////
  27. // CMainView
  29. CBrush NEAR CMainView::m_brHatch;
  30. CLIPFORMAT CMainView::m_cfObjectDescriptor=NULL;
  32. IMPLEMENT_DYNCREATE(CMainView, CScrollView)
  34. BEGIN_MESSAGE_MAP(CMainView, CScrollView)
  35. //{{AFX_MSG_MAP(CMainView)
  36. ON_COMMAND(ID_EDIT_PASTE, OnPaste)
  37. ON_COMMAND(ID_EDIT_PASTE_LINK, OnPasteLink)
  38. ON_COMMAND(ID_OLE_INSERT_NEW, OnInsertObject)
  39. ON_UPDATE_COMMAND_UI(ID_EDIT_CLEAR, OnUpdateEditMenu)
  40. ON_COMMAND(ID_EDIT_CLEAR, OnEditClear)
  41. ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  42. ON_COMMAND(ID_EDIT_CUT, OnEditCut)
  43. ON_WM_LBUTTONDBLCLK()
  44. ON_WM_LBUTTONDOWN()
  45. ON_WM_SETCURSOR()
  46. ON_WM_RBUTTONDOWN()
  47. ON_WM_CHAR()
  48. ON_WM_SETFOCUS()
  49. ON_WM_CREATE()
  50. ON_WM_SIZE()
  51. ON_COMMAND(ID_OBJECT_DISPLAYCONTENT, OnObjectDisplayContent)
  52. ON_UPDATE_COMMAND_UI(ID_OBJECT_DISPLAYCONTENT, OnUpdateObjectDisplayContent)
  53. ON_COMMAND(ID_OBJECT_DISPLAYASICON, OnObjectDisplayAsIcon)
  54. ON_UPDATE_COMMAND_UI(ID_OBJECT_DISPLAYASICON, OnUpdateObjectDisplayAsIcon)
  55. ON_COMMAND(ID_EDIT_PASTE_SPECIAL, OnPasteSpecial)
  56. ON_UPDATE_COMMAND_UI(ID_EDIT_CLONE, OnUpdateEditClone)
  57. ON_COMMAND(ID_EDIT_CLONE, OnEditClone)
  58. ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE_SPECIAL, OnUpdateEditPaste)
  59. ON_COMMAND(ID_OBJECT_RESETSIZE, OnObjectResetsize)
  60. ON_COMMAND(ID_CANCEL_INPLACE, OnCancelInplace)
  61. ON_WM_DESTROY()
  62. ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
  63. ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditMenu)
  64. ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateEditMenu)
  65. ON_UPDATE_COMMAND_UI(ID_OBJECT_RESETSIZE, OnUpdateEditMenu)
  66. ON_COMMAND(ID_OLE_CHANGE_SOURCE, OnOleChangeSource)
  67. ON_UPDATE_COMMAND_UI(ID_OLE_CHANGE_SOURCE, OnUpdateOleChangeSource)
  68. ON_COMMAND(ID_OLE_EDIT_PROPERTIES, OnOleEditProperties)
  69. ON_UPDATE_COMMAND_UI(ID_OLE_EDIT_PROPERTIES, OnUpdateOleEditProperties)
  70. //}}AFX_MSG_MAP
  71. // Standard printing commands
  72. ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
  73. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
  74. END_MESSAGE_MAP()
  76. /////////////////////////////////////////////////////////////////////////////
  77. // CMainView construction/destruction
  79. CMainView::CMainView()
  80. {
  81. if (m_brHatch.m_hObject == NULL)
  82. m_brHatch.CreateHatchBrush(HS_DIAGCROSS, RGB(0,0,0));
  83. if (m_cfObjectDescriptor == NULL)
  84. m_cfObjectDescriptor =
  85. (CLIPFORMAT)::RegisterClipboardFormat(_T("Object Descriptor"));
  87. m_pSelection = NULL;
  88. m_prevDropEffect = DROPEFFECT_NONE;
  89. m_bInDrag = FALSE;
  90. }
  92. CMainView::~CMainView()
  93. {
  94. }
  96. void CMainView::OnInitialUpdate()
  97. {
  98. CScrollView::OnInitialUpdate();
  100. // We can't pass MM_ANISOTROPIC to SetScrollSizes so we have to convert to MM_TEXT
  101. CSize size = GetDocument()->GetDocumentSize();
  102. CClientDC dc(NULL);
  103. size.cx = MulDiv(size.cx, dc.GetDeviceCaps(LOGPIXELSX), 100);
  104. size.cy = MulDiv(size.cy, dc.GetDeviceCaps(LOGPIXELSY), 100);
  105. SetScrollSizes(MM_TEXT, size);
  106. }
  108. /////////////////////////////////////////////////////////////////////////////
  109. // CMainView drawing
  111. void CMainView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
  112. {
  113. CScrollView::OnPrepareDC(pDC, pInfo);
  114. // set up a reasonable default context
  115. pDC->SetTextColor(::GetSysColor(COLOR_WINDOWTEXT));
  116. pDC->SetBkColor(::GetSysColor(COLOR_WINDOW));
  118. // LOENGLISH units are based on physical inches
  119. // We want logical inches so we have to do it differently
  120. pDC->SetMapMode(MM_ANISOTROPIC);
  121. pDC->SetViewportExt(
  122. pDC->GetDeviceCaps(LOGPIXELSX), pDC->GetDeviceCaps(LOGPIXELSY));
  123. pDC->SetWindowExt(100,-100);
  124. }
  126. void CMainView::SetupTracker(CRectTracker* pTracker, CRectItem* pItem,
  127. CRect* pTrueRect)
  128. {
  129. ASSERT(pTracker != NULL);
  130. ASSERT(pItem != NULL);
  132. pTracker->m_rect = pItem->GetRect();
  133. DocToClient(pTracker->m_rect);
  135. // set minimum size for our OLE items
  136. pTracker->m_sizeMin.cx = 8;
  137. pTracker->m_sizeMin.cy = 8;
  139. pTracker->m_nStyle = 0;
  141. // setup resize handles if item is selected
  142. if (pItem == m_pSelection)
  143. pTracker->m_nStyle |= CRectTracker::resizeInside;
  145. // put correct border depending on item type
  146. if (pItem->GetType() == OT_LINK)
  147. pTracker->m_nStyle |= CRectTracker::dottedLine;
  148. else
  149. pTracker->m_nStyle |= CRectTracker::solidLine;
  151. // put hatching over the item if it is currently open
  152. if (pItem->GetItemState() == COleClientItem::openState ||
  153. pItem->GetItemState() == COleClientItem::activeUIState)
  154. {
  155. pTracker->m_nStyle |= CRectTracker::hatchInside;
  156. }
  158. if (pTrueRect != NULL)
  159. pTracker->GetTrueRect(pTrueRect);
  160. }
  162. void CMainView::OnDraw(CDC* pDC)
  163. {
  164. CMainDoc* pDoc = GetDocument();
  166. ASSERT_VALID(pDC);
  168. if (!pDC->IsPrinting())
  169. {
  170. m_brHatch.UnrealizeObject();
  171. CPoint point(0, 0);
  172. pDC->LPtoDP(&point);
  173. pDC->SetBrushOrg(point.x % 8, point.y % 8);
  175. CRect rcClip;
  176. GetClientRect(&rcClip);
  177. ClientToDoc(rcClip);
  178. CSize docSize = pDoc->GetDocumentSize();
  179. if (rcClip.right > docSize.cx)
  180. {
  181. CRect rcFill(rcClip);
  182. rcFill.left = max(rcFill.left,docSize.cx);
  183. pDC->FillRect(rcFill,&m_brHatch);
  184. }
  185. if (rcClip.bottom < -docSize.cy)
  186. {
  187. CRect rcFill(rcClip);
  188. rcFill.top = min(rcFill.top, -docSize.cy);
  189. pDC->FillRect(rcFill,&m_brHatch);
  190. }
  191. }
  193. // Draw all the CRectItems
  194. POSITION pos = pDoc->GetStartPosition();
  195. while (pos != NULL)
  196. {
  197. CRectItem* pItem = DYNAMIC_DOWNCAST(CRectItem, pDoc->GetNextItem(pos));
  198. if (pItem != NULL)
  199. {
  200. pItem->Draw(pDC, pItem->GetRect());
  202. if (!pDC->IsPrinting())
  203. {
  204. // draw the tracker
  205. CRectTracker tracker;
  206. CRect rectTrue;
  207. SetupTracker(&tracker, pItem, &rectTrue);
  208. ClientToDoc(rectTrue);
  209. if (pDC->RectVisible(&rectTrue))
  210. tracker.Draw(pDC);
  211. }
  212. }
  213. }
  214. }
  216. // pHint is the deleted item or NULL if deselect/delete all
  217. void CMainView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint)
  218. {
  219. if (pHint == NULL && lHint == 0)
  220. {
  221. // some sort of clear all
  222. m_pSelection = NULL;
  223. }
  225. if (pHint != NULL && pHint->IsKindOf(RUNTIME_CLASS(CRectItem)))
  226. {
  227. // just invalidate the one item
  228. InvalidateItem((CRectItem*)pHint);
  230. // clear selection if pointing to deleted item
  231. if (lHint == 1 && pHint == m_pSelection)
  232. {
  233. // specific case of pHint being deleted
  234. m_pSelection = NULL;
  235. }
  236. }
  237. else if (lHint != 0)
  238. {
  239. // invalidate arbitrary rectangle
  240. InvalidateRect((CRect*)lHint);
  241. }
  242. else
  243. {
  244. // complete update
  245. CScrollView::OnUpdate(pSender, lHint, pHint);
  246. }
  247. }
  249. void CMainView::InvalidateItem(CRectItem* pItem)
  250. {
  251. if (m_nMapMode != 0)
  252. {
  253. CRectTracker tracker;
  254. CRect rect;
  255. SetupTracker(&tracker, pItem, &rect);
  256. InvalidateRect(&rect);
  257. }
  258. }
  260. BOOL CMainView::OnScrollBy(CSize sizeScroll, BOOL bDoScroll)
  261. {
  262. // remove drag/drop feedback before scrolling
  263. if (bDoScroll && m_prevDropEffect != DROPEFFECT_NONE)
  264. {
  265. CClientDC dc(this);
  266. dc.DrawFocusRect(CRect(m_dragPoint, m_dragSize));
  267. // erase previous focus rect
  268. m_prevDropEffect = DROPEFFECT_NONE;
  269. }
  271. // do the scroll
  272. if (!CScrollView::OnScrollBy(sizeScroll, bDoScroll))
  273. return FALSE;
  275. // update the position of any in-place active item
  276. if (bDoScroll)
  277. {
  278. UpdateActiveItem();
  279. UpdateWindow();
  280. }
  282. return TRUE;
  283. }
  285. /////////////////////////////////////////////////////////////////////////////
  286. // CMainView printing
  288. BOOL CMainView::OnPreparePrinting(CPrintInfo* pInfo)
  289. {
  290. // default preparation
  291. return DoPreparePrinting(pInfo);
  292. }
  294. /////////////////////////////////////////////////////////////////////////////
  295. // Selection support
  297. BOOL CMainView::IsSelected(const CObject* pDocItem) const
  298. {
  299. return (pDocItem == m_pSelection);
  300. }
  302. void CMainView::SetSelection(CRectItem* pNewSel, BOOL bSafeSelect)
  303. {
  304. if (pNewSel != NULL && pNewSel == m_pSelection)
  305. return;
  307. // deactivate any in-place active item on this view!
  308. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  309. if (pActiveItem != NULL && pNewSel != pActiveItem)
  310. {
  311. if (bSafeSelect)
  312. return;
  313. // if we found one, deactivate it
  314. pActiveItem->Close();
  315. ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
  316. }
  317. if (m_pSelection != NULL) // invalidate the old item
  318. InvalidateItem(m_pSelection);
  319. if ((m_pSelection = pNewSel) != NULL) // invalidate the new item
  320. InvalidateItem(m_pSelection);
  321. }
  323. /////////////////////////////////////////////////////////////////////////////
  324. // CMainView diagnostics
  326. #ifdef _DEBUG
  327. void CMainView::AssertValid() const
  328. {
  329. CScrollView::AssertValid();
  330. }
  332. void CMainView::Dump(CDumpContext& dc) const
  333. {
  334. CScrollView::Dump(dc);
  335. }
  337. #endif //_DEBUG
  339. /////////////////////////////////////////////////////////////////////////////
  340. // Main 'Edit' menu commands
  342. void CMainView::OnUpdateEditMenu(CCmdUI* pCmdUI)
  343. {
  344. // most Edit menu commands are enabled only if we have a selection
  345. //  and there are no in-place activations for this view
  346. pCmdUI->Enable(m_pSelection != NULL &&
  347. GetDocument()->GetInPlaceActiveItem(this) == NULL);
  348. }
  350. void CMainView::OnEditCut()
  351. {
  352. ASSERT(m_pSelection != NULL);
  353. TRY
  354. {
  355. m_pSelection->CopyToClipboard(TRUE);
  356. OnEditClear();
  357. }
  358. CATCH_ALL(e)
  359. {
  360. AfxMessageBox(IDP_CLIPBOARD_CUT_FAILED);
  361. }
  362. END_CATCH_ALL
  363. }
  365. void CMainView::OnEditCopy()
  366. {
  367. ASSERT(m_pSelection != NULL);
  368. TRY
  369. {
  370. m_pSelection->CopyToClipboard(TRUE);
  371. }
  372. CATCH_ALL(e)
  373. {
  374. AfxMessageBox(IDP_CLIPBOARD_COPY_FAILED);
  375. }
  376. END_CATCH_ALL
  377. }
  379. void CMainView::OnEditClear()
  380. {
  381. if (m_pSelection != NULL)
  382. GetDocument()->DeleteItem(m_pSelection);
  383. }
  385. void CMainView::OnPaste()
  386. {
  387. if (DoPasteItem(FALSE, NULL, NULL) == NULL)
  388. AfxMessageBox(IDP_GET_FROM_CLIPBOARD_FAILED);
  389. }
  391. void CMainView::OnPasteLink()
  392. {
  393. if (DoPasteItem(TRUE, NULL, NULL) == NULL)
  394. AfxMessageBox(IDP_GET_FROM_CLIPBOARD_FAILED);
  395. }
  397. void CMainView::DoPasteNative(
  398. COleDataObject* pDataObject, CPoint* pPoint, CRectItem* pItem)
  399. {
  400. // get file refering to clipboard data
  401. CFile* pFile = pDataObject->GetFileData(CMainDoc::m_cfPrivate);
  402. if (pFile == NULL)
  403. {
  404. // if the file failed to open, throw an exception
  405. // to force cleanup in DoPasteItem.  the exact
  406. // type of exception thrown here is unimportant...
  408. AfxThrowFileException(CFileException::generic);
  409. }
  411. CArchive ar(pFile, CArchive::load);
  412. TRY
  413. {
  414. // connect the file to an archive and read the data
  415. ar.m_pDocument = GetDocument(); // for COleClientItem serialize
  416. pItem->Serialize(ar);
  417. }
  418. CATCH_ALL(e)
  419. {
  420. ar.Close();
  421. delete pFile;
  422. THROW_LAST();
  423. }
  424. END_CATCH_ALL
  426. ar.Close();
  427. delete pFile;
  429. // adjust position to that specified by point
  430. if (pPoint != NULL)
  431. pItem->m_ptPos = *pPoint;
  432. }
  434. void CMainView::DoPasteStandard(BOOL bLink, COleDataObject* pDataObject,
  435. CPoint* pPoint, CRectItem* pItem, CLIPFORMAT cfFormat)
  436. {
  437. if (bLink)      // paste link
  438. {
  439. if (!pItem->CreateLinkFromData(pDataObject))
  440. AfxThrowMemoryException();  // any exception will do
  441. }
  442. // paste embedded
  443. else if (!pItem->CreateFromData(pDataObject) &&
  444. !pItem->CreateStaticFromData(pDataObject, OLERENDER_DRAW, cfFormat))
  445. {
  446. AfxThrowMemoryException();      // any exception will do
  447. }
  449. // copy the current iconic representation
  450. FORMATETC fmtetc;
  451. fmtetc.cfFormat = CF_METAFILEPICT;
  452. fmtetc.dwAspect = DVASPECT_ICON;
  453. fmtetc.ptd = NULL;
  454. fmtetc.tymed = TYMED_MFPICT;
  455. fmtetc.lindex = 1;
  456. HGLOBAL hObj = pDataObject->GetGlobalData(CF_METAFILEPICT, &fmtetc);
  457. if (hObj != NULL)
  458. {
  459. pItem->SetIconicMetafile(hObj);
  460. // the following code is an easy way to free a metafile pict
  461. STGMEDIUM stgMed;
  462. memset(&stgMed, 0, sizeof(stgMed));
  463. stgMed.tymed = TYMED_MFPICT;
  464. stgMed.hGlobal = hObj;
  465. ReleaseStgMedium(&stgMed);
  466. }
  468. // set the current drawing aspect
  469. hObj = pDataObject->GetGlobalData(m_cfObjectDescriptor);
  470. if (hObj != NULL)
  471. {
  472. ASSERT(hObj != NULL);
  473. // got CF_OBJECTDESCRIPTOR ok.  Lock it down and extract size.
  474. LPOBJECTDESCRIPTOR pObjDesc = (LPOBJECTDESCRIPTOR)GlobalLock(hObj);
  475. ASSERT(pObjDesc != NULL);
  476. pItem->SetDrawAspect((DVASPECT)pObjDesc->dwDrawAspect);
  477. GlobalUnlock(hObj);
  478. GlobalFree(hObj);
  479. }
  481. // set top-left based on point of drop
  482. if (pPoint != NULL)
  483. pItem->m_ptPos = *pPoint;
  485. // get size from drag/drop operation
  486. CSize size;
  487. if (GetObjectInfo(pDataObject, &size, NULL) && size.cx != 0 && size.cy != 0)
  488. {
  489. // use size obtained from object instead of default
  490. size.cx = MulDiv(size.cx, 10, 254);
  491. size.cy = -MulDiv(size.cy, 10, 254);
  492. pItem->SetSize(size);
  493. CSize sizeExtent;
  494. pItem->GetCachedExtent(&sizeExtent);
  495. pItem->SetBaseSize(sizeExtent);
  496. }
  497. else
  498. {
  499. // no extent from CF_OBJECTDESCRIPTOR, use extent from object
  500. pItem->UpdateExtent();
  501. }
  502. }
  505. // Helper for paste/pastelink
  506. //
  507. //                  bLink       pDataObject     pPoint              cfFormat
  508. //  EditPaste       FALSE       NULL(clipboard) NULL(default)       0
  509. //  Drag/Drop       TRUE/FALSE  X               X                   0
  510. //  PasteLink       TRUE        NULL(clipboard) NULL(default)       0
  511. //  PasteSpecial    TRUE/FALSE  X               NULL(default)       X
  512. CRectItem* CMainView::DoPasteItem(BOOL bLink, COleDataObject* pDataObject,
  513. CPoint* pPoint, CLIPFORMAT cfFormat)
  514. {
  515. BeginWaitCursor();
  517. CRectItem* pItem = GetDocument()->CreateItem();
  518. ASSERT_VALID(pItem);
  519. BOOL bAllowAdjust = (pPoint == NULL) ? TRUE : FALSE;
  521. // use clipboard data if not doing drag/drop
  522. COleDataObject clipboardData;
  523. if (pDataObject == NULL)
  524. {
  525. clipboardData.AttachClipboard();
  526. pDataObject = &clipboardData;
  527. }
  529. TRY
  530. {
  531. if (cfFormat == CMainDoc::m_cfPrivate)
  532. {
  533. // if format specified (i.e. PasteSpecial) then use that one
  534. DoPasteNative(pDataObject, pPoint, pItem);
  535. }
  536. else if (!bLink && cfFormat == 0 &&
  537. pDataObject->IsDataAvailable(CMainDoc::m_cfPrivate))
  538. {
  539. // if we're not pasting a link, cfFormat was unspecified,
  540. // and private format is available use it
  541. DoPasteNative(pDataObject, pPoint, pItem);
  542. }
  543. // otherwise perform a standard paste
  544. else if (bAllowAdjust)
  545. {
  546. CPoint ptDef(10, -10);
  547. DoPasteStandard(bLink, pDataObject, &ptDef, pItem, cfFormat);
  548. }
  549. else
  550. {
  551. DoPasteStandard(bLink, pDataObject, pPoint, pItem, cfFormat);
  552. }
  554. if (bAllowAdjust)
  555. {
  556. // allow document to adjust position of item so that it doesn't
  557. // lay directly over an item of the same size
  558. // this only occurs if the drop point is not specified
  559. GetDocument()->AdjustItemPosition(pItem);
  560. }
  561. }
  562. CATCH_ALL(e)
  563. {
  564. // general cleanup
  565. TRACE0("failed to embed/link an OLE objectn");
  566. pItem->Delete();
  567. pItem = NULL;
  568. }
  569. END_CATCH_ALL
  571. // set the selection with bSafeSelect = TRUE
  572. SetSelection(pItem, TRUE);
  574. // update the document and views
  575. GetDocument()->SetModifiedFlag();
  576. GetDocument()->UpdateAllViews(NULL, 0, pItem);      // including this view
  578. EndWaitCursor();
  580. return pItem;
  581. }
  583. /////////////////////////////////////////////////////////////////////////////
  584. // Insert New Object and Activate Object
  586. void CMainView::OnInsertObject()
  587. {
  588. COleInsertDialog dlg;
  589. if (dlg.DoModal() != IDOK)
  590. return;
  592. BeginWaitCursor();
  594. CRectItem* pItem = NULL;
  595. TRY
  596. {
  597. // create item from dialog results
  598. pItem = GetDocument()->CreateItem();
  599. if (!dlg.CreateItem(pItem))
  600. AfxThrowMemoryException();  // any exception will do
  602. // try to get initial presentation data
  603. pItem->UpdateLink();
  604. pItem->UpdateExtent();
  606. // if insert new object -- initially show the object
  607. if (dlg.GetSelectionType() == COleInsertDialog::createNewItem)
  608. pItem->DoVerb(OLEIVERB_SHOW, this);
  610. SetSelection(pItem);
  611. }
  612. CATCH_ALL(e)
  613. {
  614. // cleanup item, if allocated
  615. if (pItem != NULL)
  616. GetDocument()->DeleteItem(pItem);
  618. AfxMessageBox(IDP_FAILED_TO_CREATE);
  619. }
  620. END_CATCH_ALL
  622. EndWaitCursor();
  623. }
  625. void CMainView::OnLButtonDblClk(UINT, CPoint)
  626. {
  627. // Double click will activate the main verb
  628. if (m_pSelection != NULL)
  629. {
  630. BeginWaitCursor();
  631. LONG iVerb = OLEIVERB_PRIMARY;
  632. if (GetKeyState(VK_CONTROL) < 0)
  633. iVerb = OLEIVERB_OPEN;
  634. m_pSelection->DoVerb(iVerb, this);
  635. EndWaitCursor();
  636. }
  637. }
  639. /////////////////////////////////////////////////////////////////////////////
  640. // Hit detection, moving and resizing items
  642. CRectItem* CMainView::GetHitItem(CPoint point)
  643. {
  644. CMainDoc* pDoc = GetDocument();
  645. CRectItem* pItemHit = NULL;
  647. // Find the item hit by the mouse
  648. POSITION pos = pDoc->GetStartPosition();
  649. while (pos != NULL)
  650. {
  651. CRectItem* pItem = DYNAMIC_DOWNCAST(CRectItem, pDoc->GetNextItem(pos));
  652. if (pItem != NULL)
  653. {
  654. CRectTracker tracker;
  655. SetupTracker(&tracker, pItem);
  656. if (tracker.HitTest(point) >= 0)
  657. {
  658. pItemHit = pItem;
  659. // items later in the list are drawn on top - so keep looking
  660. }
  661. }
  662. }
  663. return pItemHit;
  664. }
  666. void CMainView::DocToClient(CRect& rect)
  667. {
  668. CClientDC dc(this);
  669. OnPrepareDC(&dc);
  670. dc.LPtoDP(&rect); // convert logical rect to device rect
  671. rect.NormalizeRect();
  672. }
  674. void CMainView::ClientToDoc(CRect& rect)
  675. {
  676. CClientDC dc(this);
  677. OnPrepareDC(&dc);
  678. dc.DPtoLP(&rect); // convert device rect to logical rect
  679. }
  681. void CMainView::DocToClient(CSize& size)
  682. {
  683. CClientDC dc(this);
  684. OnPrepareDC(&dc);
  685. dc.LPtoDP(&size); // convert logical size to device size
  686. size.cx = abs(size.cx);
  687. size.cy = abs(size.cy);
  688. }
  690. void CMainView::ClientToDoc(CSize& size)
  691. {
  692. CClientDC dc(this);
  693. OnPrepareDC(&dc);
  694. dc.DPtoLP(&size); // convert device rect to logical rect
  695. size.cx = abs(size.cx);
  696. size.cy = abs(size.cy);
  697. }
  699. void CMainView::DocToClient(CPoint& point)
  700. {
  701. CClientDC dc(this);
  702. OnPrepareDC(&dc);
  703. dc.LPtoDP(&point); // convert logical point to device point
  704. }
  706. void CMainView::ClientToDoc(CPoint& point)
  707. {
  708. CClientDC dc(this);
  709. OnPrepareDC(&dc);
  710. dc.DPtoLP(&point); // convert device point to logical point
  711. }
  713. void CMainView::OnLButtonDown(UINT /*nFlags*/, CPoint point)
  714. {
  715. CRectItem* pItemHit = GetHitItem(point);
  716. SetSelection(pItemHit);
  717. if (pItemHit == NULL)
  718. return;
  720. CRect rectLimit;
  721. GetClientRect(rectLimit);
  723. CRectTracker tracker;
  724. SetupTracker(&tracker, pItemHit);
  726. UpdateWindow(); // update before entering the tracker
  727. if (tracker.HitTest(point) == CRectTracker::hitMiddle) // moving, not sizing
  728. {
  729. // determine mouse position offset from the item itself
  730. CRect rect = pItemHit->GetRect();
  731. DocToClient(rect);
  732. CPoint ptOffset(point.x - rect.left, point.y - rect.top);
  734. // determine sensitivity rectangle (determines when drag starts)
  735. CRect rectDrag(rect.left, rect.top, rect.left+1, rect.top+1);
  737. // execute the drag/drop operation
  738. m_bInDrag = TRUE;
  739. ClientToScreen(&rect);  // must be in screen co-ordinates
  740. ClientToScreen(&rectDrag);
  741. DROPEFFECT dropEffect = pItemHit->DoDragDrop(rect, ptOffset,
  742. TRUE, DROPEFFECT_COPY|DROPEFFECT_MOVE, &rectDrag);
  743. if (m_bInDrag == FALSE) // move in same window
  744. return;
  745. m_bInDrag = FALSE;
  747. if (dropEffect == DROPEFFECT_MOVE)
  748. {
  749. // the item was moved (essentially a copy w/delete)
  750. pItemHit->Invalidate();
  751. if (m_pSelection == pItemHit)
  752. m_pSelection = NULL;
  753. GetDocument()->DeleteItem(pItemHit);
  754. }
  755. }
  756. else if (tracker.Track(this, point))
  757. {
  758. ClientToDoc(tracker.m_rect);
  759. pItemHit->Move(tracker.m_rect);
  760. GetDocument()->SetModifiedFlag();
  761. }
  762. }
  764. BOOL CMainView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  765. {
  766. if (pWnd == this && m_pSelection != NULL)
  767. {
  768. // give the tracker for the selection a chance
  769. CRectTracker tracker;
  770. SetupTracker(&tracker, m_pSelection);
  771. if (tracker.SetCursor(this, nHitTest))
  772. return TRUE;
  773. }
  774. return CScrollView::OnSetCursor(pWnd, nHitTest, message);
  775. }
  777. /////////////////////////////////////////////////////////////////////////////
  778. // Right mouse for popup context sensitive menu
  780. void CMainView::OnRButtonDown(UINT, CPoint point)
  781. {
  782. // make sure window is active
  783. GetParentFrame()->ActivateFrame();
  785. SetSelection(GetHitItem(point));    // reselect item if appropriate
  786. UpdateWindow();
  788. if (m_pSelection != NULL)
  789. {
  790. CMenu bar;
  791. if (bar.LoadMenu(ID_OBJECT_POPUP_MENU))
  792. {
  793. CMenu& popup = *bar.GetSubMenu(0);
  794. ASSERT(popup.m_hMenu != NULL);
  796. ClientToScreen(&point);
  797. popup.TrackPopupMenu(TPM_RIGHTBUTTON,
  798. point.x, point.y,
  799. AfxGetMainWnd()); // route commands through main window
  800. }
  801. }
  802. }
  804. void CMainView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  805. {
  806. MessageBeep(0);     // to test for proper focus transfer
  808. CScrollView::OnChar(nChar, nRepCnt, nFlags);
  809. }
  811. void CMainView::OnSetFocus(CWnd* pOldWnd)
  812. {
  813. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  814. if (pActiveItem != NULL &&
  815. pActiveItem->GetItemState() == COleClientItem::activeUIState)
  816. {
  817. // need to set focus to this item if it is in the same view
  818. CWnd* pWnd = pActiveItem->GetInPlaceWindow();
  819. if (pWnd != NULL)
  820. {
  821. pWnd->SetFocus();
  822. return;
  823. }
  824. }
  826. CScrollView::OnSetFocus(pOldWnd);
  827. }
  829. void CMainView::OnSize(UINT nType, int cx, int cy)
  830. {
  831. CScrollView::OnSize(nType, cx, cy);
  833. UpdateActiveItem();
  834. }
  836. /////////////////////////////////////////////////////////////////////////////
  837. // support for drag/drop
  839. int CMainView::OnCreate(LPCREATESTRUCT lpCreateStruct)
  840. {
  841. if (CScrollView::OnCreate(lpCreateStruct) == -1)
  842. return -1;
  844. // register drop target
  845. m_dropTarget.Register(this);
  847. return 0;
  848. }
  850. BOOL CMainView::OnDrop(COleDataObject* pDataObject,
  851. DROPEFFECT dropEffect, CPoint point)
  852. {
  853. ASSERT_VALID(this);
  855. // clean up focus rect
  856. OnDragLeave();
  858. // offset point as appropriate for dragging
  859. GetObjectInfo(pDataObject, &m_dragSize, &m_dragOffset);
  860. CClientDC dc(NULL);
  861. dc.HIMETRICtoDP(&m_dragSize);
  862. dc.HIMETRICtoDP(&m_dragOffset);
  863. point -= m_dragOffset;
  865. // if move within the view
  866. ClientToDoc(point);
  867. if ((dropEffect & DROPEFFECT_MOVE) && m_bInDrag)
  868. {
  869. ASSERT(m_pSelection != NULL);
  870. m_bInDrag = FALSE; // signal drag code that a move happened
  871. // set top-left based on point of drop
  872. CRect rect = m_pSelection->GetRect();
  873. if (rect.TopLeft() != point) // if moved
  874. {
  875. m_pSelection->Move(CRect(point,rect.Size()));
  876. GetDocument()->SetModifiedFlag();
  877. }
  878. }
  879. // check and paste link
  880. else if ((dropEffect & DROPEFFECT_LINK) && DoPasteItem(TRUE, pDataObject, &point))
  881. return TRUE;
  883. // paste embedding/static
  884. else if (DoPasteItem(FALSE, pDataObject, &point))
  885. return TRUE;
  887. return FALSE;
  888. }
  890. BOOL CMainView::GetObjectInfo(COleDataObject* pDataObject,
  891. CSize* pSize, CSize* pOffset)
  892. {
  893. ASSERT(pSize != NULL);
  895. // get object descriptor data
  896. HGLOBAL hObjDesc = pDataObject->GetGlobalData(m_cfObjectDescriptor);
  897. if (hObjDesc == NULL)
  898. {
  899. if (pOffset != NULL)
  900. *pOffset = CSize(0, 0); // fill in defaults instead
  901. *pSize = CSize(0, 0);
  902. return FALSE;
  903. }
  904. ASSERT(hObjDesc != NULL);
  906. // otherwise, got CF_OBJECTDESCRIPTOR ok.  Lock it down and extract size.
  907. LPOBJECTDESCRIPTOR pObjDesc = (LPOBJECTDESCRIPTOR)GlobalLock(hObjDesc);
  908. ASSERT(pObjDesc != NULL);
  909. pSize->cx = (int)pObjDesc->sizel.cx;
  910. pSize->cy = (int)pObjDesc->sizel.cy;
  911. if (pOffset != NULL)
  912. {
  913. pOffset->cx = (int)pObjDesc->pointl.x;
  914. pOffset->cy = (int)pObjDesc->pointl.y;
  915. }
  916. GlobalUnlock(hObjDesc);
  917. GlobalFree(hObjDesc);
  919. // successfully retrieved pSize & pOffset info
  920. return TRUE;
  921. }
  923. DROPEFFECT CMainView::OnDragEnter(COleDataObject* pDataObject,
  924. DWORD grfKeyState, CPoint point)
  925. {
  926. ASSERT(m_prevDropEffect == DROPEFFECT_NONE);
  928. GetObjectInfo(pDataObject, &m_dragSize, &m_dragOffset);
  929. CClientDC dc(NULL);
  930. dc.HIMETRICtoDP(&m_dragSize);
  931. dc.HIMETRICtoDP(&m_dragOffset);
  933. return OnDragOver(pDataObject, grfKeyState, point);
  934. }
  936. DROPEFFECT CMainView::OnDragOver(COleDataObject*,
  937. DWORD grfKeyState, CPoint point)
  938. {
  939. point -= m_dragOffset;  // adjust target rect by original cursor offset
  941. // check for point outside logical area -- i.e. in hatched region
  942. // GetTotalSize() returns the size passed to SetScrollSizes
  943. CRect rectScroll(CPoint(0, 0), GetTotalSize());
  945. CRect rectItem(point,m_dragSize);
  946. if (rectItem.IsRectEmpty())
  947. {
  948. // some apps might have a null size in the object descriptor...
  949. rectItem.InflateRect(1,1);
  950. }
  951. rectItem.OffsetRect(GetDeviceScrollPosition());
  953. DROPEFFECT de = DROPEFFECT_NONE;
  954. CRect rectTemp;
  955. if (rectTemp.IntersectRect(rectScroll, rectItem))
  956. {
  957. // check for force link
  958. if ((grfKeyState & (MK_CONTROL|MK_SHIFT)) == (MK_CONTROL|MK_SHIFT))
  959. de = DROPEFFECT_LINK;
  960. // check for force copy
  961. else if ((grfKeyState & MK_CONTROL) == MK_CONTROL)
  962. de = DROPEFFECT_COPY;
  963. // check for force move
  964. else if ((grfKeyState & MK_ALT) == MK_ALT)
  965. de = DROPEFFECT_MOVE;
  966. // default -- recommended action is move
  967. else
  968. de = DROPEFFECT_MOVE;
  969. }
  971. if (point == m_dragPoint)
  972. return de;
  974. // otherwise, cursor has moved -- need to update the drag feedback
  975. CClientDC dc(this);
  976. if (m_prevDropEffect != DROPEFFECT_NONE)
  977. {
  978. // erase previous focus rect
  979. dc.DrawFocusRect(CRect(m_dragPoint, m_dragSize));
  980. }
  981. m_prevDropEffect = de;
  982. if (m_prevDropEffect != DROPEFFECT_NONE)
  983. {
  984. m_dragPoint = point;
  985. dc.DrawFocusRect(CRect(point, m_dragSize));
  986. }
  987. return de;
  988. }
  990. void CMainView::OnDragLeave()
  991. {
  992. CClientDC dc(this);
  993. if (m_prevDropEffect != DROPEFFECT_NONE)
  994. {
  995. dc.DrawFocusRect(CRect(m_dragPoint,m_dragSize)); // erase previous focus rect
  996. m_prevDropEffect = DROPEFFECT_NONE;
  997. }
  998. }
  1000. /////////////////////////////////////////////////////////////////////////////
  1001. // Commands for switching display aspects
  1003. void CMainView::OnObjectDisplayContent()
  1004. {
  1005. if (m_pSelection == NULL)
  1006. return;
  1007. ASSERT_VALID(m_pSelection);
  1008. m_pSelection->Invalidate();
  1009. m_pSelection->SetDrawAspect(DVASPECT_CONTENT);
  1010. m_pSelection->UpdateExtent();
  1011. m_pSelection->Invalidate();
  1012. }
  1014. void CMainView::OnUpdateObjectDisplayContent(CCmdUI* pCmdUI)
  1015. {
  1016. if (m_pSelection == NULL)
  1017. {
  1018. pCmdUI->Enable(FALSE);
  1019. return;
  1020. }
  1021. ASSERT_VALID(m_pSelection);
  1022. pCmdUI->SetCheck(m_pSelection->GetDrawAspect() == DVASPECT_CONTENT);
  1023. pCmdUI->Enable(TRUE);
  1024. }
  1026. void CMainView::OnObjectDisplayAsIcon()
  1027. {
  1028. if (m_pSelection == NULL)
  1029. return;
  1030. ASSERT_VALID(m_pSelection);
  1031. m_pSelection->Invalidate();
  1032. m_pSelection->SetDrawAspect(DVASPECT_ICON);
  1033. m_pSelection->UpdateExtent();
  1034. m_pSelection->Invalidate();
  1035. }
  1037. void CMainView::OnUpdateObjectDisplayAsIcon(CCmdUI* pCmdUI)
  1038. {
  1039. if (m_pSelection == NULL)
  1040. {
  1041. pCmdUI->Enable(FALSE);
  1042. return;
  1043. }
  1044. ASSERT_VALID(m_pSelection);
  1045. pCmdUI->SetCheck(m_pSelection->GetDrawAspect() == DVASPECT_ICON);
  1046. pCmdUI->Enable(TRUE);
  1047. }
  1049. void CMainView::UpdateActiveItem()
  1050. {
  1051. // when there is an active item visible, sizing the window may cause
  1052. //  more/less of the in-place object to become visible.
  1053. //  (ie. the clipping rectangle changes with the size of the window)
  1054. // a container supporting scrolling would also have to do this
  1055. //  when scrolling the contents of the window.
  1057. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  1058. if (pActiveItem != NULL &&
  1059. pActiveItem->GetItemState() == COleClientItem::activeUIState &&
  1060. pActiveItem->GetActiveView() == this)
  1061. {
  1062. // this will update the item rectangles by calling
  1063. //  OnGetPosRect & OnGetClipRect.
  1064. pActiveItem->SetItemRects();
  1065. }
  1066. }
  1068. void CMainView::OnUpdateEditClone(CCmdUI* pCmdUI)
  1069. {
  1070. pCmdUI->Enable(m_pSelection != NULL);
  1071. }
  1073. void CMainView::OnEditClone()
  1074. {
  1075. if (m_pSelection == NULL)
  1076. return;
  1078. BeginWaitCursor();
  1080. CRectItem* pItem = NULL;
  1081. TRY
  1082. {
  1083. // create item from dialog results
  1084. pItem = GetDocument()->CreateItem();
  1085. if (!pItem->CreateCloneFrom(m_pSelection))
  1086. AfxThrowMemoryException();  // any exception will do
  1088. // offset it so we can see the clone easier
  1089. CRect rect(20, 20, 0, 0);
  1090. ClientToDoc(rect);
  1091. pItem->m_ptPos.x += rect.left;
  1092. pItem->m_ptPos.y += rect.top;
  1093. ASSERT_VALID(pItem);
  1094. }
  1095. CATCH_ALL(e)
  1096. {
  1097. // cleanup item, if allocated
  1098. if (pItem != NULL)
  1099. GetDocument()->DeleteItem(pItem);
  1101. AfxMessageBox(IDP_FAILED_TO_CREATE);
  1102. }
  1103. END_CATCH_ALL
  1105. EndWaitCursor();
  1106. }
  1108. void CMainView::OnPasteSpecial()
  1109. {
  1110. COlePasteSpecialDialog dlg;
  1111. dlg.AddFormat(CMainDoc::m_cfPrivate, TYMED_HGLOBAL,
  1112. IDS_PRIVATE_CF_DESCR, FALSE, FALSE);
  1113. dlg.AddStandardFormats();
  1114. if (dlg.DoModal() != IDOK)
  1115. return;
  1117. CRectItem* pItem = NULL;
  1118. TRY
  1119. {
  1120. // Get the clipboard format of the selected
  1121. CLIPFORMAT cf = dlg.m_ps.arrPasteEntries[dlg.m_ps.nSelectedIndex].fmtetc.cfFormat;
  1122. if (cf == CMainDoc::m_cfPrivate)
  1123. {
  1124. BOOL bLink = dlg.GetSelectionType() ==
  1125. COlePasteSpecialDialog::pasteLink;
  1126. COleDataObject dataObject;
  1127. dataObject.Attach(dlg.m_ps.lpSrcDataObj, FALSE);
  1128. pItem = DoPasteItem(bLink, &dataObject, NULL, cf);
  1130. // try to get initial presentation data
  1131. pItem->UpdateLink();
  1132. }
  1133. else
  1134. {
  1135. pItem = GetDocument()->CreateItem();
  1136. if (!dlg.CreateItem(pItem))
  1137. {
  1138. TRACE0("Warning: paste special failed to create item.n");
  1139. AfxThrowMemoryException();
  1140. }
  1142. // try to get initial presentation data
  1143. pItem->UpdateLink();
  1145. // try to get initial extent
  1146. pItem->UpdateExtent();
  1148. // allow document to offset item to avoid direct superimposition
  1149. GetDocument()->AdjustItemPosition(pItem);
  1151. // set the selection with bSafeSelect = TRUE
  1152. SetSelection(pItem, TRUE);
  1153. GetDocument()->SetModifiedFlag();
  1154. GetDocument()->UpdateAllViews(NULL, 0, pItem);
  1155. }
  1156. }
  1157. CATCH_ALL(e)
  1158. {
  1159. // cleanup item, if allocated
  1160. if (pItem != NULL)
  1161. GetDocument()->DeleteItem(pItem);
  1162. AfxMessageBox(IDP_FAILED_TO_CREATE);
  1163. return;
  1164. }
  1165. END_CATCH_ALL
  1166. }
  1168. void CMainView::OnUpdateEditPaste(CCmdUI* pCmdUI)
  1169. {
  1170. // determine if private or standard OLE formats are on the clipboard
  1171. COleDataObject dataObj;
  1172. BOOL bEnable = dataObj.AttachClipboard() &&
  1173. (dataObj.IsDataAvailable(CMainDoc::m_cfPrivate) ||
  1174.  COleClientItem::CanCreateFromData(&dataObj));
  1176. // enable command based on availability
  1177. pCmdUI->Enable(bEnable);
  1178. }
  1180. void CMainView::OnObjectResetsize()
  1181. {
  1182. ASSERT(m_pSelection != NULL);
  1183. m_pSelection->ResetSize();
  1184. }
  1186. void CMainView::OnCancelInplace()
  1187. {
  1188. // deactivate the inplace active item on this frame/view
  1189. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  1190. if (pActiveItem != NULL)
  1191. pActiveItem->Deactivate();
  1192. ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
  1193. }
  1195. void CMainView::OnDestroy()
  1196. {
  1197. CScrollView::OnDestroy();
  1199. // deactivate the inplace active item on this view
  1200. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  1201. if (pActiveItem != NULL && pActiveItem->GetActiveView() == this)
  1202. {
  1203. pActiveItem->Deactivate();
  1204. ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
  1205. }
  1206. }
  1208. void CMainView::OnUpdateOleEditProperties(CCmdUI* pCmdUI)
  1209. {
  1210. pCmdUI->Enable(m_pSelection != NULL);
  1211. }
  1213. // edit properties dialog specific to OCLIENT
  1214. class COlePropertiesEx : public COlePropertiesDialog
  1215. {
  1216. public:
  1217. COlePropertiesEx(COleClientItem* pItem,
  1218. UINT nScaleMin = 10, UINT nScaleMax = 500, CWnd* pParentWnd = NULL)
  1219. : COlePropertiesDialog(pItem, nScaleMin, nScaleMax, pParentWnd)
  1220. { }
  1222. virtual BOOL OnApplyScale(
  1223. COleClientItem* pItem, int nCurrentScale, BOOL bRelativeToOrig);
  1224. };
  1226. BOOL COlePropertiesEx::OnApplyScale(
  1227. COleClientItem* pItem, int nCurrentScale, BOOL bRelativeToOrig)
  1228. {
  1229. if (nCurrentScale != -1)
  1230. {
  1231. ASSERT_VALID(pItem);
  1232. CRectItem* pRectItem = (CRectItem*)pItem;
  1233. ASSERT_KINDOF(CRectItem, pRectItem);
  1235. // reset to original size if necessary
  1236. if (bRelativeToOrig)
  1237. pRectItem->ResetSize();
  1239. // update extent to reflect scaling factor
  1240. pRectItem->Invalidate();
  1241. CSize size = pRectItem->GetSize();
  1242. size.cx = MulDiv(size.cx, nCurrentScale, 100);
  1243. size.cy = MulDiv(size.cy, nCurrentScale, 100);
  1244. pRectItem->SetSize(size);
  1245. pRectItem->Invalidate();
  1246. }
  1247. return TRUE;
  1248. }
  1250. void CMainView::OnOleEditProperties()
  1251. {
  1252. ASSERT(m_pSelection != NULL);
  1254. COlePropertiesEx dlg(m_pSelection);
  1255. dlg.DoModal();
  1256. }
  1258. void CMainView::OnUpdateOleChangeSource(CCmdUI* pCmdUI)
  1259. {
  1260. pCmdUI->Enable(m_pSelection != NULL && m_pSelection->GetType() == OT_LINK);
  1261. }
  1263. void CMainView::OnOleChangeSource()
  1264. {
  1265. ASSERT(m_pSelection != NULL && m_pSelection->GetType() == OT_LINK);
  1267. COleChangeSourceDialog dlg(m_pSelection);
  1268. dlg.DoModal();
  1269. }