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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTMDIWndTab.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：20k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTMDIWndTab.cpp：源码内容
  1. // XTMDIWndTab.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME CONTROLS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Resource.h"
  24. #include "Common/XTPVC80Helpers.h"
  25. #include "Common/XTPSystemHelpers.h"
  27. #include "XTGlobal.h"
  28. #include "XTVC50Helpers.h"
  29. #include "XTTabCtrlButtons.h"
  30. #include "XTTabBase.h"
  31. #include "XTMDIWndTab.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. /////////////////////////////////////////////////////////////////////////////
  40. // CXTMDIClientWnd
  42. CXTMDIClientWnd::CXTMDIClientWnd(CXTMDIWndTab* pMDIWndTab)
  43. {
  44. ASSERT_VALID(pMDIWndTab);
  45. m_pMDIWndTab = pMDIWndTab;
  46. m_iBorderGap = pMDIWndTab->m_iBorderGap + ::GetSystemMetrics(SM_CXSIZEFRAME);
  47. }
  49. CXTMDIClientWnd::~CXTMDIClientWnd()
  50. {
  51. }
  53. BEGIN_MESSAGE_MAP(CXTMDIClientWnd, CWnd)
  54. //{{AFX_MSG_MAP(CXTMDIClientWnd)
  55. //}}AFX_MSG_MAP
  56. ON_MESSAGE(WM_MDICREATE, OnMDICreate)
  57. ON_MESSAGE(WM_MDIDESTROY, OnMDIDestroy)
  58. ON_MESSAGE(WM_MDIACTIVATE, OnMDIActivate)
  59. END_MESSAGE_MAP()
  61. /////////////////////////////////////////////////////////////////////////////
  62. // CXTMDIClientWnd message handlers
  64. LRESULT CXTMDIClientWnd::OnMDICreate(WPARAM /*wParam*/, LPARAM /*lParam*/)
  65. {
  66. LRESULT lResult = Default();
  67. m_pMDIWndTab->OnMDICreate((HWND)lResult);
  68. return lResult;
  69. }
  71. LRESULT CXTMDIClientWnd::OnMDIDestroy(WPARAM wParam, LPARAM /*lParam*/)
  72. {
  73. LRESULT lResult = Default();
  74. m_pMDIWndTab->OnMDIDestroy((HWND)wParam);
  75. return lResult;
  76. }
  78. LRESULT CXTMDIClientWnd::OnMDIActivate(WPARAM wParam, LPARAM /*lParam*/)
  79. {
  80. LRESULT lResult = Default();
  81. m_pMDIWndTab->OnMDIActivate((HWND)wParam);
  82. return lResult;
  83. }
  85. void CXTMDIClientWnd::CalcWindowRect(LPRECT lpClientRect, UINT nAdjustType)
  86. {
  87. if (::IsWindow(m_pMDIWndTab->m_hWnd) && m_pMDIWndTab->IsWindowVisible())
  88. {
  89. m_pMDIWndTab->MoveWindow(lpClientRect);
  91. DWORD dwStyle = m_pMDIWndTab->GetStyle();
  93. CRect rcTab;
  94. m_pMDIWndTab->GetItemRect(m_pMDIWndTab->GetCurSel(), &rcTab);
  96. int cy = rcTab.Height() * m_pMDIWndTab->GetRowCount();
  97. int cx = rcTab.Width () * m_pMDIWndTab->GetRowCount();
  99. // vertical tabs
  100. if (dwStyle & TCS_VERTICAL)
  101. {
  102. // Right
  103. if (dwStyle & TCS_RIGHT)
  104. {
  105. lpClientRect->top += m_iBorderGap;
  106. lpClientRect->left += m_iBorderGap;
  107. lpClientRect->right -= cx + m_iBorderGap + 2;
  108. lpClientRect->bottom -= m_iBorderGap;
  109. }
  111. // Left
  112. else
  113. {
  114. lpClientRect->top += m_iBorderGap;
  115. lpClientRect->left += cx + m_iBorderGap + 2;
  116. lpClientRect->right -= m_iBorderGap;
  117. lpClientRect->bottom -= m_iBorderGap;
  118. }
  119. }
  121. // horizontal tabs
  122. else
  123. {
  124. // Bottom
  125. if (dwStyle & TCS_BOTTOM)
  126. {
  127. lpClientRect->top += m_iBorderGap;
  128. lpClientRect->left += m_iBorderGap;
  129. lpClientRect->right -= m_iBorderGap;
  130. lpClientRect->bottom -= cy + m_iBorderGap + 2;
  131. }
  133. // Top
  134. else
  135. {
  136. lpClientRect->top += cy + m_iBorderGap + 2;
  137. lpClientRect->left += m_iBorderGap;
  138. lpClientRect->right -= m_iBorderGap;
  139. lpClientRect->bottom -= m_iBorderGap;
  140. }
  141. }
  142. }
  144. CWnd::CalcWindowRect(lpClientRect, nAdjustType);
  145. }
  147. /////////////////////////////////////////////////////////////////////////////
  148. // CXTMDIWndTab
  150. CXTMDIWndTab::CXTMDIWndTab()
  151. {
  152. m_bNoIcons = FALSE;
  153. m_iBorderGap = 5;
  154. m_nPos = 0;
  155. m_nDefCmd = 0;
  156. m_popupMenuID = 0;
  157. m_hActiveChild = NULL;
  158. m_pMDIClientWnd = NULL;
  159. m_pMDIFrameWnd = NULL;
  160. m_bXPBorder = false;
  161. m_dwInitSignature = 1;
  163. ImplAttach(this);
  164. }
  166. CXTMDIWndTab::~CXTMDIWndTab()
  167. {
  168. SAFE_DELETE (m_pMDIClientWnd);
  170. while (!m_arMDIChildern.IsEmpty())
  171. {
  172. MDICHILD* pMDIChild = m_arMDIChildern.RemoveHead();
  173. SAFE_DELETE(pMDIChild);
  174. }
  175. }
  177. IMPLEMENT_THEME_REFRESH(CXTMDIWndTab, CTabCtrl)
  178. IMPLEMENT_DYNAMIC(CXTMDIWndTab, CTabCtrl)
  180. BEGIN_MESSAGE_MAP(CXTMDIWndTab, CTabCtrl)
  181. //{{AFX_MSG_MAP(CXTMDIWndTab)
  182. ON_WM_NCCALCSIZE()
  183. ON_WM_NCPAINT()
  184. ON_NOTIFY_REFLECT(TCN_SELCHANGE, OnSelchange)
  185. ON_WM_DESTROY()
  186. ON_WM_RBUTTONDOWN()
  187. //}}AFX_MSG_MAP
  188. ON_MESSAGE_VOID(WM_IDLEUPDATECMDUI, OnIdleUpdateCmdUI)
  189. ON_COMMAND(XT_IDC_TAB_CLOSE, OnTabClose)
  190. ON_TABCTRL_REFLECT()
  191. END_MESSAGE_MAP()
  193. /////////////////////////////////////////////////////////////////////////////
  194. // CXTMDIWndTab message handlers
  196. bool CXTMDIWndTab::Init()
  197. {
  198. if (!CXTMDIWndTabBase::Init())
  199. return false;
  201. ShowNavButtons(xtNavBtnShowAll);
  203. int cx = ::GetSystemMetrics(SM_CXSMICON);
  204. int cy = ::GetSystemMetrics(SM_CYSMICON);
  206. if (!m_imageList.Create(cx, cy, ILC_COLOR16 | ILC_MASK, 0, 1))
  207. {
  208. TRACE0("Unable to create CXTMDIWndTab image list.n");
  209. return FALSE;
  210. }
  212. SetImageList(&m_imageList);
  213. InitializeFont();
  215. return true;
  216. }
  218. BOOL CXTMDIWndTab::Install(CMDIFrameWnd* pMDIFrameWnd, DWORD dwStyle/*= TCS_BOTTOM | TCS_HOTTRACK*/, BOOL bNoIcons/*= FALSE*/)
  219. {
  220. ASSERT_VALID(pMDIFrameWnd);                // must be valid.
  221. ASSERT_KINDOF(CMDIFrameWnd, pMDIFrameWnd); // must be MDI frame window.
  223. m_bNoIcons = bNoIcons;
  224. m_pMDIFrameWnd = pMDIFrameWnd;
  225. m_iBorderGap = GetSafeTheme()->GetTheme() != xtThemeDefault ? 1 : 5;
  227. dwStyle |= WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN;
  229. if (!Create(dwStyle, CRect(0, 0, 0, 0), m_pMDIFrameWnd, AFX_IDC_TAB_CONTROL))
  230. {
  231. TRACE0("Unable to create CXTMDIWndTab control.n");
  232. return FALSE;
  233. }
  235. m_pMDIClientWnd = new CXTMDIClientWnd(this);
  236. ASSERT(m_pMDIClientWnd != NULL);
  238. if (!m_pMDIClientWnd->SubclassWindow(m_pMDIFrameWnd->m_hWndMDIClient))
  239. return FALSE;
  241. // Retrieve the current active MDI child window.
  242. CMDIChildWnd* pActiveChild = (CMDIChildWnd*)m_pMDIFrameWnd->MDIGetActive();
  243. if (pActiveChild != NULL)
  244. {
  245. // Get the first top-level window in the list.
  246. CMDIChildWnd* pChildFrame = (CMDIChildWnd*)pActiveChild->GetWindow(GW_HWNDLAST);
  247. while (pChildFrame != NULL)
  248. {
  249. // Insert the tab and get the next frame on the window manager's list
  250. InsertTabWnd(pChildFrame, FALSE);
  251. pChildFrame = (CMDIChildWnd*)pChildFrame->GetWindow(GW_HWNDPREV);
  252. }
  253. }
  255. // Force parent frame to re-adjust layout.
  256. m_pMDIFrameWnd->RecalcLayout();
  258. return TRUE;
  259. }
  261. BOOL CXTMDIWndTab::UnInstall()
  262. {
  263. // Remove all of the items from the child array.
  264. while (!m_arMDIChildern.IsEmpty())
  265. {
  266. MDICHILD* pMDIChild = m_arMDIChildern.RemoveHead();
  267. SAFE_DELETE(pMDIChild);
  268. }
  270. CXTTabCtrlButtons* pNavBtns = GetButtons();
  271. if (pNavBtns && pNavBtns->GetSafeHwnd())
  272. {
  273. pNavBtns->UnSubclassTabButtons();
  274. }
  276. if (::IsWindow(m_hWnd) && m_pMDIFrameWnd)
  277. {
  278. // Unsubclass the MDI client and free the dynamic memory.
  279. m_pMDIClientWnd->UnsubclassWindow();
  280. SAFE_DELETE (m_pMDIClientWnd);
  282. // Force parent frame to re-adjust layout.
  283. m_pMDIFrameWnd->RecalcLayout();
  285. // Destroy this window.
  286. return DestroyWindow();
  287. }
  289. return FALSE;
  290. }
  292. void CXTMDIWndTab::InsertTabWnd(CMDIChildWnd* pChildWnd, BOOL bRecalcLayout/*= TRUE*/)
  293. {
  294. ASSERT_VALID(pChildWnd); // must be valid.
  296. // Try to locate the icon for the MDI window by calling WM_GETICON
  297. // first, this will give us the correct icon if the user has called
  298. // SetIcon(...) for the child frame.
  299. HICON hIcon = (HICON)::SendMessage(pChildWnd->m_hWnd, WM_GETICON, FALSE, 0);
  301. // If the icon returned is NULL, then try using GCLP_HICONSM to get the
  302. // document icon for the child frame
  303. if (hIcon == NULL)
  304. {
  305. hIcon = (HICON)(ULONG_PTR)::GetClassLongPtr(pChildWnd->m_hWnd, GCLP_HICONSM);
  306. }
  308. // If no icon was found, then use the default windows logo icon.
  309. if (hIcon == NULL)
  310. {
  311. hIcon = AfxGetApp()->LoadStandardIcon(IDI_WINLOGO);
  312. }
  313. m_imageList.Add(hIcon);
  315. // Get the window text for the frame.
  316. CXTStringHelper strWindowText = GetChildWndText(pChildWnd->GetSafeHwnd());
  318. int iItem = GetItemCount();
  320. MDICHILD* pMDIChild = new MDICHILD;
  321. ASSERT(pMDIChild != NULL);
  323. pMDIChild->iItem = iItem;
  324. pMDIChild->hWnd = pChildWnd->GetSafeHwnd();
  325. pMDIChild->strItem = strWindowText;
  327. m_arMDIChildern.AddTail(pMDIChild);
  329. if (GetSafeTheme()->GetTheme() != xtThemeDefault)
  330. {
  331. OnAddPadding(strWindowText);
  332. }
  334. // Insert the new item into the tab control.
  335. TC_ITEM tci;
  336. tci.mask = TCIF_IMAGE | TCIF_PARAM | TCIF_TEXT;
  337. tci.pszText = (TCHAR*)(LPCTSTR)strWindowText;
  338. tci.cchTextMax = strWindowText.GetLength();
  339. tci.iImage = m_imageList.GetImageCount()-1;
  340. tci.lParam = (LPARAM)pMDIChild;
  342. if (m_bNoIcons)
  343. {
  344. tci.iImage = -1;
  345. }
  347. InsertItem(iItem, &tci);
  349. if (m_pMDIFrameWnd->MDIGetActive() == pChildWnd)
  350. {
  351. SetCurSel(iItem);
  352. }
  354. // defer request to complete initialization
  355. RecalcLayout(bRecalcLayout);
  356. }
  358. void CXTMDIWndTab::RecalcLayout(BOOL bDelayRecalc)
  359. {
  360. // refresh labels
  361. RefreshTabLabels();
  363. // Recalc frame layout.
  364. if (bDelayRecalc)
  365. {
  366. m_pMDIFrameWnd->DelayRecalcLayout();
  367. }
  368. }
  370. void CXTMDIWndTab::RefreshIndexes()
  371. {
  372. int iItem;
  373. for (iItem = 0; iItem < GetItemCount(); ++iItem)
  374. {
  375. TC_ITEM tci;
  376. tci.mask = TCIF_PARAM;
  378. if (GetItem(iItem, &tci))
  379. {
  380. MDICHILD* pMDIChild = (MDICHILD*)tci.lParam;
  381. ASSERT(pMDIChild != NULL);
  383. if (pMDIChild) pMDIChild->iItem = iItem;
  384. }
  385. }
  386. }
  388. void CXTMDIWndTab::OnMDICreate(HWND hWnd)
  389. {
  390. CMDIChildWnd* pActiveChild = (CMDIChildWnd*)CWnd::FromHandle(hWnd);
  391. if (pActiveChild != NULL)
  392. {
  393. InsertTabWnd(pActiveChild);
  394. }
  396. RefreshIndexes();
  397. }
  399. void CXTMDIWndTab::OnMDIDestroy(HWND hWnd)
  400. {
  401. // Loop through all of the tabs to find the view that has closed.
  402. int iItem;
  403. for (iItem = 0; iItem < GetItemCount(); ++iItem)
  404. {
  405. // Get the item data for this tab.
  406. TC_ITEM tci;
  407. tci.mask = TCIF_PARAM;
  409. if (GetItem(iItem, &tci))
  410. {
  411. MDICHILD* pMDIChild = (MDICHILD*)tci.lParam;
  412. ASSERT(pMDIChild != NULL);
  414. // If it is the closed window remove it and exit loop.
  415. if (pMDIChild && (hWnd == pMDIChild->hWnd))
  416. {
  417. POSITION pos = m_arMDIChildern.Find(pMDIChild);
  418. if (pos)
  419. {
  420. m_arMDIChildern.RemoveAt(pos);
  421. SAFE_DELETE(pMDIChild);
  422. }
  424. DeleteItem(iItem);
  425. break;
  426. }
  427. }
  428. }
  430. RefreshIndexes();
  431. RecalcLayout(TRUE);
  432. }
  434. void CXTMDIWndTab::OnMDIActivate(HWND hWnd)
  435. {
  436. // Loop through all of the tabs to find the view that has activated.
  437. int iItem;
  438. for (iItem = 0; iItem < GetItemCount(); ++iItem)
  439. {
  440. // Get the item data for this tab.
  441. TC_ITEM tci;
  442. tci.mask = TCIF_PARAM;
  444. if (GetItem(iItem, &tci))
  445. {
  446. MDICHILD* pMDIChild = (MDICHILD*)tci.lParam;
  447. ASSERT(pMDIChild != NULL);
  449. // If it is the activated window select it and exit loop.
  450. if (pMDIChild && (hWnd == pMDIChild->hWnd))
  451. {
  452. SetCurSel(iItem);
  453. break;
  454. }
  455. }
  456. }
  457. }
  459. bool CXTMDIWndTab::SetTabIcon(int iIndex, HICON& hIcon)
  460. {
  461. TC_ITEM tci;
  462. tci.mask = TCIF_PARAM;
  464. if (GetItem(iIndex, &tci))
  465. {
  466. MDICHILD* pMDIChild = (MDICHILD*)tci.lParam;
  467. ASSERT(pMDIChild != NULL);
  468. if (!pMDIChild)
  469. return false;
  471. return SetTabIcon(pMDIChild->hWnd, hIcon);
  472. }
  474. return false;
  475. }
  477. bool CXTMDIWndTab::SetTabIcon(HWND hChildWnd, HICON& hIcon)
  478. {
  479. if (!hIcon || !::IsWindow(hChildWnd))
  480. {
  481. return false;
  482. }
  484. m_mapTabIcons.SetAt(hChildWnd, hIcon);
  485. return true;
  486. }
  488. bool CXTMDIWndTab::SetTabLabel(int iIndex, CString& strLabel)
  489. {
  490. TC_ITEM tci;
  491. tci.mask = TCIF_PARAM;
  493. if (GetItem(iIndex, &tci))
  494. {
  495. MDICHILD* pMDIChild = (MDICHILD*)tci.lParam;
  496. ASSERT(pMDIChild != NULL);
  497. if (!pMDIChild)
  498. return false;
  500. return SetTabLabel(pMDIChild->hWnd, strLabel);
  501. }
  503. return false;
  504. }
  506. bool CXTMDIWndTab::SetTabLabel(HWND hChildWnd, CString& strLabel)
  507. {
  508. if (strLabel.IsEmpty() || !::IsWindow(hChildWnd))
  509. {
  510. return false;
  511. }
  513. m_mapTabLabels.SetAt(hChildWnd, strLabel);
  514. return true;
  515. }
  517. CString CXTMDIWndTab::GetChildWndText(HWND hWnd) const
  518. {
  519. // Check to see if the user has defined a label for the tab first.
  520. CString strTitle;
  521. if (m_mapTabLabels.Lookup(hWnd, strTitle))
  522. {
  523. return strTitle;
  524. }
  526. // Get a pointer to the frame window.
  527. CMDIChildWnd* pChildFrame = (CMDIChildWnd*)CWnd::FromHandle(hWnd);
  528. if (!::IsWindow(pChildFrame->GetSafeHwnd()))
  529. {
  530. return _T("");
  531. }
  533. // Get the window text for the frame and use it for the tab label.
  534. pChildFrame->GetWindowText(strTitle);
  536. // If the string is empty the document's title.
  537. if (strTitle.IsEmpty())
  538. {
  539. CWnd* pChildWnd = pChildFrame->GetWindow(GW_CHILD);
  540. while (pChildWnd)
  541. {
  542. if (pChildWnd->IsKindOf(RUNTIME_CLASS(CView)))
  543. {
  544. // Get a pointer to the view's document.
  545. CDocument* pDoc = ((CView*)pChildWnd)->GetDocument();
  546. if (pDoc == NULL)
  547. {
  548. return _T("");
  549. }
  551. // Set the return string value
  552. strTitle = pDoc->GetTitle();
  554. // Reset the frames title
  555. pChildFrame->SetWindowText(strTitle);
  557. // Return the document title.
  558. return strTitle;
  559. }
  560. pChildWnd = pChildWnd->GetWindow(GW_HWNDNEXT);
  561. }
  562. }
  564. // Return the MDI frame window's title.
  565. return strTitle;
  566. }
  568. BOOL CXTMDIWndTab::RefreshActiveSel()
  569. {
  570. // Get the active MDI window, if NULL return FALSE.
  571. HWND hWndActiveChild = m_pMDIFrameWnd->MDIGetActive()->GetSafeHwnd();
  572. if (hWndActiveChild == NULL)
  573. {
  574. m_hActiveChild = NULL;
  575. return FALSE;
  576. }
  578. // Loop through all of the tabs to find the view that has activated.
  579. bool bSelectionChanged = false;
  580. if (POSITION pos = m_arMDIChildern.GetHeadPosition())
  581. {
  582. do
  583. {
  584. MDICHILD* pMDIChild = m_arMDIChildern.GetNext(pos);
  585. ASSERT(pMDIChild != NULL);
  587. // We have found the handle to the active MDI window,
  588. // lets see if the tab is selected.
  589. if (pMDIChild && (pMDIChild->hWnd == hWndActiveChild))
  590. {
  591. // If the active child pointer does not match, then
  592. // make sure that the tab is selected then save the pointer.
  593. bSelectionChanged = hWndActiveChild != m_hActiveChild;
  594. if (bSelectionChanged)
  595. {
  596. SetCurSel(pMDIChild->iItem);
  597. m_hActiveChild = hWndActiveChild;
  598. }
  599. }
  600. }
  601. while (pos != NULL && !bSelectionChanged);
  602. }
  603. return bSelectionChanged;
  604. }
  606. void CXTMDIWndTab::RefreshTabLabels()
  607. {
  608. // Loop through all of the tabs to find the view that has activated.
  609. POSITION pos = m_arMDIChildern.GetHeadPosition();
  610. while (pos != NULL)
  611. {
  612. bool bSetItem = false;
  614. MDICHILD* pMDIChild = m_arMDIChildern.GetNext(pos);
  615. ASSERT(pMDIChild != NULL);
  616. if (!pMDIChild)
  617. continue;
  619. // Get the window text for the child frame and the tab item.
  620. CXTStringHelper strWindowText = GetChildWndText(pMDIChild->hWnd);
  622. TCHAR szText[_MAX_PATH];
  623. szText[0] = 0;
  625. TC_ITEM tci;
  626. tci.mask = TCIF_TEXT | TCIF_IMAGE;
  627. tci.cchTextMax = _countof(szText);
  628. tci.pszText = szText;
  630. // Get the item data for the tab.
  631. if (GetItem(pMDIChild->iItem, &tci))
  632. {
  633. CString strTabLabel = szText;
  635. if (GetSafeTheme()->GetTheme() != xtThemeDefault)
  636. {
  637. OnAddPadding(strWindowText);
  638. }
  640. // If they do not match then update the tab item label.
  641. if (strTabLabel != strWindowText)
  642. {
  643. STRCPY_S(szText, _MAX_PATH, strWindowText);
  644. tci.cchTextMax = strWindowText.GetLength();
  646. bSetItem = true;
  647. }
  649. if (!m_bNoIcons)
  650. {
  651. // Check to see if the user set the icon for the tab label.
  652. HICON hIcon = 0;
  653. if (!m_mapTabIcons.Lookup(pMDIChild->hWnd, hIcon))
  654. {
  655. // The user may have set the icon for the child by calling WM_SETICON.  If
  656. // WM_GETICON returns an icon we need to make sure the tab icon has been updated.
  658. hIcon = (HICON)::SendMessage(pMDIChild->hWnd, WM_GETICON, FALSE, 0);
  660. // Insert the icon into map to avoid failed Lookup().
  661. m_mapTabIcons.SetAt(pMDIChild->hWnd, hIcon);
  662. }
  664. // Replace the image in image list ONLY when Lookup() failed.
  665. if ((hIcon != NULL) && (tci.iImage != -1))
  666. {
  667. bSetItem = true;
  668. m_imageList.Replace(tci.iImage, hIcon);
  669. }
  670. }
  672. if (bSetItem)
  673. {
  674. VERIFY(SetItem(pMDIChild->iItem, &tci));
  675. }
  676. }
  677. }
  678. }
  680. void CXTMDIWndTab::OnIdleUpdateCmdUI()
  681. {
  682. if (m_pMDIFrameWnd)
  683. {
  684. RefreshActiveSel();
  685. RefreshTabLabels();
  686. }
  687. }
  689. void CXTMDIWndTab::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp)
  690. {
  691. RECT& rc = lpncsp->rgrc[0];
  693. if (rc.bottom - rc.top > m_iBorderGap * 2)
  694. {
  695. rc.top += m_iBorderGap;
  696. rc.bottom -= m_iBorderGap;
  697. }
  698. else
  699. {
  700. rc.top = rc.bottom;
  701. }
  703. if (rc.right - rc.left > m_iBorderGap * 2)
  704. {
  705. rc.left += m_iBorderGap;
  706. rc.right -= m_iBorderGap;
  707. }
  708. else
  709. {
  710. rc.left = rc.right;
  711. }
  713. CTabCtrl::OnNcCalcSize(bCalcValidRects, lpncsp);
  714. }
  716. void CXTMDIWndTab::OnNcPaint()
  717. {
  718. CWindowDC dc(this);
  720. CRect rectClient;
  721. GetClientRect(rectClient);
  722. CRect rectWindow;
  723. GetWindowRect(rectWindow);
  724. rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  726. if (rectWindow.Width() > rectClient.Width())
  727. {
  728. dc.DrawEdge(rectWindow, BDR_SUNKENOUTER, BF_RECT);
  729. }
  730. }
  732. void CXTMDIWndTab::OnSelchange(NMHDR* /*pNMHDR*/, LRESULT* pResult)
  733. {
  734. // Get the item data for the currently selected tab.
  735. TC_ITEM tci;
  736. tci.mask = TCIF_PARAM;
  738. if (GetItem(GetCurSel(), &tci))
  739. {
  740. MDICHILD* pMDIChild = (MDICHILD*)tci.lParam;
  741. ASSERT(pMDIChild != NULL);
  742. if (!pMDIChild)
  743. return;
  745. // Get the pointer to the currently selected tab window.
  746. CWnd* pActiveWnd = CWnd::FromHandle(pMDIChild->hWnd);
  747. ASSERT_VALID(pActiveWnd);
  749. // Activate the new tab window.
  750. m_pMDIFrameWnd->MDIActivate(pActiveWnd);
  751. }
  753. *pResult = 0;
  754. }
  756. void CXTMDIWndTab::OnDestroy()
  757. {
  758. CTabCtrl::OnDestroy();
  760. // Delete the image list.
  761. m_imageList.DeleteImageList();
  763. // Set the active and parent windows to NULL.
  764. m_hActiveChild = NULL;
  765. m_pMDIFrameWnd = NULL;
  766. }
  768. int CXTMDIWndTab::TabFromPoint(CPoint point) const
  769. {
  770. TCHITTESTINFO tch;
  771. memset(&tch, 0, sizeof(TCHITTESTINFO));
  773. if (point == CPoint(0, 0))
  774. {
  775. CPoint pt;
  776. GetCursorPos(&pt);
  777. ScreenToClient(&pt);
  778. tch.pt = pt;
  779. }
  780. else
  781. {
  782. tch.pt = point;
  783. }
  785. return HitTest(&tch);
  786. }
  788. CMDIChildWnd* CXTMDIWndTab::GetFrameWnd(int iIndex) const
  789. {
  790. if (iIndex == -1)
  791. iIndex = m_iHitTest;
  793. TC_ITEM tci;
  794. tci.mask = TCIF_PARAM;
  796. if (GetItem(iIndex, &tci))
  797. {
  798. MDICHILD* pMDIChild = (MDICHILD*)tci.lParam;
  799. ASSERT(pMDIChild != NULL);
  800. if (!pMDIChild)
  801. return NULL;
  803. return DYNAMIC_DOWNCAST(CMDIChildWnd, CWnd::FromHandle(pMDIChild->hWnd));
  804. }
  806. return NULL;
  807. }
  809. CMDIChildWnd* CXTMDIWndTab::GetFrameWnd(CPoint point) const
  810. {
  811. return GetFrameWnd(TabFromPoint(point));
  812. }
  814. void CXTMDIWndTab::OnRButtonDown(UINT /*nFlags*/, CPoint point)
  815. {
  816. // Get the tab index based upon the cursor position.
  817. m_iHitTest = TabFromPoint(point);
  818. if (m_iHitTest != -1)
  819. {
  820. if (m_popupMenuID != 0)
  821. {
  822. CPoint pt = point;
  823. ClientToScreen(&pt);
  825. CMenu popupMenu;
  826. VERIFY(popupMenu.LoadMenu(m_popupMenuID));
  828. CMenu* pPopup = popupMenu.GetSubMenu(m_nPos);
  829. ASSERT(pPopup != NULL);
  830. if (!pPopup)
  831. return;
  833. if (m_nDefCmd != 0)
  834. {
  835. ::SetMenuDefaultItem(pPopup->m_hMenu, m_nDefCmd, FALSE);
  836. }
  838. CWnd* pWndPopupOwner = GetOwner();
  839. ASSERT_VALID(pWndPopupOwner);
  841. pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON,
  842. pt.x, pt.y, pWndPopupOwner);
  843. }
  844. }
  845. }
  847. void CXTMDIWndTab::InitializeFont()
  848. {
  849. HGDIOBJ hFont = XTAuxData().font.GetSafeHandle();
  851. // if the tabs are vertical, use the vertical menu font.
  852. if ((GetStyle() & TCS_VERTICAL) == TCS_VERTICAL)
  853. hFont = XTAuxData().fontVert.GetSafeHandle();
  855. if (hFont != NULL)
  856. {
  857. if (XTOSVersionInfo()->IsWin95())
  858. PostMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
  859. else
  860. SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
  861. }
  862. }
  864. void CXTMDIWndTab::OnTabClose()
  865. {
  866. if (m_pMDIFrameWnd)
  867. {
  868. CMDIChildWnd* pActiveChild = (CMDIChildWnd*)m_pMDIFrameWnd->MDIGetActive();
  869. if (pActiveChild != NULL)
  870. {
  871. pActiveChild->SendMessage(WM_CLOSE);
  872. }
  873. }
  874. }