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

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

对话框与窗口

开发平台：

Visual C++

XTPSkinObjectFrame.cpp：源码内容
  1. // XTPSkinObjectFrame.cpp: implementation of the XTPSkinObjectFrame class.
  2. //
  3. // This file is a part of the XTREME SKINFRAMEWORK 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"
  23. #include "Common/XTPDrawHelpers.h"
  25. #include "XTPSkinDrawTools.h"
  26. #include "XTPSkinManager.h"
  27. #include "XTPSkinImage.h"
  28. #include "XTPSkinObjectFrame.h"
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif
  37. IMPLEMENT_DYNCREATE(CXTPSkinObjectFrame, CWnd)
  39. CXTPSkinObjectFrame::CCaptionButton::CCaptionButton(int nCommand, CXTPSkinObjectFrame* pFrame, UINT nHTCode, int nClassPart)
  40. {
  41. m_pFrame = pFrame;
  42. m_nHTCode = nHTCode;
  43. m_nClassPart = nClassPart;
  44. m_nCommand = nCommand;
  45. m_bEnabled = TRUE;
  46. }
  48. BOOL CXTPSkinObjectFrame::CCaptionButton::IsPressed() const
  49. {
  50. return m_pFrame->m_pButtonPressed == this;
  51. }
  53. BOOL CXTPSkinObjectFrame::CCaptionButton::IsHighlighted() const
  54. {
  55. return m_pFrame->m_pButtonHot == this;
  56. }
  59. void CXTPSkinObjectFrame::CCaptionButton::Draw(CDC* pDC, BOOL bFrameActive)
  60. {
  61. BOOL bHot = IsHighlighted() && (IsPressed() || !m_pFrame->m_pButtonPressed);
  62. BOOL pRessed = bHot && IsPressed();
  64. int nState = !m_bEnabled ? SBS_DISABLED : pRessed? SBS_PUSHED: bHot? SBS_HOT: SBS_NORMAL;
  65. if (!bFrameActive) nState += 4;
  67. CXTPSkinManagerClass* pClassWindow = m_pFrame->GetSkinManager()->GetSkinClass(_T("WINDOW"));
  68. pClassWindow->DrawThemeBackground(pDC, m_nClassPart, nState, m_rcButton);
  69. }
  71. /////////////////////////////////////////////////////////////////////////////
  72. // CXTPSkinObjectFrame
  75. CXTPSkinObjectFrame::CXTPSkinObjectFrame()
  76. {
  77. m_rcBorders.SetRectEmpty();
  78. m_rcMenuBar.SetRectEmpty();
  79. m_pSBTrack = NULL;
  81. m_strClassName = _T("WINDOW");
  82. m_nCtlColorMessage = WM_CTLCOLORDLG;
  84. m_bMDIClient = FALSE;
  86. ZeroMemory(&m_spi[SB_VERT], sizeof(XTP_SKINSCROLLBARPOSINFO));
  87. ZeroMemory(&m_spi[SB_HORZ], sizeof(XTP_SKINSCROLLBARPOSINFO));
  89. m_spi[SB_VERT].fVert = TRUE;
  90. m_spi[SB_VERT].nBar= SB_VERT;
  92. m_spi[SB_HORZ].fVert = FALSE;
  93. m_spi[SB_HORZ].nBar = SB_HORZ;
  95. m_szFrameRegion = CSize(0, 0);
  97. m_pButtonHot = 0;
  98. m_pButtonPressed = 0;
  99. m_bActive = FALSE;
  101. m_dwExStyle = (DWORD)-1;
  102. m_dwStyle = (DWORD)-1;
  104. m_bActiveX = FALSE;
  106. m_bRegionChanged = FALSE;
  107. m_bLockFrameDraw = FALSE;
  108. m_bInUpdateRegion = FALSE;
  109. m_dwDialogTexture = ETDT_DISABLE;
  111. m_pMDIClient = NULL;
  112. }
  114. CXTPSkinObjectFrame::~CXTPSkinObjectFrame()
  115. {
  116. RemoveButtons();
  117. }
  119. void CXTPSkinObjectFrame::ScreenToFrame(LPPOINT lpPoint)
  120. {
  121. CXTPDrawHelpers::ScreenToWindow(this, lpPoint);
  122. }
  124. void CXTPSkinObjectFrame::ClientToFrame(LPPOINT lpPoint)
  125. {
  126. ClientToScreen(lpPoint);
  127. ScreenToFrame(lpPoint);
  128. }
  131. void CXTPSkinObjectFrame::AdjustFrame(CRect& rc)
  132. {
  133. rc.DeflateRect(m_rcBorders);
  134. }
  138. BEGIN_MESSAGE_MAP(CXTPSkinObjectFrame, CCmdTarget)
  139. //{{AFX_MSG_MAP(CXTPSkinObjectFrame)
  140. ON_WM_NCPAINT()
  141. ON_WM_NCCALCSIZE()
  142. ON_WM_NCMOUSEMOVE()
  143. ON_WM_NCHITTEST_EX()
  144. ON_WM_NCLBUTTONDOWN()
  145. ON_WM_NCLBUTTONDBLCLK()
  146. ON_WM_NCRBUTTONUP()
  147. ON_MESSAGE_VOID(WM_NCMOUSELEAVE, OnNcMouseLeave)
  148. ON_WM_NCACTIVATE()
  150. ON_WM_TIMER()
  151. ON_MESSAGE(WM_SETTEXT, OnSetText)
  152. ON_WM_STYLECHANGED()
  153. ON_WM_CREATE()
  154. ON_WM_WINDOWPOSCHANGING()
  155. ON_WM_WINDOWPOSCHANGED()
  156. ON_MESSAGE(WM_PRINT, OnPrint)
  157. ON_WM_GETMINMAXINFO()
  158. ON_WM_SYSCOMMAND()
  159. ON_WM_ERASEBKGND()
  160. //}}AFX_MSG_MAP
  161. END_MESSAGE_MAP()
  163. /////////////////////////////////////////////////////////////////////////////
  164. // CXTPSkinObjectFrame message handlers
  167. BOOL CXTPSkinObjectFrame::OnEraseBkgnd(CDC* pDC)
  168. {
  169. HBRUSH hbr = (HBRUSH)(DWORD_PTR)GetClassLongPtr(m_hWnd, GCLP_HBRBACKGROUND);
  170. BOOL bChanged = FALSE;
  172. if (hbr > 0 && (ULONG_PTR)hbr < (ULONG_PTR)XTP_SKINMETRICS_COLORTABLESIZE)
  173. {
  174. HBRUSH hbrTheme = GetMetrics()->m_brTheme[(ULONG_PTR)hbr - 1];
  175. SetClassLongPtr(m_hWnd, GCLP_HBRBACKGROUND, (LONG_PTR)hbrTheme);
  176. bChanged = TRUE;
  177. }
  179. BOOL bResult =  CXTPSkinObject::OnEraseBkgnd(pDC);
  181. if (bChanged)
  182. {
  183. SetClassLongPtr(m_hWnd, GCLP_HBRBACKGROUND, (LONG_PTR)hbr);
  184. }
  185. return bResult;
  186. }
  188. void CXTPSkinObjectFrame::OnNcPaint()
  189. {
  190. #if 0
  191. static _int64 nPerfomanceEnd;
  192. _int64 nPerfomanceStart;
  193. static _int64 nPerfomanceSum = 0;
  195. QueryPerformanceCounter((LARGE_INTEGER*)&nPerfomanceStart);
  196. if (nPerfomanceStart - nPerfomanceEnd  > 100000)
  197. {
  198. TRACE(_T("Reset Timer n"));
  199. nPerfomanceSum = 0;
  200. }
  201. #endif
  203. if (IsFlatScrollBarInitialized())
  204. {
  205. Default();
  206. }
  207. else
  208. {
  209. UpdateButtons();
  211. CWindowDC dc(this);
  212. DrawFrame(&dc);
  213. }
  215. #if 0
  216. QueryPerformanceCounter((LARGE_INTEGER*)&nPerfomanceEnd);
  217. nPerfomanceSum += nPerfomanceEnd - nPerfomanceStart;
  218. TRACE(_T("TotalCounter = %i n"), int(nPerfomanceSum));
  219. #endif
  220. }
  222. void CXTPSkinObjectFrame::ResizeFrame()
  223. {
  224. if (HasCaption())
  225. {
  226. CXTPWindowRect rc(this);
  228. if ((m_pManager->GetApplyOptions() & xtpSkinApplyMetrics) && ((GetStyle() & WS_CHILD) == 0))
  229. {
  230. BOOL bSmallCaption = GetExStyle() & WS_EX_TOOLWINDOW;
  231. int cyCaption = bSmallCaption ? GetMetrics()->m_cySmallCaption : GetMetrics()->m_cyCaption;
  232. int cyOsCaption = bSmallCaption ? GetMetrics()->m_cyOsSmallCaption : GetMetrics()->m_cyOsCaption;
  234. rc.bottom += cyCaption - cyOsCaption;
  235. MoveWindow(rc, FALSE);
  236. }
  238. UpdateFrameRegion(rc.Size());
  239. }
  240. }
  242. void CXTPSkinObjectFrame::OnHookAttached(LPCREATESTRUCT lpcs, BOOL bAuto)
  243. {
  244. CXTPSkinObject::OnHookAttached(lpcs, bAuto);
  246. if (!bAuto)
  247. {
  248. ResizeFrame();
  249. }
  250. }
  252. void CXTPSkinObjectFrame::RefreshFrameStyle()
  253. {
  254. if ((GetSkinManager()->GetApplyOptions() & xtpSkinApplyFrame) == 0)
  255. return;
  257. m_bLockFrameDraw++;
  258. DWORD dwStyle = GetStyle();
  259. DWORD dwStyleRemove = (WS_DLGFRAME | WS_VSCROLL | WS_HSCROLL);
  261. if (dwStyle & dwStyleRemove)
  262. {
  263. SetWindowLong(m_hWnd, GWL_STYLE, dwStyle & ~dwStyleRemove);
  265. RECT rc = CXTPWindowRect(this);
  266. SendMessage(WM_NCCALCSIZE, FALSE, (LPARAM)&rc);
  268. SetWindowLong(m_hWnd, GWL_STYLE, dwStyle);
  269. }
  270. m_bLockFrameDraw--;
  271. }
  273. void CXTPSkinObjectFrame::OnSkinChanged(BOOL bPrevState, BOOL bNewState)
  274. {
  275. if (bNewState)
  276. {
  277. RefreshFrameStyle();
  278. }
  280. if (bNewState && !bPrevState)
  281. {
  282. m_bActive = SendMessage(0x0035) != 0;
  283. }
  285. SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE);
  287. RefreshMetrics();
  289. CXTPWindowRect rc(this);
  290. m_szFrameRegion = CSize(0);
  291. UpdateFrameRegion(rc.Size());
  293. Invalidate();
  294. }
  296. void CXTPSkinObjectFrame::OnHookDetached(BOOL bAuto)
  297. {
  298. if (m_bRegionChanged && !bAuto && ::IsWindow(m_hWnd))
  299. {
  300. SetWindowRgn(NULL, TRUE);
  301. m_bRegionChanged = FALSE;
  302. SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE);
  303. }
  305. CXTPSkinObject::OnHookDetached(bAuto);
  306. }
  308. BOOL CXTPSkinObjectFrame::IsFrameScrollBars()
  309. {
  310. HWND hWnd = m_hWnd;
  311. CXTPWindowRect rcChild(hWnd);
  313. int cxEdge = GetMetrics()->m_cxEdge;
  314. int cyEdge = GetMetrics()->m_cyEdge;
  316. while (hWnd)
  317. {
  318. if ((GetWindowLong(hWnd, GWL_STYLE) & WS_CAPTION) == WS_CAPTION)
  319. {
  320. CPoint ptParent = CXTPClientRect(hWnd).BottomRight();
  321. ::ClientToScreen(hWnd, &ptParent);
  323. if ((rcChild.right + cxEdge < ptParent.x) ||
  324. (rcChild.bottom + cyEdge < ptParent.y))
  325. {
  326. return FALSE;
  327. }
  329. return hWnd ? TRUE : FALSE;
  330. }
  332. if (((GetWindowLong(hWnd, GWL_STYLE) & WS_CHILD) == 0) || ((GetWindowLong(hWnd, GWL_STYLE) & WS_CAPTION) == WS_CAPTION))
  333. break;
  335. hWnd = ::GetParent(hWnd);
  336. }
  338. return FALSE;
  339. }
  341. BOOL CXTPSkinObjectFrame::IsSizeBox()
  342. {
  343. HWND hWnd = m_hWnd;
  344. CXTPWindowRect rcChild(hWnd);
  346. int cxEdge = GetMetrics()->m_cxEdge;
  347. int cyEdge = GetMetrics()->m_cyEdge;
  349. while (hWnd)
  350. {
  351. if (GetWindowLong(hWnd, GWL_STYLE) & WS_SIZEBOX)
  352. {
  353. if ((GetWindowLong(hWnd, GWL_STYLE) & WS_MAXIMIZE))
  354. return FALSE;
  356. CPoint ptParent = CXTPClientRect(hWnd).BottomRight();
  357. ::ClientToScreen(hWnd, &ptParent);
  359. if ((rcChild.right + cxEdge < ptParent.x) ||
  360. (rcChild.bottom + cyEdge < ptParent.y))
  361. {
  362. return FALSE;
  363. }
  365. return hWnd ? TRUE : FALSE;
  366. }
  368. if (((GetWindowLong(hWnd, GWL_STYLE) & WS_CHILD) == 0) || ((GetWindowLong(hWnd, GWL_STYLE) & WS_CAPTION) == WS_CAPTION))
  369. break;
  371. hWnd = ::GetParent(hWnd);
  372. }
  374. return FALSE;
  375. }
  377. void CXTPSkinObjectFrame::RedrawFrame()
  378. {
  379. CWindowDC dc(this);
  380. DrawFrame(&dc);
  381. }
  383. void CXTPSkinObjectFrame::DrawFrame(CDC* pDC)
  384. {
  385. if (m_bLockFrameDraw)
  386. return;
  388. CXTPWindowRect rc(this);
  389. rc.OffsetRect(-rc.TopLeft());
  392. GetSkinManager()->GetSchema()->DrawThemeFrame(pDC, this);
  394. if (!m_rcMenuBar.IsRectEmpty())
  395. {
  396. DrawFrameMenuBar(pDC);
  397. }
  399. if (m_spi[SB_VERT].fVisible || m_spi[SB_HORZ].fVisible)
  400. {
  401. if (m_spi[SB_VERT].fVisible)
  402. {
  403. if (!m_pSBTrack || !m_pSBTrack->bTrackThumb)
  404. SetupScrollInfo(&m_spi[SB_VERT]);
  406. CXTPBufferDCEx dcMem(*pDC, m_spi[SB_VERT].rc);
  407. DrawScrollBar(&dcMem, &m_spi[SB_VERT]);
  408. }
  410. if (m_spi[SB_HORZ].fVisible)
  411. {
  412. if (!m_pSBTrack || !m_pSBTrack->bTrackThumb)
  413. SetupScrollInfo(&m_spi[SB_HORZ]);
  415. CXTPBufferDCEx dcMem(*pDC, m_spi[SB_HORZ].rc);
  416. DrawScrollBar(&dcMem, &m_spi[SB_HORZ]);
  417. }
  419. if (m_spi[SB_HORZ].fVisible && m_spi[SB_VERT].fVisible)
  420. {
  421. CRect rcSizeGripper(m_spi[SB_HORZ].rc.right, m_spi[SB_VERT].rc.bottom,
  422. m_spi[SB_VERT].rc.right, m_spi[SB_HORZ].rc.bottom);
  424. if (GetExStyle() & WS_EX_LEFTSCROLLBAR)
  425. {
  426. rcSizeGripper.left = m_spi[SB_VERT].rc.left;
  427. rcSizeGripper.right = m_spi[SB_HORZ].rc.left;
  428. }
  430. pDC->FillSolidRect(rcSizeGripper, m_pManager->GetSchema()->GetScrollBarSizeBoxColor(this));
  432. if (IsSizeBox())
  433. {
  434. CXTPSkinManagerClass* pClassScrollBar = GetSkinManager()->GetSkinClass(_T("SCROLLBAR"));
  435. pClassScrollBar->DrawThemeBackground(pDC, SBP_SIZEBOX, SZB_RIGHTALIGN, rcSizeGripper);
  436. }
  437. }
  438. }
  439. }
  441. BOOL CXTPSkinObjectFrame::IsFlatScrollBarInitialized() const
  442. {
  443. INT nStyle = 0;
  444. if (FlatSB_GetScrollProp(m_hWnd, WSB_PROP_VSTYLE, &nStyle))
  445. return TRUE;
  447. return FALSE;
  448. }
  451. // Not implemented
  452. BOOL CXTPSkinObjectFrame::FrameHasMenuBar()
  453. {
  454. #if 0
  455. if (GetStyle() & WS_CHILD)
  456. return FALSE;
  458. HMENU hMenu = ::GetMenu(m_hWnd);
  459. if (!hMenu)
  460. return FALSE;
  462. return GetMenuItemCount(hMenu) > 0;
  463. #else
  464. return FALSE;
  465. #endif
  466. }
  468. // Not implemented
  469. int CalcMenuBarHeight(HWND /*hWnd*/, HMENU hMenu, int /*nWidth*/)
  470. {
  471. int nHeight = GetSystemMetrics(SM_CYMENUSIZE);
  473. if (GetMenuItemCount(hMenu) == 0)
  474. return 0;
  476. return nHeight + 1;
  477. }
  479. // Not implemented
  480. void CXTPSkinObjectFrame::DrawFrameMenuBar(CDC* pDC)
  481. {
  482. #if 0
  483. CRect rc = m_rcMenuBar;
  485. pDC->FillSolidRect(rc.left, rc.top, rc.Width(), rc.Height() - 1, GetColor(COLOR_3DFACE));
  486. pDC->FillSolidRect(rc.left, rc.bottom - 1, rc.Width(), 1, GetColor(COLOR_WINDOW));
  488. CMenu* pMenu = GetMenu();
  489. int nCount = pMenu->GetMenuItemCount();
  491. CXTPFontDC font(pDC, &GetMetrics()->m_fntMenu);
  492. pDC->SetTextColor(GetColor(COLOR_MENUTEXT));
  493. pDC->SetBkMode(TRANSPARENT);
  495. int x = rc.left;
  498. TEXTMETRIC tm;
  499. pDC->GetTextMetrics(&tm);
  501. for (int nIndex = 0; nIndex < nCount; nIndex++ )
  502. {
  503. CString strMenuText;
  504. pMenu->GetMenuString(nIndex, strMenuText, MF_BYPOSITION);
  506. int nText = pDC->GetTextExtent(strMenuText).cx;
  508. CRect rcItem(x, rc.top, x + nText + (tm.tmAveCharWidth + 1) * 2, rc.bottom - 2);
  510. pDC->DrawText(strMenuText, rcItem, DT_VCENTER | DT_CENTER | DT_SINGLELINE);
  512. x = rcItem.right;
  513. }
  514. #else
  515. pDC;
  516. #endif
  517. }
  520. void CXTPSkinObjectFrame::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp)
  521. {
  522. if (IsFlatScrollBarInitialized())
  523. {
  524. m_spi[SB_VERT].fVisible = FALSE;
  525. m_spi[SB_HORZ].fVisible = FALSE;
  526. CXTPSkinObject::OnNcCalcSize(bCalcValidRects, lpncsp);
  527. return;
  528. }
  530. m_rcBorders = GetSkinManager()->GetSchema()->CalcFrameBorders(this);
  532. lpncsp[0].rgrc->top += m_rcBorders.top;
  533. lpncsp[0].rgrc->left += m_rcBorders.left;
  534. lpncsp[0].rgrc->right -= m_rcBorders.right;
  535. lpncsp[0].rgrc->bottom -= m_rcBorders.bottom;
  537. DWORD dwStyle = GetStyle();
  539. if (FrameHasMenuBar())
  540. {
  541. int nHeight = CalcMenuBarHeight(m_hWnd, ::GetMenu(m_hWnd), lpncsp[0].rgrc->right - lpncsp[0].rgrc->left);
  542. m_rcMenuBar.SetRect(m_rcBorders.left, m_rcBorders.top, m_rcBorders.left + lpncsp[0].rgrc->right - lpncsp[0].rgrc->left, m_rcBorders.top + nHeight);
  544. lpncsp[0].rgrc->top += nHeight;
  545. }
  546. else
  547. {
  548. m_rcMenuBar.SetRectEmpty();
  549. }
  551. m_spi[SB_VERT].fVisible = dwStyle & WS_VSCROLL;
  552. m_spi[SB_HORZ].fVisible = dwStyle & WS_HSCROLL;
  555. if (m_spi[SB_VERT].fVisible)
  556. {
  557. if (GetExStyle() & (WS_EX_LAYOUTRTL | WS_EX_LEFTSCROLLBAR))
  558. lpncsp[0].rgrc->left += GetMetrics()->m_cxVScroll;
  559. else
  560. lpncsp[0].rgrc->right -= GetMetrics()->m_cxVScroll;
  561. }
  563. if (m_spi[SB_HORZ].fVisible)
  564. {
  565. lpncsp[0].rgrc->bottom -= GetMetrics()->m_cyHScroll;
  566. }
  568. if (lpncsp[0].rgrc->bottom < lpncsp[0].rgrc->top)
  569. lpncsp[0].rgrc->bottom = lpncsp[0].rgrc->top;
  571. if (lpncsp[0].rgrc->right < lpncsp[0].rgrc->left)
  572. lpncsp[0].rgrc->right = lpncsp[0].rgrc->left;
  573. }
  575. LRESULT CXTPSkinObjectFrame::HandleNcHitTest(CPoint point)
  576. {
  577. ScreenToFrame(&point);
  579. DWORD dwStyle = GetStyle();
  581. if ((dwStyle & WS_VSCROLL) && m_spi[SB_VERT].fVisible && ::PtInRect(&m_spi[SB_VERT].rc, point))
  582. return (LRESULT)HTVSCROLL;
  584. if ((dwStyle & WS_HSCROLL) &&m_spi[SB_HORZ].fVisible && ::PtInRect(&m_spi[SB_HORZ].rc, point))
  585. return (LRESULT)HTHSCROLL;
  587. if ((dwStyle & WS_VSCROLL) && m_spi[SB_VERT].fVisible && (dwStyle & WS_HSCROLL) && m_spi[SB_HORZ].fVisible && IsSizeBox())
  588. {
  589. CRect rcSizeGripper(m_spi[SB_HORZ].rc.right, m_spi[SB_VERT].rc.bottom,
  590. m_spi[SB_VERT].rc.right, m_spi[SB_HORZ].rc.bottom);
  592. if (rcSizeGripper.PtInRect(point))
  593. return GetExStyle() & WS_EX_LAYOUTRTL ? HTBOTTOMLEFT : HTBOTTOMRIGHT;
  594. }
  596. if (m_rcMenuBar.PtInRect(point))
  597. return HTMENU;
  599. CCaptionButton* pButtonHot = HitTestButton(point);
  601. if (pButtonHot)
  602. {
  603. return pButtonHot->m_nHTCode;
  604. }
  606. return (LRESULT)HTNOWHERE;
  607. }
  609. LRESULT CXTPSkinObjectFrame::OnNcHitTest(CPoint point)
  610. {
  611. LRESULT nHitCode = (LRESULT)CXTPSkinObject::OnNcHitTest(point);
  613. LRESULT nHitCode2 = HandleNcHitTest(point);
  614. if (nHitCode2 != HTNOWHERE)
  615. return nHitCode2;
  617. if (nHitCode == HTCLOSE || nHitCode == HTMAXBUTTON || nHitCode == HTMINBUTTON || nHitCode == HTHELP)
  618. return (LRESULT)HTCAPTION;
  620. if ((nHitCode == HTVSCROLL || nHitCode == HTHSCROLL) && !IsFlatScrollBarInitialized())
  621. return (LRESULT)HTCLIENT;
  623. return nHitCode;
  624. }
  626. void CXTPSkinObjectFrame::CancelMouseLeaveTracking()
  627. {
  628. KillTimer(XTP_TID_MOUSELEAVE);
  629. }
  631. void CXTPSkinObjectFrame::OnTimer(UINT_PTR uTimerID)
  632. {
  633. if (uTimerID == XTP_TID_REFRESHFRAME)
  634. {
  635. RefreshFrameStyle();
  636. KillTimer(XTP_TID_REFRESHFRAME);
  637. return;
  638. }
  640. if (uTimerID == XTP_TID_MOUSELEAVE)
  641. {
  642. RECT rect;
  643. POINT pt;
  645. GetWindowRect(&rect);
  646. ::GetCursorPos (&pt);
  648. if (::GetCapture() != NULL)
  649. return;
  651. LRESULT lHitTest = HandleNcHitTest(MAKELPARAM(pt.x, pt.y));
  653. if ((lHitTest == HTCLIENT || lHitTest == HTNOWHERE || lHitTest == HTBOTTOMRIGHT || lHitTest == HTBOTTOMLEFT) || !::PtInRect (&rect, pt))
  654. {
  655. HandleMouseMove(CPoint(-1, -1));
  656. CancelMouseLeaveTracking();
  657. }
  658. return;
  659. }
  661. CXTPSkinObject::OnTimer(uTimerID);
  662. }
  664. BOOL CXTPSkinObjectFrame::HandleMouseMove(CPoint point)
  665. {
  666. CPoint ptClient(point);
  667. ScreenToFrame(&ptClient);
  669. CCaptionButton* pButton = HitTestButton(ptClient);
  671. if (m_pButtonHot != pButton)
  672. {
  673. if (m_pButtonHot && !pButton)
  674. CancelMouseLeaveTracking();
  676. m_pButtonHot = pButton;
  677. InvalidateButtons();
  679. if (m_pButtonHot)
  680. {
  681. SetTimer (XTP_TID_MOUSELEAVE, 50, NULL);
  682. return  TRUE;
  683. }
  684. }
  686. if (m_pSBTrack)
  687. return TRUE;
  689. BOOL bResult = FALSE;
  690. for (int i = 0; i < 2; i++)
  691. {
  692. XTP_SKINSCROLLBARPOSINFO* pSBInfo = &m_spi[i];
  693. int ht = HitTestScrollBar(pSBInfo, ptClient);
  695. if (ht != pSBInfo->ht && pSBInfo->fVisible)
  696. {
  697. if (pSBInfo->ht != HTNOWHERE && ht == HTNOWHERE && !bResult)
  698. {
  699. CancelMouseLeaveTracking();
  700. }
  702. pSBInfo->ht = ht;
  703. RedrawScrollBar(pSBInfo);
  704. }
  706. if (ht != HTNOWHERE)
  707. {
  708. SetTimer (XTP_TID_MOUSELEAVE, 50, NULL);
  709. bResult = TRUE;
  710. }
  711. }
  713. return bResult;
  714. }
  716. void CXTPSkinObjectFrame::OnNcMouseMove(UINT nHitTest, CPoint point)
  717. {
  718. if (HandleMouseMove(point))
  719. return;
  721. CXTPSkinObject::OnNcMouseMove(nHitTest, point);
  722. }
  724. void CXTPSkinObjectFrame::OnNcMouseLeave()
  725. {
  726. if (HandleMouseMove(CPoint(-1, -1)))
  727. return;
  729. Default();
  730. }
  732. void CXTPSkinObjectFrame::OnNcLButtonDblClk(UINT nHitTest, CPoint point)
  733. {
  734. OnNcLButtonDown(nHitTest, point);
  735. }
  737. void CXTPSkinObjectFrame::OnNcRButtonUp(UINT nHitTest, CPoint point)
  738. {
  739. CPoint ptClient(point);
  740. ScreenToFrame(&ptClient);
  742. for (int i = 0; i < 2; i++)
  743. {
  744. XTP_SKINSCROLLBARPOSINFO* pSBInfo = &m_spi[i];
  745. int ht = HitTestScrollBar(pSBInfo, ptClient);
  747. if (ht != HTNOWHERE)
  748. {
  749. m_bLockFrameDraw++;
  750. RECT rc = CXTPWindowRect(this);
  751. SendMessage(WM_NCCALCSIZE, FALSE, (LPARAM)&rc);
  752. m_bLockFrameDraw--;
  754. SendMessage(WM_CONTEXTMENU, (WPARAM)m_hWnd, MAKELPARAM(point.x, point.y));
  756. RefreshFrameStyle();
  757. return;
  758. }
  759. }
  761. CXTPSkinObject::OnNcRButtonDown(nHitTest, point);
  762. }
  765. void CXTPSkinObjectFrame::OnNcLButtonDown(UINT nHitTest, CPoint point)
  766. {
  767. if (m_pButtonHot)
  768. {
  769. TrackCaptionButton();
  770. }
  772. CPoint ptClient(point);
  773. ScreenToFrame(&ptClient);
  775. for (int i = 0; i < 2; i++)
  776. {
  777. XTP_SKINSCROLLBARPOSINFO* pSBInfo = &m_spi[i];
  778. int ht = HitTestScrollBar(pSBInfo, ptClient);
  780. if (ht != HTNOWHERE)
  781. {
  782. TrackInit(ptClient, pSBInfo, (GetKeyState(VK_SHIFT) < 0) ? TRUE : FALSE);
  783. return;
  784. }
  785. }
  787. if (nHitTest == HTZOOM || nHitTest == HTREDUCE || nHitTest == HTCLOSE || nHitTest == HTHELP)
  788. return;
  790. CXTPSkinObject::OnNcLButtonDown(nHitTest, point);
  791. }
  793. BOOL CXTPSkinObjectFrame::OnHookDefWindowProc(UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  794. {
  795. if (nMessage == WM_CTLCOLORBTN || nMessage == WM_CTLCOLORDLG ||
  796. nMessage == WM_CTLCOLORSTATIC || nMessage == WM_CTLCOLOREDIT || nMessage == WM_CTLCOLORLISTBOX)
  797. {
  798. if (m_strClassName == _T("COMBOBOX"))
  799. return FALSE;
  801. if (nMessage == WM_CTLCOLOREDIT || nMessage == WM_CTLCOLORLISTBOX)
  802. {
  803. ::SetBkColor((HDC)wParam, GetColor(COLOR_WINDOW));
  804. ::SetTextColor((HDC)wParam, GetColor(COLOR_WINDOWTEXT));
  805. lResult = (LRESULT)GetMetrics()->m_brTheme[COLOR_WINDOW];
  806. return TRUE;
  807. }
  809. if (CWnd::GrayCtlColor((HDC)wParam, (HWND)lParam,
  810. (UINT)(nMessage - WM_CTLCOLORMSGBOX),
  811. m_pManager->GetMetrics()->m_brushDialog, 0))
  812. {
  813. lResult = (LRESULT)GetClientBrush((HDC)wParam, (HWND)lParam, (UINT)(nMessage - WM_CTLCOLORMSGBOX));
  814. return TRUE;
  815. }
  816. }
  818. return CXTPSkinObject::OnHookDefWindowProc(nMessage, wParam, lParam, lResult);
  819. }
  821. BOOL CXTPSkinObjectFrame::IsDefWindowProcAvail(int nMessage) const
  822. {
  823. if (!CXTPSkinObject::IsDefWindowProcAvail(nMessage))
  824. return FALSE;
  826. return TRUE;
  827. }
  829. BOOL CXTPSkinObjectFrame::PreHookMessage(UINT nMessage)
  830. {
  831. if ((nMessage == WM_ENTERIDLE) &&
  832. ((GetStyle() & (WS_CAPTION | WS_MINIMIZE | WS_VISIBLE)) == (WS_CAPTION | WS_MINIMIZE | WS_VISIBLE)))
  833. {
  834. RedrawFrame();
  835. }
  837. if (m_bLockFrameDraw && (nMessage == WM_NCCALCSIZE || nMessage == WM_STYLECHANGED || nMessage == WM_STYLECHANGING))
  838. return TRUE;
  840. if ((m_pManager->GetApplyOptions() & xtpSkinApplyFrame) == 0)
  841. {
  842. if (nMessage == WM_NCPAINT || nMessage == WM_NCCALCSIZE ||
  843. nMessage == WM_NCHITTEST || nMessage == WM_NCLBUTTONDOWN ||
  844. nMessage == WM_NCLBUTTONDBLCLK ||
  845. nMessage == WM_WINDOWPOSCHANGED || nMessage == WM_NCMOUSEMOVE ||
  846. nMessage == WM_NCMOUSELEAVE || nMessage == WM_NCACTIVATE ||
  847. nMessage == WM_WINDOWPOSCHANGING || nMessage == WM_PRINT)
  848. return TRUE;
  849. }
  851. return CXTPSkinObject::PreHookMessage(nMessage);
  852. }
  854. BOOL CXTPSkinObjectFrame::OnHookMessage(UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  855. {
  856. if (nMessage == WM_CTLCOLORBTN || nMessage == WM_CTLCOLORDLG ||
  857. nMessage == WM_CTLCOLORSTATIC || nMessage == WM_CTLCOLORLISTBOX  || nMessage == WM_CTLCOLOREDIT)
  858. {
  859. if (m_strClassName == _T("COMBOBOX"))
  860. return FALSE;
  862. if (IsDefWindowProcAvail(nMessage) &&
  863. (m_dwDialogTexture != ETDT_ENABLETAB || !m_bActiveX))
  864. {
  865. return FALSE;
  866. }
  868. if (nMessage == WM_CTLCOLORLISTBOX || nMessage == WM_CTLCOLOREDIT)
  869. {
  870. ::SetBkColor((HDC)wParam, GetColor(COLOR_WINDOW));
  871. ::SetTextColor((HDC)wParam, GetColor(COLOR_WINDOWTEXT));
  872. lResult = (LRESULT)GetMetrics()->m_brTheme[COLOR_WINDOW];
  873. return TRUE;
  874. }
  876. // handle standard gray backgrounds if enabled
  877. if (CWnd::GrayCtlColor((HDC)wParam, (HWND)lParam,
  878. (UINT)(nMessage - WM_CTLCOLORMSGBOX),
  879. m_pManager->GetMetrics()->m_brushDialog, 0))
  880. {
  881. lResult = (LRESULT)GetClientBrush((HDC)wParam, (HWND)lParam, (UINT)(nMessage - WM_CTLCOLORMSGBOX));
  882. return TRUE;
  883. }
  884. }
  886. if (nMessage == WM_ERASEBKGND && m_dwDialogTexture == ETDT_ENABLETAB)
  887. {
  888. ::SetBrushOrgEx((HDC)wParam, 0, 0, NULL);
  889. FillRect((HDC)wParam, CXTPClientRect(this), GetClientBrush((HDC)wParam, m_hWnd, CTLCOLOR_DLG));
  890. return TRUE;
  891. }
  893. return CXTPSkinObject::OnHookMessage(nMessage, wParam, lParam, lResult);
  894. }
  896. //////////////////////////////////////////////////////////////////////////
  897. // CXTPSkinObjectFrame;
  899. void CXTPSkinObjectFrame::RemoveButtons()
  900. {
  901. for (int i = 0; i < m_arrButtons.GetSize(); i++)
  902. delete m_arrButtons[i];
  904. m_arrButtons.RemoveAll();
  905. }
  908. void CXTPSkinObjectFrame::UpdateButton(int nCommand, BOOL bVisible, BOOL bEnabled, UINT htCode, int nClassPart)
  909. {
  910. if (bVisible)
  911. {
  912. CCaptionButton* pButton = new CCaptionButton(nCommand, this, htCode, nClassPart);
  913. pButton->m_bEnabled = bEnabled;
  915. m_arrButtons.Add(pButton);
  916. }
  917. }
  919. void CXTPSkinObjectFrame::UpdateButtons()
  920. {
  921. DWORD dwExStyle = GetExStyle();
  922. DWORD dwStyle = GetStyle();
  924. if (m_dwStyle == dwStyle && m_dwExStyle == dwExStyle)
  925. return;
  927. m_dwExStyle = dwExStyle;
  928. m_dwStyle = dwStyle;
  930. RemoveButtons();
  932. if (HasCaption())
  933. {
  934. BOOL bToolWindow = (dwExStyle & WS_EX_TOOLWINDOW) == WS_EX_TOOLWINDOW;
  935. BOOL bMaximized = (dwStyle & WS_MAXIMIZE) == WS_MAXIMIZE;
  936. BOOL bMinimized = (dwStyle & WS_MINIMIZE) == WS_MINIMIZE;
  938. BOOL bSysMenu = (dwStyle & WS_SYSMENU);
  939. BOOL bDialogFrame = (dwStyle & WS_DLGFRAME || dwExStyle & WS_EX_DLGMODALFRAME);
  941. BOOL bEnableClose = TRUE;
  942. BOOL bEnabledMaximize = ((dwStyle & WS_MAXIMIZEBOX) == WS_MAXIMIZEBOX);
  943. BOOL bEnabledMinimize = ((dwStyle & WS_MINIMIZEBOX) == WS_MINIMIZEBOX);
  944. BOOL bShowMinMaxButtons = !bToolWindow && bSysMenu && (bEnabledMaximize || bEnabledMinimize);
  946. if (bSysMenu && !bToolWindow)
  947. {
  948. CMenu* pMenu = GetSystemMenu(FALSE);
  949. if (pMenu->GetMenuState(SC_CLOSE, MF_BYCOMMAND) & (MF_DISABLED | MF_GRAYED)) bEnableClose = FALSE;
  950. }
  952. UpdateButton(SC_CLOSE, !bDialogFrame || bSysMenu,
  953. bEnableClose, HTCLOSE, bToolWindow? WP_SMALLCLOSEBUTTON: WP_CLOSEBUTTON);
  955. UpdateButton(SC_MAXIMIZE, !bMaximized && bShowMinMaxButtons,
  956. bEnabledMaximize, HTMAXBUTTON, WP_MAXBUTTON);
  958. if (bMinimized)
  959. {
  960. UpdateButton(SC_RESTORE, bShowMinMaxButtons,
  961. bEnabledMinimize, HTMINBUTTON, WP_RESTOREBUTTON);
  962. }
  963. else
  964. {
  965. UpdateButton(SC_RESTORE,  bMaximized && bShowMinMaxButtons,
  966. bEnabledMaximize, HTMAXBUTTON, WP_RESTOREBUTTON);
  968. UpdateButton(SC_MINIMIZE, bShowMinMaxButtons,
  969. bEnabledMinimize, HTMINBUTTON, WP_MINBUTTON);
  970. }
  972. UpdateButton(SC_CONTEXTHELP, ((dwExStyle & WS_EX_CONTEXTHELP) == WS_EX_CONTEXTHELP) && !bToolWindow && bSysMenu,
  973. TRUE, HTHELP, WP_HELPBUTTON);
  974. }
  976. }
  979. CXTPSkinObjectFrame::CCaptionButton* CXTPSkinObjectFrame::HitTestButton(CPoint pt)
  980. {
  981. DWORD dwStyle = GetStyle();
  983. for (int i = 0; i < m_arrButtons.GetSize(); i++)
  984. {
  985. CCaptionButton* pButton = m_arrButtons[i];
  986. CRect rcButton(pButton->m_rcButton);
  988. if ((dwStyle & (WS_MAXIMIZE | WS_CHILD)) == WS_MAXIMIZE)
  989. rcButton.InflateRect(0, 2, i == 0 ? 2 : 0, 0);
  991. if (rcButton.PtInRect(pt) && pButton->m_bEnabled)
  992. return pButton;
  993. }
  994. return NULL;
  995. }
  998. /////////////////////////////////////////////////////////////////////////////
  999. // CXTPSkinObjectFrame message handlers
  1001. LRESULT CXTPSkinObjectFrame::OnSetText(WPARAM wParam, LPARAM lParam)
  1002. {
  1003. if ((GetStyle() & WS_CAPTION) == WS_CAPTION)
  1004. {
  1005. LRESULT lRet = DefWindowProc(WM_SETTEXT, wParam, lParam);
  1007. RedrawFrame();
  1009. return lRet;
  1010. }
  1012. return Default();
  1013. }
  1015. HWND CXTPSkinObjectFrame::FindMDIClient()
  1016. {
  1017. return m_pMDIClient ? m_pMDIClient->m_hWnd : NULL;
  1018. }
  1020. #if (_MSC_VER <= 1200) && !defined(_WIN64)
  1021. #define GetWindowLongPtrW GetWindowLongW
  1022. #define GetWindowLongPtrA GetWindowLongA
  1023. #endif
  1025. #ifndef DWLP_DLGPROC
  1026. #define DWLP_DLGPROC 4
  1027. #endif
  1030. LRESULT CXTPSkinObjectFrame::CallDefDlgProc(UINT nMessage, WPARAM wParam, LPARAM lParam)
  1031. {
  1032. if (m_dwDialogTexture == ETDT_ENABLE) // Dialog ?
  1033. {
  1034. int nNotifyFormat = (int)SendMessage(WM_NOTIFYFORMAT, 0, NF_QUERY);
  1036. WNDPROC pDlgWndProc = (WNDPROC) (nNotifyFormat == NFR_UNICODE ?
  1037. GetWindowLongPtrW(m_hWnd, DWLP_DLGPROC) : GetWindowLongPtrA(m_hWnd, DWLP_DLGPROC));
  1039. if (pDlgWndProc && (HIWORD((ULONG)(ULONG_PTR)pDlgWndProc) != 0xFFFF))
  1040. {
  1041. return (pDlgWndProc)(m_hWnd, nMessage, wParam, lParam);
  1042. }
  1043. }
  1044. return 0;
  1045. }
  1047. BOOL CXTPSkinObjectFrame::OnNcActivate(BOOL bActive)
  1048. {
  1049. if (HasCaption())
  1050. {
  1051. CallDefDlgProc(WM_NCACTIVATE, (WPARAM)bActive, 0);
  1053. if (!bActive)
  1054. {
  1055. CWnd* pWnd = CWnd::FromHandlePermanent(m_hWnd);
  1056. // Mimic MFC kludge to stay active if WF_STAYACTIVE bit is on
  1057. //
  1058. if (pWnd && pWnd->m_nFlags & WF_STAYACTIVE)
  1059. bActive = TRUE;
  1061. if (!IsWindowEnabled())
  1062. bActive = FALSE;
  1063. }
  1066. HWND hWndClient = FindMDIClient();
  1067. HWND hWndActive = hWndClient ? (HWND)::SendMessage(hWndClient, WM_MDIGETACTIVE, 0, 0) : NULL;
  1069. if (hWndActive != m_hWnd && hWndActive)
  1070. {
  1071. ::SendMessage(hWndActive, WM_NCACTIVATE, bActive, 0);
  1072. ::SendMessage(hWndActive, WM_NCPAINT, 0, 0);
  1073. }
  1075. m_bActive = bActive;            // update state
  1077. RedrawFrame();
  1078. return TRUE;
  1079. }
  1081. return CXTPSkinObject::OnNcActivate(bActive);
  1082. }
  1085. int CXTPSkinObjectFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
  1086. {
  1087. if (CXTPSkinObject::OnCreate(lpCreateStruct) == -1)
  1088. return -1;
  1090. ResizeFrame();
  1092. return 0;
  1093. }
  1095. BOOL CXTPSkinObjectFrame::HasCaption() const
  1096. {
  1097. return (GetStyle() & WS_CAPTION) == WS_CAPTION;
  1098. }
  1101. void CXTPSkinObjectFrame::UpdateFrameRegion(CSize szFrameRegion)
  1102. {
  1103. if (m_bInUpdateRegion)
  1104. return;
  1106. m_bInUpdateRegion = TRUE;
  1108. if (m_bRegionChanged && !HasCaption())
  1109. {
  1110. SetWindowRgn(NULL, TRUE);
  1111. m_bRegionChanged = FALSE;
  1112. }
  1113. //  DWORD dwStyle = GetStyle();
  1115. if (HasCaption() && (m_szFrameRegion != szFrameRegion))
  1116. {
  1117. if (GetSkinManager()->IsEnabled() && GetSkinManager()->GetApplyOptions() & xtpSkinApplyFrame)
  1118. {
  1119. HRGN hRgn = GetSkinManager()->GetSchema()->CalcFrameRegion(this, szFrameRegion);
  1121. SetWindowRgn(hRgn, TRUE);
  1122. m_bRegionChanged = TRUE;
  1123. }
  1124. else if (m_bRegionChanged)
  1125. {
  1126. SetWindowRgn(NULL, TRUE);
  1127. m_bRegionChanged = FALSE;
  1128. }
  1130. m_szFrameRegion = szFrameRegion;
  1131. }
  1133. m_bInUpdateRegion = FALSE;
  1134. }
  1136. void CXTPSkinObjectFrame::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)
  1137. {
  1138. CXTPSkinObject::OnWindowPosChanging(lpwndpos);
  1140. CSize szFrameRegion(lpwndpos->cx, lpwndpos->cy);
  1142. if (((lpwndpos->flags & SWP_NOSIZE) ==  0) && (m_szFrameRegion != szFrameRegion))
  1143. {
  1144. if ((GetExStyle() & WS_EX_LAYOUTRTL) == 0)
  1145. UpdateFrameRegion(szFrameRegion);
  1146. }
  1147. }
  1149. void CXTPSkinObjectFrame::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos)
  1150. {
  1151. CXTPSkinObject::OnWindowPosChanged(lpwndpos);
  1153. CSize szFrameRegion(lpwndpos->cx, lpwndpos->cy);
  1155. if (((lpwndpos->flags & SWP_NOSIZE) ==  0) && (m_szFrameRegion != szFrameRegion))
  1156. {
  1157. if ((GetExStyle() & WS_EX_LAYOUTRTL) != 0)
  1158. UpdateFrameRegion(szFrameRegion);
  1159. }
  1160. }
  1163. void CXTPSkinObjectFrame::RefreshMetrics()
  1164. {
  1165. CXTPSkinObject::RefreshMetrics();
  1167. m_szFrameRegion = CSize(0, 0);
  1169. PostMessage(WM_SYSCOLORCHANGE);
  1170. }
  1174. void CXTPSkinObjectFrame::InvalidateButtons()
  1175. {
  1176. RedrawFrame();
  1177. }
  1180. void CXTPSkinObjectFrame::TrackCaptionButton()
  1181. {
  1182. SetCapture();
  1183. BOOL bAccept = FALSE;
  1184. m_pButtonPressed = m_pButtonHot;
  1185. CCaptionButton* pButtonPressed = m_pButtonHot;
  1186. ASSERT(pButtonPressed);
  1188. RedrawFrame();
  1190. while (::GetCapture() == m_hWnd)
  1191. {
  1192. MSG msg;
  1194. if (!::GetMessage(&msg, NULL, 0, 0))
  1195. {
  1196. AfxPostQuitMessage((int)msg.wParam);
  1197. break;
  1198. }
  1200. if (msg.message == WM_LBUTTONUP)
  1201. {
  1202. bAccept = m_pButtonPressed == pButtonPressed;
  1203. break;
  1204. }
  1205. else if (msg.message == WM_NCMOUSELEAVE)
  1206. {
  1208. }
  1209. else if (msg.message == WM_MOUSEMOVE)
  1210. {
  1211. POINT point = msg.pt;
  1212. ScreenToFrame(&point);
  1214. CCaptionButton* pButton = HitTestButton(point) == pButtonPressed ? pButtonPressed : NULL;
  1216. if (pButton != m_pButtonPressed)
  1217. {
  1218. m_pButtonPressed = pButton;
  1219. RedrawFrame();
  1220. }
  1221. }
  1222. else
  1223. {
  1224. TranslateMessage(&msg);
  1225. DispatchMessage(&msg);
  1226. }
  1227. }
  1229. m_pButtonPressed = NULL;
  1230. m_pButtonHot = NULL;
  1231. ReleaseCapture();
  1232. RedrawFrame();
  1234. if (bAccept)
  1235. {
  1236. SendMessage(WM_SYSCOMMAND, pButtonPressed->m_nCommand);
  1237. }
  1238. }
  1240. LRESULT CXTPSkinObjectFrame::OnPrint(WPARAM wParam, LPARAM lParam)
  1241. {
  1242. LRESULT lResult = TRUE;
  1244. if (lParam != PRF_NONCLIENT)
  1245. {
  1246. m_bLockFrameDraw++;
  1247. lResult = DefWindowProc(WM_PRINT, wParam, lParam);
  1248. m_bLockFrameDraw--;
  1249. }
  1251. if (lParam & PRF_NONCLIENT)
  1252. {
  1253. if (m_spi[SB_VERT].fVisible) m_spi[SB_VERT].fVisible = GetStyle() & WS_VSCROLL;
  1254. if (m_spi[SB_HORZ].fVisible) m_spi[SB_HORZ].fVisible = GetStyle() & WS_HSCROLL;
  1256. CDC* pDC = CDC::FromHandle((HDC)wParam);
  1258. if ((GetExStyle() & WS_EX_LAYOUTRTL) && !XTPDrawHelpers()->IsContextRTL(pDC))
  1259. XTPDrawHelpers()->SetContextRTL(pDC, 1);
  1261. DrawFrame(pDC);
  1262. }
  1264. return lResult;
  1265. }
  1267. void CXTPSkinObjectFrame::OnSysCommand(UINT nID, LPARAM lParam)
  1268. {
  1269. UINT nCmd = (nID & 0xFFF0);
  1271. if ((nCmd == SC_MAXIMIZE) && (m_pManager->GetApplyOptions() & xtpSkinApplyMetrics) &&
  1272. ((GetExStyle() & WS_EX_MDICHILD) == WS_EX_MDICHILD) &&
  1273. ((GetStyle() & WS_MAXIMIZE) == 0))
  1274. {
  1275. CXTPSkinObject::OnSysCommand(nID, lParam);
  1277. RECT rc;
  1278. GetParent()->GetClientRect(&rc);
  1279. int cx = rc.right - rc.left;
  1280. int cy = rc.bottom - rc.top;
  1282. rc.left = -m_rcBorders.left;
  1283. rc.top = -m_rcBorders.top;
  1284. rc.right = cx + m_rcBorders.right;
  1285. rc.bottom = cy + m_rcBorders.bottom;
  1287. MoveWindow(rc.left, rc.top,
  1288. rc.right - rc.left, rc.bottom - rc.top, TRUE);
  1289. return;
  1290. }
  1292. if (nCmd == SC_MOUSEMENU || nCmd == SC_KEYMENU || nCmd == SC_MOUSEMENU)
  1293. {
  1294. if (HasCaption() && (m_pManager->GetApplyOptions() & xtpSkinApplyMetrics))
  1295. {
  1296. RECT rc = {0, 0, 100, 100};
  1297. AdjustWindowRectEx(&rc, GetStyle(), FALSE, GetExStyle());
  1298. CRect rcBorder = GetSkinManager()->GetSchema()->CalcFrameBorders(this);
  1300. m_sMenuOffset.y = rcBorder.top + rc.top;
  1301. m_sMenuOffset.x = rcBorder.left + rc.left;
  1302. }
  1303. }
  1305. if ((nCmd == SC_MOVE) && (GetStyle() & WS_MINIMIZE))
  1306. {
  1307. DoDefWindowProc(WM_NCPAINT, 0, 0);
  1308. RedrawFrame();
  1309. }
  1312. CXTPSkinObject::OnSysCommand(nID, lParam);
  1314. if (nCmd == SC_MINIMIZE)
  1315. {
  1316. RedrawFrame();
  1317. }
  1319. m_sMenuOffset.x = m_sMenuOffset.y = 0;
  1320. }
  1322. void CXTPSkinObjectFrame::OnGetMinMaxInfo(MINMAXINFO* lpMMI)
  1323. {
  1324. CXTPSkinObject::OnGetMinMaxInfo(lpMMI);
  1326. if ((m_pManager->GetApplyOptions() & xtpSkinApplyFrame) && HasCaption())
  1327. {
  1328. int yMin = m_rcBorders.top + m_rcBorders.bottom;
  1329. int xMin = (int)m_arrButtons.GetSize() * m_rcBorders.top;
  1331. xMin += GetSystemMetrics(SM_CYSIZE) + 2 * GetSystemMetrics(SM_CXEDGE);
  1333. lpMMI->ptMinTrackSize.x = max(lpMMI->ptMinTrackSize.x, xMin);
  1334. lpMMI->ptMinTrackSize.y = max(lpMMI->ptMinTrackSize.y, yMin);
  1335. }
  1337. if ((m_pManager->GetApplyOptions() & xtpSkinApplyMetrics) && ((GetExStyle() & WS_EX_MDICHILD) == WS_EX_MDICHILD))
  1338. {
  1340. int nDelta = m_rcBorders.top + lpMMI->ptMaxPosition.y;
  1341. lpMMI->ptMaxPosition.y -= nDelta;
  1342. lpMMI->ptMaxSize.y += nDelta;
  1343. }
  1344. }
  1346. void CXTPSkinObjectFrame::OnStyleChanged(int nStyleType, LPSTYLESTRUCT lpStyleStruct)
  1347. {
  1348. CXTPSkinObject::OnStyleChanged(nStyleType, lpStyleStruct);
  1350. m_rcBorders = GetSkinManager()->GetSchema()->CalcFrameBorders(this);
  1352. CXTPWindowRect rc(this);
  1353. m_szFrameRegion = CSize(0);
  1354. UpdateFrameRegion(rc.Size());
  1356. UpdateButtons();
  1357. }
  1359. int CXTPSkinObjectFrame::GetClientBrushMessage()
  1360. {
  1361. return m_nCtlColorMessage;
  1362. }
  1364. HBRUSH CXTPSkinObjectFrame::GetClientBrush(CDC* pDC)
  1365. {
  1366. return GetFillBackgroundBrush(pDC, GetClientBrushMessage());
  1367. }
  1369. HBRUSH CXTPSkinObjectFrame::GetFillBackgroundBrush(CDC* pDC, int nMessage)
  1370. {
  1371. if (GetParent() == NULL)
  1372. return GetMetrics()->m_brTheme[COLOR_3DFACE];
  1374. HBRUSH hBrush = (HBRUSH)::SendMessage(GetParent()->GetSafeHwnd(), nMessage, (WPARAM)pDC->GetSafeHdc(), (LPARAM)m_hWnd);
  1375. if (hBrush)
  1376. {
  1377. if ((DWORD_PTR)hBrush < XTP_SKINMETRICS_COLORTABLESIZE)
  1378. {
  1379. hBrush = GetMetrics()->m_brTheme[(DWORD_PTR)hBrush - 1];
  1380. }
  1381. return hBrush;
  1382. }
  1384. return nMessage == WM_CTLCOLOREDIT || nMessage == WM_CTLCOLORLISTBOX ?
  1385. GetMetrics()->m_brTheme[COLOR_WINDOW] :
  1386. GetMetrics()->m_brTheme[COLOR_3DFACE];
  1387. }
  1389. HBRUSH CXTPSkinObjectFrame::FillBackground(CDC* pDC, LPCRECT lprc, int nMessage /*= WM_CTLCOLORSTATIC*/)
  1390. {
  1391. HBRUSH hBrush = ::GetParent(m_hWnd) ? (HBRUSH)::SendMessage(::GetParent(m_hWnd), nMessage, (WPARAM)pDC->GetSafeHdc(), (LRESULT)m_hWnd) : NULL;
  1392. if (hBrush)
  1393. {
  1394. if ((DWORD_PTR)hBrush < XTP_SKINMETRICS_COLORTABLESIZE)
  1395. {
  1396. hBrush = GetMetrics()->m_brTheme[(DWORD_PTR)hBrush - 1];
  1397. }
  1398. ::FillRect(pDC->GetSafeHdc(), lprc, hBrush);
  1399. return hBrush;
  1400. }
  1402. pDC->FillSolidRect(lprc, GetColor(COLOR_3DFACE));
  1403. return GetMetrics()->m_brTheme[COLOR_3DFACE];
  1404. }