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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
DRAWVW.CPP
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：62k
源码类别：

界面编程

开发平台：

Visual C++

DRAWVW.CPP：源码内容
  1. // drawvw.cpp : implementation of the CDrawView 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 <afxpriv.h>
  17. #include "drawcli.h"
  19. #include "drawdoc.h"
  20. #include "drawobj.h"
  21. #include "cntritem.h"
  22. #include "drawvw.h"
  24. #include "drawobj.h"
  25. #include "drawtool.h"
  26. #include "mainfrm.h"
  28. #ifdef _DEBUG
  29. #undef THIS_FILE
  30. static char BASED_CODE THIS_FILE[] = __FILE__;
  31. #endif
  33. // private clipboard format (list of Draw objects)
  34. CLIPFORMAT CDrawView::m_cfDraw = (CLIPFORMAT)
  35. ::RegisterClipboardFormat(_T("MFC Draw Sample"));
  36. CLIPFORMAT CDrawView::m_cfObjectDescriptor = NULL;
  38. /////////////////////////////////////////////////////////////////////////////
  39. // CDrawView
  41. IMPLEMENT_DYNCREATE (CDrawView, CScrollView )
  43. BEGIN_MESSAGE_MAP( CDrawView, CScrollView )
  44. //{{AFX_MSG_MAP(CDrawView)
  45. ON_COMMAND(ID_OLE_INSERT_NEW, OnInsertObject)
  46. ON_COMMAND(ID_CANCEL_EDIT, OnCancelEdit)
  47. ON_COMMAND(ID_CANCEL_EDIT_CNTR, OnCancelEditCntr)
  48. ON_COMMAND(ID_CANCEL_EDIT_SRVR, OnCancelEditSrvr)
  49. ON_WM_LBUTTONDOWN()
  50. ON_WM_LBUTTONUP()
  51. ON_WM_MOUSEMOVE()
  52. ON_WM_LBUTTONDBLCLK()
  53. ON_COMMAND(ID_DRAW_SELECT, OnDrawSelect)
  54. ON_COMMAND(ID_DRAW_ROUNDRECT, OnDrawRoundRect)
  55. ON_COMMAND(ID_DRAW_RECT, OnDrawRect)
  56. ON_COMMAND(ID_DRAW_LINE, OnDrawLine)
  57. ON_COMMAND(ID_DRAW_ELLIPSE, OnDrawEllipse)
  58. ON_UPDATE_COMMAND_UI(ID_DRAW_ELLIPSE, OnUpdateDrawEllipse)
  59. ON_UPDATE_COMMAND_UI(ID_DRAW_LINE, OnUpdateDrawLine)
  60. ON_UPDATE_COMMAND_UI(ID_DRAW_RECT, OnUpdateDrawRect)
  61. ON_UPDATE_COMMAND_UI(ID_DRAW_ROUNDRECT, OnUpdateDrawRoundRect)
  62. ON_UPDATE_COMMAND_UI(ID_DRAW_SELECT, OnUpdateDrawSelect)
  63. ON_UPDATE_COMMAND_UI(ID_OBJECT_MOVEBACK, OnUpdateSingleSelect)
  64. ON_COMMAND(ID_EDIT_SELECT_ALL, OnEditSelectAll)
  65. ON_COMMAND(ID_EDIT_CLEAR, OnEditClear)
  66. ON_UPDATE_COMMAND_UI(ID_EDIT_CLEAR, OnUpdateAnySelect)
  67. ON_COMMAND(ID_DRAW_POLYGON, OnDrawPolygon)
  68. ON_UPDATE_COMMAND_UI(ID_DRAW_POLYGON, OnUpdateDrawPolygon)
  69. ON_WM_SIZE()
  70. ON_COMMAND(ID_VIEW_GRID, OnViewGrid)
  71. ON_UPDATE_COMMAND_UI(ID_VIEW_GRID, OnUpdateViewGrid)
  72. ON_WM_ERASEBKGND()
  73. ON_COMMAND(ID_OBJECT_FILLCOLOR, OnObjectFillColor)
  74. ON_COMMAND(ID_OBJECT_LINECOLOR, OnObjectLineColor)
  75. ON_COMMAND(ID_OBJECT_MOVEBACK, OnObjectMoveBack)
  76. ON_COMMAND(ID_OBJECT_MOVEFORWARD, OnObjectMoveForward)
  77. ON_COMMAND(ID_OBJECT_MOVETOBACK, OnObjectMoveToBack)
  78. ON_COMMAND(ID_OBJECT_MOVETOFRONT, OnObjectMoveToFront)
  79. ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  80. ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
  81. ON_COMMAND(ID_EDIT_CUT, OnEditCut)
  82. ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateEditCut)
  83. ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
  84. ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
  85. ON_WM_SETFOCUS()
  86. ON_COMMAND(ID_VIEW_SHOWOBJECTS, OnViewShowObjects)
  87. ON_UPDATE_COMMAND_UI(ID_VIEW_SHOWOBJECTS, OnUpdateViewShowObjects)
  88. ON_COMMAND(ID_EDIT_PROPERTIES, OnEditProperties)
  89. ON_UPDATE_COMMAND_UI(ID_EDIT_PROPERTIES, OnUpdateEditProperties)
  90. ON_WM_DESTROY()
  91. ON_UPDATE_COMMAND_UI(ID_EDIT_SELECT_ALL, OnUpdateEditSelectAll)
  92. ON_WM_CREATE()
  93. ON_WM_CONTEXTMENU()
  94. ON_UPDATE_COMMAND_UI(ID_OBJECT_MOVEFORWARD, OnUpdateSingleSelect)
  95. ON_UPDATE_COMMAND_UI(ID_OBJECT_MOVETOBACK, OnUpdateSingleSelect)
  96. ON_UPDATE_COMMAND_UI(ID_OBJECT_MOVETOFRONT, OnUpdateSingleSelect)
  97. ON_UPDATE_COMMAND_UI(ID_DOC_LINE_WIDTH, OnUpdateDocLineWidth)
  98. //}}AFX_MSG_MAP
  100. ON_REGISTERED_MESSAGE(
  101. CExtPopupMenuWnd::g_nMsgPrepareOneMenuLevel,
  102. OnExtMenuPrepare
  103. )
  105. //  ON_UPDATE_COMMAND_UI(ID_OBJECT_MOVEBACK, OnUpdateSelectionSingle)
  106. //  ON_UPDATE_COMMAND_UI(ID_OBJECT_MOVEFORWARD, OnUpdateSelectionSingle)
  107. //  ON_UPDATE_COMMAND_UI(ID_OBJECT_MOVETOBACK, OnUpdateSelectionSingle)
  108. //  ON_UPDATE_COMMAND_UI(ID_OBJECT_MOVETOFRONT, OnUpdateSelectionSingle)
  109. ON_UPDATE_COMMAND_UI(ID_OBJECT_FILLCOLOR, OnUpdateSelectionNonEmpty)
  110. ON_UPDATE_COMMAND_UI(ID_OBJECT_LINECOLOR, OnUpdateSelectionNonEmpty)
  112. // color popup menu
  113. ON_REGISTERED_MESSAGE(
  114. CExtPopupColorMenuWnd::g_nMsgNotifyColorChangedFinally,
  115. OnColorChangedFinally
  116. )
  117. ON_REGISTERED_MESSAGE(
  118. CExtPopupColorMenuWnd::g_nMsgNotifyCustColor,
  119. OnColorSelectCustom
  120. )
  122. ON_COMMAND_RANGE(
  123. ID_LINE_WIDTH_0,
  124. ID_LINE_WIDTH_OTHER,
  125. OnLineWidth
  126. )
  127. ON_UPDATE_COMMAND_UI_RANGE(
  128. ID_LINE_WIDTH_0,
  129. ID_LINE_WIDTH_OTHER,
  130. OnUpdateLineWidth
  131. )
  133. ON_REGISTERED_MESSAGE(
  134. CExtPopupMenuWnd::g_nMsgPopupDrawItem,
  135. OnDrawPopupMenuItem
  136. )
  138. #if (defined __EXT_MFC_NO_PRINT)
  139. ON_COMMAND( ID_FILE_PRINT, OnFilePrint )
  140. ON_COMMAND( ID_FILE_PRINT_PREVIEW, OnFilePrintPreview )
  141. #endif
  143. END_MESSAGE_MAP()
  145. /////////////////////////////////////////////////////////////////////////////
  146. // CDrawView construction/destruction
  148. CDrawView::CDrawView()
  149. {
  150. m_bGrid = TRUE;
  151. m_gridColor = RGB(0, 0, 128);
  152. m_bActive = FALSE;
  153. // new
  154. if( m_cfObjectDescriptor == NULL )
  155. m_cfObjectDescriptor = (CLIPFORMAT)::RegisterClipboardFormat(_T("Object Descriptor") );
  156. m_prevDropEffect = DROPEFFECT_NONE;
  157. // end new
  158. }
  160. CDrawView::~CDrawView()
  161. {
  162. }
  164. BOOL CDrawView::PreCreateWindow(CREATESTRUCT& cs)
  165. {
  166. ASSERT(cs.style & WS_CHILD);
  167. if (cs.lpszClass == NULL)
  168. cs.lpszClass = AfxRegisterWndClass(CS_DBLCLKS);
  170. cs.dwExStyle &= ~(WS_EX_CLIENTEDGE|WS_EX_WINDOWEDGE|WS_EX_STATICEDGE);
  171. return TRUE;
  172. }
  174. void CDrawView::OnActivateView(BOOL bActivate, CView* pActiveView,
  175. CView* pDeactiveView)
  176. {
  177. CView::OnActivateView(bActivate, pActiveView, pDeactiveView);
  179. // invalidate selections when active status changes
  180. if (m_bActive != bActivate)
  181. {
  182. if( bActivate )  // if becoming active update as if active
  183. {
  184. m_bActive = bActivate;
  185. SyncToolbarObjButtons();
  186. }
  187. if (!m_selection.IsEmpty())
  188. OnUpdate(NULL, HINT_UPDATE_SELECTION, NULL);
  189. m_bActive = bActivate;
  190. }
  191. }
  193. /////////////////////////////////////////////////////////////////////////////
  194. // CDrawView drawing
  196. void CDrawView::InvalObj(CDrawObj* pObj)
  197. {
  198. CRect rect = pObj->m_position;
  199. DocToClient(rect);
  200. if (m_bActive && IsSelected(pObj))
  201. {
  202. rect.left -= 4;
  203. rect.top -= 5;
  204. rect.right += 5;
  205. rect.bottom += 4;
  206. }
  207. rect.InflateRect(1, 1); // handles CDrawOleObj objects
  209. InvalidateRect(rect, FALSE);
  210. }
  212. void CDrawView::OnUpdate(CView* , LPARAM lHint, CObject* pHint)
  213. {
  214. switch (lHint)
  215. {
  216. case HINT_UPDATE_WINDOW:    // redraw entire window
  217. Invalidate(FALSE);
  218. break;
  220. case HINT_UPDATE_DRAWOBJ:   // a single object has changed
  221. InvalObj((CDrawObj*)pHint);
  222. break;
  224. case HINT_UPDATE_SELECTION: // an entire selection has changed
  225. {
  226. CDrawObjList* pList = pHint != NULL ?
  227. (CDrawObjList*)pHint : &m_selection;
  228. POSITION pos = pList->GetHeadPosition();
  229. while (pos != NULL)
  230. InvalObj(pList->GetNext(pos));
  231. }
  232. break;
  234. case HINT_DELETE_SELECTION: // an entire selection has been removed
  235. if (pHint != &m_selection)
  236. {
  237. CDrawObjList* pList = (CDrawObjList*)pHint;
  238. POSITION pos = pList->GetHeadPosition();
  239. while (pos != NULL)
  240. {
  241. CDrawObj* pObj = pList->GetNext(pos);
  242. InvalObj(pObj);
  243. Remove(pObj);   // remove it from this view's selection
  244. }
  245. }
  246. break;
  248. case HINT_UPDATE_OLE_ITEMS:
  249. {
  250. CDrawDoc* pDoc = GetDocument();
  251. POSITION pos = pDoc->GetObjects()->GetHeadPosition();
  252. while (pos != NULL)
  253. {
  254. CDrawObj* pObj = pDoc->GetObjects()->GetNext(pos);
  255. if (pObj->IsKindOf(RUNTIME_CLASS(CDrawOleObj)))
  256. InvalObj(pObj);
  257. }
  258. }
  259. break;
  261. case HINT_UPDATE_TOOLBAR_COLOR_BUTTONS:
  262. {
  263. CWnd * pWndFocus = GetFocus();
  264. if( pWndFocus != NULL
  265. && (pWndFocus == this || IsChild(pWndFocus) )
  266. )
  267. SyncToolbarObjButtons();
  268. }
  269. break;
  270. default:
  271. ASSERT(FALSE);
  272. break;
  273. }
  274. }
  276. void CDrawView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
  277. {
  278. CScrollView :: OnPrepareDC( pDC, pInfo );
  280. // mapping mode is MM_ANISOTROPIC
  281. // these extents setup a mode similar to MM_LOENGLISH
  282. // MM_LOENGLISH is in .01 physical inches
  283. // these extents provide .01 logical inches
  285. pDC->SetMapMode(MM_ANISOTROPIC);
  286. pDC->SetViewportExt(
  287. ::GetDeviceCaps( pDC->m_hDC, LOGPIXELSX ),
  288. ::GetDeviceCaps( pDC->m_hDC, LOGPIXELSY )
  289. );
  290. pDC->SetWindowExt(100, -100);
  292. // set the origin of the coordinate system to the center of the page
  293. CPoint ptOrg;
  294. ptOrg.x = GetDocument()->GetSize().cx / 2;
  295. ptOrg.y = GetDocument()->GetSize().cy / 2;
  297. // ptOrg is in logical coordinates
  298. pDC->OffsetWindowOrg(-ptOrg.x,ptOrg.y);
  299. }
  301. BOOL CDrawView::OnScrollBy(CSize sizeScroll, BOOL bDoScroll)
  302. {
  303. // do the scroll
  304. if( ! __BASE_OF_CDrawView__ :: OnScrollBy( sizeScroll, bDoScroll ) )
  305. return FALSE;
  307. // update the position of any in-place active item
  308. if( bDoScroll )
  309. {
  310. UpdateActiveItem();
  311. UpdateWindow();
  312. }
  313. return TRUE;
  314. }
  316. void CDrawView::OnDraw(CDC* pDC)
  317. {
  318. CDrawDoc * pDoc = GetDocument();
  319. ASSERT_VALID(pDoc);
  320. CDC dc;
  321. CDC * pDrawDC = pDC;
  322. CBitmap bitmap;
  323. CBitmap * pOldBitmap = NULL;
  324. // only paint the rect that needs repainting
  325. CRect client;
  326. pDC->GetClipBox(client);
  327. CRect rect = client;
  328. DocToClient(rect);
  329. if( ! pDC->IsPrinting() )
  330. {
  332. ////////////////////////////////////////////////////////
  333. ////////////////////////////////////////////////////////
  334. // BEGIN: FIRST VERSION OF THE "TRASH-LINES" PROBLEM FIX
  335. GetClientRect( &rect );
  336. client = rect;
  337. ClientToDoc( client );
  338. pDC->SelectClipRgn( NULL );
  339. // END: FIRST VERSION OF THE "TRASH-LINES" PROBLEM FIX
  340. ////////////////////////////////////////////////////////
  341. ////////////////////////////////////////////////////////
  343. // draw to offscreen bitmap for fast looking repaints
  344. if( dc.CreateCompatibleDC( pDC ) )
  345. {
  346. if( bitmap.CreateCompatibleBitmap(
  347. pDC,
  348. rect.Width(),
  349. rect.Height()
  350. )
  351. )
  352. {
  353. OnPrepareDC(&dc, NULL);
  354. pDrawDC = &dc;
  355. // offset origin more because bitmap is just piece
  356. // of the whole drawing
  357. dc.OffsetViewportOrg( -rect.left, -rect.top );
  358. pOldBitmap = dc.SelectObject( &bitmap );
  359. dc.SetBrushOrg( rect.left % 8, rect.top % 8 );
  360. // might as well clip to the same rectangle
  361. dc.IntersectClipRect( client );
  362. }
  363. }
  364. }
  365. // paint background
  366. if( (! pDC->IsPrinting() ) && m_bGrid )
  367. {
  368. CBrush brush;
  369. if( ! brush.CreateSolidBrush( pDoc->GetPaperColor() ) )
  370. return;
  371. brush.UnrealizeObject();
  372. pDrawDC->FillRect( client, &brush );
  373. DrawGrid( pDrawDC );
  374. }
  375. pDoc->Draw( pDrawDC, this );
  376. if( pDrawDC != pDC )
  377. {
  378. pDC->SetViewportOrg( 0, 0 );
  379. pDC->SetWindowOrg( 0, 0 );
  380. pDC->SetMapMode( MM_TEXT );
  381. dc.SetViewportOrg( 0, 0 );
  382. dc.SetWindowOrg( 0, 0 );
  383. dc.SetMapMode( MM_TEXT );
  384. pDC->BitBlt(
  385. rect.left,
  386. rect.top,
  387. rect.Width(),
  388. rect.Height(),
  389. &dc,
  390. 0,
  391. 0,
  392. SRCCOPY
  393. );
  394. dc.SelectObject( pOldBitmap );
  395. }
  396. }
  398. void CDrawView::Remove(CDrawObj* pObj)
  399. {
  400. POSITION pos = m_selection.Find(pObj);
  401. if (pos != NULL)
  402. m_selection.RemoveAt(pos);
  403. }
  405. void CDrawView::PasteNative(COleDataObject& dataObject)
  406. {
  407. // get file refering to clipboard data
  408. CFile* pFile = dataObject.GetFileData(m_cfDraw);
  409. if (pFile == NULL)
  410. return;
  412. // connect the file to the archive
  413. CArchive ar(pFile, CArchive::load);
  414. TRY
  415. {
  416. ar.m_pDocument = GetDocument(); // set back-pointer in archive
  418. // read the selection
  419. m_selection.Serialize(ar);
  420. }
  421. CATCH_ALL(e)
  422. {
  423. ar.Close();
  424. delete pFile;
  425. THROW_LAST();
  426. }
  427. END_CATCH_ALL
  429. ar.Close();
  430. delete pFile;
  431. }
  433. void CDrawView::PasteEmbedded(COleDataObject& dataObject, CPoint point )
  434. {
  435. BeginWaitCursor();
  437. // paste embedded
  438. CDrawOleObj* pObj = new CDrawOleObj(GetInitialPosition());
  439. ASSERT_VALID(pObj);
  440. CDrawItem* pItem = new CDrawItem(GetDocument(), pObj);
  441. ASSERT_VALID(pItem);
  442. pObj->m_pClientItem = pItem;
  444. TRY
  445. {
  446. if (!pItem->CreateFromData(&dataObject) &&
  447. !pItem->CreateStaticFromData(&dataObject))
  448. {
  449. AfxThrowMemoryException();      // any exception will do
  450. }
  452. // add the object to the document
  453. GetDocument()->Add(pObj);
  454. m_selection.AddTail(pObj);
  455. ClientToDoc( point );
  456. pObj->MoveTo( CRect( point, pObj->m_extent ), this );
  458. // try to get initial presentation data
  459. pItem->UpdateLink();
  460. pItem->UpdateExtent();
  461. }
  462. CATCH_ALL(e)
  463. {
  464. // clean up item
  465. pItem->Delete();
  466. pObj->m_pClientItem = NULL;
  467. GetDocument()->Remove(pObj);
  468. pObj->Remove();
  470. AfxMessageBox(IDP_FAILED_TO_CREATE);
  471. }
  472. END_CATCH_ALL
  474. EndWaitCursor();
  475. }
  477. void CDrawView::DrawGrid(CDC* pDC)
  478. {
  479. CDrawDoc* pDoc = GetDocument();
  481. COLORREF oldBkColor = pDC->SetBkColor(pDoc->GetPaperColor());
  483. CRect rect;
  484. rect.left = -pDoc->GetSize().cx / 2;
  485. rect.top = -pDoc->GetSize().cy / 2;
  486. rect.right = rect.left + pDoc->GetSize().cx;
  487. rect.bottom = rect.top + pDoc->GetSize().cy;
  489. // Center lines
  490. CPen penDash;
  491. penDash.CreatePen(PS_DASH, 1, m_gridColor);
  492. CPen* pOldPen = pDC->SelectObject(&penDash);
  494. pDC->MoveTo(0, rect.top);
  495. pDC->LineTo(0, rect.bottom);
  496. pDC->MoveTo(rect.left, 0);
  497. pDC->LineTo(rect.right, 0);
  499. // Major unit lines
  500. CPen penDot;
  501. penDot.CreatePen(PS_DOT, 1, m_gridColor);
  502. pDC->SelectObject(&penDot);
  504. for (int x = rect.left / 100 * 100; x < rect.right; x += 100)
  505. {
  506. if (x != 0)
  507. {
  508. pDC->MoveTo(x, rect.top);
  509. pDC->LineTo(x, rect.bottom);
  510. }
  511. }
  513. for (int y = rect.top / 100 * 100; y < rect.bottom; y += 100)
  514. {
  515. if (y != 0)
  516. {
  517. pDC->MoveTo(rect.left, y);
  518. pDC->LineTo(rect.right, y);
  519. }
  520. }
  522. // Outlines
  523. CPen penSolid;
  524. penSolid.CreatePen(PS_SOLID, 1, m_gridColor);
  525. pDC->SelectObject(&penSolid);
  526. pDC->MoveTo(rect.left, rect.top);
  527. pDC->LineTo(rect.right, rect.top);
  528. pDC->LineTo(rect.right, rect.bottom);
  529. pDC->LineTo(rect.left, rect.bottom);
  530. pDC->LineTo(rect.left, rect.top);
  532. pDC->SelectObject(pOldPen);
  533. pDC->SetBkColor(oldBkColor);
  534. }
  536. void CDrawView::OnInitialUpdate()
  537. {
  538. CSize size = GetDocument()->GetSize();
  539. CClientDC dc(NULL);
  540. size.cx =
  541. MulDiv(
  542. size.cx,
  543. ::GetDeviceCaps( dc.m_hDC, LOGPIXELSX ),
  544. 100
  545. );
  546. size.cy =
  547. MulDiv(
  548. size.cy,
  549. ::GetDeviceCaps( dc.m_hDC, LOGPIXELSY ),
  550. 100
  551. );
  552. SetScrollSizes( MM_TEXT, size, sizeDefault, CSize( 1, 1 ) );
  553. }
  555. void CDrawView::SetPageSize(CSize size)
  556. {
  557. CClientDC dc(NULL);
  558. size.cx =
  559. MulDiv(
  560. size.cx,
  561. ::GetDeviceCaps( dc.m_hDC, LOGPIXELSX ),
  562. 100
  563. );
  564. size.cy =
  565. MulDiv(
  566. size.cy,
  567. ::GetDeviceCaps( dc.m_hDC, LOGPIXELSY ),
  568. 100
  569. );
  570. SetScrollSizes(MM_TEXT, size);
  571. GetDocument()->UpdateAllViews(NULL, HINT_UPDATE_WINDOW, NULL);
  572. }
  574. /////////////////////////////////////////////////////////////////////////////
  575. // CDrawView printing
  577. BOOL CDrawView::OnPreparePrinting(CPrintInfo* pInfo)
  578. {
  579. if( ! DoPreparePrinting( pInfo ) )
  580. return FALSE;
  581. WORD nPageNoMin = 1, nPageNoMax = 1;
  582. pInfo->m_nNumPreviewPages    = nPageNoMax;
  583. pInfo->m_pPD->m_pd.nMinPage  = nPageNoMin;
  584. pInfo->m_pPD->m_pd.nFromPage = nPageNoMin;
  585. pInfo->m_pPD->m_pd.nMaxPage  = nPageNoMax;
  586. pInfo->m_pPD->m_pd.nToPage   = nPageNoMax;
  587. return TRUE;
  588. }
  590. void CDrawView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
  591. {
  592. CScrollView :: OnBeginPrinting( pDC, pInfo );
  594. // check page size -- user could have gone into print setup
  595. // from print dialog and changed paper or orientation
  596. GetDocument()->ComputePageSize();
  597. }
  599. void CDrawView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  600. {
  601. // TODO: add cleanup after printing
  602. }
  604. /////////////////////////////////////////////////////////////////////////////
  605. // OLE Client support and commands
  607. BOOL CDrawView::IsSelected(const CObject* pDocItem) const
  608. {
  609. CDrawObj* pDrawObj = (CDrawObj*)pDocItem;
  610. if (pDocItem->IsKindOf(RUNTIME_CLASS(CDrawItem)))
  611. pDrawObj = ((CDrawItem*)pDocItem)->m_pDrawObj;
  612. return m_selection.Find(pDrawObj) != NULL;
  613. }
  615. void CDrawView::OnInsertObject()
  616. {
  617. // Invoke the standard Insert Object dialog box to obtain information
  618. //  for new CDrawItem object.
  619. COleInsertDialog dlgOleInsert;
  620. if( dlgOleInsert.DoModal() != IDOK )
  621. return;
  623. BeginWaitCursor();
  625. // First create the C++ object
  626. CDrawOleObj* pObj = new CDrawOleObj(GetInitialPosition());
  627. ASSERT_VALID(pObj);
  628. CDrawItem* pItem = new CDrawItem(GetDocument(), pObj);
  629. ASSERT_VALID(pItem);
  630. pObj->m_pClientItem = pItem;
  632. // Now create the OLE object/item
  633. TRY
  634. {
  635. if( ! dlgOleInsert.CreateItem(pObj->m_pClientItem ) )
  636. AfxThrowMemoryException();
  638. // add the object to the document
  639. GetDocument()->Add(pObj);
  641. // try to get initial presentation data
  642. pItem->UpdateLink();
  643. pItem->UpdateExtent();
  645. // if insert new object -- initially show the object
  646. if (dlgOleInsert.GetSelectionType() == COleInsertDialog::createNewItem)
  647. pItem->DoVerb(OLEIVERB_SHOW, this);
  648. }
  649. CATCH_ALL(e)
  650. {
  651. // clean up item
  652. pItem->Delete();
  653. pObj->m_pClientItem = NULL;
  654. GetDocument()->Remove(pObj);
  655. pObj->Remove();
  657. AfxMessageBox(IDP_FAILED_TO_CREATE);
  658. }
  659. END_CATCH_ALL
  661. EndWaitCursor();
  662. }
  664. // The following command handler provides the standard keyboard
  665. //  user interface to cancel an in-place editing session.
  666. void CDrawView::OnCancelEdit()
  667. {
  668. // deactivate any in-place active item on this view!
  669. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  670. if (pActiveItem != NULL)
  671. {
  672. // if we found one, deactivate it
  673. pActiveItem->Close();
  674. }
  675. ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
  676. // escape also brings us back into select mode
  677. ReleaseCapture();
  678. CDrawTool* pTool = CDrawTool::FindTool(CDrawTool::c_drawShape);
  679. if (pTool != NULL)
  680. pTool->OnCancel();
  681. CDrawTool::c_drawShape = selection;
  682. }
  684. void CDrawView::OnSetFocus(CWnd* pOldWnd)
  685. {
  686. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  687. if (pActiveItem != NULL &&
  688. pActiveItem->GetItemState() == COleClientItem::activeUIState)
  689. {
  690. // need to set focus to this item if it is in the same view
  691. CWnd* pWnd = pActiveItem->GetInPlaceWindow();
  692. if (pWnd != NULL)
  693. {
  694. pWnd->SetFocus();
  695. return;
  696. }
  697. }
  699. __BASE_OF_CDrawView__ :: OnSetFocus( pOldWnd );
  700. }
  702. CRect CDrawView::GetInitialPosition()
  703. {
  704. CRect rect(10, 10, 10, 10);
  705. ClientToDoc(rect);
  706. return rect;
  707. }
  709. void CDrawView::ClientToDoc(CPoint& point)
  710. {
  711. CClientDC dc(this);
  712. OnPrepareDC(&dc, NULL);
  713. dc.DPtoLP(&point);
  714. }
  716. void CDrawView::ClientToDoc(CRect& rect)
  717. {
  718. CClientDC dc(this);
  719. OnPrepareDC(&dc, NULL);
  720. dc.DPtoLP(rect);
  721. ASSERT(rect.left <= rect.right);
  722. ASSERT(rect.bottom <= rect.top);
  723. }
  725. void CDrawView::DocToClient(CPoint& point)
  726. {
  727. CClientDC dc(this);
  728. OnPrepareDC(&dc, NULL);
  729. dc.LPtoDP(&point);
  730. }
  732. void CDrawView::DocToClient(CRect& rect)
  733. {
  734. CClientDC dc(this);
  735. OnPrepareDC(&dc, NULL);
  736. dc.LPtoDP(rect);
  737. rect.NormalizeRect();
  738. }
  740. void CDrawView::Select(CDrawObj* pObj, BOOL bAdd)
  741. {
  742. if (!bAdd)
  743. {
  744. OnUpdate(NULL, HINT_UPDATE_SELECTION, NULL);
  745. m_selection.RemoveAll();
  746. }
  748. if (pObj == NULL || IsSelected(pObj))
  749. return;
  751. m_selection.AddTail(pObj);
  752. InvalObj(pObj);
  753. }
  755. // rect is in device coordinates
  756. void CDrawView::SelectWithinRect(CRect rect, BOOL bAdd)
  757. {
  758. if (!bAdd)
  759. Select(NULL);
  761. ClientToDoc(rect);
  763. CDrawObjList* pObList = GetDocument()->GetObjects();
  764. POSITION posObj = pObList->GetHeadPosition();
  765. while (posObj != NULL)
  766. {
  767. CDrawObj* pObj = pObList->GetNext(posObj);
  768. if (pObj->Intersects(rect))
  769. Select(pObj, TRUE);
  770. }
  771. }
  773. void CDrawView::Deselect(CDrawObj* pObj)
  774. {
  775. POSITION pos = m_selection.Find(pObj);
  776. if (pos != NULL)
  777. {
  778. InvalObj(pObj);
  779. m_selection.RemoveAt(pos);
  780. }
  781. }
  783. void CDrawView::CloneSelection()
  784. {
  785. POSITION pos = m_selection.GetHeadPosition();
  786. while (pos != NULL)
  787. {
  788. CDrawObj* pObj = m_selection.GetNext(pos);
  789. pObj->Clone(pObj->m_pDocument);
  790. // copies object and adds it to the document
  791. }
  792. }
  794. void CDrawView::UpdateActiveItem()
  795. {
  796. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  797. if (pActiveItem != NULL &&
  798. pActiveItem->GetItemState() == COleClientItem::activeUIState)
  799. {
  800. // this will update the item rectangles by calling
  801. //  OnGetPosRect & OnGetClipRect.
  802. pActiveItem->SetItemRects();
  803. }
  804. }
  806. /////////////////////////////////////////////////////////////////////////////
  807. // CDrawView message handlers
  809. void CDrawView::OnLButtonDown(UINT nFlags, CPoint point)
  810. {
  811. if (!m_bActive)
  812. return;
  813. CDrawTool* pTool = CDrawTool::FindTool(CDrawTool::c_drawShape);
  814. if (pTool != NULL)
  815. pTool->OnLButtonDown(this, nFlags, point);
  816. SyncToolbarObjButtons();
  817. }
  819. void CDrawView::OnLButtonUp(UINT nFlags, CPoint point)
  820. {
  821. if (!m_bActive)
  822. return;
  823. CDrawTool* pTool = CDrawTool::FindTool(CDrawTool::c_drawShape);
  824. if (pTool != NULL)
  825. pTool->OnLButtonUp(this, nFlags, point);
  826. SyncToolbarObjButtons();
  827. }
  829. void CDrawView::OnMouseMove(UINT nFlags, CPoint point)
  830. {
  831. if (!m_bActive)
  832. return;
  833. CDrawTool* pTool = CDrawTool::FindTool(CDrawTool::c_drawShape);
  834. if (pTool != NULL)
  835. pTool->OnMouseMove(this, nFlags, point);
  836. }
  838. void CDrawView::OnLButtonDblClk(UINT nFlags, CPoint point)
  839. {
  840. if (!m_bActive)
  841. return;
  842. CDrawTool* pTool = CDrawTool::FindTool(CDrawTool::c_drawShape);
  843. if (pTool != NULL)
  844. pTool->OnLButtonDblClk(this, nFlags, point);
  845. }
  847. void CDrawView::OnDestroy()
  848. {
  849. __BASE_OF_CDrawView__ :: OnDestroy();
  851. // deactivate the inplace active item on this view
  852. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  853. if (pActiveItem != NULL && pActiveItem->GetActiveView() == this)
  854. {
  855. pActiveItem->Deactivate();
  856. ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
  857. }
  858. }
  860. void CDrawView::OnDrawSelect()
  861. {
  862. CDrawTool::c_drawShape = selection;
  863. }
  865. void CDrawView::OnDrawRoundRect()
  866. {
  867. CDrawTool::c_drawShape = roundRect;
  868. }
  870. void CDrawView::OnDrawRect()
  871. {
  872. CDrawTool::c_drawShape = rect;
  873. }
  875. void CDrawView::OnDrawLine()
  876. {
  877. CDrawTool::c_drawShape = line;
  878. }
  880. void CDrawView::OnDrawEllipse()
  881. {
  882. CDrawTool::c_drawShape = ellipse;
  883. }
  885. void CDrawView::OnDrawPolygon()
  886. {
  887. CDrawTool::c_drawShape = poly;
  888. }
  890. void CDrawView::OnUpdateDrawEllipse(CCmdUI* pCmdUI)
  891. {
  892. if( IsPrintPreviewMode() )
  893. {
  894. pCmdUI->SetRadio();
  895. pCmdUI->Enable( FALSE );
  896. return;
  897. }
  898. pCmdUI->SetRadio(CDrawTool::c_drawShape == ellipse);
  899. }
  901. void CDrawView::OnUpdateDrawLine(CCmdUI* pCmdUI)
  902. {
  903. if( IsPrintPreviewMode() )
  904. {
  905. pCmdUI->SetRadio();
  906. pCmdUI->Enable( FALSE );
  907. return;
  908. }
  909. pCmdUI->SetRadio(CDrawTool::c_drawShape == line);
  910. }
  912. void CDrawView::OnUpdateDrawRect(CCmdUI* pCmdUI)
  913. {
  914. if( IsPrintPreviewMode() )
  915. {
  916. pCmdUI->SetRadio();
  917. pCmdUI->Enable( FALSE );
  918. return;
  919. }
  920. pCmdUI->SetRadio(CDrawTool::c_drawShape == rect);
  921. }
  923. void CDrawView::OnUpdateDrawRoundRect(CCmdUI* pCmdUI)
  924. {
  925. if( IsPrintPreviewMode() )
  926. {
  927. pCmdUI->SetRadio();
  928. pCmdUI->Enable( FALSE );
  929. return;
  930. }
  931. pCmdUI->SetRadio(CDrawTool::c_drawShape == roundRect);
  932. }
  934. void CDrawView::OnUpdateDrawSelect(CCmdUI* pCmdUI)
  935. {
  936. if( IsPrintPreviewMode() )
  937. {
  938. pCmdUI->SetRadio();
  939. pCmdUI->Enable( FALSE );
  940. return;
  941. }
  942. pCmdUI->Enable();
  943. pCmdUI->SetRadio(CDrawTool::c_drawShape == selection);
  944. }
  946. void CDrawView::OnUpdateSingleSelect(CCmdUI* pCmdUI)
  947. {
  948. if( IsPrintPreviewMode() )
  949. {
  950. pCmdUI->SetCheck( 0 );
  951. return;
  952. }
  953. pCmdUI->Enable( m_selection.GetCount() == 1 && GetDocument()->GetObjects()->GetCount() > 1 );
  954. }
  956. void CDrawView::OnEditSelectAll()
  957. {
  958. CDrawObjList* pObList = GetDocument()->GetObjects();
  959. POSITION pos = pObList->GetHeadPosition();
  960. while (pos != NULL)
  961. Select(pObList->GetNext(pos), TRUE);
  962. }
  964. void CDrawView::OnUpdateEditSelectAll(CCmdUI* pCmdUI)
  965. {
  966. if( IsPrintPreviewMode() )
  967. {
  968. pCmdUI->Enable( FALSE );
  969. return;
  970. }
  971. pCmdUI->Enable(GetDocument()->GetObjects()->GetCount() != 0);
  972. }
  974. void CDrawView::OnEditClear()
  975. {
  976. // update all the views before the selection goes away
  977. GetDocument()->UpdateAllViews(NULL, HINT_DELETE_SELECTION, &m_selection);
  978. OnUpdate(NULL, HINT_UPDATE_SELECTION, NULL);
  980. // now remove the selection from the document
  981. POSITION pos = m_selection.GetHeadPosition();
  982. while (pos != NULL)
  983. {
  984. CDrawObj* pObj = m_selection.GetNext(pos);
  985. GetDocument()->Remove(pObj);
  986. pObj->Remove();
  987. }
  988. m_selection.RemoveAll();
  989. }
  991. void CDrawView::OnUpdateAnySelect(CCmdUI* pCmdUI)
  992. {
  993. if( IsPrintPreviewMode() )
  994. {
  995. pCmdUI->Enable( FALSE );
  996. return;
  997. }
  998. pCmdUI->Enable(!m_selection.IsEmpty());
  999. }
  1001. void CDrawView::OnUpdateDrawPolygon(CCmdUI* pCmdUI)
  1002. {
  1003. if( IsPrintPreviewMode() )
  1004. {
  1005. pCmdUI->SetRadio();
  1006. pCmdUI->Enable( FALSE );
  1007. return;
  1008. }
  1009. pCmdUI->SetRadio(CDrawTool::c_drawShape == poly);
  1010. }
  1012. void CDrawView::OnSize(UINT nType, int cx, int cy)
  1013. {
  1014. __BASE_OF_CDrawView__ :: OnSize( nType, cx, cy );
  1015. UpdateActiveItem();
  1016. // if( m_wndScrollBarH.GetSafeHwnd() != NULL
  1017. // || m_wndScrollBarV.GetSafeHwnd() != NULL
  1018. // )
  1019. // RepositionBars( 0, 0xFFFF, 0 );
  1020. }
  1022. void CDrawView::OnViewGrid()
  1023. {
  1024. m_bGrid = !m_bGrid;
  1025. Invalidate(FALSE);
  1026. }
  1028. void CDrawView::OnUpdateViewGrid(CCmdUI* pCmdUI)
  1029. {
  1030. if( IsPrintPreviewMode() )
  1031. {
  1032. pCmdUI->SetCheck( 0 );
  1033. pCmdUI->Enable( FALSE );
  1034. return;
  1035. }
  1036. pCmdUI->Enable();
  1037. pCmdUI->SetCheck(m_bGrid);
  1039. }
  1041. BOOL CDrawView::OnEraseBkgnd( CDC * pDC )
  1042. {
  1043. pDC;
  1044. return TRUE;
  1045. }
  1047. void CDrawView::OnObjectFillColor()
  1048. {
  1049. int nSelCount = int( m_selection.GetCount() );
  1050. if( nSelCount == 0 )
  1051. {
  1052. ASSERT( FALSE ); // should be disabled
  1053. return;
  1054. }
  1055. POSITION pos = m_selection.GetHeadPosition();
  1056. ASSERT( pos != NULL );
  1057. CDrawObj * pObj = m_selection.GetNext( pos );
  1058. ASSERT( pObj != NULL );
  1059. CExtColorDlg dlgColor;
  1060. dlgColor.m_clrInit
  1061. = dlgColor.m_clrNew
  1062. = pObj->GetFillColor();
  1063. VERIFY(
  1064. dlgColor.m_strCaption.LoadString( ID_OBJECT_FILLCOLOR )
  1065. );
  1066. if( dlgColor.DoModal() != IDOK )
  1067. return;
  1068. pos = m_selection.GetHeadPosition();
  1069. ASSERT( pos != NULL );
  1070. while( pos != NULL )
  1071. {
  1072. pObj = m_selection.GetNext( pos );
  1073. ASSERT( pObj != NULL );
  1074. pObj->SetNoFill( FALSE );
  1075. pObj->SetFillColor( dlgColor.m_clrNew );
  1076. }
  1077. SyncToolbarObjButtons();
  1078. }
  1080. void CDrawView::OnObjectLineColor()
  1081. {
  1082. int nSelCount = int( m_selection.GetCount() );
  1083. if( nSelCount == 0 )
  1084. {
  1085. ASSERT( FALSE ); // should be disabled
  1086. return;
  1087. }
  1088. POSITION pos = m_selection.GetHeadPosition();
  1089. ASSERT( pos != NULL );
  1090. CDrawObj * pObj = m_selection.GetNext( pos );
  1091. ASSERT( pObj != NULL );
  1092. CExtColorDlg dlgColor;
  1093. dlgColor.m_clrInit
  1094. = dlgColor.m_clrNew
  1095. = pObj->GetLineColor();
  1096. VERIFY(
  1097. dlgColor.m_strCaption.LoadString( ID_OBJECT_LINECOLOR )
  1098. );
  1099. if( dlgColor.DoModal() != IDOK )
  1100. return;
  1101. pos = m_selection.GetHeadPosition();
  1102. ASSERT( pos != NULL );
  1103. while( pos != NULL )
  1104. {
  1105. pObj = m_selection.GetNext( pos );
  1106. ASSERT( pObj != NULL );
  1107. pObj->SetNoOutline( FALSE );
  1108. pObj->SetLineColor( dlgColor.m_clrNew );
  1109. }
  1110. SyncToolbarObjButtons();
  1111. }
  1113. void CDrawView::OnObjectMoveBack()
  1114. {
  1115. CDrawDoc* pDoc = GetDocument();
  1116. CDrawObj* pObj = m_selection.GetHead();
  1117. CDrawObjList* pObjects = pDoc->GetObjects();
  1118. POSITION pos = pObjects->Find(pObj);
  1119. ASSERT(pos != NULL);
  1120. if (pos != pObjects->GetHeadPosition())
  1121. {
  1122. POSITION posPrev = pos;
  1123. pObjects->GetPrev(posPrev);
  1124. pObjects->RemoveAt(pos);
  1125. pObjects->InsertBefore(posPrev, pObj);
  1126. InvalObj(pObj);
  1127. }
  1128. }
  1130. void CDrawView::OnObjectMoveForward()
  1131. {
  1132. CDrawDoc* pDoc = GetDocument();
  1133. CDrawObj* pObj = m_selection.GetHead();
  1134. CDrawObjList* pObjects = pDoc->GetObjects();
  1135. POSITION pos = pObjects->Find(pObj);
  1136. ASSERT(pos != NULL);
  1137. if (pos != pObjects->GetTailPosition())
  1138. {
  1139. POSITION posNext = pos;
  1140. pObjects->GetNext(posNext);
  1141. pObjects->RemoveAt(pos);
  1142. pObjects->InsertAfter(posNext, pObj);
  1143. InvalObj(pObj);
  1144. }
  1145. }
  1147. void CDrawView::OnObjectMoveToBack()
  1148. {
  1149. CDrawDoc* pDoc = GetDocument();
  1150. CDrawObj* pObj = m_selection.GetHead();
  1151. CDrawObjList* pObjects = pDoc->GetObjects();
  1152. POSITION pos = pObjects->Find(pObj);
  1153. ASSERT(pos != NULL);
  1154. pObjects->RemoveAt(pos);
  1155. pObjects->AddHead(pObj);
  1156. InvalObj(pObj);
  1157. }
  1159. void CDrawView::OnObjectMoveToFront()
  1160. {
  1161. CDrawDoc* pDoc = GetDocument();
  1162. CDrawObj* pObj = m_selection.GetHead();
  1163. CDrawObjList* pObjects = pDoc->GetObjects();
  1164. POSITION pos = pObjects->Find(pObj);
  1165. ASSERT(pos != NULL);
  1166. pObjects->RemoveAt(pos);
  1167. pObjects->AddTail(pObj);
  1168. InvalObj(pObj);
  1169. }
  1171. void CDrawView::OnEditCopy()
  1172. {
  1173. ASSERT_VALID(this);
  1174. ASSERT(m_cfDraw != NULL);
  1176. // Create a shared file and associate a CArchive with it
  1177. CSharedFile file;
  1178. CArchive ar(&file, CArchive::store);
  1180. // Serialize selected objects to the archive
  1181. m_selection.Serialize(ar);
  1182. ar.Close();
  1184. COleDataSource* pDataSource = NULL;
  1185. TRY
  1186. {
  1187. pDataSource = new COleDataSource;
  1188. // put on local format instead of or in addation to
  1189. pDataSource->CacheGlobalData(m_cfDraw, file.Detach());
  1191. // if only one item and it is a COleClientItem then also
  1192. // paste in that format
  1193. CDrawObj* pDrawObj = m_selection.GetHead();
  1194. if (m_selection.GetCount() == 1 &&
  1195. pDrawObj->IsKindOf(RUNTIME_CLASS(CDrawOleObj)))
  1196. {
  1197. CDrawOleObj* pDrawOle = (CDrawOleObj*)pDrawObj;
  1198. pDrawOle->m_pClientItem->GetClipboardData(pDataSource, FALSE);
  1199. }
  1200. pDataSource->SetClipboard();
  1201. }
  1202. CATCH_ALL(e)
  1203. {
  1204. delete pDataSource;
  1205. THROW_LAST();
  1206. }
  1207. END_CATCH_ALL
  1208. }
  1210. void CDrawView::OnUpdateEditCopy(CCmdUI* pCmdUI)
  1211. {
  1212. if( IsPrintPreviewMode() )
  1213. {
  1214. pCmdUI->Enable( FALSE );
  1215. return;
  1216. }
  1217. pCmdUI->Enable(!m_selection.IsEmpty());
  1218. }
  1220. void CDrawView::OnEditCut()
  1221. {
  1222. OnEditCopy();
  1223. OnEditClear();
  1224. OnDrawSelect();
  1225. }
  1227. void CDrawView::OnUpdateEditCut(CCmdUI* pCmdUI)
  1228. {
  1229. if( IsPrintPreviewMode() )
  1230. {
  1231. pCmdUI->Enable( FALSE );
  1232. return;
  1233. }
  1234. pCmdUI->Enable(!m_selection.IsEmpty());
  1235. }
  1237. void CDrawView::OnEditPaste()
  1238. {
  1239. COleDataObject dataObject;
  1240. dataObject.AttachClipboard();
  1242. // invalidate current selection since it will be deselected
  1243. OnUpdate(NULL, HINT_UPDATE_SELECTION, NULL);
  1244. m_selection.RemoveAll();
  1245. if (dataObject.IsDataAvailable(m_cfDraw))
  1246. {
  1247. PasteNative(dataObject);
  1249. // now add all items in m_selection to document
  1250. POSITION pos = m_selection.GetHeadPosition();
  1251. while (pos != NULL)
  1252. GetDocument()->Add(m_selection.GetNext(pos));
  1253. }
  1254. else
  1255. PasteEmbedded(dataObject, GetInitialPosition().TopLeft() );
  1257. GetDocument()->SetModifiedFlag();
  1259. // invalidate new pasted stuff
  1260. GetDocument()->UpdateAllViews(NULL, HINT_UPDATE_SELECTION, &m_selection);
  1261. }
  1263. void CDrawView::OnUpdateEditPaste(CCmdUI* pCmdUI)
  1264. {
  1265. if( IsPrintPreviewMode() )
  1266. {
  1267. pCmdUI->Enable( FALSE );
  1268. return;
  1269. }
  1271. // determine if private or standard OLE formats are on the clipboard
  1272. COleDataObject dataObject;
  1273. BOOL bEnable = dataObject.AttachClipboard() &&
  1274. (dataObject.IsDataAvailable(m_cfDraw) ||
  1275.  COleClientItem::CanCreateFromData(&dataObject));
  1277. // enable command based on availability
  1278. pCmdUI->Enable(bEnable);
  1279. }
  1281. void CDrawView::OnViewShowObjects()
  1282. {
  1283. CDrawOleObj::c_bShowItems = !CDrawOleObj::c_bShowItems;
  1284. GetDocument()->UpdateAllViews(NULL, HINT_UPDATE_OLE_ITEMS, NULL);
  1285. }
  1287. void CDrawView::OnUpdateViewShowObjects(CCmdUI* pCmdUI)
  1288. {
  1289. if( IsPrintPreviewMode() )
  1290. {
  1291. pCmdUI->SetCheck( 0 );
  1292. pCmdUI->Enable( FALSE );
  1293. return;
  1294. }
  1295. pCmdUI->Enable();
  1296. pCmdUI->SetCheck(CDrawOleObj::c_bShowItems);
  1297. }
  1299. void CDrawView::OnEditProperties()
  1300. {
  1301. if (m_selection.GetCount() == 1 && CDrawTool::c_drawShape == selection)
  1302. {
  1303. CDrawTool* pTool =
  1304. CDrawTool::FindTool(
  1305. CDrawTool::c_drawShape
  1306. );
  1307. ASSERT(pTool != NULL);
  1308. pTool->OnEditProperties(this);
  1309. }
  1310. }
  1312. void CDrawView::OnUpdateEditProperties(CCmdUI* pCmdUI)
  1313. {
  1314. if( IsPrintPreviewMode() )
  1315. {
  1316. pCmdUI->Enable( FALSE );
  1317. return;
  1318. }
  1319. pCmdUI->Enable( m_selection.GetCount() == 1 && CDrawTool::c_drawShape == selection );
  1320. }
  1322. /////////////////////////////////////////////////////////////////////////////
  1323. // CDrawView diagnostics
  1325. #ifdef _DEBUG
  1326. void CDrawView::AssertValid() const
  1327. {
  1328. __BASE_OF_CDrawView__ :: AssertValid();
  1329. }
  1331. void CDrawView::Dump(CDumpContext& dc) const
  1332. {
  1333. __BASE_OF_CDrawView__ :: Dump( dc );
  1334. }
  1335. #endif //_DEBUG
  1337. /////////////////////////////////////////////////////////////////////////////
  1338. // new
  1339. // support for drag/drop
  1341. int CDrawView::OnCreate(LPCREATESTRUCT lpCreateStruct)
  1342. {
  1343. if( __BASE_OF_CDrawView__ :: OnCreate( lpCreateStruct ) == -1 )
  1344. return -1;
  1346. //CFrameWnd * pWndFrame = GetParentFrame();
  1347. // if( pWndFrame == NULL
  1348. // || (! pWndFrame->IsKindOf( RUNTIME_CLASS(CMDIChildWnd) ) )
  1349. // || pWndFrame->IsKindOf( RUNTIME_CLASS(CDrawInPlaceFrame) )
  1350. // )
  1351. // {
  1352. // m_wndScrollBarH.m_eSO = CExtScrollBar::__ESO_BOTTOM;
  1353. // m_wndScrollBarV.m_eSO = CExtScrollBar::__ESO_RIGHT;
  1354. // if( ! m_wndScrollBarV.Create(
  1355. // WS_CHILD|WS_VISIBLE|SBS_VERT|SBS_RIGHTALIGN,
  1356. // CRect(0,0,0,0),
  1357. // this,
  1358. // 1
  1359. // )
  1360. // )
  1361. // {
  1362. // ASSERT( FALSE );
  1363. // return -1;
  1364. // }
  1365. // if( ! m_wndScrollBarH.Create(
  1366. // WS_CHILD|WS_VISIBLE|SBS_HORZ|SBS_BOTTOMALIGN,
  1367. // CRect(0,0,0,0),
  1368. // this,
  1369. // 2
  1370. // )
  1371. // )
  1372. // {
  1373. // ASSERT( FALSE );
  1374. // return -1;
  1375. // }
  1376. // m_wndScrollBarH.SyncReservedSpace( &m_wndScrollBarV );
  1377. // m_wndScrollBarV.SyncReservedSpace( &m_wndScrollBarH );
  1378. // ModifyStyle( WS_HSCROLL|WS_VSCROLL, 0, SWP_FRAMECHANGED );
  1379. // }
  1381. // register drop target
  1382. if( m_dropTarget.Register( this ) )
  1383. return 0;
  1384. else
  1385. return -1;
  1386. }
  1388. CScrollBar* CDrawView::GetScrollBarCtrl(int nBar) const
  1389. {
  1390. ASSERT_VALID( this );
  1391. if( m_hWnd == NULL || (! ::IsWindow(m_hWnd) ) )
  1392. return NULL;
  1393. // ASSERT( nBar == SB_HORZ || nBar == SB_VERT );
  1394. // if( nBar == SB_HORZ )
  1395. // {
  1396. // if( m_wndScrollBarH.GetSafeHwnd() != NULL )
  1397. // return ( const_cast < CExtScrollBar * > ( &m_wndScrollBarH ) );
  1398. // } // if( nBar == SB_HORZ )
  1399. // else if( nBar == SB_VERT )
  1400. // {
  1401. // if( m_wndScrollBarV.GetSafeHwnd() != NULL )
  1402. // return ( const_cast < CExtScrollBar * > ( &m_wndScrollBarV ) );
  1403. // } // else from if( nBar == SB_HORZ )
  1404. return __BASE_OF_CDrawView__ :: GetScrollBarCtrl( nBar );
  1405. }
  1407. BOOL CDrawView::GetObjectInfo(COleDataObject* pDataObject,
  1408. CSize* pSize, CSize* pOffset)
  1409. {
  1410. ASSERT(pSize != NULL);
  1412. // get object descriptor data
  1413. HGLOBAL hObjDesc = pDataObject->GetGlobalData(m_cfObjectDescriptor);
  1414. if (hObjDesc == NULL)
  1415. {
  1416. if (pOffset != NULL)
  1417. *pOffset = CSize(0, 0); // fill in defaults instead
  1418. *pSize = CSize(0, 0);
  1419. return FALSE;
  1420. }
  1421. ASSERT(hObjDesc != NULL);
  1423. // otherwise, got CF_OBJECTDESCRIPTOR ok.  Lock it down and extract size.
  1424. LPOBJECTDESCRIPTOR pObjDesc = (LPOBJECTDESCRIPTOR)GlobalLock(hObjDesc);
  1425. ASSERT(pObjDesc != NULL);
  1426. pSize->cx = (int)pObjDesc->sizel.cx;
  1427. pSize->cy = (int)pObjDesc->sizel.cy;
  1428. if (pOffset != NULL)
  1429. {
  1430. pOffset->cx = (int)pObjDesc->pointl.x;
  1431. pOffset->cy = (int)pObjDesc->pointl.y;
  1432. }
  1433. GlobalUnlock(hObjDesc);
  1434. GlobalFree(hObjDesc);
  1436. // successfully retrieved pSize & pOffset info
  1437. return TRUE;
  1438. }
  1440. DROPEFFECT CDrawView::OnDragEnter(COleDataObject* pDataObject,
  1441. DWORD grfKeyState, CPoint point)
  1442. {
  1443. ASSERT(m_prevDropEffect == DROPEFFECT_NONE);
  1444. m_bDragDataAcceptable = FALSE;
  1445. if (!COleClientItem::CanCreateFromData(pDataObject))
  1446. return DROPEFFECT_NONE;
  1448. m_bDragDataAcceptable = TRUE;
  1449. GetObjectInfo(pDataObject, &m_dragSize, &m_dragOffset);
  1450. CClientDC dc(NULL);
  1451. dc.HIMETRICtoDP(&m_dragSize);
  1452. dc.HIMETRICtoDP(&m_dragOffset);
  1454. return OnDragOver(pDataObject, grfKeyState, point);
  1455. }
  1457. DROPEFFECT CDrawView::OnDragOver(COleDataObject*,
  1458. DWORD grfKeyState, CPoint point)
  1459. {
  1460. if(m_bDragDataAcceptable == FALSE)
  1461. return DROPEFFECT_NONE;
  1463. point -= m_dragOffset;  // adjust target rect by original cursor offset
  1465. // check for point outside logical area -- i.e. in hatched region
  1466. // GetTotalSize() returns the size passed to SetScrollSizes
  1467. CRect rectScroll(CPoint(0, 0), GetTotalSize());
  1469. CRect rectItem(point,m_dragSize);
  1470. rectItem.OffsetRect(GetDeviceScrollPosition());
  1472. DROPEFFECT de = DROPEFFECT_NONE;
  1473. CRect rectTemp;
  1474. if (rectTemp.IntersectRect(rectScroll, rectItem))
  1475. {
  1476. // check for force link
  1477. if ((grfKeyState & (MK_CONTROL|MK_SHIFT)) == (MK_CONTROL|MK_SHIFT))
  1478. de = DROPEFFECT_NONE; // DRAWCLI isn't a linking container
  1479. // check for force copy
  1480. else if ((grfKeyState & MK_CONTROL) == MK_CONTROL)
  1481. de = DROPEFFECT_COPY;
  1482. // check for force move
  1483. else if ((grfKeyState & MK_ALT) == MK_ALT)
  1484. de = DROPEFFECT_MOVE;
  1485. // default -- recommended action is move
  1486. else
  1487. de = DROPEFFECT_MOVE;
  1488. }
  1490. if (point == m_dragPoint)
  1491. return de;
  1493. // otherwise, cursor has moved -- need to update the drag feedback
  1494. CClientDC dc(this);
  1495. if (m_prevDropEffect != DROPEFFECT_NONE)
  1496. {
  1497. // erase previous focus rect
  1498. dc.DrawFocusRect(CRect(m_dragPoint, m_dragSize));
  1499. }
  1500. m_prevDropEffect = de;
  1501. if (m_prevDropEffect != DROPEFFECT_NONE)
  1502. {
  1503. m_dragPoint = point;
  1504. dc.DrawFocusRect(CRect(point, m_dragSize));
  1505. }
  1506. return de;
  1507. }
  1509. BOOL CDrawView::OnDrop(COleDataObject* pDataObject,
  1510. DROPEFFECT /*dropEffect*/, CPoint point)
  1511. {
  1512. ASSERT_VALID(this);
  1514. // clean up focus rect
  1515. OnDragLeave();
  1517. // offset point as appropriate for dragging
  1518. GetObjectInfo(pDataObject, &m_dragSize, &m_dragOffset);
  1519. CClientDC dc(NULL);
  1520. dc.HIMETRICtoDP(&m_dragSize);
  1521. dc.HIMETRICtoDP(&m_dragOffset);
  1522. point -= m_dragOffset;
  1524. // invalidate current selection since it will be deselected
  1525. OnUpdate(NULL, HINT_UPDATE_SELECTION, NULL);
  1526. m_selection.RemoveAll();
  1527. if (m_bDragDataAcceptable)
  1528. PasteEmbedded(*pDataObject, point);
  1530. // update the document and views
  1531. GetDocument()->SetModifiedFlag();
  1532. GetDocument()->UpdateAllViews(NULL, 0, NULL);      // including this view
  1534. return TRUE;
  1535. }
  1537. void CDrawView::OnDragLeave()
  1538. {
  1539. CClientDC dc(this);
  1540. if (m_prevDropEffect != DROPEFFECT_NONE)
  1541. {
  1542. dc.DrawFocusRect(CRect(m_dragPoint,m_dragSize)); // erase previous focus rect
  1543. m_prevDropEffect = DROPEFFECT_NONE;
  1544. }
  1545. }
  1548. void CDrawView::OnContextMenu(CWnd* /*pWnd*/, CPoint point)
  1549. {
  1550. if( IsPrintPreviewMode() )
  1551. return;
  1552. CDrawDoc * pDoc = GetDocument();
  1553. ASSERT_VALID( pDoc );
  1555. // make sure window is active
  1556. GetParentFrame()->ActivateFrame();
  1558. CPoint ptLocal = point;
  1559. ScreenToClient( &ptLocal );
  1560. ClientToDoc( ptLocal );
  1562. bool bTryProcessItemFocus = !( (point.x < 0) || (point.y < 0) );
  1563. CDrawObj * pObj = NULL;
  1564. if( bTryProcessItemFocus )
  1565. {
  1566. pObj = GetDocument()->ObjectAt( ptLocal );
  1567. if( pObj == NULL )
  1568. return;
  1569. if( !IsSelected(pObj) )
  1570. Select( pObj, FALSE ); // reselect item if appropriate
  1571. Invalidate();
  1572. UpdateWindow();
  1573. } // if( bTryProcessItemFocus )
  1574. else
  1575. {
  1576. POSITION pos = m_selection.GetHeadPosition();
  1577. if( pos == NULL )
  1578. return;
  1579. pObj = m_selection.GetNext( pos );
  1580. } // else from if( bTryProcessItemFocus )
  1582. ASSERT( pObj != NULL );
  1584. SyncToolbarObjButtons();
  1586. CMenu menu;
  1587. if( !menu.LoadMenu(ID_POPUP_MENU) )
  1588. {
  1589. ASSERT( FALSE );
  1590. return;
  1591. }
  1593. HWND hWnd = AfxGetMainWnd()->GetSafeHwnd();
  1594. ASSERT( hWnd != NULL );
  1595. ASSERT( ::IsWindow( hWnd ) );
  1597. CExtPopupMenuWnd * pPopup = new CExtPopupMenuWnd;
  1598. VERIFY( pPopup->UpdateFromMenu( hWnd, &menu ) );
  1600. VERIFY(
  1601. pPopup->TrackPopupMenu(
  1602. TPMX_OWNERDRAW_FIXED|TPMX_HIDE_KEYBOARD_ACCELERATORS,
  1603. point.x,
  1604. point.y
  1605. )
  1606. );
  1607. }
  1609. void CDrawView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
  1610. {
  1611. if (pInfo->m_bPreview == FALSE)
  1612. ((CDrawDoc*)GetDocument())->m_pSummInfo->RecordPrintDate();
  1613. OnDraw(pDC);
  1614. }
  1616. LRESULT CDrawView::OnExtMenuPrepare(WPARAM wParam, LPARAM lParam)
  1617. {
  1618. lParam;
  1619. CExtPopupMenuWnd::MsgPrepareMenuData_t * pData =
  1620. reinterpret_cast
  1621. < CExtPopupMenuWnd::MsgPrepareMenuData_t * >
  1622. ( wParam );
  1623. ASSERT( pData != NULL );
  1624. CExtPopupMenuWnd * pPopup = pData->m_pPopup;
  1625. ASSERT( pPopup != NULL );
  1627. if( ( pPopup->TrackFlagsGet() & TPMX_NO_CMD_UI ) != 0 )
  1628. return 0;
  1630. CDrawDoc * pDoc = GetDocument();
  1631. ASSERT_VALID( pDoc );
  1633. CDrawObj * pObj = NULL;
  1634. POSITION pos = m_selection.GetHeadPosition();
  1635. if( pos != NULL )
  1636. {
  1637. pObj = m_selection.GetNext( pos );
  1638. ASSERT( pObj != NULL );
  1639. }
  1641. INT nDefaultItemPos =
  1642. pPopup->ItemFindPosForCmdID(ID_EDIT_PROPERTIES);
  1643. if( nDefaultItemPos >= 0 )
  1644. pPopup->ItemDefaultSet(nDefaultItemPos);
  1646. INT nNextPos, nReplacePos =
  1647. pPopup->ItemFindPosForCmdID( ID_OLE_VERB_FIRST, -1 );
  1648. for( nNextPos = nReplacePos;
  1649. nReplacePos >= 0;
  1650. nNextPos = nReplacePos =
  1651. pPopup->ItemFindPosForCmdID( ID_OLE_VERB_FIRST, nNextPos + 1 )
  1652. )
  1653. {
  1654. CDrawOleObj * pDrawOleObj =
  1655. DYNAMIC_DOWNCAST(CDrawOleObj,pObj);
  1656. if( pDrawOleObj != NULL )
  1657. { // if menu for OLE object
  1658. // delete OLE verb entry
  1659. VERIFY( pPopup->ItemRemove( nReplacePos ) );
  1660. CMenu menu;
  1661. VERIFY( menu.CreatePopupMenu() );
  1662. ASSERT( menu.GetSafeHmenu() != NULL );
  1663. CMenu * pMenuPopup = &menu; // menu.GetSubMenu(0);
  1664. //ASSERT( pMenuPopup->GetSafeHmenu() != NULL );
  1665. VERIFY( pMenuPopup->AppendMenu( 0, ID_OLE_VERB_FIRST ) );
  1666. nNextPos ++;
  1667. UINT nConvertID = ID_OLE_EDIT_CONVERT;
  1668. AFX_CMDHANDLERINFO info;
  1669. if( ! pDoc->OnCmdMsg( ID_OLE_EDIT_CONVERT, CN_COMMAND, NULL, &info ) )
  1670. nConvertID = 0;
  1671. ASSERT( pDrawOleObj->m_pClientItem != NULL );
  1672. ASSERT( ::IsMenu( pMenuPopup->GetSafeHmenu() ) );
  1673. AfxOleSetEditMenu(
  1674. pDrawOleObj->m_pClientItem,
  1675. pMenuPopup, // &menu,
  1676. pMenuPopup->GetMenuItemCount() - 1, // First OLE cmd
  1677. ID_OLE_VERB_FIRST,
  1678. ID_OLE_VERB_LAST,
  1679. nConvertID
  1680. );
  1681. const CExtCmdIcon & _iconOLE =
  1682. g_CmdManager->CmdGetIcon(
  1683. g_CmdManager->ProfileNameFromWnd( GetSafeHwnd() ),
  1684. ID_OLE_INSERT_NEW
  1685. );
  1686. CString sOlePopupText;
  1687. pMenuPopup->GetMenuString(0,sOlePopupText,MF_BYPOSITION);
  1688. ASSERT( !sOlePopupText.IsEmpty() );
  1689. VERIFY(
  1690. pPopup->ItemInsert(
  1691. (UINT)CExtPopupMenuWnd::TYPE_POPUP,
  1692. nReplacePos,
  1693. (LPCTSTR)sOlePopupText,
  1694. _iconOLE
  1695. )
  1696. );
  1697. nNextPos ++;
  1698. pPopup->ItemSetDisplayed( nReplacePos, true );
  1699. CExtPopupMenuWnd * pOlePopup = pPopup->ItemGetPopup( nReplacePos );
  1700. ASSERT( pOlePopup != NULL );
  1701. if( pOlePopup != NULL )
  1702. {
  1703. if( ! pOlePopup->UpdateFromMenu(
  1704. AfxGetMainWnd()->GetSafeHwnd(),
  1705. &menu,
  1706. true,
  1707. false,
  1708. true
  1709. )
  1710. )
  1711. {
  1712. pPopup->ItemRemove( nReplacePos );
  1713. nNextPos ++;
  1714. }
  1715. else
  1716. pOlePopup->TrackFlagsSet( pOlePopup->TrackFlagsGet() | TPMX_NO_CMD_UI );
  1717. } // if( pOlePopup != NULL )
  1718. } // if menu for OLE object
  1719. else
  1720. { // if menu for internal object
  1721. // delete OLE verb entry
  1722. VERIFY( pPopup->ItemRemove( nReplacePos ) );
  1723. nNextPos --;
  1724. if( nReplacePos > 0
  1725. && pPopup->ItemGetCmdID( nReplacePos - 1 ) == ID_SEPARATOR
  1726. )
  1727. { // delete separator before OLE verb entry
  1728. VERIFY( pPopup->ItemRemove( nReplacePos - 1 ) );
  1729. nNextPos --;
  1730. } // delete separator before OLE verb entry
  1731. } // if menu for internal object
  1732. }
  1734. if( pObj != NULL )
  1735. {
  1736. CExtPopupColorMenuWnd * pColorPopup;
  1737. CString sNoColor;
  1739. nReplacePos =
  1740. pPopup->ItemFindPosForCmdID(ID_OBJECT_FILLCOLOR);
  1741. if( nReplacePos >= 0 )
  1742. {
  1743. VERIFY( sNoColor.LoadString(IDS_STRING_NO_COLOR_FILL) );
  1744. ASSERT( !sNoColor.IsEmpty() );
  1745. pColorPopup = new CExtPopupColorMenuWnd;
  1746. pColorPopup->m_sBtnTextColorDefault = sNoColor;
  1747. pColorPopup->m_lParamCookie = LPARAM(ID_OBJECT_FILLCOLOR);
  1748. pColorPopup->m_hWndNotifyColorChanged = GetSafeHwnd();
  1749. pColorPopup->m_clrDefault = COLORREF(-1);
  1750. pColorPopup->m_clrInitial =
  1751. pObj->IsNoFill() ? COLORREF(-1) : pObj->GetFillColor();
  1752. VERIFY(
  1753. pPopup->ItemInsertSpecPopup(
  1754. pColorPopup,
  1755. nReplacePos + 1,
  1756. pPopup->ItemGetText(nReplacePos),
  1757. pPopup->ItemGetIcon(nReplacePos)
  1758. )
  1759. );
  1760. pPopup->ItemSetDisplayed( nReplacePos + 1, true );
  1761. VERIFY( pPopup->ItemRemove(nReplacePos) );
  1762. } // if( nReplacePos >= 0 )
  1764. nReplacePos =
  1765. pPopup->ItemFindPosForCmdID(ID_OBJECT_LINECOLOR);
  1766. if( nReplacePos >= 0 )
  1767. {
  1768. VERIFY( sNoColor.LoadString(IDS_STRING_NO_COLOR_OUTLINE) );
  1769. ASSERT( !sNoColor.IsEmpty() );
  1770. pColorPopup = new CExtPopupColorMenuWnd;
  1771. pColorPopup->m_sBtnTextColorDefault = sNoColor;
  1772. //pColorPopup->m_bEnableBtnColorDefault = false;
  1773. pColorPopup->m_lParamCookie = LPARAM(ID_OBJECT_LINECOLOR);
  1774. pColorPopup->m_hWndNotifyColorChanged = GetSafeHwnd();
  1775. pColorPopup->m_clrDefault = COLORREF(-1);
  1776. pColorPopup->m_clrInitial =
  1777. pObj->IsNoOutline() ? COLORREF(-1) : pObj->GetLineColor();
  1778. VERIFY(
  1779. pPopup->ItemInsertSpecPopup(
  1780. pColorPopup,
  1781. nReplacePos + 1,
  1782. pPopup->ItemGetText(nReplacePos),
  1783. pPopup->ItemGetIcon(nReplacePos)
  1784. )
  1785. );
  1786. pPopup->ItemSetDisplayed( nReplacePos + 1, true );
  1787. VERIFY( pPopup->ItemRemove(nReplacePos) );
  1788. } // if( nReplacePos >= 0 )
  1790. } // if( pObj != NULL )
  1792. nReplacePos = pPopup->ItemFindByText( _T("Line &Width...") );
  1793. if( nReplacePos >= 0 )
  1794. {
  1795. const CExtCmdIcon & _icon =
  1796. g_CmdManager->CmdGetIcon(
  1797. g_CmdManager->ProfileNameFromWnd( GetSafeHwnd() ),
  1798. ID_DOC_LINE_WIDTH
  1799. );
  1800. pPopup->ItemSetPopupIcon( nReplacePos, _icon );
  1801. }
  1804. return TRUE;
  1805. }
  1807. LRESULT CDrawView::OnColorChangedFinally(WPARAM wParam, LPARAM lParam)
  1808. {
  1809. POSITION pos = m_selection.GetHeadPosition();
  1810. ASSERT( pos != NULL );
  1811. while( pos != NULL )
  1812. {
  1813. CDrawObj * pObj = m_selection.GetNext( pos );
  1814. ASSERT( pObj != NULL );
  1815. switch( lParam )
  1816. {
  1817. case ID_OBJECT_FILLCOLOR:
  1818. if( COLORREF(wParam) == COLORREF(-1) )
  1819. pObj->SetNoFill();
  1820. else
  1821. {
  1822. pObj->SetNoFill( FALSE );
  1823. pObj->SetFillColor( COLORREF(wParam) );
  1824. }
  1825. break;
  1826. case ID_OBJECT_LINECOLOR:
  1827. if( COLORREF(wParam) == COLORREF(-1) )
  1828. pObj->SetNoOutline();
  1829. else
  1830. {
  1831. pObj->SetNoOutline( FALSE );
  1832. pObj->SetLineColor( COLORREF(wParam) );
  1833. }
  1834. break;
  1835. } // switch( lParam )
  1836. }
  1837. Invalidate();
  1838. UpdateWindow();
  1839. SyncToolbarObjButtons();
  1840. return 0;
  1841. }
  1843. LRESULT CDrawView::OnColorSelectCustom(WPARAM wParam, LPARAM lParam)
  1844. {
  1845. wParam;
  1846. switch( lParam )
  1847. {
  1848. case ID_OBJECT_FILLCOLOR:
  1849. case ID_OBJECT_LINECOLOR:
  1850. PostMessage(WM_COMMAND,lParam,0);
  1851. break;
  1852. } // switch( lParam )
  1853. return 0;
  1854. }
  1856. void CDrawView::OnUpdateSelectionSingle(CCmdUI* pCmdUI)
  1857. {
  1858. if( IsPrintPreviewMode() )
  1859. {
  1860. pCmdUI->Enable( FALSE );
  1861. return;
  1862. }
  1863. int nSelCount = int( m_selection.GetCount() );
  1864. pCmdUI->Enable( nSelCount == 1 );
  1865. }
  1867. void CDrawView::OnUpdateSelectionNonEmpty(CCmdUI* pCmdUI)
  1868. {
  1869. if( IsPrintPreviewMode() )
  1870. {
  1871. pCmdUI->Enable( FALSE );
  1872. return;
  1873. }
  1874. int nSelCount = int( m_selection.GetCount() );
  1875. pCmdUI->Enable( nSelCount > 0 );
  1876. }
  1878. void CDrawView::OnLineWidth( UINT nCmdID )
  1879. {
  1880. ASSERT( ID_LINE_WIDTH_0 <= nCmdID && nCmdID <= ID_LINE_WIDTH_OTHER );
  1881. #ifdef _DEBUG
  1882. int nSelCount = int( m_selection.GetCount() );
  1883. ASSERT( nSelCount > 0 );
  1884. #endif // _DEBUG
  1886. POSITION pos = m_selection.GetHeadPosition();
  1887. ASSERT( pos != NULL );
  1889. while( pos != NULL )
  1890. {
  1891. CDrawObj * pObj = m_selection.GetNext( pos );
  1892. ASSERT( pObj != NULL );
  1894. switch( nCmdID )
  1895. {
  1896. case ID_LINE_WIDTH_OTHER:
  1897. ASSERT( nSelCount == 1 );
  1898. if( CDrawTool::c_drawShape == selection )
  1899. PostMessage( WM_COMMAND, ID_EDIT_PROPERTIES );
  1900. return;
  1901. case ID_LINE_WIDTH_0:
  1902. pObj->SetNoOutline( TRUE );
  1903. break;
  1904. default:
  1905. {
  1906. ASSERT( ID_LINE_WIDTH_1 <= nCmdID && nCmdID <= ID_LINE_WIDTH_10 );
  1907. UINT nLineWidth = nCmdID - ID_LINE_WIDTH_0;
  1908. ASSERT( 1 <= nLineWidth && nLineWidth <= 10 );
  1909. pObj->SetNoOutline( FALSE );
  1910. pObj->m_logpen.lopnWidth.x = nLineWidth;
  1911. pObj->m_logpen.lopnWidth.y = nLineWidth;
  1912. }
  1913. break;
  1914. } // switch( nCmdID )
  1916. } // while( pos != NULL )
  1918. Invalidate();
  1919. }
  1921. void CDrawView::OnUpdateLineWidth( CCmdUI * pCmdUI )
  1922. {
  1923. ASSERT( pCmdUI != NULL );
  1924. if( IsPrintPreviewMode() )
  1925. {
  1926. pCmdUI->SetRadio( 0 );
  1927. pCmdUI->Enable( FALSE );
  1928. return;
  1929. }
  1930. UINT nCmdID = pCmdUI->m_nID;
  1931. ASSERT( ID_LINE_WIDTH_0 <= nCmdID && nCmdID <= ID_LINE_WIDTH_OTHER );
  1932. int nSelCount = int( m_selection.GetCount() );
  1934. CDrawObj * pObj = NULL;
  1935. if( nSelCount > 0 )
  1936. {
  1937. POSITION pos = m_selection.GetHeadPosition();
  1938. ASSERT( pos != NULL );
  1939. pObj = m_selection.GetNext( pos );
  1940. ASSERT( pObj != NULL );
  1941. }
  1942. else
  1943. {
  1944. pCmdUI->Enable( FALSE );
  1945. pCmdUI->SetRadio( FALSE );
  1946. }
  1948. if( nCmdID == ID_LINE_WIDTH_OTHER )
  1949. {
  1950. pCmdUI->Enable( nSelCount == 1 && m_selection.GetCount() == 1 && CDrawTool::c_drawShape == selection );
  1951. if( pObj != NULL )
  1952. pCmdUI->SetRadio( pObj->m_logpen.lopnWidth.x > 10 );
  1953. return;
  1954. }
  1956. pCmdUI->Enable( nSelCount > 0 );
  1958. if( nCmdID == ID_LINE_WIDTH_0 )
  1959. {
  1960. if( pObj != NULL )
  1961. pCmdUI->SetRadio( pObj->IsNoOutline() );
  1962. return;
  1963. }
  1965. ASSERT( ID_LINE_WIDTH_1 <= nCmdID && nCmdID <= ID_LINE_WIDTH_10 );
  1966. UINT nLineWidth = nCmdID - ID_LINE_WIDTH_0;
  1967. ASSERT( 1 <= nLineWidth && nLineWidth <= 10 );
  1968. pCmdUI->Enable( nSelCount > 0 );
  1969. if( pObj != NULL )
  1970. pCmdUI->SetRadio( UINT(pObj->m_logpen.lopnWidth.x) == nLineWidth );
  1972. }
  1974. LRESULT CDrawView::OnDrawPopupMenuItem(WPARAM wParam, LPARAM lParam)
  1975. {
  1976. wParam;
  1978. CExtPopupMenuWnd::DRAWITEMDATA * pDrawItemData =
  1979. reinterpret_cast < CExtPopupMenuWnd::DRAWITEMDATA * > ( lParam );
  1980. ASSERT( pDrawItemData != NULL );
  1981. UINT nCmdID = pDrawItemData->GetCmdID();
  1982. if( ! ( ID_LINE_WIDTH_1 <= nCmdID && nCmdID <= ID_LINE_WIDTH_10 ) )
  1983. return FALSE; // default painting
  1985. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  1986. const CExtCustomizeCmdTreeNode * pNode =
  1987. pDrawItemData->m_pItemData->GetCmdNode();
  1988. if( pNode != NULL )
  1989. {
  1990. ASSERT_VALID( pNode );
  1991. if( (pNode->GetFlags() & __ECTN_TBB_SEPARATED_DROPDOWN) != 0 )
  1992. return FALSE;
  1993. } // if( pNode != NULL )
  1994. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  1997. // paint default menu item background
  1998. pDrawItemData->PaintDefault(
  1999. false,
  2000. true,
  2001. false,
  2002. false,
  2003. false
  2004. );
  2007. UINT nLineWidth = nCmdID - ID_LINE_WIDTH_0;
  2008. ASSERT( 1 <= nLineWidth && nLineWidth <= 10 );
  2010. INT nIconAreaWidth = g_PaintManager->GetMenuIconAreaWidth();
  2011. if( nIconAreaWidth < 0 )
  2012. {
  2013. nIconAreaWidth = __EXT_MENU_ICON_CX + __EXT_MENU_GAP * 2;
  2014. nIconAreaWidth = g_PaintManager->UiScalingDo( nIconAreaWidth, CExtPaintManager::__EUIST_X );
  2015. } 
  2017. bool bRTL = pDrawItemData->m_pPopup->OnQueryLayoutRTL();
  2018. CRect rcItem = LPCRECT(*pDrawItemData);
  2019. if( bRTL )
  2020. rcItem.DeflateRect( 2, 0, nIconAreaWidth + 4, 0 );
  2021. else
  2022. rcItem.DeflateRect( nIconAreaWidth + 4, 0, 2, 0 );
  2023. rcItem.top += rcItem.Height()/2;
  2024. rcItem.top -= nLineWidth/2;
  2025. rcItem.bottom = rcItem.top + nLineWidth;
  2027. // get draw DC
  2028. CDC & dc = *( (CDC *) *pDrawItemData );
  2030. dc.FillSolidRect(
  2031. &rcItem,
  2032. g_PaintManager->GetColor(
  2033. (m_selection.GetCount() > 0)
  2034. ? COLOR_3DDKSHADOW
  2035. : COLOR_3DSHADOW
  2036. ,
  2037. this
  2038. )
  2039. );
  2041. return TRUE;
  2042. }
  2044. void CDrawView::OnUpdateDocLineWidth(CCmdUI* pCmdUI) 
  2045. {
  2046. if( IsPrintPreviewMode() )
  2047. {
  2048. pCmdUI->Enable( FALSE );
  2049. return;
  2050. }
  2051. pCmdUI->Enable( m_selection.GetCount() > 0 );
  2052. }
  2054. void CDrawView::SyncToolbarObjButtons()
  2055. {
  2056. if( IsPrintPreviewMode() )
  2057. return;
  2058. CFrameWnd * pFrame = GetParentFrame();
  2059. ASSERT_VALID( pFrame );
  2060. if( pFrame->IsKindOf( RUNTIME_CLASS(CMDIChildWnd) ) )
  2061. {
  2062. CMainFrame * pMainFrame = (CMainFrame *)pFrame->GetParentFrame();
  2063. ASSERT_VALID( pMainFrame );
  2064. ASSERT_KINDOF( CMainFrame, pMainFrame );
  2065. int nSelCount = int( m_selection.GetCount() );
  2066. CDrawObj * pObj = NULL;
  2067. if( nSelCount > 0 )
  2068. {
  2069. POSITION pos = m_selection.GetHeadPosition();
  2070. ASSERT( pos != NULL );
  2071. pObj = m_selection.GetNext( pos );
  2072. ASSERT( pObj != NULL );
  2073. } // if( nSelCount > 0 )
  2074. #if (defined __EXT_MFC_NO_CUSTOMIZE)
  2075. if( pObj != NULL )
  2076. {
  2077. if( pMainFrame->m_pBtnColorFillS != NULL
  2078. && pMainFrame->m_pBtnColorFillS->ColorGet(true)
  2079. != pObj->GetFillColor()
  2080. )
  2081. {
  2082. ASSERT_VALID( pMainFrame->m_pBtnColorFillS );
  2083. ASSERT( pMainFrame->m_pBtnColorFillP != NULL );
  2084. ASSERT_VALID( pMainFrame->m_pBtnColorFillS );
  2085. pMainFrame->m_pBtnColorFillS->ColorSet(
  2086. pObj->IsNoFill() ? COLORREF(-1) : pObj->GetFillColor(),
  2087. false
  2088. );
  2089. pMainFrame->m_pBtnColorFillP->ColorSet(
  2090. pObj->IsNoFill() ? COLORREF(-1) : pObj->GetFillColor(),
  2091. false
  2092. );
  2093. pMainFrame->m_pBtnColorFillS->ColorSet(
  2094. COLORREF(-1),
  2095. true
  2096. );
  2097. pMainFrame->m_pBtnColorFillP->ColorSet(
  2098. COLORREF(-1),
  2099. true
  2100. );
  2101. pMainFrame->m_pBtnColorFillS->RedrawButton();
  2102. pMainFrame->m_pBtnColorFillP->RedrawButton();
  2103. }
  2104. if( pMainFrame->m_pBtnColorOutlineS != NULL
  2105. && pMainFrame->m_pBtnColorOutlineS->ColorGet(false)
  2106. != pObj->GetLineColor()
  2107. )
  2108. {
  2109. ASSERT_VALID( pMainFrame->m_pBtnColorOutlineS );
  2110. ASSERT( pMainFrame->m_pBtnColorOutlineP != NULL );
  2111. ASSERT_VALID( pMainFrame->m_pBtnColorOutlineP );
  2112. pMainFrame->m_pBtnColorOutlineS->ColorSet(
  2113. pObj->IsNoOutline() ? COLORREF(-1) : pObj->GetLineColor(),
  2114. false
  2115. );
  2116. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2117. pObj->IsNoOutline() ? COLORREF(-1) : pObj->GetLineColor(),
  2118. false
  2119. );
  2120. pMainFrame->m_pBtnColorOutlineS->ColorSet(
  2121. COLORREF(-1),
  2122. true
  2123. );
  2124. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2125. COLORREF(-1),
  2126. true
  2127. );
  2128. pMainFrame->m_pBtnColorOutlineS->RedrawButton();
  2129. pMainFrame->m_pBtnColorOutlineP->RedrawButton();
  2130. }
  2132. CExtBarButton * pTBB =
  2133. pMainFrame->m_wndToolBarStandard.GetButton(
  2134. pMainFrame->m_wndToolBarStandard.CommandToIndex(
  2135. ID_DOC_LINE_WIDTH
  2136. )
  2137. );
  2138. ASSERT_VALID( pTBB );
  2139. UINT nCmdID = pTBB->GetCmdID( true );
  2140. ASSERT( ID_LINE_WIDTH_0 <= nCmdID && nCmdID <= ID_LINE_WIDTH_OTHER );
  2142. UINT nAdjustCmdID = ID_LINE_WIDTH_0;
  2143. if( !pObj->IsNoOutline() )
  2144. {
  2145. UINT xw = (UINT)pObj->m_logpen.lopnWidth.x;
  2146. if( xw <= 10 )
  2147. {
  2148. ASSERT( xw > 0 );
  2149. nAdjustCmdID = ID_LINE_WIDTH_0 + xw;
  2150. ASSERT( ID_LINE_WIDTH_1 <= nAdjustCmdID && nAdjustCmdID <= ID_LINE_WIDTH_10 );
  2151. }
  2152. else
  2153. nAdjustCmdID = ID_LINE_WIDTH_OTHER;
  2154. }
  2156. if( nCmdID != nAdjustCmdID )
  2157. pTBB->SetCmdID( nAdjustCmdID, true, true );
  2158. } // if( pObj != NULL )
  2160. #else // (defined __EXT_MFC_NO_CUSTOMIZE)
  2162. if( pObj != NULL )
  2163. {
  2164. if( pMainFrame->m_pBtnColorFillP != NULL
  2165. && pMainFrame->m_pBtnColorFillP->ColorGet(true)
  2166. != pObj->GetFillColor()
  2167. )
  2168. {
  2169. ASSERT_VALID( pMainFrame->m_pBtnColorFillP );
  2170. pMainFrame->m_pBtnColorFillP->ColorSet(
  2171. pObj->IsNoFill() ? COLORREF(-1) : pObj->GetFillColor(),
  2172. false
  2173. );
  2174. pMainFrame->m_pBtnColorFillP->ColorSet(
  2175. COLORREF(-1),
  2176. true
  2177. );
  2178. pMainFrame->m_pBtnColorFillP->RedrawButton();
  2179. }
  2180. if( pMainFrame->m_pBtnColorOutlineP != NULL
  2181. && pMainFrame->m_pBtnColorOutlineP->ColorGet(false)
  2182. != pObj->GetLineColor()
  2183. )
  2184. {
  2185. ASSERT_VALID( pMainFrame->m_pBtnColorOutlineP );
  2186. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2187. pObj->IsNoOutline() ? COLORREF(-1) : pObj->GetLineColor(),
  2188. false
  2189. );
  2190. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2191. COLORREF(-1),
  2192. true
  2193. );
  2194. pMainFrame->m_pBtnColorOutlineP->RedrawButton();
  2195. }
  2196. } // if( pObj != NULL )
  2198. pMainFrame->RedrawCommandItems( ID_OBJECT_FILLCOLOR ); 
  2199. pMainFrame->RedrawCommandItems( ID_OBJECT_LINECOLOR ); 
  2200. pMainFrame->RedrawCommandItems( ID_LINE_WIDTH_OTHER ); 
  2202. #endif // not - (defined __EXT_MFC_NO_CUSTOMIZE)
  2203. return;
  2204. } // if( pFrame->IsKindOf( RUNTIME_CLASS(CMDIChildWnd) ) );
  2205. else if( pFrame->IsKindOf( RUNTIME_CLASS(CDrawInPlaceFrame) ) )
  2206. {
  2207. CDrawInPlaceFrame * pMainFrame = (CDrawInPlaceFrame*)pFrame;
  2208. ASSERT_VALID( pMainFrame );
  2209. ASSERT_KINDOF( CDrawInPlaceFrame, pMainFrame );
  2210. int nSelCount = int( m_selection.GetCount() );
  2211. CDrawObj * pObj = NULL;
  2212. if( nSelCount > 0 )
  2213. {
  2214. POSITION pos = m_selection.GetHeadPosition();
  2215. ASSERT( pos != NULL );
  2216. pObj = m_selection.GetNext( pos );
  2217. ASSERT( pObj != NULL );
  2218. } // if( nSelCount > 0 )
  2219. if( pObj != NULL )
  2220. {
  2221. if( pMainFrame->m_pBtnColorFillS != NULL
  2222. && pMainFrame->m_pBtnColorFillS->ColorGet(true)
  2223. != pObj->GetFillColor()
  2224. )
  2225. {
  2226. ASSERT_VALID( pMainFrame->m_pBtnColorFillS );
  2227. ASSERT( pMainFrame->m_pBtnColorFillP != NULL );
  2228. ASSERT_VALID( pMainFrame->m_pBtnColorFillS );
  2229. pMainFrame->m_pBtnColorFillS->ColorSet(
  2230. pObj->IsNoFill() ? COLORREF(-1) : pObj->GetFillColor(),
  2231. false
  2232. );
  2233. pMainFrame->m_pBtnColorFillP->ColorSet(
  2234. pObj->IsNoFill() ? COLORREF(-1) : pObj->GetFillColor(),
  2235. false
  2236. );
  2237. pMainFrame->m_pBtnColorFillS->ColorSet(
  2238. COLORREF(-1),
  2239. true
  2240. );
  2241. pMainFrame->m_pBtnColorFillP->ColorSet(
  2242. COLORREF(-1),
  2243. true
  2244. );
  2245. pMainFrame->m_pBtnColorFillS->RedrawButton();
  2246. pMainFrame->m_pBtnColorFillP->RedrawButton();
  2247. }
  2248. if( pMainFrame->m_pBtnColorOutlineS != NULL
  2249. && pMainFrame->m_pBtnColorOutlineS->ColorGet(false)
  2250. != pObj->GetLineColor()
  2251. )
  2252. {
  2253. ASSERT_VALID( pMainFrame->m_pBtnColorOutlineS );
  2254. ASSERT( pMainFrame->m_pBtnColorOutlineP != NULL );
  2255. ASSERT_VALID( pMainFrame->m_pBtnColorOutlineP );
  2256. pMainFrame->m_pBtnColorOutlineS->ColorSet(
  2257. pObj->IsNoOutline() ? COLORREF(-1) : pObj->GetLineColor(),
  2258. false
  2259. );
  2260. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2261. pObj->IsNoOutline() ? COLORREF(-1) : pObj->GetLineColor(),
  2262. false
  2263. );
  2264. pMainFrame->m_pBtnColorOutlineS->ColorSet(
  2265. COLORREF(-1),
  2266. true
  2267. );
  2268. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2269. COLORREF(-1),
  2270. true
  2271. );
  2272. pMainFrame->m_pBtnColorOutlineS->RedrawButton();
  2273. pMainFrame->m_pBtnColorOutlineP->RedrawButton();
  2274. }
  2276. CExtBarButton * pTBB =
  2277. pMainFrame->m_wndToolBarStandard.GetButton(
  2278. pMainFrame->m_wndToolBarStandard.CommandToIndex(
  2279. ID_DOC_LINE_WIDTH
  2280. )
  2281. );
  2282. ASSERT_VALID( pTBB );
  2283. UINT nCmdID = pTBB->GetCmdID( true );
  2284. ASSERT( ID_LINE_WIDTH_0 <= nCmdID && nCmdID <= ID_LINE_WIDTH_OTHER );
  2286. UINT nAdjustCmdID = ID_LINE_WIDTH_0;
  2287. if( !pObj->IsNoOutline() )
  2288. {
  2289. UINT xw = (UINT)pObj->m_logpen.lopnWidth.x;
  2290. if( xw <= 10 )
  2291. {
  2292. ASSERT( xw > 0 );
  2293. nAdjustCmdID = ID_LINE_WIDTH_0 + xw;
  2294. ASSERT( ID_LINE_WIDTH_1 <= nAdjustCmdID && nAdjustCmdID <= ID_LINE_WIDTH_10 );
  2295. }
  2296. else
  2297. nAdjustCmdID = ID_LINE_WIDTH_OTHER;
  2298. }
  2300. if( nCmdID != nAdjustCmdID )
  2301. pTBB->SetCmdID( nAdjustCmdID, true, true );
  2302. } // if( pObj != NULL )
  2304. return;
  2305. } // else if( pFrame->IsKindOf( RUNTIME_CLASS(CDrawInPlaceFrame) ) )
  2308. /*
  2309. #if (defined __EXT_MFC_NO_CUSTOMIZE)
  2310. if( pObj != NULL )
  2311. {
  2312. if( pMainFrame->m_pBtnColorFillS != NULL
  2313. && pMainFrame->m_pBtnColorFillS->ColorGet(true)
  2314. != pObj->GetFillColor()
  2315. )
  2316. {
  2317. ASSERT_VALID( pMainFrame->m_pBtnColorFillS );
  2318. ASSERT( pMainFrame->m_pBtnColorFillP != NULL );
  2319. ASSERT_VALID( pMainFrame->m_pBtnColorFillS );
  2320. pMainFrame->m_pBtnColorFillS->ColorSet(
  2321. pObj->IsNoFill() ? COLORREF(-1) : pObj->GetFillColor(),
  2322. false
  2323. );
  2324. pMainFrame->m_pBtnColorFillP->ColorSet(
  2325. pObj->IsNoFill() ? COLORREF(-1) : pObj->GetFillColor(),
  2326. false
  2327. );
  2328. pMainFrame->m_pBtnColorFillS->ColorSet(
  2329. COLORREF(-1),
  2330. true
  2331. );
  2332. pMainFrame->m_pBtnColorFillP->ColorSet(
  2333. COLORREF(-1),
  2334. true
  2335. );
  2336. pMainFrame->m_pBtnColorFillS->RedrawButton();
  2337. pMainFrame->m_pBtnColorFillP->RedrawButton();
  2338. }
  2339. if( pMainFrame->m_pBtnColorOutlineS != NULL
  2340. && pMainFrame->m_pBtnColorOutlineS->ColorGet(false)
  2341. != pObj->GetLineColor()
  2342. )
  2343. {
  2344. ASSERT_VALID( pMainFrame->m_pBtnColorOutlineS );
  2345. ASSERT( pMainFrame->m_pBtnColorOutlineP != NULL );
  2346. ASSERT_VALID( pMainFrame->m_pBtnColorOutlineP );
  2347. pMainFrame->m_pBtnColorOutlineS->ColorSet(
  2348. pObj->IsNoOutline() ? COLORREF(-1) : pObj->GetLineColor(),
  2349. false
  2350. );
  2351. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2352. pObj->IsNoOutline() ? COLORREF(-1) : pObj->GetLineColor(),
  2353. false
  2354. );
  2355. pMainFrame->m_pBtnColorOutlineS->ColorSet(
  2356. COLORREF(-1),
  2357. true
  2358. );
  2359. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2360. COLORREF(-1),
  2361. true
  2362. );
  2363. pMainFrame->m_pBtnColorOutlineS->RedrawButton();
  2364. pMainFrame->m_pBtnColorOutlineP->RedrawButton();
  2365. }
  2367. CExtBarButton * pTBB =
  2368. pMainFrame->m_wndToolBarStandard.GetButton(
  2369. pMainFrame->m_wndToolBarStandard.CommandToIndex(
  2370. ID_DOC_LINE_WIDTH
  2371. )
  2372. );
  2373. ASSERT_VALID( pTBB );
  2374. UINT nCmdID = pTBB->GetCmdID( true );
  2375. ASSERT( ID_LINE_WIDTH_0 <= nCmdID && nCmdID <= ID_LINE_WIDTH_OTHER );
  2377. UINT nAdjustCmdID = ID_LINE_WIDTH_0;
  2378. if( !pObj->IsNoOutline() )
  2379. {
  2380. UINT xw = (UINT)pObj->m_logpen.lopnWidth.x;
  2381. if( xw <= 10 )
  2382. {
  2383. ASSERT( xw > 0 );
  2384. nAdjustCmdID = ID_LINE_WIDTH_0 + xw;
  2385. ASSERT( ID_LINE_WIDTH_1 <= nAdjustCmdID && nAdjustCmdID <= ID_LINE_WIDTH_10 );
  2386. }
  2387. else
  2388. nAdjustCmdID = ID_LINE_WIDTH_OTHER;
  2389. }
  2391. if( nCmdID != nAdjustCmdID )
  2392. pTBB->SetCmdID( nAdjustCmdID, true, true );
  2393. } // if( pObj != NULL )
  2395. #else // (defined __EXT_MFC_NO_CUSTOMIZE)
  2397. if( pObj != NULL )
  2398. {
  2399. if( pMainFrame->m_pBtnColorFillP != NULL
  2400. && pMainFrame->m_pBtnColorFillP->ColorGet(true)
  2401. != pObj->GetFillColor()
  2402. )
  2403. {
  2404. ASSERT_VALID( pMainFrame->m_pBtnColorFillP );
  2405. pMainFrame->m_pBtnColorFillP->ColorSet(
  2406. pObj->IsNoFill() ? COLORREF(-1) : pObj->GetFillColor(),
  2407. false
  2408. );
  2409. pMainFrame->m_pBtnColorFillP->ColorSet(
  2410. COLORREF(-1),
  2411. true
  2412. );
  2413. pMainFrame->m_pBtnColorFillP->RedrawButton();
  2414. }
  2415. if( pMainFrame->m_pBtnColorOutlineP != NULL
  2416. && pMainFrame->m_pBtnColorOutlineP->ColorGet(false)
  2417. != pObj->GetLineColor()
  2418. )
  2419. {
  2420. ASSERT_VALID( pMainFrame->m_pBtnColorOutlineP );
  2421. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2422. pObj->IsNoOutline() ? COLORREF(-1) : pObj->GetLineColor(),
  2423. false
  2424. );
  2425. pMainFrame->m_pBtnColorOutlineP->ColorSet(
  2426. COLORREF(-1),
  2427. true
  2428. );
  2429. pMainFrame->m_pBtnColorOutlineP->RedrawButton();
  2430. }
  2431. } // if( pObj != NULL )
  2433. pMainFrame->RedrawCommandItems( ID_OBJECT_FILLCOLOR ); 
  2434. pMainFrame->RedrawCommandItems( ID_OBJECT_LINECOLOR ); 
  2435. pMainFrame->RedrawCommandItems( ID_LINE_WIDTH_OTHER ); 
  2437. #endif // not - (defined __EXT_MFC_NO_CUSTOMIZE)
  2438. */
  2439. }
  2441. // The following command handler provides the standard keyboard
  2442. //  user interface to cancel an in-place editing session.  Here,
  2443. //  the container (not the server) causes the deactivation.
  2444. void CDrawView::OnCancelEditCntr()
  2445. {
  2446. // Close any in-place active item on this view.
  2447. COleClientItem* pActiveItem = GetDocument()->GetInPlaceActiveItem(this);
  2448. if (pActiveItem != NULL)
  2449. {
  2450. pActiveItem->Close();
  2451. }
  2452. ASSERT(GetDocument()->GetInPlaceActiveItem(this) == NULL);
  2453. }
  2455. // The following command handler provides the standard keyboard
  2456. //  user interface to cancel an in-place editing session.  Here,
  2457. //  the server (not the container) causes the deactivation.
  2458. void CDrawView::OnCancelEditSrvr()
  2459. {
  2460. GetDocument()->OnDeactivateUI(FALSE);
  2461. }