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

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

Windows编程

开发平台：

Visual C++

SVRVIEW.CPP：源码内容
  1. // svrview.cpp : implementation of the CServerView class
  2. //
  3. // This is a part of the Microsoft Foundation Classes C++ library.
  4. // Copyright (C) 1992-1995 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 Microsoft
  9. // QuickHelp and/or WinHelp documentation provided with the library.
  10. // See these sources for detailed information regarding the
  11. // Microsoft Foundation Classes product.
  13. #include "stdafx.h"
  14. #include "afxdlgs.h"        // for FileOpen
  15. #include "$$root$$.h"
  17. #include "svrdoc.h"
  18. #include "svrview.h"
  19. #include "svritem.h"
  20. #include "zoomdlg.h"
  21. $$IF(WANTS_TEXTVIEW)
  22. #include "textview.h"
  23. $$ENDIF
  25. #ifdef _DEBUG
  26. #undef THIS_FILE
  27. static char BASED_CODE THIS_FILE[] = __FILE__;
  28. #endif
  30. CServerNode* NEAR CServerView::m_pDragNode = NULL;
  32. static int ReadString(CArchive& ar, char* pString, int nMaxLen);
  33. static BOOL FindItemRect(CDC* pDC, CServerNode* pItemFind, LPRECT lpRect,
  34. CPoint& ptStart, CServerNode* pRoot);
  35. static CServerNode* HitDetect(CDC* pDC, CPoint point,
  36. CPoint& ptStart, CServerNode* pRoot);
  38. /////////////////////////////////////////////////////////////////////////////
  39. // support for zooming
  41. static int NEAR rgiZoomFactor[] =
  42. {
  43. 25, 50, 75, 100, 125, 150, 175, 200, 250, 300
  44. };
  46. /////////////////////////////////////////////////////////////////////////////
  47. // CServerView
  49. IMPLEMENT_DYNCREATE(CServerView, CScrollView)
  51. BEGIN_MESSAGE_MAP(CServerView, CScrollView)
  52. //{{AFX_MSG_MAP(CServerView)
  53. ON_COMMAND(ID_CHANGE_NAME, OnChangeName)
  54. ON_COMMAND(ID_ADD_NODE, OnAddNode)
  55. ON_UPDATE_COMMAND_UI(ID_CHANGE_NAME, OnUpdateHasSel)
  56. ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  57. ON_WM_LBUTTONDOWN()
  58. ON_WM_RBUTTONDOWN()
  59. ON_COMMAND(ID_IMPORT_TEXT, OnImportText)
  60. ON_COMMAND(ID_VIEW_ZOOMCUSTOM, OnViewZoomCustom)
  61. ON_COMMAND(ID_EDIT_CUT, OnEditCut)
  62. ON_WM_LBUTTONDBLCLK()
  63. ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
  64. ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
  65. ON_WM_CREATE()
  66. ON_COMMAND(ID_EDIT_CLEAR, OnEditClear)
  67. ON_COMMAND(ID_TREE_COLLAPSEBRANCH, OnTreeCollapsebranch)
  68. ON_COMMAND(ID_TREE_EXPANDALL, OnTreeExpandall)
  69. ON_COMMAND(ID_TREE_EXPANDBRANCH, OnTreeExpandbranch)
  70. ON_COMMAND(ID_TREE_EXPANDONELEVEL, OnTreeExpandonelevel)
  71. ON_UPDATE_COMMAND_UI(ID_TREE_COLLAPSEBRANCH, OnUpdateTreeCollapsebranch)
  72. ON_UPDATE_COMMAND_UI(ID_TREE_EXPANDONELEVEL, OnUpdateTreeExpandonelevel)
  73. ON_UPDATE_COMMAND_UI(ID_TREE_EXPANDALL, OnUpdateTreeExpandall)
  74. ON_UPDATE_COMMAND_UI(ID_TREE_EXPANDBRANCH, OnUpdateTreeExpandbranch)
  75. ON_WM_KEYDOWN()
  76. ON_UPDATE_COMMAND_UI(ID_ADD_NODE, OnUpdateHasSel)
  77. ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateHasSel)
  78. ON_UPDATE_COMMAND_UI(ID_IMPORT_TEXT, OnUpdateHasSel)
  79. ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateHasSel)
  80. ON_UPDATE_COMMAND_UI(ID_EDIT_CLEAR, OnUpdateHasSel)
  81. $$IF(WANTS_TEXTVIEW)
  82. ON_COMMAND(ID_VIEW_TEXT_VIEW, OnViewTextView)
  83. $$ENDIF
  84. ON_WM_SIZE()
  85. //}}AFX_MSG_MAP
  86. ON_COMMAND_RANGE(ID_VIEW_ZOOM25, ID_VIEW_ZOOM300, OnZoom)
  87. ON_UPDATE_COMMAND_UI_RANGE(ID_VIEW_ZOOM25, ID_VIEW_ZOOM300, OnUpdateZoom)
  88. END_MESSAGE_MAP()
  90. /////////////////////////////////////////////////////////////////////////////
  91. // CServerView construction/destruction
  93. CServerView::CServerView()
  94. {
  95. m_pSelectedNode = NULL;
  96. m_ptStart = CPoint(CX_MARGIN, CY_MARGIN);   // upper left position
  98. // initialize zoom state (100% from size cache)
  99. m_zoomNum = CSize(100, 100);
  100. m_zoomDenom = CSize(100, 100);
  101. m_prevDropEffect = DROPEFFECT_NONE;
  102. }
  104. CServerView::~CServerView()
  105. {
  106. }
  108. /////////////////////////////////////////////////////////////////////////////
  109. // Attributes -- public
  111. void CServerView::SetSelection(CServerNode* pNewSel, CDC* pDC)
  112. {
  113. if (pNewSel == m_pSelectedNode)
  114. return;     // already set
  115. InvalidateItem(m_pSelectedNode, pDC);
  116. m_pSelectedNode = pNewSel;
  117. InvalidateItem(m_pSelectedNode, pDC);
  118. }
  120. void CServerView::SetSelection(CServerNode* pNewSel)
  121. {
  122. CServerDC dc(this);
  123. SetSelection(pNewSel, &dc);
  124. }
  126. /////////////////////////////////////////////////////////////////////////////
  127. // Operations -- public
  129. void CServerView::SetScrollInfo()
  130. {
  131. CServerNode* pRoot = GetDocument()->m_pRoot;
  132. ASSERT(pRoot != NULL);
  134. //BLOCK: determine new scrolling sizes
  135. CSize sizeLine;
  136. CSize sizePage;
  137. CSize sizeTotal;
  138. {
  139. CServerDC dc(this);
  141. pRoot->CalcNodeSize(&dc, sizeLine);
  142. sizeLine.cx = sizeDefault.cx;
  143. sizeLine.cy += CY_SEPARATOR;
  144. sizePage.cx = sizeDefault.cx;
  145. sizePage.cy = sizeLine.cy * 10;
  147. // set the scroll sizes dependent on the zoom factor
  148. dc.LPtoDP(&sizePage);
  149. dc.LPtoDP(&sizeLine);
  150. sizeTotal = CalcActualViewSize(&dc);
  151. // subtract out the right and bottom margins
  152. // these are not interesting and this way we avoid
  153. // some problems with nonlinear scaling of fonts
  154. CSize sizeMargin(CX_MARGIN, CY_MARGIN);
  155. CRect rect(CPoint(0, 0), sizeMargin);
  156. dc.LPtoDP(rect);
  157. sizeTotal -= rect.Size();
  158. }
  160. SetScrollSizes(MM_TEXT, sizeTotal, sizePage, sizeLine);
  161. }
  163. BOOL CServerView::SetZoomFactor(CSize zoomNum, CSize zoomDenom)
  164. {
  165. if (zoomDenom != m_zoomDenom || zoomNum != m_zoomNum)
  166. {
  167. // sync to new zoom factor
  168. m_zoomNum = zoomNum;
  169. m_zoomDenom = zoomDenom;
  171. // resync to new sizes
  172. Invalidate();
  173. return TRUE;
  174. }
  175. return FALSE;
  176. }
  178. void CServerView::UpdateServerView()
  179. {
  180. CServerDoc* pDoc = GetDocument();
  181. pDoc->SetModifiedFlag();
  182. pDoc->UpdateAllItems(NULL);
  183. pDoc->UpdateAllViews(NULL);
  184. }
  186. CSize CServerView::CalcActualViewSize(CDC *pDC)
  187. {
  188. return CalcActualItemSize(GetDocument()->m_pRoot, pDC);
  189. }
  191. CSize CServerView::CalcActualItemSize(CServerNode* pItem, CDC *pDC)
  192. {
  193. CSize sizeTotal(0, 0);
  194. CPoint ptStart = m_ptStart;
  195. pItem->CalcBounding(pDC, ptStart, sizeTotal);
  196. sizeTotal.cx += CX_MARGIN;
  197. // sizeTotal is the extent in logical coords
  198. // convert from logical to device
  199. CRect rc(CPoint(0,0),sizeTotal);
  200. pDC->LPtoDP(rc);
  201. return rc.Size();
  202. }
  204. CSize CServerView::CalcScaledViewSize()
  205. {
  206. return CalcScaledItemSize(GetDocument()->m_pRoot);
  207. }
  209. CSize CServerView::CalcScaledItemSize(CServerNode* pItem)
  210. {
  211. CServerDC dc(this);
  212. // set extent to 100%
  213. dc.SetViewportExt(CSize(1,1));
  214. dc.SetWindowExt(CSize(1,1));
  216. CSize sizeTotal(0, 0);
  217. CPoint ptStart = m_ptStart;
  218. pItem->CalcBounding(&dc, ptStart, sizeTotal);
  219. sizeTotal.cx += CX_MARGIN;
  220. // sizeTotal is the native extent in device coords
  221. sizeTotal.cx = MulDiv(sizeTotal.cx,m_zoomNum.cx,m_zoomDenom.cx);
  222. sizeTotal.cy = MulDiv(sizeTotal.cy,m_zoomNum.cy,m_zoomDenom.cy);
  223. return sizeTotal;
  224. }
  226. CServerNode* CServerView::DoPasteItem(COleDataObject* pDataObject)
  227. {
  228. ASSERT(pDataObject != NULL);
  229. ASSERT_VALID(this);
  230. ASSERT(m_pSelectedNode != NULL);
  232. BeginWaitCursor();
  234. CServerNode* pItem = new CServerNode(GetDocument());
  235. ASSERT_VALID(pItem);
  237. TRY
  238. {
  239. if (pDataObject->IsDataAvailable(CServerDoc::m_cfPrivate))
  240. DoPasteNative(pDataObject,pItem);
  241. else if (pDataObject->IsDataAvailable(CF_TEXT))
  242. DoPasteText(pDataObject,pItem);
  243. else
  244. AfxThrowNotSupportedException();
  245. }
  246. CATCH_ALL(e)
  247. {
  248. // general cleanup
  249. TRACE0("failed to embed/link an OLE objectn");
  250. delete pItem;
  251. pItem = NULL;
  252. }
  253. END_CATCH_ALL
  255. EndWaitCursor();
  257. // update the document and views
  258. SetSelection(pItem);
  259. return pItem;
  260. }
  262. void CServerView::DoPasteNative(COleDataObject *pDataObject,CServerNode *pItem)
  263. {
  264. ASSERT(m_pSelectedNode != NULL);
  266. // get file refering to clipboard data
  267. CFile *pFile = pDataObject->GetFileData(CServerDoc::m_cfPrivate);
  268. if (pFile == NULL)
  269. return;
  271. // connect the file to the archive and read the contents
  272. CArchive ar(pFile, CArchive::load);
  273. ar.m_pDocument = GetDocument(); // for COleClientItem serialize
  274. pItem->Serialize(ar);
  275. ar.Close();
  276. delete pFile;
  278. // add the item to selected node
  279. m_pSelectedNode->m_listChild.AddHead(pItem);
  280. }
  282. void CServerView::DoPasteText(COleDataObject *pDataObject, CServerNode*)
  283. {
  284. ASSERT(m_pSelectedNode != NULL);
  286. // get file refering to clipboard data
  287. CFile *pFile = pDataObject->GetFileData(CF_TEXT);
  288. if (pFile == NULL)
  289. return;
  291. // connect the file to the archive and read the contents
  292. CArchive ar(pFile, CArchive::load);
  293. DoImportText(ar);
  294. ar.Close();
  295. delete pFile;
  296. }
  298. void CServerView::DoImportText(CArchive &ar)
  299. {
  300. // read in lines appending items from this node
  301. char szNode[256];
  302. #ifdef _UNICODE
  303. TCHAR szT[256];
  304. #endif
  305. int nCurLevel = 0;
  306. CServerNode* parents[MAX_LEVEL];
  307. parents[0] = m_pSelectedNode;   // must have a parent at the current level
  309. while (ReadString(ar, szNode, sizeof(szNode)) != NULL)
  310. {
  311. int cch = strlen(szNode);
  312. if (cch == 0)
  313. continue;
  314. if (szNode[cch-1] != 'n')
  315. {
  316. AfxMessageBox(
  317. _T("Text file contains too long a line - aborting readn"));
  318. break;      // leaves items loaded so far
  319. }
  320. szNode[cch-1] = '';
  321. // check the indentation level
  322. char* pch = szNode;
  323. while (*pch == 't')
  324. pch++;
  325. int nLevel = (pch - szNode)+1;
  326. ASSERT(nLevel >= 1);        // levels are 1 based, 0 is the root
  328. if (*pch == '')
  329. continue;       // skip blank lines
  330. if (nLevel > nCurLevel + 1 || nLevel >= MAX_LEVEL)
  331. {
  332. AfxMessageBox(
  333. _T("Text file contains too many tabs = aborting readn"));
  334. break;      // leaves items loaded so far
  335. }
  337. #ifdef _UNICODE
  338. _mbstowcsz(szT, pch, sizeof(szT)/sizeof(szT[0]));
  339. parents[nLevel] = parents[nLevel-1]->CreateChildNode(szT);
  340. #else
  341. parents[nLevel] = parents[nLevel-1]->CreateChildNode(pch);
  342. #endif
  343. nCurLevel = nLevel;
  344. }
  345. if (nCurLevel == 0)
  346. return;     // nothing added
  348. UpdateServerView();
  349. }
  351. void CServerView::ScrollToItem(CServerNode *pItem, BOOL bScrollUp)
  352. {
  353. CServerDC dc(this);
  355. CRect rect;
  356. CPoint ptStart = m_ptStart;
  357. if (FindItemRect(&dc, pItem, &rect, ptStart, GetDocument()->m_pRoot))
  358. {
  359. CRect rc;
  360. dc.LPtoDP(rect);
  361. if (GetDocument()->IsInPlaceActive())
  362. {
  363. CRect rcPos,rcClip;
  364. GetDocument()->GetItemPosition(&rcPos);
  365. GetDocument()->GetItemClipRect(&rcClip);
  366. rc.IntersectRect(&rcPos,&rcClip);
  367. rc.OffsetRect(-rcPos.left,-rcPos.top);
  368. if (!rc.PtInRect(rect.TopLeft()) || !rc.PtInRect(rect.BottomRight()))
  369. {
  370. CSize size(0, 0);
  371. // scroll inplace site
  372. if (bScrollUp)
  373. size.cy = rect.top - rc.top;
  374. else
  375. size.cy = rect.bottom + rcPos.top - rcClip.bottom;
  376. GetDocument()->ScrollContainerBy(size);
  377. }
  378. }
  379. else
  380. {
  381. GetClientRect(rc);
  382. if (!rc.PtInRect(rect.TopLeft()) || !rc.PtInRect(rect.BottomRight()))
  383. {
  384. CPoint ptDevScroll = GetDeviceScrollPosition();
  385. if (bScrollUp)
  386. ScrollToPosition(CPoint(0,rect.top + ptDevScroll.y));
  387. else
  388. ScrollToPosition(
  389. CPoint(0,ptDevScroll.y + rect.bottom - rc.Height()));
  390. }
  391. }
  392. }
  393. }
  395. void CServerView::Locate(int nCount, BOOL bScrollUp)
  396. {
  397. CServerNode* pRoot = GetDocument()->m_pRoot;
  398. CServerNode* pItem = pRoot;
  400. if (m_pSelectedNode == NULL)
  401. SetSelection(pRoot);
  403. if (nCount == 0) // goto top or bottom depending on direction
  404. {
  405. if (bScrollUp)
  406. pItem = pRoot;
  407. else
  408. {
  409. while (pItem->HasChildren())
  410. pItem = (CServerNode *)(pItem->m_listChild.GetTail());
  411. }
  412. }
  413. else if (bScrollUp)
  414. {
  415. pItem = m_pSelectedNode;
  416. while (nCount--)
  417. pItem = pRoot->GetPrev(pItem);
  418. }
  419. else // going down
  420. {
  421. pItem = m_pSelectedNode;
  422. while (nCount--)
  423. pItem = pRoot->GetNext(pItem);
  424. }
  425. ScrollToItem(pItem, bScrollUp);
  426. SetSelection(pItem);
  427. UpdateWindow();
  428. }
  430. void CServerView::InvalidateItem(CServerNode *pItem, CDC* pDC)
  431. {
  432. if (pItem != NULL)
  433. {
  434. CRect rect;
  435. CPoint ptStart = m_ptStart;
  436. if (FindItemRect(pDC, pItem, &rect, ptStart, GetDocument()->m_pRoot))
  437. {
  438. pDC->LPtoDP(rect);
  439. InvalidateRect(rect, FALSE);
  440. }
  441. }
  442. }
  444. void CServerView::InvalidateItem(CServerNode* pItem)
  445. {
  446. CServerDC dc(this);
  447. InvalidateItem(pItem, &dc);
  448. }
  450. void CServerView::ToggleSelectedItem()
  451. {
  452. if (m_pSelectedNode != NULL && m_pSelectedNode->HasChildren())
  453. {
  454. if (m_pSelectedNode->m_bHideChildren)
  455. OnTreeExpandonelevel();
  456. else
  457. OnTreeCollapsebranch();
  458. }
  459. }
  461. /////////////////////////////////////////////////////////////////////////////
  462. // Implementation
  464. void CServerView::OnDraw(CDC* pDC)
  465. {
  466. if (GetDocument()->DrawTree(pDC, m_ptStart, m_pSelectedNode) == -1)
  467. TRACE0("Error: CServerDoc::DrawTree failed!!n");
  468. }
  470. void CServerView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint)
  471. {
  472. CScrollView::OnUpdate(pSender, lHint, pHint);
  473. CServerDoc* pDoc = GetDocument();
  474. CServerNode* pRoot = pDoc->m_pRoot;
  475. ASSERT(pRoot != NULL);
  477. if (m_pSelectedNode == NULL)
  478. m_pSelectedNode = pRoot;
  480. if (pDoc->IsInPlaceActive())
  481. {
  482. ASSERT_VALID(pDoc->m_pRoot);
  483. CRect rect;
  484. pDoc->GetItemPosition(rect);
  486. // adjust rect for new size of view
  487. rect.BottomRight() = rect.TopLeft() + CalcScaledViewSize();
  488. pDoc->RequestPositionChange(rect);
  489. // may resize the window before returning
  490. }
  491. SetScrollInfo();
  492. }
  494. void CServerView::OnInitialUpdate()
  495. {
  496. // initialize zoom state (100% from size cache)
  497. m_zoomNum = CSize(100, 100);
  498. m_zoomDenom = CSize(100, 100);
  500. // call base class last (will call OnUpdate)
  501. CScrollView::OnInitialUpdate();
  502. }
  504. void CServerView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
  505. {
  506. CScrollView::OnPrepareDC(pDC, pInfo);
  508. pDC->SetMapMode(MM_ANISOTROPIC);
  509. pDC->SetViewportExt(m_zoomNum);
  510. pDC->SetWindowExt(m_zoomDenom);
  511. }
  513. void CServerView::SelectAtPoint(CPoint point, CPoint& pointHit)
  514. {
  515. CServerDC dc(this);
  517. // change the selection as appropriate
  518. pointHit = m_ptStart;
  519. CServerNode* pSelection = HitDetect(&dc, point, pointHit,
  520. GetDocument()->m_pRoot);
  522. // now set the selection to new hit-tested node
  523. SetSelection(pSelection, &dc);
  524. }
  526. void CServerView::DoBranch(CServerNode *pItem, BOOL bHide)
  527. {
  528. if (pItem->HasChildren())
  529. {
  530. pItem->m_bHideChildren = bHide;
  531. POSITION pos = pItem->m_listChild.GetHeadPosition();
  532. while (pos != NULL)
  533. DoBranch((CServerNode *)pItem->m_listChild.GetNext(pos),bHide);
  534. }
  535. }
  537. BOOL CServerView::OnDrop(COleDataObject* pDataObject, DROPEFFECT, CPoint)
  538. {
  539. ASSERT_VALID(this);
  540. OnDragLeave();
  541. if (DoPasteItem(pDataObject) != NULL)
  542. {
  543. UpdateServerView();
  544. return TRUE;
  545. }
  546. else
  547. return FALSE;
  548. }
  550. DROPEFFECT CServerView::OnDragEnter(COleDataObject* pDataObject,
  551. DWORD grfKeyState, CPoint point)
  552. {
  553. ASSERT(m_prevDropEffect == DROPEFFECT_NONE);
  554. return OnDragOver(pDataObject, grfKeyState, point);
  555. }
  557. DROPEFFECT CServerView::OnDragOver(COleDataObject* pDataObject,
  558. DWORD grfKeyState, CPoint point)
  559. {
  560. DROPEFFECT dropEffect = DROPEFFECT_NONE;
  561. if (pDataObject->IsDataAvailable(CServerDoc::m_cfPrivate) ||
  562. pDataObject->IsDataAvailable(CF_TEXT))
  563. {
  564. CPoint pointHit;
  565. SelectAtPoint(point, pointHit);
  566. UpdateWindow();
  567. if (m_pSelectedNode != NULL)
  568. {
  569. // don't allow a node to drop on itself
  570. if (m_pDragNode == m_pSelectedNode)
  571. dropEffect = DROPEFFECT_NONE;
  572. // if drop target is a child of drag source
  573. // then don't drop
  574. else if (m_pDragNode != NULL && m_pDragNode->IsChild(m_pSelectedNode))
  575. dropEffect = DROPEFFECT_NONE;
  576. // check for force link
  577. else if ((grfKeyState & (MK_CONTROL|MK_SHIFT)) == (MK_CONTROL|MK_SHIFT))
  578. dropEffect = DROPEFFECT_COPY;
  579. // check for force copy
  580. else if ((grfKeyState & MK_CONTROL) == MK_CONTROL)
  581. dropEffect = DROPEFFECT_COPY;
  582. // check for force move
  583. else if ((grfKeyState & MK_ALT) == MK_ALT)
  584. dropEffect = DROPEFFECT_MOVE;
  585. // if m_pDragNode == NULL then not dropping on self
  586. // so make default effect be copy
  587. // if dropping on self make default be move
  588. else
  589. dropEffect = (m_pDragNode == NULL) ? DROPEFFECT_COPY :
  590. DROPEFFECT_MOVE;
  591. }
  592. }
  593. m_prevDropEffect = dropEffect;
  594. return dropEffect;
  595. }
  597. void CServerView::OnDragLeave()
  598. {
  599. m_prevDropEffect = DROPEFFECT_NONE;
  600. }
  602. /////////////////////////////////////////////////////////////////////////////
  603. // CServerView commands
  605. void CServerView::OnUpdateHasSel(CCmdUI* pCmdUI)
  606. {
  607. pCmdUI->Enable(m_pSelectedNode != NULL);
  608. }
  610. void CServerView::OnChangeName()
  611. {
  612. if (m_pSelectedNode != NULL && m_pSelectedNode->PromptChangeNode())
  613. {
  614. GetDocument()->SetModifiedFlag();
  615. GetDocument()->UpdateAllItems(NULL);
  616. GetDocument()->UpdateAllViews(NULL);
  617. }
  618. }
  620. void CServerView::OnAddNode()
  621. {
  622. if (m_pSelectedNode == NULL)
  623. AfxThrowNotSupportedException();
  624. CServerNode* pNew;
  625. if ((pNew = m_pSelectedNode->PromptNewChildNode()) == NULL)
  626. return;
  628. SetSelection(pNew);
  629. UpdateServerView();
  630. }
  632. void CServerView::OnEditCopy()
  633. {
  634. ASSERT_VALID(this);
  635. if (m_pSelectedNode == NULL)
  636. return;
  638. // get a server item suitable to generate the clipboard data
  639. CServerItem* pItem = m_pSelectedNode->m_pServerItem;
  640. if (pItem == NULL)
  641. pItem = new CServerItem(GetDocument(), m_pSelectedNode);
  642. ASSERT_VALID(pItem);
  644. pItem->CopyToClipboard(TRUE);
  645. }
  647. void CServerView::OnLButtonDown(UINT, CPoint point)
  648. {
  649. // m_pDragNode != NULL only when drag in progress
  650. ASSERT(m_pDragNode == NULL);
  651. CPoint pointHit;
  652. SelectAtPoint(point, pointHit);
  653. UpdateWindow();
  655. // maybe start drag drop operation on selection
  656. if (m_pSelectedNode != NULL)
  657. {
  658. // record current selection because a drop back in same view
  659. // will change the current selection
  660. m_pDragNode = m_pSelectedNode;
  662. // determine rectangle of object we'll be dragging
  663. CServerDC dc(this);
  664. CSize size = CalcActualItemSize(m_pSelectedNode, &dc);
  665. CRect rect(pointHit, size);
  667. // get a server item suitable to generate the clipboard data
  668. CServerItem* pItem = m_pSelectedNode->m_pServerItem;
  669. if (pItem == NULL)
  670. pItem = new CServerItem(GetDocument(), m_pSelectedNode);
  671. ASSERT_VALID(pItem);
  673. // rect must be in screen co-ordinates
  674. dc.LPtoDP(&rect);
  675. CPoint ptOffset = point - rect.TopLeft();
  676. ClientToScreen(&rect);
  678. // drag the object
  679. if (pItem->DoDragDrop(rect, ptOffset, TRUE,
  680. DROPEFFECT_COPY | DROPEFFECT_MOVE) == DROPEFFECT_MOVE)
  681. {
  682. // the object was moved, need to delete/move depending on dest
  683. CServerDoc* pDoc = GetDocument();
  684. if (m_pSelectedNode == m_pDragNode)
  685. SetSelection(pDoc->m_pRoot->GetPrev(m_pSelectedNode));
  686. if (m_pDragNode == pDoc->m_pRoot)
  687. pDoc->m_pRoot->InitRootNode();
  688. else
  689. pDoc->m_pRoot->FindAndDelete(m_pDragNode);
  691. // if drop was not back in same view clear selected node
  692. UpdateServerView();
  693. }
  694. m_pDragNode = NULL;
  695. }
  696. }
  698. void CServerView::OnRButtonDown(UINT /*nFlags*/, CPoint point)
  699. {
  700. // make sure window is active
  701. GetParentFrame()->ActivateFrame();
  703. CPoint pointHit;
  704. SelectAtPoint(point, pointHit); // select node first
  705. UpdateWindow();
  707. int iSub;
  708. if (m_pSelectedNode == NULL ||
  709.   (iSub = m_pSelectedNode->GetPopupMenuIndex()) == -1)
  710.    return;  // nothing if no selection or no popup
  712. CMenu popups;
  713. if (!popups.LoadMenu(IDR_POPUPS))
  714. AfxThrowResourceException();
  715. CMenu* pMenu = popups.GetSubMenu(iSub);
  716. ASSERT(pMenu != NULL);
  718. ClientToScreen(&point);
  719. pMenu->TrackPopupMenu(TPM_CENTERALIGN | TPM_RIGHTBUTTON,
  720. point.x, point.y, AfxGetMainWnd());
  721. }
  723. void CServerView::OnImportText()
  724. {
  725. if (m_pSelectedNode == NULL)
  726. AfxThrowNotSupportedException();
  728. CFileDialog dlg(TRUE, _T("txt"), NULL,
  729. OFN_FILEMUSTEXIST | OFN_HIDEREADONLY,
  730. _T("Text Files (*.txt)|*.txt|All Files (*.*)|*.*||"));
  732. if (dlg.DoModal() != IDOK)
  733. return;                 // stay with old data file
  735. OpenTextFile(dlg.GetPathName());
  737. }
  739. void CServerView::OpenTextFile(CString Name)
  740. {
  741. CFile file;
  742. if (!file.Open(Name, CFile::modeRead))
  743. {
  744. AfxMessageBox(_T("Failed to open text file"));
  745. return;
  746. }
  748. CArchive ar(&file,CArchive::load);
  749. DoImportText(ar);
  750. ar.Close();
  751. file.Close();
  752. }
  754. static int ReadString(CArchive& ar, char* pString, int nMaxLen)
  755. {
  756. int nCount = 0;
  757. char ch;
  758. pString[nCount] = (char)0;
  759. TRY
  760. {
  761. do
  762. {
  763. ar >> (BYTE&)ch;
  765. // watch out for ^Z (EOF under DOS)
  766. if (ch == 0x1A)
  767. break;
  769. // combine "rn" pair into single "n"
  770. if (ch == 'n' && nCount != 0 && pString[nCount-1] == 'r')
  771. nCount--;
  773. //Remove any extra r
  774. if (ch == 'r' && nCount != 0 && pString[nCount-1] == 'r')
  775. nCount--;
  777. pString[nCount++] = ch;
  779. } while (nCount < nMaxLen-1 && ch != 'n');
  780. }
  781. END_TRY
  783. // insert newline if missing
  784. if (nCount != 0 && pString[nCount-1] != 'n' && nCount < nMaxLen-1)
  785. pString[nCount++] = 'n';
  786. pString[nCount] = (char)0;
  788. return nCount;
  789. }
  791. /////////////////////////////////////////////////////////////////////////////
  792. // Zooming user interface
  794. void CServerView::OnZoom(UINT nID)
  795. {
  796. ASSERT(nID >= ID_VIEW_ZOOM25 && nID <= ID_VIEW_ZOOM300);
  798. CSize zoomDenom;
  799. CSize zoomNum;
  801. // all of our zoom factors use denominator of 100
  802. zoomDenom.cx = 100;
  803. zoomDenom.cy = 100;
  805. // get zoom factor numerator and set it
  806. ASSERT(nID-ID_VIEW_ZOOM25 < sizeof(rgiZoomFactor)/sizeof(rgiZoomFactor[0]));
  807. int iZoomFactor = rgiZoomFactor[nID-ID_VIEW_ZOOM25];
  808. zoomNum.cx = iZoomFactor;
  809. zoomNum.cy = iZoomFactor;
  811. // change the zoom factor to new zoom factor
  812. SetZoomFactor(zoomNum, zoomDenom);
  813. SetScrollInfo();
  814. }
  816. void CServerView::OnUpdateZoom(CCmdUI* pCmdUI)
  817. {
  818. UINT nID = pCmdUI->m_nID;
  820. if (m_zoomDenom.cx == 100 && m_zoomDenom.cy == 100 &&
  821. nID != ID_VIEW_ZOOMCUSTOM)
  822. {
  823. ASSERT(nID-ID_VIEW_ZOOM25 <
  824. sizeof(rgiZoomFactor)/sizeof(rgiZoomFactor[0]));
  825. int iZoomFactor = rgiZoomFactor[nID-ID_VIEW_ZOOM25];
  827. if (iZoomFactor == m_zoomNum.cx && iZoomFactor == m_zoomNum.cy)
  828. {
  829. pCmdUI->SetCheck(TRUE);
  830. return;
  831. }
  832. }
  834. // default to not checked
  835. pCmdUI->SetCheck(FALSE);
  836. }
  838. void CServerView::OnViewZoomCustom()
  839. {
  840. // prepare dialog data
  841. CZoomDlg dlg;
  842. dlg.m_zoomX = m_zoomNum.cx;
  843. dlg.m_zoomY = m_zoomNum.cy;
  845. // launch dialog
  846. if (dlg.DoModal() == IDOK)
  847. {
  848. // set new zoom factors
  849. CSize zoomNum(dlg.m_zoomX, dlg.m_zoomY);
  850. SetZoomFactor(zoomNum, m_zoomDenom);
  851. SetScrollInfo();
  852. }
  853. }
  855. /////////////////////////////////////////////////////////////////////////////
  857. void CServerView::OnEditCut()
  858. {
  859. ASSERT(m_pSelectedNode != NULL);
  860. CServerDoc* pDoc = GetDocument();
  861. OnEditCopy();
  862. if (m_pSelectedNode == pDoc->m_pRoot)
  863. pDoc->m_pRoot->InitRootNode();
  864. else if (pDoc->m_pRoot->FindAndDelete(m_pSelectedNode))
  865. m_pSelectedNode = NULL;
  866. UpdateServerView();
  867. }
  869. void CServerView::OnLButtonDblClk(UINT /*nFlags*/, CPoint point)
  870. {
  871. CPoint pointHit;
  872. SelectAtPoint(point, pointHit);
  873. ToggleSelectedItem();
  874. }
  876. void CServerView::OnEditPaste()
  877. {
  878. COleDataObject clipboardData;
  879. clipboardData.AttachClipboard();
  880. DoPasteItem(&clipboardData);
  881. UpdateServerView();
  882. }
  884. void CServerView::OnUpdateEditPaste(CCmdUI* pCmdUI)
  885. {
  886. // determine if private or standard OLE formats are on the clipboard
  887. COleDataObject dataObj;
  888. BOOL bEnable = m_pSelectedNode != NULL &&
  889. dataObj.AttachClipboard() &&
  890. (dataObj.IsDataAvailable(CServerDoc::m_cfPrivate) ||
  891.  dataObj.IsDataAvailable(CF_TEXT));
  892. // enable command based on availability
  893. pCmdUI->Enable(bEnable);
  894. }
  896. int CServerView::OnCreate(LPCREATESTRUCT lpCreateStruct)
  897. {
  898. if (CScrollView::OnCreate(lpCreateStruct) == -1)
  899. return -1;
  901. // register drop target
  902. m_dropTarget.Register(this);
  904. // setup scroll state so it is possible to calculate the extent
  905. SetScrollSizes(MM_TEXT, CSize(0, 0));
  907. return 0;
  908. }
  910. void CServerView::OnEditClear()
  911. {
  912. CServerNode* pRoot = GetDocument()->m_pRoot;
  913. if (m_pSelectedNode == NULL)
  914. return;
  915. if (m_pSelectedNode == pRoot)
  916. pRoot->InitRootNode();
  917. else
  918. {
  919. CServerNode *pItem = pRoot->GetPrev(m_pSelectedNode);
  920. if (pRoot->FindAndDelete(m_pSelectedNode))
  921. m_pSelectedNode = pRoot->GetNext(pItem);
  922. }
  923. UpdateServerView();
  924. }
  926. void CServerView::OnTreeCollapsebranch()
  927. {
  928. DoBranch(m_pSelectedNode,TRUE);
  929. UpdateServerView();
  930. }
  932. void CServerView::OnTreeExpandall()
  933. {
  934. DoBranch(GetDocument()->m_pRoot,FALSE);
  935. UpdateServerView();
  936. }
  938. void CServerView::OnTreeExpandbranch()
  939. {
  940. DoBranch(m_pSelectedNode,FALSE);
  941. UpdateServerView();
  942. }
  944. void CServerView::OnTreeExpandonelevel()
  945. {
  946. if (m_pSelectedNode->HasChildren())
  947. {
  948. m_pSelectedNode->m_bHideChildren = FALSE;
  949. UpdateServerView();
  950. }
  951. }
  953. void CServerView::OnUpdateTreeCollapsebranch(CCmdUI* pCmdUI)
  954. {
  955. pCmdUI->Enable(m_pSelectedNode != NULL && m_pSelectedNode->HasChildren() &&
  956. !m_pSelectedNode->m_bHideChildren);
  957. }
  959. void CServerView::OnUpdateTreeExpandonelevel(CCmdUI* pCmdUI)
  960. {
  961. pCmdUI->Enable(m_pSelectedNode != NULL && m_pSelectedNode->HasChildren() &&
  962. m_pSelectedNode->m_bHideChildren);
  963. }
  965. void CServerView::OnUpdateTreeExpandall(CCmdUI* pCmdUI)
  966. {
  967. pCmdUI->Enable(GetDocument()->m_pRoot != NULL &&
  968. GetDocument()->m_pRoot->HasChildren());
  969. }
  971. void CServerView::OnUpdateTreeExpandbranch(CCmdUI* pCmdUI)
  972. {
  973. pCmdUI->Enable(m_pSelectedNode != NULL && m_pSelectedNode->HasChildren());
  974. }
  976. void CServerView::OnKeyDown(UINT nChar, UINT /*nRepCnt*/, UINT /*nFlags*/)
  977. {
  978. switch (nChar)
  979. {
  980. case VK_RETURN:
  981. ToggleSelectedItem();
  982. break;
  983. case VK_UP:
  984. Locate(1, TRUE);
  985. break;
  986. case VK_DOWN:
  987. Locate(1, FALSE);
  988. break;
  989. case VK_HOME:
  990. Locate(0, TRUE);
  991. break;
  992. case VK_END:
  993. Locate(0, FALSE);
  994. break;
  995. case VK_PRIOR:
  996. Locate(10, TRUE);
  997. break;
  998. case VK_NEXT:
  999. Locate(10, FALSE);
  1000. break;
  1001. }
  1002. }
  1004. void CServerView::OnSize(UINT nType, int cx, int cy)
  1005. {
  1006. // update scroll bar size before handling the size message
  1007. //  (this avoids multiple updates during in-place activation)
  1008. SetScrollInfo();
  1010. CScrollView::OnSize(nType, cx, cy);
  1011. }
  1013. /////////////////////////////////////////////////////////////////////////////
  1014. // CServerDC class -- helper for setting up and cleaning up DC
  1016. CServerDC::CServerDC(CServerView *pView) : CClientDC(pView)
  1017. {
  1018. pView->OnPrepareDC(this);
  1019. pOldFont = pView->GetDocument()->SelectDocFont(this, font);
  1020. }
  1022. CServerDC::~CServerDC()
  1023. {
  1024. if (pOldFont != NULL)
  1025. SelectObject(pOldFont);
  1026. }
  1028. /////////////////////////////////////////////////////////////////////////////
  1029. // non-member static functions
  1031. // calculate the bounding rect for a given item in the context of this view
  1032. static BOOL FindItemRect(CDC* pDC, CServerNode* pItemFind, LPRECT lpRect,
  1033. CPoint& ptStart, CServerNode* pRoot)
  1034. {
  1035. ASSERT(pItemFind != NULL);
  1036. ASSERT(lpRect != NULL);
  1037. ASSERT(pRoot != NULL);
  1039. CSize sizeNode;
  1040. pRoot->CalcNodeSize(pDC, sizeNode);
  1041. if (pItemFind == pRoot)
  1042. {
  1043. // item rect does not include separator
  1044. lpRect->right = (lpRect->left = ptStart.x) + sizeNode.cx;
  1045. lpRect->bottom = (lpRect->top = ptStart.y) + sizeNode.cy;
  1046. return TRUE;
  1047. }
  1049. CPoint pt(CX_INDENT, CY_SEPARATOR);
  1050. ptStart.x += CX_INDENT; // not essential for calculation
  1051. ptStart.y += sizeNode.cy + CY_SEPARATOR;
  1053. // check the kids
  1054. if (!pRoot->m_bHideChildren)
  1055. {
  1056. POSITION pos = pRoot->m_listChild.GetHeadPosition();
  1057. while (pos != NULL)
  1058. {
  1059. CServerNode* pChild = (CServerNode*) (pRoot->m_listChild.GetNext(pos));
  1060. if (FindItemRect(pDC, pItemFind, lpRect, ptStart, pChild))
  1061. return TRUE;    // found
  1062. }
  1063. }
  1064. ptStart.x -= CX_INDENT;
  1065. return FALSE;
  1066. }
  1068. // calculate the bounding rect for a given item in the context of this view
  1069. static CServerNode* HitDetect(CDC* pDC, CPoint point,
  1070. CPoint& ptStart, CServerNode* pRoot)
  1071. {
  1072. ASSERT(pRoot != NULL);
  1074. CSize sizeNode;
  1075. pRoot->CalcNodeSize(pDC, sizeNode);
  1076. CRect rect(ptStart, sizeNode);
  1077. pDC->LPtoDP(rect);
  1078. if (rect.PtInRect(point))
  1079. return pRoot;
  1081. ptStart.x += CX_INDENT;
  1082. ptStart.y += sizeNode.cy + CY_SEPARATOR;
  1083. CPoint pt = ptStart;
  1084. pDC->LPtoDP(&pt);
  1085. if (pt.y >= point.y)
  1086. return FALSE;       // no point in looking any lower
  1088. // check the kids
  1089. if (!pRoot->m_bHideChildren)
  1090. {
  1091. POSITION pos = pRoot->m_listChild.GetHeadPosition();
  1092. while (pos != NULL)
  1093. {
  1094. CServerNode* pChild = (CServerNode*) (pRoot->m_listChild.GetNext(pos));
  1095. CServerNode* pItem = HitDetect(pDC, point, ptStart, pChild);
  1096. if (pItem != NULL)
  1097. return pItem;   // found
  1098. }
  1099. }
  1100. ptStart.x -= CX_INDENT;
  1101. return NULL;
  1102. }
  1104. /////////////////////////////////////////////////////////////////////////////
  1105. // CServerView diagnostics
  1107. #ifdef _DEBUG
  1108. void CServerView::AssertValid() const
  1109. {
  1110. CScrollView::AssertValid();
  1111. }
  1113. void CServerView::Dump(CDumpContext& dc) const
  1114. {
  1115. CScrollView::Dump(dc);
  1116. }
  1117. #endif //_DEBUG
  1119. $$IF(WANTS_TEXTVIEW)
  1120. void CServerView::OnViewTextView()
  1121. {
  1122. // Show the active document in text view.
  1123. CServerDoc* pServerDoc = GetDocument();
  1124. CDocument * pNewDoc ;
  1125. pNewDoc = ((CServerApp *)AfxGetApp())->pDocTxtTemplate->OpenDocumentFile(NULL);
  1127.    //Detach the view from the newly created doc and attach it to the CServerDoc document
  1128. POSITION pos = pNewDoc->GetFirstViewPosition() ;
  1129. CTextView * pTxtvw = ( CTextView *)pNewDoc->GetNextView(pos) ;
  1130. pNewDoc->RemoveView(pTxtvw) ;
  1131. pServerDoc->AddView(pTxtvw) ;
  1132. pTxtvw->RedrawText() ; // Do an initial draw of textview
  1134. }
  1135. void CServerView::CreateTextView()
  1136. {
  1137. OnViewTextView() ;
  1138. }
  1140. $$ENDIF //WANTS_TEXTVIEW