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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
TreePropSheet.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：23k
源码类别：

多媒体编程

开发平台：

Visual C++

TreePropSheet.cpp：源码内容
  1. /********************************************************************
  2. *
  3. * Copyright (c) 2002 Sven Wiegand <mail@sven-wiegand.de>
  4. *
  5. * You can use this and modify this in any way you want,
  6. * BUT LEAVE THIS HEADER INTACT.
  7. *
  8. * Redistribution is appreciated.
  9. *
  10. * $Workfile:$
  11. * $Revision: 1.2 $
  12. * $Modtime:$
  13. * $Author: gabest $
  14. *
  15. * Revision History:
  16. * $History:$
  17. *
  18. *********************************************************************/
  21. #include "stdafx.h"
  22. #include "TreePropSheet.h"
  23. #include "PropPageFrameDefault.h"
  25. #ifdef _DEBUG
  26. #define new DEBUG_NEW
  27. #undef THIS_FILE
  28. static char THIS_FILE[] = __FILE__;
  29. #endif
  33. namespace TreePropSheet
  34. {
  36. //-------------------------------------------------------------------
  37. // class CTreePropSheet
  38. //-------------------------------------------------------------------
  40. BEGIN_MESSAGE_MAP(CTreePropSheet, CPropertySheet)
  41. //{{AFX_MSG_MAP(CTreePropSheet)
  42. ON_WM_DESTROY()
  43. //}}AFX_MSG_MAP
  44. ON_MESSAGE(PSM_ADDPAGE, OnAddPage)
  45. ON_MESSAGE(PSM_REMOVEPAGE, OnRemovePage)
  46. ON_MESSAGE(PSM_SETCURSEL, OnSetCurSel)
  47. ON_MESSAGE(PSM_SETCURSELID, OnSetCurSelId)
  48. ON_MESSAGE(PSM_ISDIALOGMESSAGE, OnIsDialogMessage)
  50. ON_NOTIFY(TVN_SELCHANGINGA, s_unPageTreeId, OnPageTreeSelChanging)
  51. ON_NOTIFY(TVN_SELCHANGINGW, s_unPageTreeId, OnPageTreeSelChanging)
  52. ON_NOTIFY(TVN_SELCHANGEDA, s_unPageTreeId, OnPageTreeSelChanged)
  53. ON_NOTIFY(TVN_SELCHANGEDW, s_unPageTreeId, OnPageTreeSelChanged)
  54. END_MESSAGE_MAP()
  56. IMPLEMENT_DYNAMIC(CTreePropSheet, CPropertySheet)
  58. const UINT CTreePropSheet::s_unPageTreeId = 0x7EEE;
  60. CTreePropSheet::CTreePropSheet()
  61. : m_bPageTreeSelChangedActive(FALSE),
  62. m_bTreeViewMode(TRUE),
  63. m_bPageCaption(FALSE),
  64. m_bTreeImages(FALSE),
  65. m_nPageTreeWidth(150),
  66. m_pwndPageTree(NULL),
  67. m_pFrame(NULL)
  68. {}
  71. CTreePropSheet::CTreePropSheet(UINT nIDCaption, CWnd* pParentWnd, UINT iSelectPage)
  72. : CPropertySheet(nIDCaption, pParentWnd, iSelectPage),
  73. m_bPageTreeSelChangedActive(FALSE),
  74. m_bTreeViewMode(TRUE),
  75. m_bPageCaption(FALSE),
  76. m_bTreeImages(FALSE),
  77. m_nPageTreeWidth(150),
  78. m_pwndPageTree(NULL),
  79. m_pFrame(NULL)
  80. {
  81. }
  84. CTreePropSheet::CTreePropSheet(LPCTSTR pszCaption, CWnd* pParentWnd, UINT iSelectPage)
  85. : CPropertySheet(pszCaption, pParentWnd, iSelectPage),
  86. m_bPageTreeSelChangedActive(FALSE),
  87. m_bTreeViewMode(TRUE),
  88. m_bPageCaption(FALSE),
  89. m_bTreeImages(FALSE),
  90. m_nPageTreeWidth(150),
  91. m_pwndPageTree(NULL),
  92. m_pFrame(NULL)
  93. {
  94. }
  97. CTreePropSheet::~CTreePropSheet()
  98. {
  99. if(m_Images.GetSafeHandle()) m_Images.DeleteImageList();
  100. delete m_pwndPageTree, m_pwndPageTree = NULL;
  101. delete m_pFrame, m_pFrame = NULL;
  102. }
  104. /////////////////////////////////////////////////////////////////////
  105. // Operationen
  107. BOOL CTreePropSheet::SetTreeViewMode(BOOL bTreeViewMode /* = TRUE */, BOOL bPageCaption /* = FALSE */, BOOL bTreeImages /* = FALSE */)
  108. {
  109. if (IsWindow(m_hWnd))
  110. {
  111. // needs to becalled, before the window has been created
  112. ASSERT(FALSE);
  113. return FALSE;
  114. }
  116. m_bTreeViewMode = bTreeViewMode;
  117. if (m_bTreeViewMode)
  118. {
  119. m_bPageCaption = bPageCaption;
  120. m_bTreeImages = bTreeImages;
  121. }
  123. return TRUE;
  124. }
  127. BOOL CTreePropSheet::SetTreeWidth(int nWidth)
  128. {
  129. if (IsWindow(m_hWnd))
  130. {
  131. // needs to be called, before the window is created.
  132. ASSERT(FALSE);
  133. return FALSE;
  134. }
  136. m_nPageTreeWidth = nWidth;
  138. return TRUE;
  139. }
  142. void CTreePropSheet::SetEmptyPageText(LPCTSTR lpszEmptyPageText)
  143. {
  144. m_strEmptyPageMessage = lpszEmptyPageText;
  145. }
  148. DWORD CTreePropSheet::SetEmptyPageTextFormat(DWORD dwFormat)
  149. {
  150. DWORD dwPrevFormat = m_pFrame->GetMsgFormat();
  151. m_pFrame->SetMsgFormat(dwFormat);
  152. return dwPrevFormat;
  153. }
  156. BOOL CTreePropSheet::SetTreeDefaultImages(CImageList *pImages)
  157. {
  158. if (pImages->GetImageCount() != 2)
  159. {
  160. ASSERT(FALSE);
  161. return FALSE;
  162. }
  164. if (m_DefaultImages.GetSafeHandle())
  165. m_DefaultImages.DeleteImageList();
  166. m_DefaultImages.Create(pImages);
  168. // update, if necessary
  169. if (IsWindow(m_hWnd))
  170. RefillPageTree();
  172. return TRUE;
  173. }
  176. BOOL CTreePropSheet::SetTreeDefaultImages(UINT unBitmapID, int cx, COLORREF crMask)
  177. {
  178. if (m_DefaultImages.GetSafeHandle())
  179. m_DefaultImages.DeleteImageList();
  180. if (!m_DefaultImages.Create(unBitmapID, cx, 0, crMask))
  181. return FALSE;
  183. if (m_DefaultImages.GetImageCount() != 2)
  184. {
  185. m_DefaultImages.DeleteImageList();
  186. return FALSE;
  187. }
  189. return TRUE;
  190. }
  193. CTreeCtrl* CTreePropSheet::GetPageTreeControl()
  194. {
  195. return m_pwndPageTree;
  196. }
  199. /////////////////////////////////////////////////////////////////////
  200. // public helpers
  202. BOOL CTreePropSheet::SetPageIcon(CPropertyPage *pPage, HICON hIcon)
  203. {
  204. pPage->m_psp.dwFlags|= PSP_USEHICON;
  205. pPage->m_psp.hIcon = hIcon;
  206. return TRUE;
  207. }
  210. BOOL CTreePropSheet::SetPageIcon(CPropertyPage *pPage, UINT unIconId)
  211. {
  212. HICON hIcon = AfxGetApp()->LoadIcon(unIconId);
  213. if (!hIcon)
  214. return FALSE;
  216. return SetPageIcon(pPage, hIcon);
  217. }
  220. BOOL CTreePropSheet::SetPageIcon(CPropertyPage *pPage, CImageList &Images, int nImage)
  221. {
  222. HICON hIcon = Images.ExtractIcon(nImage);
  223. if (!hIcon)
  224. return FALSE;
  226. return SetPageIcon(pPage, hIcon);
  227. }
  230. BOOL CTreePropSheet::DestroyPageIcon(CPropertyPage *pPage)
  231. {
  232. if (!pPage || !(pPage->m_psp.dwFlags&PSP_USEHICON) || !pPage->m_psp.hIcon)
  233. return FALSE;
  235. DestroyIcon(pPage->m_psp.hIcon);
  236. pPage->m_psp.dwFlags&= ~PSP_USEHICON;
  237. pPage->m_psp.hIcon = NULL;
  239. return TRUE;
  240. }
  243. /////////////////////////////////////////////////////////////////////
  244. // Overridable implementation helpers
  246. CString CTreePropSheet::GenerateEmptyPageMessage(LPCTSTR lpszEmptyPageMessage, LPCTSTR lpszCaption)
  247. {
  248. CString strMsg;
  249. strMsg.Format(lpszEmptyPageMessage, lpszCaption);
  250. return strMsg;
  251. }
  254. CTreeCtrl* CTreePropSheet::CreatePageTreeObject()
  255. {
  256. return new CTreeCtrl;
  257. }
  260. CPropPageFrame* CTreePropSheet::CreatePageFrame()
  261. {
  262. return new CPropPageFrameDefault;
  263. }
  266. /////////////////////////////////////////////////////////////////////
  267. // Implementation helpers
  269. void CTreePropSheet::MoveChildWindows(int nDx, int nDy)
  270. {
  271. CWnd *pWnd = GetWindow(GW_CHILD);
  272. while (pWnd)
  273. {
  274. CRect rect;
  275. pWnd->GetWindowRect(rect);
  276. rect.OffsetRect(nDx, nDy);
  277. ScreenToClient(rect);
  278. pWnd->MoveWindow(rect);
  280. pWnd = pWnd->GetNextWindow();
  281. }
  282. }
  285. void CTreePropSheet::RefillPageTree()
  286. {
  287. if (!IsWindow(m_hWnd))
  288. return;
  290. m_pwndPageTree->DeleteAllItems();
  292. CTabCtrl *pTabCtrl = GetTabControl();
  293. if (!IsWindow(pTabCtrl->GetSafeHwnd()))
  294. {
  295. ASSERT(FALSE);
  296. return;
  297. }
  299. const int nPageCount = pTabCtrl->GetItemCount();
  301. // rebuild image list
  302. if (m_bTreeImages)
  303. {
  304. for (int i = m_Images.GetImageCount()-1; i >= 0; --i)
  305. m_Images.Remove(i);
  307. // add page images
  308. CImageList *pPageImages = pTabCtrl->GetImageList();
  309. if (pPageImages)
  310. {
  311. for (int nImage = 0; nImage < pPageImages->GetImageCount(); ++nImage)
  312. {
  313. HICON hIcon = pPageImages->ExtractIcon(nImage);
  314. m_Images.Add(hIcon);
  315. DestroyIcon(hIcon);
  316. }
  317. }
  319. // add default images
  320. if (m_DefaultImages.GetSafeHandle())
  321. {
  322. HICON hIcon;
  324. // add default images
  325. hIcon = m_DefaultImages.ExtractIcon(0);
  326. if (hIcon)
  327. {
  328. m_Images.Add(hIcon);
  329. DestroyIcon(hIcon);
  330. }
  331. hIcon = m_DefaultImages.ExtractIcon(1);
  332. {
  333. m_Images.Add(hIcon);
  334. DestroyIcon(hIcon);
  335. }
  336. }
  337. }
  339. // insert tree items
  340. for (int nPage = 0; nPage < nPageCount; ++nPage)
  341. {
  342. // Get title and image of the page
  343. CString strPagePath;
  345. TCITEM ti;
  346. ZeroMemory(&ti, sizeof(ti));
  347. ti.mask = TCIF_TEXT|TCIF_IMAGE;
  348. ti.cchTextMax = MAX_PATH;
  349. ti.pszText = strPagePath.GetBuffer(ti.cchTextMax);
  350. ASSERT(ti.pszText);
  351. if (!ti.pszText)
  352. return;
  354. pTabCtrl->GetItem(nPage, &ti);
  355. strPagePath.ReleaseBuffer();
  357. // Create an item in the tree for the page
  358. HTREEITEM hItem = CreatePageTreeItem(ti.pszText);
  359. ASSERT(hItem);
  360. if (hItem)
  361. {
  362. m_pwndPageTree->SetItemData(hItem, nPage);
  364. // set image
  365. if (m_bTreeImages)
  366. {
  367. int nImage = ti.iImage;
  368. if (nImage < 0 || nImage >= m_Images.GetImageCount())
  369. nImage = m_DefaultImages.GetSafeHandle()? m_Images.GetImageCount()-1 : -1;
  371. m_pwndPageTree->SetItemImage(hItem, nImage, nImage);
  372. }
  373. }
  374. }
  375. }
  378. HTREEITEM CTreePropSheet::CreatePageTreeItem(LPCTSTR lpszPath, HTREEITEM hParent /* = TVI_ROOT */)
  379. {
  380. CString strPath(lpszPath);
  381. CString strTopMostItem(SplitPageTreePath(strPath));
  383. // Check if an item with the given text does already exist
  384. HTREEITEM hItem = NULL;
  385. HTREEITEM hChild = m_pwndPageTree->GetChildItem(hParent);
  386. while (hChild)
  387. {
  388. if (m_pwndPageTree->GetItemText(hChild) == strTopMostItem)
  389. {
  390. hItem = hChild;
  391. break;
  392. }
  393. hChild = m_pwndPageTree->GetNextItem(hChild, TVGN_NEXT);
  394. }
  396. // If item with that text does not already exist, create a new one
  397. if (!hItem)
  398. {
  399. hItem = m_pwndPageTree->InsertItem(strTopMostItem, hParent);
  400. m_pwndPageTree->SetItemData(hItem, -1);
  401. if (!strPath.IsEmpty() && m_bTreeImages && m_DefaultImages.GetSafeHandle())
  402. // set folder image
  403. m_pwndPageTree->SetItemImage(hItem, m_Images.GetImageCount()-2, m_Images.GetImageCount()-2);
  404. }
  405. if (!hItem)
  406. {
  407. ASSERT(FALSE);
  408. return NULL;
  409. }
  411. if (strPath.IsEmpty())
  412. return hItem;
  413. else
  414. return CreatePageTreeItem(strPath, hItem);
  415. }
  418. CString CTreePropSheet::SplitPageTreePath(CString &strRest)
  419. {
  420. int nSeperatorPos = 0;
  421. while (TRUE)
  422. {
  423. nSeperatorPos = strRest.Find(_T("::"), nSeperatorPos);
  424. if (nSeperatorPos == -1)
  425. {
  426. CString strItem(strRest);
  427. strRest.Empty();
  428. return strItem;
  429. }
  430. else if (nSeperatorPos>0)
  431. {
  432. // if there is an odd number of backslashes infront of the
  433. // seperator, than do not interpret it as separator
  434. int nBackslashCount = 0;
  435. for (int nPos = nSeperatorPos-1; nPos >= 0 && strRest[nPos]==_T('\'); --nPos, ++nBackslashCount);
  436. if (nBackslashCount%2 == 0)
  437. break;
  438. else
  439. ++nSeperatorPos;
  440. }
  441. }
  443. CString strItem(strRest.Left(nSeperatorPos));
  444. strItem.Replace(_T("\::"), _T("::"));
  445. strItem.Replace(_T("\\"), _T("\"));
  446. strRest = strRest.Mid(nSeperatorPos+2);
  447. return strItem;
  448. }
  451. BOOL CTreePropSheet::KillActiveCurrentPage()
  452. {
  453. HWND hCurrentPage = PropSheet_GetCurrentPageHwnd(m_hWnd);
  454. if (!IsWindow(hCurrentPage))
  455. {
  456. ASSERT(FALSE);
  457. return TRUE;
  458. }
  460. // Check if the current page is really active (if page is invisible
  461. // an virtual empty page is the active one.
  462. if (!::IsWindowVisible(hCurrentPage))
  463. return TRUE;
  465. // Try to deactivate current page
  466. PSHNOTIFY pshn;
  467. pshn.hdr.code = PSN_KILLACTIVE;
  468. pshn.hdr.hwndFrom = m_hWnd;
  469. pshn.hdr.idFrom = GetDlgCtrlID();
  470. pshn.lParam = 0;
  471. if (::SendMessage(hCurrentPage, WM_NOTIFY, pshn.hdr.idFrom, (LPARAM)&pshn))
  472. // current page does not allow page change
  473. return FALSE;
  475. // Hide the page
  476. ::ShowWindow(hCurrentPage, SW_HIDE);
  478. return TRUE;
  479. }
  482. HTREEITEM CTreePropSheet::GetPageTreeItem(int nPage, HTREEITEM hRoot /* = TVI_ROOT */)
  483. {
  484. // Special handling for root case
  485. if (hRoot == TVI_ROOT)
  486. hRoot = m_pwndPageTree->GetNextItem(NULL, TVGN_ROOT);
  488. // Check parameters
  489. if (nPage < 0 || nPage >= GetPageCount())
  490. {
  491. ASSERT(FALSE);
  492. return NULL;
  493. }
  495. if (hRoot == NULL)
  496. {
  497. ASSERT(FALSE);
  498. return NULL;
  499. }
  501. // we are performing a simple linear search here, because we are
  502. // expecting only little data
  503. HTREEITEM hItem = hRoot;
  504. while (hItem)
  505. {
  506. if ((signed)m_pwndPageTree->GetItemData(hItem) == nPage)
  507. return hItem;
  508. if (m_pwndPageTree->ItemHasChildren(hItem))
  509. {
  510. HTREEITEM hResult = GetPageTreeItem(nPage, m_pwndPageTree->GetNextItem(hItem, TVGN_CHILD));
  511. if (hResult)
  512. return hResult;
  513. }
  515. hItem = m_pwndPageTree->GetNextItem(hItem, TVGN_NEXT);
  516. }
  518. // we've found nothing, if we arrive here
  519. return hItem;
  520. }
  523. BOOL CTreePropSheet::SelectPageTreeItem(int nPage)
  524. {
  525. HTREEITEM hItem = GetPageTreeItem(nPage);
  526. if (!hItem)
  527. return FALSE;
  529. return m_pwndPageTree->SelectItem(hItem);
  530. }
  533. BOOL CTreePropSheet::SelectCurrentPageTreeItem()
  534. {
  535. CTabCtrl *pTab = GetTabControl();
  536. if (!IsWindow(pTab->GetSafeHwnd()))
  537. return FALSE;
  539. return SelectPageTreeItem(pTab->GetCurSel());
  540. }
  543. void CTreePropSheet::UpdateCaption()
  544. {
  545. HWND hPage = PropSheet_GetCurrentPageHwnd(GetSafeHwnd());
  546. BOOL bRealPage = IsWindow(hPage) && ::IsWindowVisible(hPage);
  547. HTREEITEM hItem = m_pwndPageTree->GetSelectedItem();
  548. if (!hItem)
  549. return;
  550. CString strCaption = m_pwndPageTree->GetItemText(hItem);
  552. // if empty page, then update empty page message
  553. if (!bRealPage)
  554. m_pFrame->SetMsgText(GenerateEmptyPageMessage(m_strEmptyPageMessage, strCaption));
  556. // if no captions are displayed, cancel here
  557. if (!m_pFrame->GetShowCaption())
  558. return;
  560. // get tab control, to the the images from
  561. CTabCtrl *pTabCtrl = GetTabControl();
  562. if (!IsWindow(pTabCtrl->GetSafeHwnd()))
  563. {
  564. ASSERT(FALSE);
  565. return;
  566. }
  568. if (m_bTreeImages)
  569. {
  570. // get image from tree
  571. int nImage;
  572. m_pwndPageTree->GetItemImage(hItem, nImage, nImage);
  573. HICON hIcon = m_Images.ExtractIcon(nImage);
  574. m_pFrame->SetCaption(strCaption, hIcon);
  575. if (hIcon)
  576. DestroyIcon(hIcon);
  577. }
  578. else if (bRealPage)
  579. {
  580. // get image from hidden (original) tab provided by the original
  581. // implementation
  582. CImageList *pImages = pTabCtrl->GetImageList();
  583. if (pImages)
  584. {
  585. TCITEM ti;
  586. ZeroMemory(&ti, sizeof(ti));
  587. ti.mask = TCIF_IMAGE;
  589. HICON hIcon = NULL;
  590. if (pTabCtrl->GetItem((int)m_pwndPageTree->GetItemData(hItem), &ti))
  591. hIcon = pImages->ExtractIcon(ti.iImage);
  593. m_pFrame->SetCaption(strCaption, hIcon);
  594. if (hIcon)
  595. DestroyIcon(hIcon);
  596. }
  597. else
  598. m_pFrame->SetCaption(strCaption);
  599. }
  600. else
  601. m_pFrame->SetCaption(strCaption);
  602. }
  605. void CTreePropSheet::ActivatePreviousPage()
  606. {
  607. if (!IsWindow(m_hWnd))
  608. return;
  610. if (!IsWindow(m_pwndPageTree->GetSafeHwnd()))
  611. {
  612. // normal tab property sheet. Simply use page index
  613. int nPageIndex = GetActiveIndex();
  614. if (nPageIndex<0 || nPageIndex>=GetPageCount())
  615. return;
  617. int nPrevIndex = (nPageIndex==0)? GetPageCount()-1 : nPageIndex-1;
  618. SetActivePage(nPrevIndex);
  619. }
  620. else
  621. {
  622. // property sheet with page tree.
  623. // we need a more sophisticated handling here, than simply using
  624. // the page index, because we won't skip empty pages.
  625. // so we have to walk the page tree
  626. HTREEITEM hItem = m_pwndPageTree->GetSelectedItem();
  627. ASSERT(hItem);
  628. if (!hItem)
  629. return;
  631. HTREEITEM hPrevItem = NULL;
  632. if (hPrevItem=m_pwndPageTree->GetPrevSiblingItem(hItem))
  633. {
  634. while (m_pwndPageTree->ItemHasChildren(hPrevItem))
  635. {
  636. hPrevItem = m_pwndPageTree->GetChildItem(hPrevItem);
  637. while (m_pwndPageTree->GetNextSiblingItem(hPrevItem))
  638. hPrevItem = m_pwndPageTree->GetNextSiblingItem(hPrevItem);
  639. }
  640. }
  641. else 
  642. hPrevItem=m_pwndPageTree->GetParentItem(hItem);
  644. if (!hPrevItem)
  645. {
  646. // no prev item, so cycle to the last item
  647. hPrevItem = m_pwndPageTree->GetRootItem();
  649. while (TRUE)
  650. {
  651. while (m_pwndPageTree->GetNextSiblingItem(hPrevItem))
  652. hPrevItem = m_pwndPageTree->GetNextSiblingItem(hPrevItem);
  654. if (m_pwndPageTree->ItemHasChildren(hPrevItem))
  655. hPrevItem = m_pwndPageTree->GetChildItem(hPrevItem);
  656. else
  657. break;
  658. }
  659. }
  661. if (hPrevItem)
  662. m_pwndPageTree->SelectItem(hPrevItem);
  663. }
  664. }
  667. void CTreePropSheet::ActivateNextPage()
  668. {
  669. if (!IsWindow(m_hWnd))
  670. return;
  672. if (!IsWindow(m_pwndPageTree->GetSafeHwnd()))
  673. {
  674. // normal tab property sheet. Simply use page index
  675. int nPageIndex = GetActiveIndex();
  676. if (nPageIndex<0 || nPageIndex>=GetPageCount())
  677. return;
  679. int nNextIndex = (nPageIndex==GetPageCount()-1)? 0 : nPageIndex+1;
  680. SetActivePage(nNextIndex);
  681. }
  682. else
  683. {
  684. // property sheet with page tree.
  685. // we need a more sophisticated handling here, than simply using
  686. // the page index, because we won't skip empty pages.
  687. // so we have to walk the page tree
  688. HTREEITEM hItem = m_pwndPageTree->GetSelectedItem();
  689. ASSERT(hItem);
  690. if (!hItem)
  691. return;
  693. HTREEITEM hNextItem = NULL;
  694. if (hNextItem=m_pwndPageTree->GetChildItem(hItem))
  695. ;
  696. else if (hNextItem=m_pwndPageTree->GetNextSiblingItem(hItem))
  697. ;
  698. else if (m_pwndPageTree->GetParentItem(hItem))
  699. {
  700. while (!hNextItem)
  701. {
  702. hItem = m_pwndPageTree->GetParentItem(hItem);
  703. if (!hItem)
  704. break;
  706. hNextItem = m_pwndPageTree->GetNextSiblingItem(hItem);
  707. }
  708. }
  710. if (!hNextItem)
  711. // no next item -- so cycle to the first item
  712. hNextItem = m_pwndPageTree->GetRootItem();
  714. if (hNextItem)
  715. m_pwndPageTree->SelectItem(hNextItem);
  716. }
  717. }
  720. /////////////////////////////////////////////////////////////////////
  721. // Overridings
  723. BOOL CTreePropSheet::OnInitDialog() 
  724. {
  725. if (m_bTreeViewMode)
  726. {
  727. // be sure, there are no stacked tabs, because otherwise the
  728. // page caption will be to large in tree view mode
  729. EnableStackedTabs(FALSE);
  731. // Initialize image list.
  732. if (m_DefaultImages.GetSafeHandle())
  733. {
  734. IMAGEINFO ii;
  735. m_DefaultImages.GetImageInfo(0, &ii);
  736. if (ii.hbmImage) DeleteObject(ii.hbmImage);
  737. if (ii.hbmMask) DeleteObject(ii.hbmMask);
  738. m_Images.Create(ii.rcImage.right-ii.rcImage.left, ii.rcImage.bottom-ii.rcImage.top, ILC_COLOR32|ILC_MASK, 0, 1);
  739. }
  740. else
  741. m_Images.Create(16, 16, ILC_COLOR32|ILC_MASK, 0, 1);
  742. }
  744. // perform default implementation
  745. BOOL bResult = __super::OnInitDialog();
  747. if (!m_bTreeViewMode)
  748. // stop here, if we would like to use tabs
  749. return bResult;
  751. // Get tab control...
  752. CTabCtrl *pTab = GetTabControl();
  753. if (!IsWindow(pTab->GetSafeHwnd()))
  754. {
  755. ASSERT(FALSE);
  756. return bResult;
  757. }
  759. // ... and hide it
  760. pTab->ShowWindow(SW_HIDE);
  761. pTab->EnableWindow(FALSE);
  763. // Place another (empty) tab ctrl, to get a frame instead
  764. CRect rectFrame;
  765. pTab->GetWindowRect(rectFrame);
  766. ScreenToClient(rectFrame);
  768. m_pFrame = CreatePageFrame();
  769. if (!m_pFrame)
  770. {
  771. ASSERT(FALSE);
  772. AfxThrowMemoryException();
  773. }
  774. m_pFrame->Create(WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS, rectFrame, this, 0xFFFF);
  775. m_pFrame->ShowCaption(m_bPageCaption);
  777. // Lets make place for the tree ctrl
  778. const int nTreeWidth = m_nPageTreeWidth;
  779. const int nTreeSpace = 5;
  781. CRect rectSheet;
  782. GetWindowRect(rectSheet);
  783. rectSheet.right+= nTreeWidth;
  784. SetWindowPos(NULL, -1, -1, rectSheet.Width(), rectSheet.Height(), SWP_NOZORDER|SWP_NOMOVE);
  785. CenterWindow();
  787. MoveChildWindows(nTreeWidth, 0);
  789. // Lets calculate the rectangle for the tree ctrl
  790. CRect rectTree(rectFrame);
  791. rectTree.right = rectTree.left + nTreeWidth - nTreeSpace;
  793. // calculate caption height
  794. CTabCtrl wndTabCtrl;
  795. wndTabCtrl.Create(WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS, rectFrame, this, 0x1234);
  796. wndTabCtrl.InsertItem(0, _T(""));
  797. CRect rectFrameCaption;
  798. wndTabCtrl.GetItemRect(0, rectFrameCaption);
  799. wndTabCtrl.DestroyWindow();
  800. m_pFrame->SetCaptionHeight(rectFrameCaption.Height());
  802. // if no caption should be displayed, make the window smaller in
  803. // height
  804. if (!m_bPageCaption)
  805. {
  806. // make frame smaller
  807. m_pFrame->GetWnd()->GetWindowRect(rectFrame);
  808. ScreenToClient(rectFrame);
  809. rectFrame.top+= rectFrameCaption.Height();
  810. m_pFrame->GetWnd()->MoveWindow(rectFrame);
  812. // move all child windows up
  813. MoveChildWindows(0, -rectFrameCaption.Height());
  815. // modify rectangle for the tree ctrl
  816. rectTree.bottom-= rectFrameCaption.Height();
  818. // make us smaller
  819. CRect rect;
  820. GetWindowRect(rect);
  821. rect.top+= rectFrameCaption.Height()/2;
  822. rect.bottom-= rectFrameCaption.Height()-rectFrameCaption.Height()/2;
  823. // if (GetParent())
  824. // GetParent()->ScreenToClient(rect);
  825. MoveWindow(rect);
  826. }
  828. // finally create tht tree control
  829. const DWORD dwTreeStyle = TVS_SHOWSELALWAYS|TVS_TRACKSELECT|TVS_HASLINES|TVS_LINESATROOT|TVS_HASBUTTONS;
  830. m_pwndPageTree = CreatePageTreeObject();
  831. if (!m_pwndPageTree)
  832. {
  833. ASSERT(FALSE);
  834. AfxThrowMemoryException();
  835. }
  837. // MFC7-support here (Thanks to Rainer Wollgarten)
  838. #if _MFC_VER >= 0x0700
  839. {
  840. m_pwndPageTree->CreateEx(
  841. WS_EX_CLIENTEDGE|WS_EX_NOPARENTNOTIFY, 
  842. WS_TABSTOP|WS_CHILD|WS_VISIBLE|dwTreeStyle, 
  843. rectTree, this, s_unPageTreeId);
  844. }
  845. #else
  846. {
  847. m_pwndPageTree->CreateEx(
  848. WS_EX_CLIENTEDGE|WS_EX_NOPARENTNOTIFY, 
  849. _T("SysTreeView32"), _T("PageTree"), 
  850. WS_TABSTOP|WS_CHILD|WS_VISIBLE|dwTreeStyle, 
  851. rectTree, this, s_unPageTreeId);
  852. }
  853. #endif
  855. if (m_bTreeImages)
  856. {
  857. m_pwndPageTree->SetImageList(&m_Images, TVSIL_NORMAL);
  858. m_pwndPageTree->SetImageList(&m_Images, TVSIL_STATE);
  859. }
  861. // Fill the tree ctrl
  862. RefillPageTree();
  864. // Select item for the current page
  865. if (pTab->GetCurSel() > -1)
  866. SelectPageTreeItem(pTab->GetCurSel());
  868. return bResult;
  869. }
  872. void CTreePropSheet::OnDestroy() 
  873. {
  874. __super::OnDestroy();
  876. if(m_pwndPageTree && m_pwndPageTree->m_hWnd)
  877. m_pwndPageTree->DestroyWindow();
  879. if(m_pFrame && m_pFrame->GetWnd()->m_hWnd)
  880. m_pFrame->GetWnd()->DestroyWindow();
  881. }
  884. LRESULT CTreePropSheet::OnAddPage(WPARAM wParam, LPARAM lParam)
  885. {
  886. LRESULT lResult = DefWindowProc(PSM_ADDPAGE, wParam, lParam);
  887. if (!m_bTreeViewMode)
  888. return lResult;
  890. RefillPageTree();
  891. SelectCurrentPageTreeItem();
  893. return lResult;
  894. }
  897. LRESULT CTreePropSheet::OnRemovePage(WPARAM wParam, LPARAM lParam)
  898. {
  899. LRESULT lResult = DefWindowProc(PSM_REMOVEPAGE, wParam, lParam);
  900. if (!m_bTreeViewMode)
  901. return lResult;
  903. RefillPageTree();
  904. SelectCurrentPageTreeItem();
  906. return lResult;
  907. }
  910. LRESULT CTreePropSheet::OnSetCurSel(WPARAM wParam, LPARAM lParam)
  911. {
  912. LRESULT lResult = DefWindowProc(PSM_SETCURSEL, wParam, lParam);
  913. if (!m_bTreeViewMode)
  914. return lResult;
  916. SelectCurrentPageTreeItem();
  917. UpdateCaption();
  918. return lResult;
  919. }
  922. LRESULT CTreePropSheet::OnSetCurSelId(WPARAM wParam, LPARAM lParam)
  923. {
  924. LRESULT lResult = DefWindowProc(PSM_SETCURSEL, wParam, lParam);
  925. if (!m_bTreeViewMode)
  926. return lResult;
  928. SelectCurrentPageTreeItem();
  929. UpdateCaption();
  930. return lResult;
  931. }
  934. void CTreePropSheet::OnPageTreeSelChanging(NMHDR *pNotifyStruct, LRESULT *plResult)
  935. {
  936. *plResult = 0;
  937. if (m_bPageTreeSelChangedActive)
  938. return;
  939. else
  940. m_bPageTreeSelChangedActive = TRUE;
  942. NMTREEVIEW *pTvn = reinterpret_cast<NMTREEVIEW*>(pNotifyStruct);
  943. int nPage = m_pwndPageTree->GetItemData(pTvn->itemNew.hItem);
  944. BOOL bResult;
  945. if (nPage<0 || (unsigned)nPage>=m_pwndPageTree->GetCount())
  946. bResult = KillActiveCurrentPage();
  947. else
  948. bResult = SetActivePage(nPage);
  950. if (!bResult)
  951. // prevent selection to change
  952. *plResult = TRUE;
  954. // Set focus to tree ctrl (I guess that's what the user expects)
  955. m_pwndPageTree->SetFocus();
  957. m_bPageTreeSelChangedActive = FALSE;
  959. return;
  960. }
  963. void CTreePropSheet::OnPageTreeSelChanged(NMHDR *pNotifyStruct, LRESULT *plResult)
  964. {
  965. *plResult = 0;
  967. UpdateCaption();
  969. return;
  970. }
  973. LRESULT CTreePropSheet::OnIsDialogMessage(WPARAM wParam, LPARAM lParam)
  974. {
  975. MSG *pMsg = reinterpret_cast<MSG*>(lParam);
  976. if (pMsg->message==WM_KEYDOWN && pMsg->wParam==VK_TAB && GetKeyState(VK_CONTROL)&0x8000)
  977. {
  978. if (GetKeyState(VK_SHIFT)&0x8000)
  979. ActivatePreviousPage();
  980. else
  981. ActivateNextPage();
  982. return TRUE;
  983. }
  986. return __super::DefWindowProc(PSM_ISDIALOGMESSAGE, wParam, lParam);
  987. }
  989. } //namespace TreePropSheet