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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
MarkupView.cpp
资源名称：CMarkup.rar　[点击查看]
上传用户：hawkcdm
上传日期：2013-02-10
资源大小：411k
文件大小：17k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

MarkupView.cpp：源码内容
  1. // MarkupView.cpp : implementation of the CMarkupView class
  2. //
  3. // Markup Release 6.1 Lite
  4. // Copyright (C) 1999-2001 First Objective Software, Inc. All rights reserved
  5. // This entire notice must be retained in this source code
  6. // Redistributing this source code requires written permission
  7. // This software is provided "as is", with no warranty.
  8. // Latest fixes enhancements and documentation at www.firstobject.com
  10. #include "stdafx.h"
  11. #include "MarkupApp.h"
  13. #include "MarkupDoc.h"
  14. #include "MarkupView.h"
  16. #define IDC_MARKUP_TREE 1020
  17. #define IDC_MARKUP_EDIT 1021
  18. #define IDC_MARKUP_DIVIDER 1022
  20. #ifdef _DEBUG
  21. #define new DEBUG_NEW
  22. #undef THIS_FILE
  23. static char THIS_FILE[] = __FILE__;
  24. #endif
  26. /////////////////////////////////////////////////////////////////////////////
  27. // CMarkupView
  29. IMPLEMENT_DYNCREATE(CMarkupView, CView)
  31. BEGIN_MESSAGE_MAP(CMarkupView, CView)
  32. //{{AFX_MSG_MAP(CMarkupView)
  33. ON_WM_CREATE()
  34. ON_WM_SIZE()
  35. ON_COMMAND(ID_MARKUP_FIND, OnMarkupFind)
  36. ON_COMMAND(ID_MARKUP_ADD, OnMarkupAdd)
  37. ON_COMMAND(ID_MARKUP_ADD_CHILD, OnMarkupAddChild)
  38. ON_COMMAND(ID_MARKUP_ADD_ATTRIB, OnMarkupAddAttrib)
  39. ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  40. ON_COMMAND(ID_EDIT_CUT, OnEditCut)
  41. ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
  42. ON_COMMAND(ID_EDIT_UNDO, OnEditUndo)
  43. ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateEditUndo)
  44. //}}AFX_MSG_MAP
  45. // Standard printing commands
  46. ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
  47. ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
  48. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
  49. ON_EN_CHANGE(IDC_MARKUP_EDIT, OnChangeEdit)
  50. ON_MESSAGE( WM_APP, OnAppMessage )
  51. END_MESSAGE_MAP()
  53. /////////////////////////////////////////////////////////////////////////////
  54. // CMarkupView construction/destruction
  56. CMarkupView::CMarkupView()
  57. {
  58. m_nAddAttrib = 0;
  59. }
  61. CMarkupView::~CMarkupView()
  62. {
  63. }
  65. BOOL CMarkupView::PreCreateWindow(CREATESTRUCT& cs)
  66. {
  67. // TODO: Modify the Window class or styles here by modifying
  68. //  the CREATESTRUCT cs
  70. return CView::PreCreateWindow(cs);
  71. }
  73. /////////////////////////////////////////////////////////////////////////////
  74. // CMarkupView drawing
  76. void CMarkupView::OnDraw(CDC* pDC)
  77. {
  78. UNREFERENCED_PARAMETER(pDC);
  79. CMarkupDoc* pDoc = GetDocument();
  80. ASSERT_VALID(pDoc);
  81. }
  83. /////////////////////////////////////////////////////////////////////////////
  84. // CMarkupView printing
  86. BOOL CMarkupView::OnPreparePrinting(CPrintInfo* pInfo)
  87. {
  88. // default preparation
  89. return DoPreparePrinting(pInfo);
  90. }
  92. void CMarkupView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  93. {
  94. // TODO: add extra initialization before printing
  95. }
  97. void CMarkupView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  98. {
  99. // TODO: add cleanup after printing
  100. }
  102. /////////////////////////////////////////////////////////////////////////////
  103. // CMarkupView diagnostics
  105. #ifdef _DEBUG
  106. void CMarkupView::AssertValid() const
  107. {
  108. CView::AssertValid();
  109. }
  111. void CMarkupView::Dump(CDumpContext& dc) const
  112. {
  113. CView::Dump(dc);
  114. }
  116. CMarkupDoc* CMarkupView::GetDocument() // non-debug version is inline
  117. {
  118. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMarkupDoc)));
  119. return (CMarkupDoc*)m_pDocument;
  120. }
  121. #endif //_DEBUG
  123. /////////////////////////////////////////////////////////////////////////////
  124. // CMarkupView message handlers
  126. void CMarkupView::OnInitialUpdate() 
  127. {
  128. m_pXML = &GetDocument()->m_doc;
  129. CView::OnInitialUpdate();
  131. // Maximize first time
  132. static BOOL bFirst = TRUE;
  133. if ( bFirst )
  134. {
  135. bFirst = FALSE;
  136. GetParent()->ShowWindow( SW_MAXIMIZE );
  137. }
  139. // Divider
  140. m_divider.m_nFractionOf1000 = 350;
  141. m_divider.m_enumOrientation = m_divider.MoveHorizontal;
  143. // Initial resize
  144. CRect rect;
  145. GetClientRect( &rect );
  146. CalcSize( rect.Width(), rect.Height() );
  148. // Text
  149. const int nMax = 64000; // Win 95 limit
  150. m_edit.SetLimitText( nMax );
  151. CString csText = GetDocument()->m_csText;
  152. if ( csText.GetLength() > nMax )
  153. AfxMessageBox( _T("Document is larger than edit buffer maximum") );
  154. m_edit.SetWindowText( csText );
  156. GetDocument()->SetParsedFlag( TRUE );
  157. GetDocument()->SetModifiedFlag( FALSE );
  158. }
  160. void CMarkupView::GetEditText( CString& csDoc )
  161. {
  162. if ( m_edit.GetSafeHwnd() )
  163. m_edit.GetWindowText( csDoc );
  164. }
  166. CString CMarkupView::SetEditTextFromDoc()
  167. {
  168. // Set document in rich edit control
  169. CString csDoc = m_pXML->GetDoc();
  170. m_edit.SetWindowText( csDoc );
  171. GetDocument()->m_csText = csDoc;
  172. GetDocument()->SetParsedFlag( TRUE );
  173. return csDoc;
  174. }
  176. int CMarkupView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  177. {
  178. if (CView::OnCreate(lpCreateStruct) == -1)
  179. return -1;
  181. // Create controls
  182. int nFlags = WS_VISIBLE|WS_CHILD|WS_GROUP;
  183. if ( ! m_tree.Create( nFlags|TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS,
  184. CRect(0,0,0,0), this, IDC_MARKUP_TREE ) )
  185. return -1;
  186. m_ilTree.Create(IDB_IL_TREE,16,0,RGB(255,255,255));
  187. m_tree.SetImageList(&m_ilTree,TVSIL_NORMAL);
  188. if ( ! m_divider.CreateEx(WS_EX_DLGMODALFRAME,_T("STATIC"),NULL,nFlags|SS_NOTIFY,
  189. CRect(0,0,0,0),this,IDC_MARKUP_DIVIDER) )
  190. return -1;
  191. nFlags = WS_CHILD|WS_VISIBLE|ES_MULTILINE|ES_WANTRETURN|WS_VSCROLL;
  192. if ( ! m_edit.Create( nFlags, CRect(0,0,0,0), this, IDC_MARKUP_EDIT ) )
  193. return -1;
  195. // Get default system font
  196. HFONT hSystemFont = (HFONT)GetStockObject(SYSTEM_FONT);
  197. LOGFONT systemFont;
  198. VERIFY(::GetObject(hSystemFont, sizeof(LOGFONT), (void*)&systemFont));
  200. // Set a Unicode font as the default
  201. // If you have a font that does not support the unicode characters you
  202. // are trying to view, then the characters appear as blocks or blanks
  203. // If unicode is not desired replace with the following
  204. // m_font.CreateFontIndirect(&systemFont);
  205. LOGFONT logFont; memset(&logFont, 0, sizeof(LOGFONT));
  206. logFont.lfHeight = systemFont.lfHeight + 1;
  207. logFont.lfWeight = FW_NORMAL;
  208. logFont.lfCharSet = DEFAULT_CHARSET;
  209. lstrcpy(logFont.lfFaceName, _T("Lucida Sans Unicode"));
  210. if ( ! m_font.CreateFontIndirect(&logFont) )
  211. m_font.CreateFontIndirect(&systemFont);
  212. m_edit.SetFont( &m_font );
  214. return 0;
  215. }
  217. void CMarkupView::CalcSize( int cx, int cy )
  218. {
  219. CRect rectBorder( 0, 0, cx, cy );
  220. CRect rect( rectBorder );
  221. int nOffset = m_divider.CalculateOffset( rectBorder.Width() );
  222. rect.right = rect.left + nOffset;
  223. m_tree.MoveWindow( &rect );
  224. rect.left += nOffset;
  225. rect.right = rect.left + m_divider.m_nWidth;
  226. m_divider.MoveWindow( &rect );
  227. rect.left = rect.right;
  228. rect.right = rectBorder.right;
  229. m_edit.MoveWindow( &rect );
  230. m_tree.Invalidate();
  231. m_divider.Invalidate();
  232. m_edit.Invalidate();
  233. }
  235. void CMarkupView::OnSize(UINT nType, int cx, int cy) 
  236. {
  237. CView::OnSize(nType, cx, cy);
  239. if ( m_tree.GetSafeHwnd() )
  240. CalcSize( cx, cy );
  241. }
  243. void CMarkupView::GetNthWisePos( HTREEITEM hItem, CUIntArray& aNths )
  244. {
  245. // Populate aNths with sibling number on each level
  246. // if it is the first sibling, it is set to 1, etc
  247. while ( hItem )
  248. {
  249. HTREEITEM hParentItem = m_tree.GetParentItem( hItem );
  251. // Calculate Nth position on this level
  252. aNths.InsertAt( 0, 0, 1 );
  253. while ( hItem )
  254. {
  255. if ( m_tree.GetItemData(hItem) == 0 ) // It is Elem? (not attrib)
  256. ++aNths[0];
  257. hItem = m_tree.GetPrevSiblingItem( hItem );
  258. }
  260. // Remove if attribute
  261. if ( aNths[0] == 0 )
  262. aNths.RemoveAt( 0 );
  264. // Go to parent item
  265. hItem = hParentItem;
  266. }
  267. }
  269. void CMarkupView::SetPos( HTREEITEM hItem, BOOL bChild )
  270. {
  271. // Synchronize current position in XML document
  272. CUIntArray aNths;
  273. GetNthWisePos( hItem, aNths );
  274. m_pXML->ResetPos();
  275. int nLev = 0;
  276. int nCount = aNths[nLev];
  277. while ( nCount-- )
  278. m_pXML->FindElem();
  279. while ( ++nLev < aNths.GetSize() )
  280. {
  281. nCount = aNths[nLev];
  282. while ( nCount-- )
  283. m_pXML->FindChildElem();
  284. if ( nLev < aNths.GetSize() - 1 || ! bChild )
  285. m_pXML->IntoElem();
  286. }
  287. }
  289. void CMarkupView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint) 
  290. {
  291. // Refill the tree after load or parse
  292. //
  293. UNREFERENCED_PARAMETER(pSender);
  294. UNREFERENCED_PARAMETER(pHint);
  295. UNREFERENCED_PARAMETER(lHint);
  296. CWaitCursor wait;
  298. if ( lHint )
  299. {
  300. m_edit.SetWindowText( GetDocument()->m_csText );
  301. GetDocument()->SetParsedFlag( TRUE );
  302. }
  304. // Find selected position
  305. HTREEITEM hSelectedItem = m_tree.GetSelectedItem();
  306. CUIntArray aNths;
  307. GetNthWisePos( hSelectedItem, aNths );
  308. hSelectedItem = NULL;
  310. // Traverse root and immediate children
  311. // plus any elements on path to the selected position
  312. m_tree.DeleteAllItems();
  313. m_pXML->ResetPos();
  314. BOOL bFound = m_pXML->FindElem();
  315. HTREEITEM hItem, hParentItem = TVI_ROOT;
  316. int nLev = 0;
  317. CUIntArray aCurNth;
  318. aCurNth.Add(1);
  319. while ( bFound )
  320. {
  321. hItem = AddElemToTree( hParentItem );
  323. // Select it if this is the correct item
  324. if ( nLev == aNths.GetSize()-1 && aCurNth[nLev] == aNths[nLev] )
  325. hSelectedItem = hItem;
  327. // Is there a child?
  328. bFound = ElemHasSubItems();
  330. // Above 2 levels, leave children blank to be filled on expand
  331. // Set flag indicating whether this element is on path to selection position
  332. BOOL bOnPath = nLev < aNths.GetSize() && aCurNth[nLev] == aNths[nLev];
  333. if ( bFound && nLev > 0 && ! bOnPath )
  334. {
  335. m_tree.InsertItem( _T(""), hItem );
  336. bFound = FALSE;
  337. }
  339. if ( bFound )
  340. {
  341. // Go into child
  342. m_pXML->ResetChildPos();
  343. if ( m_pXML->FindChildElem() )
  344. {
  345. hParentItem = hItem;
  346. m_pXML->IntoElem();
  347. ++nLev;
  348. aCurNth.SetAtGrow( nLev, 1 );
  349. }
  350. else
  351. {
  352. bFound = FALSE;
  353. }
  354. }
  356. if ( ! bFound )
  357. {
  358. // Look for more on same level or toward root
  359. while ( (bFound=m_pXML->FindElem()) == 0 && nLev )
  360. {
  361. m_tree.Expand( hParentItem, TVE_EXPAND );
  362. hParentItem = m_tree.GetParentItem(hParentItem);
  363. m_pXML->OutOfElem();
  364. --nLev;
  365. }
  366. ++aCurNth[nLev];
  367. }
  368. }
  370. // Was corresponding item to previously selected found?
  371. if ( hSelectedItem )
  372. {
  373. m_tree.SelectItem( hSelectedItem );
  374. m_tree.EnsureVisible( hSelectedItem );
  375. }
  376. }
  378. void CMarkupView::OnChangeEdit() 
  379. {
  380. GetDocument()->SetModifiedFlag();
  381. GetDocument()->SetParsedFlag( FALSE );
  382. }
  384. LRESULT CMarkupView::OnAppMessage( WPARAM, LPARAM )
  385. {
  386. // Post WM_APP, then here set focus to m_edit
  387. // So that selection in document is visible
  388. m_edit.SetFocus();
  389. return 0;
  390. }
  392. HTREEITEM CMarkupView::AddElemToTree(HTREEITEM hParentItem)
  393. {
  394. HTREEITEM hItem;
  395. hItem = m_tree.InsertItem( m_pXML->GetTagName(), hParentItem );
  396. m_tree.SetItemData( hItem, 0 );
  397. return hItem;
  398. }
  400. BOOL CMarkupView::ElemHasSubItems()
  401. {
  402. BOOL bElemHasSubItems = FALSE;
  403. if ( m_pXML->FindChildElem() || ! m_pXML->GetChildData().IsEmpty() )
  404. bElemHasSubItems = TRUE;
  405. return bElemHasSubItems;
  406. }
  408. BOOL CMarkupView::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult) 
  409. {
  410. // NMHDR is { HWND hwndFrom; UINT idFrom; UINT code; }
  411. NMHDR* pNMHDR = (NMHDR*)lParam;
  413. // Double-click on tree
  414. if ( pNMHDR->code == NM_DBLCLK && pNMHDR->idFrom == IDC_MARKUP_TREE )
  415. {
  416. if ( m_tree.GetSelectedItem() )
  417. {
  418. OnMarkupFind();
  420. // Message handled
  421. *pResult = 0;
  422. return TRUE;
  423. }
  424. }
  426. // Right-click on tree
  427. if ( pNMHDR->code == NM_RCLICK && pNMHDR->idFrom == IDC_MARKUP_TREE )
  428. {
  429. // Create popup menu
  430. // From resource, use menu.LoadMenu( IDR_MARKUPTREE );
  431. // and menu.GetSubMenu(0)->TrackPopupMenu()
  432. CMenu menu;
  433. UINT nFlags = MF_STRING;
  434. BOOL bShowMenu = TRUE;
  435. DWORD dwPos = GetMessagePos();
  436. CPoint point(LOWORD(dwPos), HIWORD(dwPos));
  437. ScreenToClient(&point);
  439. if ( GetDocument()->IsParsed() )
  440. {
  441. // Determine item right-clicked on
  442. HTREEITEM hItem = m_tree.HitTest( point );
  443. if ( hItem )
  444. {
  445. // Select item clicked on
  446. m_tree.SelectItem( hItem );
  448. // Is it an attribute?
  449. BOOL bIsAttrib = m_tree.GetItemData( hItem );
  451. // Is this the root element or root element attribute?
  452. BOOL bRootElem = FALSE;
  453. HTREEITEM hParentItem = m_tree.GetParentItem( hItem );
  454. if ( ! hParentItem ||
  455. ( ! m_tree.GetParentItem(hParentItem) && m_tree.GetItemData(hItem)==1 ) )
  456. bRootElem = TRUE;
  458. menu.CreatePopupMenu();
  459. if ( bIsAttrib )
  460. {
  461. menu.AppendMenu( nFlags, ID_MARKUP_FIND, _T("&Find Elem") );
  462. menu.AppendMenu( nFlags, ID_MARKUP_ADD_ATTRIB, _T("Add A&ttrib") );
  463. }
  464. else
  465. {
  466. menu.AppendMenu( nFlags, ID_MARKUP_FIND, _T("&Find Elem") );
  467. if ( ! bRootElem )
  468. menu.AppendMenu( nFlags, ID_MARKUP_ADD, _T("&Add Elem") );
  469. menu.AppendMenu( nFlags, ID_MARKUP_ADD_CHILD, _T("Add &Child Elem") );
  470. menu.AppendMenu( nFlags, ID_MARKUP_ADD_ATTRIB, _T("Add A&ttrib") );
  471. }
  472. }
  473. else
  474. bShowMenu = FALSE;
  475. }
  476. else
  477. {
  478. menu.CreatePopupMenu();
  479. menu.AppendMenu( nFlags, ID_FILE_PARSE, _T("&Parse") );
  480. }
  482. if ( bShowMenu )
  483. {
  484. // Run popup menu
  485. ClientToScreen(&point);
  486. menu.TrackPopupMenu(
  487. TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this );
  488. }
  490. // Message handled
  491. *pResult = 0;
  492. return TRUE;
  493. }
  495. // Expand item in tree
  496. if ( pNMHDR->code == TVN_ITEMEXPANDING && pNMHDR->idFrom == IDC_MARKUP_TREE )
  497. {
  498. NMTREEVIEW* pnmtv = (NMTREEVIEW*)pNMHDR;
  499. if ( pnmtv->action & TVE_EXPAND )
  500. {
  501. // Is the child empty?
  502. HTREEITEM hParentItem = pnmtv->itemNew.hItem;
  503. HTREEITEM hItem = m_tree.GetChildItem( hParentItem );
  504. if ( hItem && m_tree.GetItemText( hItem ).IsEmpty() )
  505. {
  506. // Remove blank child
  507. m_tree.DeleteItem( hItem );
  509. // Add attribs and child elements to tree
  510. SetPos( hParentItem );
  511. while ( m_pXML->FindChildElem() )
  512. {
  513. // Go into child
  514. m_pXML->IntoElem();
  516. // Add to tree control
  517. hItem = AddElemToTree( hParentItem );
  519. // Create empty child under it, if it has data, attribs, or children
  520. if ( ElemHasSubItems() )
  521. m_tree.InsertItem( _T(""), hItem );
  523. // Back to parent to find next child
  524. m_pXML->OutOfElem();
  525. }
  526. }
  527. }
  528. }
  530. return CView::OnNotify(wParam, lParam, pResult);
  531. }
  533. void CMarkupView::OnMarkupFind() 
  534. {
  535. if ( GetDocument()->IsParsed() )
  536. {
  537. HTREEITEM hItem = m_tree.GetSelectedItem();
  538. if ( hItem )
  539. {
  540. // Select element
  541. SetPos( hItem );
  542. int nStart, nEnd;
  543. GetDocument()->m_doc.GetOffsets( nStart, nEnd );
  544. m_edit.SetSel( nStart, nEnd + 1 );
  546. // Edit control must have focus to display selection
  547. // Post message so that it gets focus after current message is complete
  548. PostMessage( WM_APP );
  549. }
  550. }
  551. }
  553. void CMarkupView::OnMarkupAdd() 
  554. {
  555. if ( GetDocument()->IsParsed() )
  556. {
  557. HTREEITEM hItem = m_tree.GetSelectedItem();
  558. if ( hItem )
  559. {
  560. // Add a new element to the document
  561. SetPos( hItem );
  562. CString csName = m_pXML->GetTagName();
  563. m_pXML->AddElem( csName );
  565. // Add item to tree
  566. HTREEITEM hParentItem = m_tree.GetParentItem( hItem );
  567. hItem = m_tree.InsertItem( csName, hParentItem, hItem );
  568. m_tree.SetItemData( hItem, 0 );
  570. // Set document in edit window
  571. SetEditTextFromDoc();
  572. }
  573. }
  574. }
  576. void CMarkupView::OnMarkupAddChild() 
  577. {
  578. if ( GetDocument()->IsParsed() )
  579. {
  580. HTREEITEM hParentItem = m_tree.GetSelectedItem();
  581. if ( hParentItem )
  582. {
  583. // Find last child position
  584. HTREEITEM hItem = m_tree.GetChildItem( hParentItem );
  585. HTREEITEM hItemSet = hParentItem;
  586. BOOL bChild = FALSE;
  587. while ( hItem )
  588. {
  589. hItemSet = hItem;
  590. bChild = TRUE;
  591. hItem = m_tree.GetNextSiblingItem( hItem );
  592. }
  593. SetPos( hItemSet, bChild );
  595. // Add a new element to the document
  596. CString csName = _T("ChildOf") + m_pXML->GetTagName();
  597. m_pXML->AddChildElem( csName );
  599. // Add item to tree
  600. hItem = m_tree.InsertItem( csName, hParentItem );
  601. m_tree.SetItemData( hItem, 0 );
  602. m_tree.Expand( hParentItem, TVE_EXPAND );
  604. // Set document in edit window
  605. SetEditTextFromDoc();
  606. }
  607. }
  608. }
  610. void CMarkupView::OnMarkupAddAttrib() 
  611. {
  612. if ( GetDocument()->IsParsed() )
  613. {
  614. HTREEITEM hItem = m_tree.GetSelectedItem();
  615. if ( hItem )
  616. {
  617. // Add a new attrib to the element
  618. SetPos( hItem );
  619. ++m_nAddAttrib;
  620. CString csAttribName;
  621. csAttribName.Format( _T("attrib%d"), m_nAddAttrib );
  622. CString csAttribValue;
  623. csAttribValue.Format( _T("val%d"), m_nAddAttrib );
  624. m_pXML->AddAttrib( csAttribName, csAttribValue );
  626. // If selected item is attribute, get element item
  627. if ( m_tree.GetItemData(hItem) == 1 )
  628. hItem = m_tree.GetParentItem( hItem );
  630. // Determine last attribute item
  631. HTREEITEM hAttribItem = TVI_FIRST;
  632. HTREEITEM hNextChildItem = m_tree.GetChildItem( hItem );
  634. // Make sure its not an unexpanded tree item already having children
  635. if ( ! hNextChildItem || ! m_tree.GetItemText(hNextChildItem).IsEmpty() )
  636. {
  637. while ( hNextChildItem && m_tree.GetItemData( hNextChildItem ) == 1 )
  638. {
  639. hAttribItem = hNextChildItem;
  640. hNextChildItem = m_tree.GetNextSiblingItem( hNextChildItem );
  641. }
  642. }
  643. m_tree.Expand( hItem, TVE_EXPAND );
  645. // Set document in edit window
  646. SetEditTextFromDoc();
  647. }
  648. }
  649. }
  651. void CMarkupView::OnEditCopy() 
  652. {
  653. m_edit.Copy();
  654. }
  656. void CMarkupView::OnEditCut() 
  657. {
  658. m_edit.Cut();
  659. }
  661. void CMarkupView::OnEditPaste() 
  662. {
  663. m_edit.Paste();
  664. }
  666. void CMarkupView::OnEditUndo() 
  667. {
  668. m_edit.Undo();
  669. }
  671. void CMarkupView::OnUpdateEditUndo(CCmdUI* pCmdUI) 
  672. {
  673. pCmdUI->Enable( m_edit.CanUndo() );
  674. }