//-------------------------------------------------------------------------// // NCTheme.cpp //-------------------------------------------------------------------------// // bug: resizable dialog (themesel) doesn't repaint client when needed // (for test case, resize "themesel" using "bussolid" theme. //-------------------------------------------------------------------------// #include "stdafx.h" #include "nctheme.h" #include "sethook.h" #include "info.h" #include "rgn.h" // AddToCompositeRgn() #include "scroll.h" // DrawSizeBox, DrawScrollBar, HandleScrollCmd #include "resource.h" #include "tmreg.h" #include "wrapper.h" #include "appinfo.h" //-------------------------------------------------------------------------// /// local macros, consts, vars //-------------------------------------------------------------------------// const RECT rcNil = {-1,-1,-1,-1}; const WINDOWPARTS BOGUS_WINDOWPART = (WINDOWPARTS)0; #define VALID_WINDOWPART(part) ((part)!=BOGUS_WINDOWPART) #define WS_MINMAX (WS_MINIMIZEBOX | WS_MAXIMIZEBOX) #define HAS_CAPTIONBAR( dwStyle ) (WS_CAPTION == ((dwStyle) & WS_CAPTION)) #define DLGWNDCLASSNAME TEXT("#32770") #define DLGWNDCLASSNAMEW L"#32770" #define NUMBTNSTATES 4 /*number of defined states*/ #define MAKE_BTNSTATE(framestate, state) ((((framestate)-1) * NUMBTNSTATES) + (state)) #define MDIBTNINDEX(ncrc) ((ncrc)-NCMDIBTNFIRST) #ifdef MAKEPOINT #undef MAKEPOINT #endif MAKEPOINT #define MAKEPOINT(pt,lParam) POINTSTOPOINT(pt, MAKEPOINTS(lParam)) #define IsHTFrameButton(htCode) \ (((htCode) == HTMINBUTTON) || \ ((htCode) == HTMAXBUTTON) || \ ((htCode) == HTCLOSE) || \ ((htCode) == HTHELP)) #define IsTopLevelWindow(hwnd) (IsWindow(hwnd) && NULL==GetParent(hwnd)) #define IsHTScrollBar(htCode) (((htCode) == HTVSCROLL) || ((htCode) == HTHSCROLL)) #define SIG_CTHEMEWND_HEAD "themewnd" #define SIG_CTHEMEWND_TAIL "end" //-------------------------------------------------------------------------// HWND _hwndFirstTop = NULL; // first themed window in process TCHAR _szWindowMetrics[128] = {0}; // WM_SETTINGCHANGE string param. //-------------------------------------------------------------------------// // debug painting switch. #define DEBUG_NCPAINT //-------------------------------------------------------------------------// // internal helper forwards //-------------------------------------------------------------------------// HDC _GetNonclientDC( IN HWND hwnd, IN OPTIONAL HRGN hrgnUpdate ); BOOL _ClientRectToScreen( HWND, LPRECT prcClient ); void _ScreenToParent( HWND, LPRECT prcWnd ); BOOL _GetWindowMonitorRect( HWND hwnd, LPRECT prcMonitor ); BOOL _GetMaximizedContainer( IN HWND hwnd, OUT LPRECT prcContainer ); BOOL _IsFullMaximized( IN OPTIONAL HWND hwnd, IN LPCRECT prcWnd ); BOOL _IsMessageWindow( HWND ); void _MDIUpdate( HWND hwndMDIChildOrClient, UINT uSwpFlags ); BOOL _MDIClientUpdateChildren( HWND hwndMDIClient ); void _MDIChildUpdateParent( HWND hwndMDIChild, BOOL fSetMenu = FALSE ); HWND _MDIGetActive( HWND, OUT OPTIONAL BOOL* pfMaximized = NULL ); HWND _MDIGetParent( HWND hwnd, OUT OPTIONAL CThemeWnd** ppMdiFrame = NULL, OUT OPTIONAL HWND *phwndMDIClient = NULL ); HRESULT _CreateBackgroundBitmap( IN OPTIONAL HDC, IN HTHEME, IN int iPartId, IN int iStateId, IN OUT LPSIZE, OUT HBITMAP*); HRESULT _CreateMdiMenuItemBitmap( IN HDC hdc, IN HTHEME hTheme, IN OUT SIZE* pSize, IN OUT MENUITEMINFO* pmii ); void _ComputeElementOffset( HTHEME, int iPartId, int iStateId, LPCRECT prcBase, POINT *pptOffset); int _GetRawClassicCaptionHeight( DWORD dwStyle, DWORD dwExStyle ); int _GetSumClassicCaptionHeight( DWORD dwStyle, DWORD dwExStyle ); void _ComputeNcWindowStatus( IN HWND, IN DWORD dwStatus, IN OUT NCWNDMET* pncwm ); BOOL _NeedsWindowEdgeStyle(DWORD dwStyle, DWORD dwExStyle ); BOOL _MNCanClose(HWND); int _GetWindowBorders(LONG lStyle, DWORD dwExStyle ); BOOL _GetWindowMetrics( HWND, IN OPTIONAL HWND hwndMDIActive, OUT NCWNDMET* pncwm ); BOOL _IsNcPartTransparent( WINDOWPARTS part, const NCTHEMEMET& nctm ); BOOL _GetNcFrameMetrics( HWND, HTHEME hTheme, const NCTHEMEMET&, IN OUT NCWNDMET& ); BOOL _GetNcCaptionMargins( HTHEME hTheme, IN const NCTHEMEMET& nctm, IN OUT NCWNDMET& ncwm ); LPWSTR _AllocWindowText( IN HWND hwnd ); BOOL _GetNcCaptionTextSize( IN HTHEME hTheme, IN HWND hwnd, IN HFONT hf, OUT SIZE* psizeCaption ); BOOL _GetNcCaptionTextRect( IN OUT NCWNDMET* pncwm ); COLORREF _GetNcCaptionTextColor( FRAMESTATES iStateId ); void _GetNcBtnHitTestRect( IN const NCWNDMET* pncwm, IN UINT uHitcode, BOOL fWindowRelative, OUT LPRECT prcHit ); void _GetBrushesForPart(HTHEME hTheme, int iPart, HBITMAP* phbm, HBRUSH* phbr); BOOL _ShouldAssignFrameRgn( IN const NCWNDMET* pncwm, IN const NCTHEMEMET& nctm ); BOOL _IsNcPartTransparent( WINDOWPARTS part, const NCTHEMEMET& nctm ); BOOL _ComputeNcPartTransparency( HTHEME, IN OUT NCTHEMEMET* pnctm ); HRESULT _LoadNcThemeMetrics( HWND, IN OUT OPTIONAL NCTHEMEMET* pnctm ); HRESULT _LoadNcThemeSysMetrics( HWND hwnd, IN OUT OPTIONAL NCTHEMEMET* pnctm ); void _NcSetPreviewMetrics( BOOL fPreview ); BOOL _NcUsingPreviewMetrics(); //-------------------------------------------------------------------------// #ifdef THEMED_NCBTNMETRICS BOOL _GetClassicNcBtnMetrics( IN OPTIONAL NCWNDMET* pncwm, IN OPTIONAL HICON hAppIcon, IN OPTIONAL BOOL fCanClose, IN OPTIONAL BOOL fRefresh = FALSE ); #else THEMED_NCBTNMETRICS BOOL _GetNcBtnMetrics( IN OUT NCWNDMET*, IN const NCTHEMEMET*, IN HICON, IN OPTIONAL BOOL ); #endif THEMED_NCBTNMETRICS //-------------------------------------------------------------------------// // Debug painting. #if defined(DEBUG) ULONG _NcTraceFlags = 0; # if defined(DEBUG_NCPAINT) # define BEGIN_DEBUG_NCPAINT() int cgbl = 0; if(TESTFLAG(_NcTraceFlags, NCTF_NCPAINT)) {GdiSetBatchLimit(1);} # define END_DEBUG_NCPAINT() if(TESTFLAG(_NcTraceFlags, NCTF_NCPAINT)) {GdiSetBatchLimit(cgbl);} HRESULT _DebugDrawThemeBackground(HTHEME, HDC, int, int, const RECT*, OPTIONAL const RECT*); HRESULT _DebugDrawThemeBackgroundEx(HTHEME, HDC, int, int, const RECT *prc, OPTIONAL const DTBGOPTS*); void NcDebugClipRgn( HDC hdc, COLORREF rgbPaint ); # define NcDrawThemeBackground _DebugDrawThemeBackground # define NcDrawThemeBackgroundEx _DebugDrawThemeBackgroundEx # else //defined(DEBUG_NCPAINT) # define BEGIN_DEBUG_NCPAINT() # define END_DEBUG_NCPAINT() # define NcDrawThemeBackground DrawThemeBackground # define NcDrawThemeBackgroundEx DrawThemeBackgroundEx # define NcDebugClipRgn(hdc,rgbPaint) # endif //defined(DEBUG_NCPAINT) #else # define BEGIN_DEBUG_NCPAINT() # define END_DEBUG_NCPAINT() # define NcDrawThemeBackground DrawThemeBackground # define NcDrawThemeBackgroundEx DrawThemeBackgroundEx # define NcDebugClipRgn(hdc,rgbPaint) #endif //defined(DEBUG) #define RGBDEBUGBKGND RGB(0xFF,0x00,0xFF) // debug background indicator fill color //-------------------------------------------------------------------------// // process-global metrics static NCTHEMEMET _nctmCurrent = {0}; CRITICAL_SECTION _csNcSysMet = {0}; // protects access to _incmCurrent CRITICAL_SECTION _csThemeMet = {0}; // protects access to _nctmCurrent //-------------------------------------------------------------------------// // process NONCLIENTMETRICS cache. struct CInternalNonclientMetrics //-------------------------------------------------------------------------// { const NONCLIENTMETRICS& GetNcm() { Acquire(FALSE); return _ncm; } HFONT GetFont( BOOL fSmallCaption ) { if( _fSet) { return fSmallCaption ? _hfSmCaption : _hfCaption; } return NULL; } void operator =( const NONCLIENTMETRICS& ncmSrc ) { _ncm = ncmSrc; SAFE_DELETE_GDIOBJ(_hfCaption); _hfCaption = CreateFontIndirect( &_ncm.lfCaptionFont ); SAFE_DELETE_GDIOBJ(_hfSmCaption); _hfSmCaption = CreateFontIndirect( &_ncm.lfSmCaptionFont ); _fSet = TRUE; } BOOL Acquire( BOOL fRefresh ) { //---- quick check for outdated metrics ---- if (!_fPreview) { int iNewHeight = GetSystemMetrics(SM_CYSIZE); if (iNewHeight != _iCaptionButtonHeight) // out of date { fRefresh = TRUE; // force the issue _iCaptionButtonHeight = iNewHeight; } } // normal metrics if( !_fSet || fRefresh ) { // save logfont checksum LOGFONT lfCaption = _ncm.lfCaptionFont; LOGFONT lfSmCaption = _ncm.lfSmCaptionFont; Log(LOG_TMLOAD, L"Acquire: calling ClassicSystemParmetersInfo"); _ncm.cbSize = sizeof(_ncm); _fSet = ClassicSystemParametersInfo( SPI_GETNONCLIENTMETRICS, 0, &_ncm, FALSE ); if( _fSet ) { // if old, new logfont checksums don't match, recycle our fonts if( CompareLogfont( &lfCaption, &_ncm.lfCaptionFont) ) { SAFE_DELETE_GDIOBJ(_hfCaption); _hfCaption = CreateFontIndirect(&_ncm.lfCaptionFont); } if( CompareLogfont( &lfSmCaption, &_ncm.lfSmCaptionFont) ) { SAFE_DELETE_GDIOBJ(_hfSmCaption); _hfSmCaption = CreateFontIndirect(&_ncm.lfSmCaptionFont); } } } return _fSet; } void Clear() { SAFE_DELETE_GDIOBJ(_hfCaption); SAFE_DELETE_GDIOBJ(_hfSmCaption); ZeroMemory( &_ncm, sizeof(_ncm) ); _fSet = FALSE; } static int CompareLogfont( const LOGFONT* plf1, const LOGFONT* plf2 ) { int n = memcmp( plf1, plf2, sizeof(LOGFONT) - sizeof(plf1->lfFaceName) ); if( !n ) { n = lstrcmp( plf1->lfFaceName, plf2->lfFaceName ); } return n; } NONCLIENTMETRICS _ncm; int _iCaptionButtonHeight; BOOL _fSet; HFONT _hfCaption; HFONT _hfSmCaption; BOOL _fPreview; } _incmCurrent = {0}, _incmPreview = {0}; //-------------------------------------------------------------------------// // MDI sys button group abstraction class CMdiBtns //-------------------------------------------------------------------------// { public: CMdiBtns(); ~CMdiBtns() { Unload(); } BOOL Load( IN HTHEME hTheme, IN OPTIONAL HDC hdc = NULL, IN OPTIONAL UINT uSysCmd = 0 ); BOOL ThemeItem( HMENU hMenu, int iPos, MENUITEMINFO* pmii, BOOL fTheme ); void Unload( IN OPTIONAL UINT uSysCmd = 0 ); BOOL Measure( IN HTHEME hTheme, IN OUT MEASUREITEMSTRUCT* pmis ); BOOL Draw( IN HTHEME hTheme, IN DRAWITEMSTRUCT* pdis ); private: #define MDIBTNCOUNT 3 // 1=min, 2=restore, 3=close //------------------------------------// // MDI sys button descriptor element struct MDIBTN { UINT wID; WINDOWPARTS iPartId; SIZINGTYPE sizingType; SIZE size; UINT fTypePrev; HBITMAP hbmPrev; HBITMAP hbmTheme; } _rgBtns[MDIBTNCOUNT]; private: MDIBTN* _FindBtn( IN UINT wID ); static CLOSEBUTTONSTATES _CalcState( IN ULONG ulodAction, IN ULONG ulodState ); }; //-------------------------------------------------------------------------// //-------------------------------------------------------------------------// // utility impl //-------------------------------------------------------------------------// //-------------------------------------------------------------------------// BOOL _ClientRectToScreen( HWND hwnd, LPRECT prcClient ) { if( prcClient && GetClientRect( hwnd, prcClient ) ) { POINT* pp = (POINT*)prcClient; //---- use MapWindowPoints() to account for mirrored windows ---- MapWindowPoints(hwnd, HWND_DESKTOP, pp, 2); return TRUE; } return FALSE; } //-------------------------------------------------------------------------// void _ScreenToParent( HWND hwnd, LPRECT prcWnd ) { //if we have a parent, we need to convert to those coords HWND hwndParent = GetAncestor(hwnd, GA_PARENT); POINT* pp = (POINT*)prcWnd; //---- use MapWindowPoints() to account for mirrored windows ---- MapWindowPoints(HWND_DESKTOP, hwndParent, pp, 2); } //-------------------------------------------------------------------------// inline BOOL _StrictPtInRect( LPCRECT prc, const POINT& pt ) { // Win32 PtInRect will test positive for an empty rectangle... return !IsRectEmpty(prc) && PtInRect( prc, pt ); } //-------------------------------------------------------------------------// inline BOOL _RectInRect( LPCRECT prcTest, LPCRECT prc ) { if ( prc->left < prcTest->left && prc->right > prcTest->right && prc->top < prcTest->top && prc->bottom > prcTest->bottom ) { return TRUE; } else { return FALSE; } } //-------------------------------------------------------------------------// inline HDC _GetNonclientDC( IN HWND hwnd, IN OPTIONAL HRGN hrgnUpdate ) { // private GetDCEx #defines from user #define DCX_USESTYLE 0x00010000L #define DCX_NODELETERGN 0x00040000L DWORD dwDCX = DCX_USESTYLE|DCX_WINDOW|DCX_LOCKWINDOWUPDATE; if( hrgnUpdate != NULL ) dwDCX |= (DCX_INTERSECTRGN|DCX_NODELETERGN); return GetDCEx( hwnd, hrgnUpdate, dwDCX ); } //-------------------------------------------------------------------------// HWND _MDIGetActive( HWND hwndMDIClient, OUT OPTIONAL BOOL* pfMaximized ) { BOOL fMaximized = FALSE; HWND hwndActive = NULL; if( IsWindow( hwndMDIClient ) ) hwndActive = (HWND)SendMessage( hwndMDIClient, WM_MDIGETACTIVE, 0, (LPARAM)&fMaximized ); if( pfMaximized ) *pfMaximized = fMaximized; return hwndActive; } //-------------------------------------------------------------------------//// // computes rectangle of window's default monitor BOOL _GetWindowMonitorRect( HWND hwnd, LPRECT prcMonitor ) { if( IsWindow(hwnd) ) { // default to primary monitor SetRect( prcMonitor, 0, 0, NcGetSystemMetrics(SM_CXSCREEN), NcGetSystemMetrics(SM_CYSCREEN)); // try determining window's real monitor HMONITOR hMon = MonitorFromWindow( hwnd, MONITOR_DEFAULTTONULL ); if( hMon ) { MONITORINFO mi; mi.cbSize = sizeof(mi); if( GetMonitorInfo( hMon, &mi ) ) { *prcMonitor = mi.rcWork; } } return TRUE; } return FALSE; } //-------------------------------------------------------------------------//// // determines whether the indicate window is as large or larger than // the target monitor BOOL _GetMaximizedContainer( IN HWND hwnd, OUT LPRECT prcContainer ) { ASSERT(IsWindow(hwnd)); HWND hwndParent = GetParent(hwnd); if( hwndParent ) { return GetWindowRect( hwndParent, prcContainer ); } // top-level window: container is primary monitor return _GetWindowMonitorRect( hwnd, prcContainer ); } //-------------------------------------------------------------------------//// // determines whether the indicate window is as large or larger than // the target monitor BOOL _IsFullMaximized( IN OPTIONAL HWND hwnd, IN LPCRECT prcWnd ) { if( !IsWindow(hwnd) ) return TRUE; // assume full-screen maximized window if( IsZoomed(hwnd) ) { RECT rcContainer = {0}; if( !_GetMaximizedContainer( hwnd, &rcContainer ) ) return TRUE; // determine whether the rect is contained in the screen rect return _RectInRect( &rcContainer, prcWnd ); } return FALSE; } //-------------------------------------------------------------------------// // // _GetRawClassicCaptionHeight() - // // Using system metrics, computes the total height of the caption bar // including edge and borders // inline int _GetRawClassicCaptionHeight( DWORD dwStyle, DWORD dwExStyle ) { ASSERT(HAS_CAPTIONBAR(dwStyle)); // shouldn't be here without WS_CAPTION return NcGetSystemMetrics( TESTFLAG(dwExStyle, WS_EX_TOOLWINDOW ) ? SM_CYSMCAPTION : SM_CYCAPTION ); } //-------------------------------------------------------------------------// // // _GetSumClassicCaptionHeight() - // // Using system metrics, computes the total height of the caption bar // including edge and borders // inline int _GetSumClassicCaptionHeight( DWORD dwStyle, DWORD dwExStyle ) { ASSERT(HAS_CAPTIONBAR(dwStyle)); // shouldn't be here without WS_CAPTION // Factor in window border width. return _GetWindowBorders( dwStyle, dwExStyle) + _GetRawClassicCaptionHeight( dwStyle, dwExStyle ); } //-------------------------------------------------------------------------// // // GetWindowBorders() - port from win32k, rtl\winmgr.c // // Computes window border dimensions based on style bits. // int _GetWindowBorders(LONG lStyle, DWORD dwExStyle ) { int cBorders = 0; // // Is there a 3D border around the window? // if( TESTFLAG(dwExStyle, WS_EX_WINDOWEDGE) ) cBorders += 2; else if ( TESTFLAG(dwExStyle, WS_EX_STATICEDGE) ) ++cBorders; // // Is there a single flat border around the window? This is true for // WS_BORDER, WS_DLGFRAME, and WS_EX_DLGMODALFRAME windows. // if( TESTFLAG(lStyle, WS_CAPTION) || TESTFLAG(dwExStyle, WS_EX_DLGMODALFRAME) ) ++cBorders; // // Is there a sizing flat border around the window? // if( TESTFLAG(lStyle, WS_THICKFRAME) && !TESTFLAG(lStyle, WS_MINIMIZE) ) { NONCLIENTMETRICS ncm; cBorders += (NcGetNonclientMetrics( &ncm, FALSE ) ? ncm.iBorderWidth : NcGetSystemMetrics( SM_CXBORDER )); } return(cBorders); } //-------------------------------------------------------------------------// // Determines whether WS_EX_WINDOWEDGE should be assumed. // Ripped from USER sources (rtl\winmgr.c) BOOL _NeedsWindowEdgeStyle(DWORD dwStyle, DWORD dwExStyle ) { BOOL fGetsWindowEdge = FALSE; if (dwExStyle & WS_EX_DLGMODALFRAME) fGetsWindowEdge = TRUE; else if (dwExStyle & WS_EX_STATICEDGE) fGetsWindowEdge = FALSE; else if (dwStyle & WS_THICKFRAME) fGetsWindowEdge = TRUE; else switch (dwStyle & WS_CAPTION) { case WS_DLGFRAME: fGetsWindowEdge = TRUE; break; case WS_CAPTION: fGetsWindowEdge = TRUE; // PORTPORT: SHIMSHIM should be: = (RtlGetExpWinVer(hMod) > VER40) // we will assume a new app; old apps are denied. break; } return(fGetsWindowEdge); } //-------------------------------------------------------------------------// // _MNCanClose // // returns TRUE only if USER32 determines that the window can be closed // (by checking its system menu items and their disabled state) // BOOL _MNCanClose(HWND hwnd) { LogEntryNC(L"_MNCanClose"); BOOL fRetVal = FALSE; TITLEBARINFO tbi = {sizeof(tbi)}; //---- don't use GetSystemMenu() - has user handle leak issues ---- if (GetTitleBarInfo(hwnd, &tbi)) { //---- mask out the good bits ---- DWORD dwVal = (tbi.rgstate[5] & (~(STATE_SYSTEM_PRESSED | STATE_SYSTEM_FOCUSABLE))); fRetVal = (dwVal == 0); // only if no bad bits are left } if ( !fRetVal && TESTFLAG(GetWindowLong(hwnd, GWL_EXSTYLE), WS_EX_MDICHILD) ) { HMENU hMenu = GetSystemMenu(hwnd, FALSE); MENUITEMINFO menuInfo; menuInfo.cbSize = sizeof(MENUITEMINFO); menuInfo.fMask = MIIM_STATE; if ( GetMenuItemInfo(hMenu, SC_CLOSE, FALSE, &menuInfo) ) { fRetVal = !(menuInfo.fState & MFS_GRAYED) ? TRUE : FALSE; } } LogExitNC(L"_MNCanClose"); return fRetVal; } //-------------------------------------------------------------------------// void CThemeWnd::UpdateMDIFrameStuff( HWND hwndMDIClient, BOOL fSetMenu ) { HWND hwndMDIActive = _MDIGetActive( hwndMDIClient, NULL ); // cache MDIClient, maximized M window handle _hwndMDIClient = IsWindow(hwndMDIActive) ? hwndMDIClient : NULL; } //-------------------------------------------------------------------------// BOOL CALLBACK _FreshenThemeMetricsCB( HWND hwnd, LPARAM lParam ) { CThemeWnd* pwnd = CThemeWnd::FromHwnd( hwnd ); if( VALID_THEMEWND(pwnd) ) { pwnd->AddRef(); pwnd->GetNcWindowMetrics( NULL, NULL, NULL, NCWMF_RECOMPUTE ); pwnd->Release(); } return TRUE; } //-------------------------------------------------------------------------// BOOL _IsMessageWindow( HWND hwnd ) { // A window parented by HWND_MESSAGE has no UI and should not be themed. static ATOM _atomMsgWnd = 0; HWND hwndParent = (HWND)GetWindowLongPtr( hwnd, GWLP_HWNDPARENT ); if( hwndParent ) { ATOM atomParent = (ATOM)GetClassLong( hwndParent, GCW_ATOM ); // have we seen the message window wndclass before? if( _atomMsgWnd ) return (atomParent == _atomMsgWnd); // compare class atoms // haven't seen a message window come through in this process, // so compare class names. WCHAR szClass[128]; if( GetClassNameW( hwndParent, szClass, ARRAYSIZE(szClass) ) ) { if( 0 == AsciiStrCmpI( szClass, L"Message" ) ) { _atomMsgWnd = atomParent; return TRUE; } } } return FALSE; } //-------------------------------------------------------------------------// // Retrieves MDI frame and/or MDICLIENT window for an MDI child window HWND _MDIGetParent( HWND hwnd, OUT OPTIONAL CThemeWnd** ppMdiFrame, OUT OPTIONAL HWND* phwndMDIClient ) { if( ppMdiFrame ) *ppMdiFrame = NULL; if( phwndMDIClient ) *phwndMDIClient = NULL; if( TESTFLAG(GetWindowLong( hwnd, GWL_EXSTYLE ), WS_EX_MDICHILD) ) { HWND hwndMDIClient = GetParent(hwnd); if( IsWindow(hwndMDIClient) ) { HWND hwndFrame = GetParent(hwndMDIClient); if( IsWindow(hwndFrame) ) { if( phwndMDIClient ) *phwndMDIClient = hwndMDIClient; if( ppMdiFrame ) *ppMdiFrame = CThemeWnd::FromHwnd(hwndFrame); return hwndFrame; } } } return NULL; } //-------------------------------------------------------------------------// HWND _FindMDIClient( HWND hwndFrame ) { for( HWND hwndChild = GetWindow(hwndFrame, GW_CHILD); hwndChild != NULL; hwndChild = GetNextWindow(hwndChild, GW_HWNDNEXT)) { TCHAR szClass[48]; if( GetClassName(hwndChild, szClass, ARRAYSIZE(szClass)) ) { if( 0 == lstrcmpi(szClass, TEXT("MDIClient")) ) { return hwndChild; } } } return NULL; } //-------------------------------------------------------------------------// // Handle MDI relative updating on WM_WINDOWPOSCHANGED void _MDIUpdate( HWND hwnd, UINT uSwpFlags) { // Notify MDI frame if we became maximized, etc. BOOL bIsClient = FALSE; // Could be the MDI client, could be a MDI child if (!(TESTFLAG(uSwpFlags, SWP_NOMOVE) && TESTFLAG(uSwpFlags, SWP_NOSIZE))) { bIsClient = _MDIClientUpdateChildren( hwnd ); } if (!bIsClient) { _MDIChildUpdateParent( hwnd, FALSE ); } } //-------------------------------------------------------------------------// // Post-WM_WINDOWPOSCHANGED processing for MDI client or children. // We need to recompute each child when the MDI client moves. BOOL _MDIClientUpdateChildren( HWND hwndMDIChildOrClient ) { // Find if it's the MDI client window HWND hWndChild = GetWindow(hwndMDIChildOrClient, GW_CHILD); if (IsWindow(hWndChild) && TESTFLAG(GetWindowLong(hWndChild, GWL_EXSTYLE), WS_EX_MDICHILD)) { // Yes it's the MDI client, refresh each MDI child's metrics do { _FreshenThemeMetricsCB(hWndChild, NULL); } while (NULL != (hWndChild = GetWindow(hWndChild, GW_HWNDNEXT))); return TRUE; } return FALSE; } //-------------------------------------------------------------------------// // Informs MDI frame that a child window may void _MDIChildUpdateParent( HWND hwndMDIChild, BOOL fSetMenu ) { CThemeWnd* pwndParent; HWND hwndMDIClient; if( _MDIGetParent( hwndMDIChild, &pwndParent, &hwndMDIClient ) && VALID_THEMEWND(pwndParent) ) { pwndParent->UpdateMDIFrameStuff( hwndMDIClient, fSetMenu ); } } //-------------------------------------------------------------------------// // Creates a replacement menu item bitmap for MDI frame window menubar // buttons for maximized MDI child. HRESULT _CreateMdiMenuItemBitmap( IN HDC hdc, IN HTHEME hTheme, IN OUT SIZE* pSize, IN OUT MENUITEMINFO* pmii ) { WINDOWPARTS iPartId; CLOSEBUTTONSTATES iStateId = CBS_NORMAL; switch( (UINT)pmii->wID ) { case SC_CLOSE: iPartId = WP_MDICLOSEBUTTON; break; case SC_MINIMIZE: iPartId = WP_MDIMINBUTTON; break; case SC_RESTORE: iPartId = WP_MDIRESTOREBUTTON; break; default: return E_INVALIDARG; } iStateId = TESTFLAG(pmii->fState, MFS_DISABLED) ? CBS_DISABLED : CBS_NORMAL; if( NULL == pSize ) { SIZE size; size.cx = NcGetSystemMetrics(SM_CXMENUSIZE); size.cy = NcGetSystemMetrics(SM_CYMENUSIZE); pSize = &size; } return _CreateBackgroundBitmap( hdc, hTheme, iPartId, iStateId, pSize, &pmii->hbmpItem ); } //-------------------------------------------------------------------------// HRESULT _CreateBackgroundBitmap( IN OPTIONAL HDC hdcCompatible, IN HTHEME hTheme, IN int iPartId, IN int iStateId, IN OUT LPSIZE pSize, // in: if cx <= 0 || cx <=0, assume truesize. out: background size OUT HBITMAP* phbmOut ) { ASSERT(hdcCompatible); ASSERT(hTheme); ASSERT(pSize); ASSERT(phbmOut); HRESULT hr = E_FAIL; SIZE size; *phbmOut = NULL; size = *pSize; pSize->cx = pSize->cy = 0; // Create working DC. HDC hdcMem = CreateCompatibleDC(hdcCompatible); if( hdcMem != NULL ) { // determine output size; hr = (size.cx <= 0 || size.cy <= 0) ? GetThemePartSize( hTheme, hdcCompatible, iPartId, iStateId, NULL, TS_TRUE, &size ) : S_OK; if( SUCCEEDED(hr) ) { HBITMAP hbmOut = CreateCompatibleBitmap( hdcCompatible, size.cx, size.cy ); if( hbmOut ) { HBITMAP hbm0 = (HBITMAP)SelectObject(hdcMem, hbmOut); RECT rcBkgnd; SetRect( &rcBkgnd, 0, 0, size.cx, size.cy ); hr = NcDrawThemeBackground( hTheme, hdcMem, iPartId, iStateId, &rcBkgnd, 0 ); SelectObject( hdcMem, hbm0 ); if( SUCCEEDED(hr) ) { *phbmOut = hbmOut; pSize->cx = size.cx; pSize->cy = size.cy; } else { SAFE_DELETE_GDIOBJ(hbmOut); } } else { hr = E_OUTOFMEMORY; } } DeleteDC(hdcMem); } return hr; } //-------------------------------------------------------------------------// // _ComputeElementOffset() - calculates specified offset for caption or button // This could be generalized in the themeapi, yes? [scotthan] void _ComputeElementOffset( HTHEME hTheme, int iPartId, int iStateId, LPCRECT prcBase, POINT *pptOffset) { OFFSETTYPE eOffsetType; if (FAILED(GetThemeEnumValue(hTheme, iPartId, iStateId, TMT_OFFSETTYPE, (int *)&eOffsetType))) eOffsetType = OT_TOPLEFT; // default value POINT ptOffset; if (FAILED(GetThemePosition(hTheme, iPartId, iStateId, TMT_OFFSET, &ptOffset))) { ptOffset.x = 0; ptOffset.y = 0; } RECT rcBase = *prcBase; switch (eOffsetType) { case OT_TOPLEFT: ptOffset.x += rcBase.left; ptOffset.y += rcBase.top; break; case OT_TOPRIGHT: ptOffset.x += rcBase.right; ptOffset.y += rcBase.top; break; case OT_TOPMIDDLE: ptOffset.x += (rcBase.left + rcBase.right)/2; ptOffset.y += rcBase.top; break; case OT_BOTTOMLEFT: ptOffset.x += rcBase.left; ptOffset.y += rcBase.bottom; break; case OT_BOTTOMRIGHT: ptOffset.x += rcBase.right; ptOffset.y += rcBase.bottom; break; case OT_BOTTOMMIDDLE: ptOffset.x += (rcBase.left + rcBase.right)/2; ptOffset.y += rcBase.bottom; break; // Todo: handle the remaining cases: case OT_LEFTOFCAPTION: case OT_RIGHTOFCAPTION: case OT_LEFTOFLASTBUTTON: case OT_RIGHTOFLASTBUTTON: case OT_ABOVELASTBUTTON: case OT_BELOWLASTBUTTON: ASSERT(FALSE); break; } *pptOffset = ptOffset; } //-------------------------------------------------------------------------// // _ComputeNcWindowStatus // // Assigns and translates window status bits to/in NCWNDMET block. // void _ComputeNcWindowStatus( IN HWND hwnd, IN DWORD dwStatus, IN OUT NCWNDMET* pncwm ) { BOOL fActive = TESTFLAG( dwStatus, WS_ACTIVECAPTION ); if (fActive || !HAS_CAPTIONBAR(pncwm->dwStyle) ) { pncwm->framestate = FS_ACTIVE; } else { pncwm->framestate = FS_INACTIVE; } if( HAS_CAPTIONBAR(pncwm->dwStyle) ) { pncwm->rgbCaption = _GetNcCaptionTextColor( pncwm->framestate ); } } //-------------------------------------------------------------------------//// BOOL _GetWindowMetrics( HWND hwnd, IN OPTIONAL HWND hwndMDIActive, OUT NCWNDMET* pncwm ) { WINDOWINFO wi; wi.cbSize = sizeof(wi); if( GetWindowInfo( hwnd, &wi ) ) { pncwm->dwStyle = wi.dwStyle; pncwm->dwExStyle = wi.dwExStyle; pncwm->rcS0[NCRC_WINDOW] = wi.rcWindow; pncwm->rcS0[NCRC_CLIENT] = wi.rcClient; pncwm->fMin = IsIconic(hwnd); pncwm->fMaxed = IsZoomed(hwnd); pncwm->fFullMaxed = pncwm->fMaxed ? _IsFullMaximized(hwnd, &wi.rcWindow) : FALSE; pncwm->dwWindowStatus = wi.dwWindowStatus; // if this window is the active MDI child and is owned by the foreground window // (which may not be the case if a popup, for example, is foremost), then // fix up the status bit. if( hwnd == hwndMDIActive ) { HWND hwndFore = GetForegroundWindow(); if( IsChild(hwndFore, hwndMDIActive) ) { pncwm->dwWindowStatus = WS_ACTIVECAPTION; } } return TRUE; } return FALSE; } //-------------------------------------------------------------------------// BOOL _ShouldAssignFrameRgn( IN const NCWNDMET* pncwm, IN const NCTHEMEMET& nctm ) { if( TESTFLAG( CThemeWnd::EvaluateStyle(pncwm->dwStyle, pncwm->dwExStyle), TWCF_FRAME|TWCF_TOOLFRAME) ) { // always need window region for maximized windows. if( pncwm->fFullMaxed ) return TRUE; // otherwise, need region only if the background is transparent for( int i = 0; i < ARRAYSIZE( pncwm->rgframeparts ); i++ ) { if( _IsNcPartTransparent( pncwm->rgframeparts[i], nctm ) ) return TRUE; } } return FALSE; } //-------------------------------------------------------------------------// BOOL _IsNcPartTransparent( WINDOWPARTS part, const NCTHEMEMET& nctm ) { #define GET_NCTRANSPARENCY(part,field) \ case part: return nctm.nct.##field switch(part) { GET_NCTRANSPARENCY(WP_CAPTION, fCaption); GET_NCTRANSPARENCY(WP_SMALLCAPTION, fCaption); GET_NCTRANSPARENCY(WP_MINCAPTION, fMinCaption); GET_NCTRANSPARENCY(WP_SMALLMINCAPTION, fSmallMinCaption); GET_NCTRANSPARENCY(WP_MAXCAPTION, fMaxCaption); GET_NCTRANSPARENCY(WP_SMALLMAXCAPTION, fSmallMaxCaption); GET_NCTRANSPARENCY(WP_FRAMELEFT, fFrameLeft); GET_NCTRANSPARENCY(WP_FRAMERIGHT, fFrameRight); GET_NCTRANSPARENCY(WP_FRAMEBOTTOM, fFrameBottom); GET_NCTRANSPARENCY(WP_SMALLFRAMELEFT, fSmFrameLeft); GET_NCTRANSPARENCY(WP_SMALLFRAMERIGHT, fSmFrameRight); GET_NCTRANSPARENCY(WP_SMALLFRAMEBOTTOM, fSmFrameBottom); } return FALSE; } //-------------------------------------------------------------------------// BOOL _ComputeNcPartTransparency( HTHEME hTheme, IN OUT NCTHEMEMET* pnctm ) { #define TEST_NCTRANSPARENCY(part) IsThemePartDefined(hTheme,part,0) ? \ IsThemeBackgroundPartiallyTransparent(hTheme,part,FS_ACTIVE) : FALSE; pnctm->nct.fCaption = TEST_NCTRANSPARENCY(WP_CAPTION); pnctm->nct.fSmallCaption = TEST_NCTRANSPARENCY(WP_SMALLCAPTION); pnctm->nct.fMinCaption = TEST_NCTRANSPARENCY(WP_MINCAPTION); pnctm->nct.fSmallMinCaption = TEST_NCTRANSPARENCY(WP_SMALLMINCAPTION); pnctm->nct.fMaxCaption = TEST_NCTRANSPARENCY(WP_MAXCAPTION); pnctm->nct.fSmallMaxCaption = TEST_NCTRANSPARENCY(WP_SMALLMAXCAPTION); pnctm->nct.fFrameLeft = TEST_NCTRANSPARENCY(WP_FRAMELEFT); pnctm->nct.fFrameRight = TEST_NCTRANSPARENCY(WP_FRAMERIGHT); pnctm->nct.fFrameBottom = TEST_NCTRANSPARENCY(WP_FRAMEBOTTOM); pnctm->nct.fSmFrameLeft = TEST_NCTRANSPARENCY(WP_SMALLFRAMELEFT); pnctm->nct.fSmFrameRight = TEST_NCTRANSPARENCY(WP_SMALLFRAMERIGHT); pnctm->nct.fSmFrameBottom = TEST_NCTRANSPARENCY(WP_SMALLFRAMEBOTTOM); return TRUE; } //-------------------------------------------------------------------------// // NCTHEMEMET implementation //-------------------------------------------------------------------------// //-------------------------------------------------------------------------// BOOL GetCurrentNcThemeMetrics( OUT NCTHEMEMET* pnctm ) { *pnctm = _nctmCurrent; return IsValidNcThemeMetrics( pnctm ); } //-------------------------------------------------------------------------// HTHEME GetCurrentNcThemeHandle() { return _nctmCurrent.hTheme; } //-------------------------------------------------------------------------// void InitNcThemeMetrics( NCTHEMEMET* pnctm ) { if( !pnctm ) pnctm = &_nctmCurrent; ZeroMemory( pnctm, sizeof(*pnctm) ); } //--------------------------------------------------------------------------- void ClearNcThemeMetrics( NCTHEMEMET* pnctm ) { if( !pnctm ) pnctm = &_nctmCurrent; //---- minimize THREAD-UNSAFE access to _nctmCurrent by ---- //---- NULL-ing out the hTheme type members as soon as ---- //---- they are closed ---- if( pnctm->hTheme ) { CloseThemeData( pnctm->hTheme ); pnctm->hTheme = NULL; } if( pnctm->hThemeTab ) { CloseThemeData( pnctm->hThemeTab ); pnctm->hThemeTab = NULL; } SAFE_DELETE_GDIOBJ( pnctm->hbmTabDialog ); SAFE_DELETE_GDIOBJ( pnctm->hbrTabDialog ); InitNcThemeMetrics( pnctm ); } //-------------------------------------------------------------------------// // Computes process-global, per-theme metrics for the nonclient area theme. HRESULT AcquireNcThemeMetrics() { HRESULT hr = S_OK; EnterCriticalSection( &_csThemeMet ); ClearNcThemeMetrics( &_nctmCurrent ); NcGetNonclientMetrics( NULL, FALSE ); hr = _LoadNcThemeMetrics(NULL, &_nctmCurrent); LeaveCriticalSection( &_csThemeMet ); Log(LOG_TMCHANGE, L"AcquireNcThemeMetrics: got hTheme=0x%x", _nctmCurrent.hTheme); return hr; } //-------------------------------------------------------------------------// // Computes and/or loads per-theme (as opposed to per-window) // system metrics and resources not managed by the theme manager. // // Called by _LoadNcThemeMetrics HRESULT _LoadNcThemeSysMetrics( HWND hwnd, IN OUT NCTHEMEMET* pnctm ) { HRESULT hr = E_FAIL; ASSERT(pnctm); // grab system metrics for nonclient area. NONCLIENTMETRICS ncm = {0}; ncm.cbSize = sizeof(ncm); if( NcGetNonclientMetrics( &ncm, FALSE ) ) { #ifdef THEMED_NCBTNMETRICS _GetClassicNcBtnMetrics( NULL, NULL, FALSE, TRUE ); #endif THEMED_NCBTNMETRICS hr = S_OK; // Establish minimized window size if( 0 >= pnctm->sizeMinimized.cx ) pnctm->sizeMinimized.cx = NcGetSystemMetrics( SM_CXMINIMIZED ); if( 0 >= pnctm->sizeMinimized.cy ) pnctm->sizeMinimized.cy = NcGetSystemMetrics( SM_CYMINIMIZED ); } else { hr = HRESULT_FROM_WIN32(GetLastError()); if( SUCCEEDED(hr) ) hr = E_FAIL; } // Maximized caption height or width pnctm->cyMaxCaption = _GetRawClassicCaptionHeight( WS_CAPTION|WS_OVERLAPPED, 0 ); return hr; } //-------------------------------------------------------------------------// // Computes and/or loads per-theme (as opposed to per-window) // metrics and resources not managed by the theme manager HRESULT _LoadNcThemeMetrics( HWND hwnd, NCTHEMEMET* pnctm ) { HRESULT hr = E_FAIL; // Initialize incoming NCTHEMEMET: if( pnctm ) { InitNcThemeMetrics( pnctm ); HTHEME hTheme = ::OpenNcThemeData( hwnd, L"Window" ); if( hTheme ) { pnctm->hTheme = hTheme; // determine transparency for each frame part. _ComputeNcPartTransparency(hTheme, pnctm); // menubar pixels not accounted for by CalcMenuBar or PaintMenuBar pnctm->dyMenuBar = NcGetSystemMetrics(SM_CYMENU) - NcGetSystemMetrics(SM_CYMENUSIZE); // normal caption margins if( FAILED( GetThemeMargins( hTheme, NULL, WP_CAPTION, CS_ACTIVE, TMT_CAPTIONMARGINS, NULL, &pnctm->marCaptionText )) ) { FillMemory( &pnctm->marCaptionText, sizeof(pnctm->marCaptionText), 0 ); } // maximized caption margins if( FAILED( GetThemeMargins( hTheme, NULL, WP_MAXCAPTION, CS_ACTIVE, TMT_CAPTIONMARGINS, NULL, &pnctm->marMaxCaptionText )) ) { FillMemory( &pnctm->marMaxCaptionText, sizeof(pnctm->marMaxCaptionText), 0 ); } // minimized caption margins if( FAILED( GetThemeMargins( hTheme, NULL, WP_MINCAPTION, CS_ACTIVE, TMT_CAPTIONMARGINS, NULL, &pnctm->marMinCaptionText )) ) { FillMemory( &pnctm->marMinCaptionText, sizeof(pnctm->marMinCaptionText), 0 ); } // dynamically resizing small (toolframe) caption margins if( FAILED( GetThemeMargins( hTheme, NULL, WP_SMALLCAPTION, CS_ACTIVE, TMT_CAPTIONMARGINS, NULL, &pnctm->marSmCaptionText )) ) { FillMemory( &pnctm->marSmCaptionText, sizeof(pnctm->marSmCaptionText), 0 ); } // caption and frame resizing border hittest template parts pnctm->fCapSizingTemplate = IsThemePartDefined( hTheme, WP_CAPTIONSIZINGTEMPLATE, 0); pnctm->fLeftSizingTemplate = IsThemePartDefined( hTheme, WP_FRAMELEFTSIZINGTEMPLATE, 0); pnctm->fRightSizingTemplate = IsThemePartDefined( hTheme, WP_FRAMERIGHTSIZINGTEMPLATE, 0); pnctm->fBottomSizingTemplate = IsThemePartDefined( hTheme, WP_FRAMEBOTTOMSIZINGTEMPLATE, 0); // toolwindow caption and frame resizing border hittest template parts pnctm->fSmCapSizingTemplate = IsThemePartDefined( hTheme, WP_SMALLCAPTIONSIZINGTEMPLATE, 0); pnctm->fSmLeftSizingTemplate = IsThemePartDefined( hTheme, WP_SMALLFRAMELEFTSIZINGTEMPLATE, 0); pnctm->fSmRightSizingTemplate = IsThemePartDefined( hTheme, WP_SMALLFRAMERIGHTSIZINGTEMPLATE, 0); pnctm->fSmBottomSizingTemplate = IsThemePartDefined( hTheme, WP_SMALLFRAMEBOTTOMSIZINGTEMPLATE, 0); // Minimized window size. // If this is a truesize image, honor its dimensions; otherwise use // width, height properties. Fall back on system metrics. SIZINGTYPE st = ST_TRUESIZE; hr = GetThemeInt( hTheme, WP_MINCAPTION, FS_ACTIVE, TMT_SIZINGTYPE, (int*)&st ); if( ST_TRUESIZE == st ) { hr = GetThemePartSize( hTheme, NULL, WP_MINCAPTION, FS_ACTIVE, NULL, TS_TRUE, &pnctm->sizeMinimized ); if( FAILED(hr) ) { GetThemeMetric( hTheme, NULL, WP_MINCAPTION, FS_ACTIVE, TMT_WIDTH, (int*)&pnctm->sizeMinimized.cx ); GetThemeMetric( hTheme, NULL, WP_MINCAPTION, FS_ACTIVE, TMT_HEIGHT, (int*)&pnctm->sizeMinimized.cy ); } } // -- normal nonclient button size. int cy = NcGetSystemMetrics( SM_CYSIZE ); hr = GetThemePartSize( pnctm->hTheme, NULL, WP_CLOSEBUTTON, 0, NULL, TS_TRUE, &pnctm->sizeBtn ); if( SUCCEEDED(hr) ) { pnctm->theme_sysmets.cxBtn = MulDiv( cy, pnctm->sizeBtn.cx, pnctm->sizeBtn.cy ); } else { pnctm->theme_sysmets.cxBtn = pnctm->sizeBtn.cx = NcGetSystemMetrics( SM_CXSIZE ); pnctm->sizeBtn.cy = cy; } // -- toolframe nonclient button size. cy = NcGetSystemMetrics( SM_CYSMSIZE ); hr = GetThemePartSize( pnctm->hTheme, NULL, WP_SMALLCLOSEBUTTON, 0, NULL, TS_TRUE, &pnctm->sizeSmBtn ); if( SUCCEEDED(hr) ) { pnctm->theme_sysmets.cxSmBtn = MulDiv( cy, pnctm->sizeSmBtn.cx, pnctm->sizeSmBtn.cy ); } else { pnctm->theme_sysmets.cxSmBtn = pnctm->sizeSmBtn.cx = NcGetSystemMetrics( SM_CXSMSIZE ); pnctm->sizeSmBtn.cy = cy; } // -- validate sysmet hook values pnctm->theme_sysmets.fValid = TRUE; // dialog background for dialogs parented by PROPSHEETs or // specifically stamped via EnableThemeDialogTexture to match the tab control background. // // We need to open the tab control's theme so that we can get the background of tab dialogs // We can't dynamically load this because of how this cache is set up: It's all or nothing. pnctm->hThemeTab = ::OpenThemeData(hwnd, L"Tab"); _GetBrushesForPart(pnctm->hThemeTab, TABP_BODY, &pnctm->hbmTabDialog, &pnctm->hbrTabDialog); hr = _LoadNcThemeSysMetrics( hwnd, pnctm ); } } return hr; } //-------------------------------------------------------------------------// BOOL IsValidNcThemeMetrics( NCTHEMEMET* pnctm ) { return pnctm->hTheme != NULL; } //-------------------------------------------------------------------------// // THREADWINDOW implementation //-------------------------------------------------------------------------// // // Note: this is a fixed length array of threads-window mappings. // We'll use this to keep track of the threads processing a certain message // // Thread local storage would be better suited to the task, but we // learned early on that the unique load/unload situation of uxtheme // causes us to miss DLL_THREAD_DETACH in some scenarios, which would mean // leaking the TLS. // typedef struct _THREADWINDOW { DWORD dwThread; HWND hwnd; } THREADWINDOW; //-------------------------------------------------------------------------// // WM_NCPAINT tracking: THREADWINDOW _rgtwNcPaint[16] = {0}; // threads processing NCPAINT in this process int _cNcPaintWnd = 0; // count of threads processing NCPAINT in this process CRITICAL_SECTION _csNcPaint; // serializes access to _rgtwNcPaint //-------------------------------------------------------------------------// void NcPaintWindow_Add( HWND hwnd ) { EnterCriticalSection( &_csNcPaint ); for( int i = 0; i < ARRAYSIZE(_rgtwNcPaint); i++ ) { if( 0 == _rgtwNcPaint[i].dwThread ) { _rgtwNcPaint[i].dwThread = GetCurrentThreadId(); _rgtwNcPaint[i].hwnd = hwnd; _cNcPaintWnd++; } } LeaveCriticalSection( &_csNcPaint ); } //-------------------------------------------------------------------------// void NcPaintWindow_Remove() { if( _cNcPaintWnd ) { DWORD dwThread = GetCurrentThreadId(); EnterCriticalSection( &_csNcPaint ); for( int i = 0; i < ARRAYSIZE(_rgtwNcPaint); i++ ) { if( dwThread == _rgtwNcPaint[i].dwThread ) { _rgtwNcPaint[i].dwThread = 0; _rgtwNcPaint[i].hwnd = 0; _cNcPaintWnd--; break; } } LeaveCriticalSection( &_csNcPaint ); } } //-------------------------------------------------------------------------// HWND NcPaintWindow_Find() { HWND hwnd = NULL; if( _cNcPaintWnd ) { DWORD dwThread = GetCurrentThreadId(); EnterCriticalSection( &_csNcPaint ); for( int i = 0; i < ARRAYSIZE(_rgtwNcPaint); i++ ) { if( dwThread == _rgtwNcPaint[i].dwThread ) { hwnd = _rgtwNcPaint[i].hwnd; break; } } LeaveCriticalSection( &_csNcPaint ); } return hwnd; } //-------------------------------------------------------------------------// // CThemeWnd implementation //-------------------------------------------------------------------------// //-------------------------------------------------------------------------// LONG CThemeWnd::_cObj = 0; //-------------------------------------------------------------------------// CThemeWnd::CThemeWnd() : _hwnd(NULL), _hTheme(NULL), _dwRenderedNcParts(0), _hwndMDIClient(NULL), _hAppIcon(NULL), _hrgnWnd(NULL), _fClassFlags(0), _fDirtyFrameRgn(0), _fFrameThemed(FALSE), _fThemedMDIBtns(FALSE), _pMdiBtns(NULL), _fAssigningFrameRgn(FALSE), _fAssignedFrameRgn(FALSE), _fSuppressStyleMsgs(FALSE), _fInThemeSettingChange(FALSE), _fDetached(FALSE), _fCritSectsInit(FALSE), _dwRevokeFlags(0), _cLockRedraw(0), _cNcPaint(0), _cNcThemePaint(0), _htHot(HTERROR), _fProcessedEraseBk(0), #ifdef LAME_BUTTON _hFontLame(NULL), #endif // LAME_BUTTON #ifdef DEBUG_THEMEWND_DESTRUCTOR _fDestructed(FALSE), _fDeleteCritsec(FALSE), #endif DEBUG_THEMEWND_DESTRUCTOR _cRef(1) { InterlockedIncrement( &_cObj ); // set object validation signature tags strcpy(_szHead, SIG_CTHEMEWND_HEAD); strcpy(_szTail, SIG_CTHEMEWND_TAIL); // cached subregion arrays ZeroMemory( _rghrgnParts, sizeof(_rghrgnParts) ); ZeroMemory( _rghrgnSizingTemplates, sizeof(_rghrgnSizingTemplates) ); // initialize add'l structures. InitWindowMetrics(); FillMemory(&_sizeRgn, sizeof(_sizeRgn), 0xFF); #ifdef DEBUG *_szCaption = *_szWndClass = 0; #endif DEBUG } //-------------------------------------------------------------------------// CThemeWnd::~CThemeWnd() { _CloseTheme(); _FreeRegionHandles(); UnloadMdiBtns(); ClearLameResources(); if( _fCritSectsInit ) { DeleteCriticalSection( &_cswm ); #ifdef DEBUG_THEMEWND_DESTRUCTOR _fDeleteCritsec = TRUE; #endif DEBUG_THEMEWND_DESTRUCTOR } InterlockedDecrement( &_cObj ); #ifdef DEBUG_THEMEWND_DESTRUCTOR _fDestructed = TRUE; // destructor has been called. #endif DEBUG_THEMEWND_DESTRUCTOR } //-------------------------------------------------------------------------// void CThemeWnd::_CloseTheme() { if( _hTheme ) { CloseThemeData(_hTheme); _hTheme = NULL; } } //-------------------------------------------------------------------------// LONG CThemeWnd::AddRef() { return InterlockedIncrement( &_cRef ); } //-------------------------------------------------------------------------// LONG CThemeWnd::Release() { LONG cRef = InterlockedDecrement( &_cRef ); if( 0 == cRef ) { if (_hwnd) { //---- check if last window of app ---- ShutDownCheck(_hwnd); } //Log(LOG_RFBUG, L"DELETING CThemeWnd=0x%08x", this); delete this; } return cRef; } //-------------------------------------------------------------------------// ULONG CThemeWnd::EvaluateWindowStyle( HWND hwnd ) { ULONG dwStyle = GetWindowLong( hwnd, GWL_STYLE ); ULONG dwExStyle = GetWindowLong( hwnd, GWL_EXSTYLE ); return EvaluateStyle( dwStyle, dwExStyle ); } //-------------------------------------------------------------------------// // CThemeWnd::EvaluateStyle() - determines appropriate theming flags for the // specified window style bits. ULONG CThemeWnd::EvaluateStyle( DWORD dwStyle, DWORD dwExStyle ) { ULONG fClassFlags = 0; //--- frame check --- if( HAS_CAPTIONBAR(dwStyle) ) { fClassFlags |= (TESTFLAG(dwExStyle, WS_EX_TOOLWINDOW) ? TWCF_TOOLFRAME : TWCF_FRAME ); } //--- client edge check --- if( TESTFLAG(dwExStyle, WS_EX_CLIENTEDGE) ) fClassFlags |= TWCF_CLIENTEDGE; //--- scrollbar check --- if( TESTFLAG(dwStyle, WS_HSCROLL|WS_VSCROLL) ) fClassFlags |= TWCF_SCROLLBARS; return fClassFlags; } //-------------------------------------------------------------------------// // CThemeWnd::_EvaluateExclusions() - determines special-case per-window exclusions ULONG CThemeWnd::_EvaluateExclusions( HWND hwnd, NCEVALUATE* pnce ) { // Windows parented by HWND_MESSAGE should not be themed.. if( _IsMessageWindow(hwnd) ) { pnce->fExile = TRUE; return 0L; } TCHAR szWndClass[128]; *szWndClass = 0; if( TESTFLAG(pnce->fClassFlags, (TWCF_FRAME|TWCF_TOOLFRAME)) ) { do { if( !pnce->fIgnoreWndRgn ) { //--- Complex region check on frame RECT rcRgn = {0}; int nRgn = GetWindowRgnBox( hwnd, &rcRgn ); if( COMPLEXREGION == nRgn || SIMPLEREGION == nRgn ) { pnce->fClassFlags &= ~TWCF_FRAME; break; } } // SHIMSHIM [scotthan]: #ifndef __NO_APPHACKS__ // Check for excluded window classes. static LPCWSTR _rgExcludedClassesW[] = { L"MsoCommandBar", // Outlook's custom combobox control. // (122225) In OnOwpPostCreate we call SetWindowPos which causes // a WM_WINDOWPOSCHANGING to be sent to the control. However // the controls isn't ready to begin accepting messages and // the following error message is display: // // Runtime Error! // Program: Outlook.exe // R6025 - pure virtual function call L"Exceed", // 150248: Hummingbird Exceed 6.xx // The application's main window class name, a hidden window // whose only purpose is to appear in the task bar in order to handle // his context menu. The ExceedWndProc AVs when themed due to the // additional messages generated in OnOwpPostCreate. //---- winlogoon hidden windows ---- L"NDDEAgnt", // on private desktop L"MM Notify Callback", // on private desktop L"SAS window class", // on private desktop }; if( GetClassNameW( hwnd, szWndClass, ARRAYSIZE(szWndClass) ) && AsciiScanStringList( szWndClass, _rgExcludedClassesW, ARRAYSIZE(_rgExcludedClassesW), TRUE ) ) { pnce->fClassFlags &= ~TWCF_FRAME; pnce->fExile = TRUE; break; } #endif __NO_APPHACKS__ } while(0); } // Some applications (MsDev) create scrollbar controls and incorrectly include // WS_[V|H]SCROLL style bits causing us to think they are non-client scrolls. // See #204191. if( TESTFLAG(pnce->fClassFlags, TWCF_SCROLLBARS) ) { if( !*szWndClass && GetClassName( hwnd, szWndClass, ARRAYSIZE(szWndClass) ) ) { if( 0 == AsciiStrCmpI(szWndClass, L"scrollbar") ) pnce->fClassFlags &= ~TWCF_SCROLLBARS; } } return pnce->fClassFlags; } //-------------------------------------------------------------------------// // CThemeWnd::_Evaluate() - determines appropriate theming flags for the // specified window. ULONG CThemeWnd::_Evaluate( HWND hwnd, NCEVALUATE* pnce ) { pnce->fClassFlags = 0; pnce->dwStyle = GetWindowLong( hwnd, GWL_STYLE ); pnce->dwExStyle = GetWindowLong( hwnd, GWL_EXSTYLE ); if( GetClassLong( hwnd, GCW_ATOM ) == (DWORD)(DWORD_PTR)WC_DIALOG ) { pnce->fClassFlags |= TWCF_DIALOG; } #ifdef DEBUG //--- dialog check --- if( TESTFLAG( pnce->fClassFlags, TWCF_DIALOG ) ) { TCHAR szWndClass[96]; if( !GetClassNameW( hwnd, szWndClass, ARRAYSIZE(szWndClass) ) ) return 0; ASSERT(0 == lstrcmpW(szWndClass, DLGWNDCLASSNAMEW)); } #endif DEBUG pnce->fClassFlags |= EvaluateStyle( pnce->dwStyle, pnce->dwExStyle ); if( pnce->fClassFlags ) { pnce->fClassFlags = _EvaluateExclusions( hwnd, pnce ); } return pnce->fClassFlags; } //-------------------------------------------------------------------------// // Retrieves the address of the CThemeWnd object instance from the // indicated window. CThemeWnd* CThemeWnd::FromHwnd( HWND hwnd ) { CThemeWnd *pwnd = NULL; if( IsWindow(hwnd) ) { if( g_dwProcessId ) { DWORD dwPid = 0; GetWindowThreadProcessId( hwnd, &dwPid ); if( dwPid == g_dwProcessId ) { pwnd = (CThemeWnd*)GetProp( hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_NONCLIENT)) ); if ( VALID_THEMEWND(pwnd) ) { // verify this is a valid CThemeWnd object pointer if ( IsBadReadPtr(pwnd, sizeof(CThemeWnd)) || (memcmp(pwnd->_szHead, SIG_CTHEMEWND_HEAD, ARRAYSIZE(pwnd->_szHead)) != 0) || (memcmp(pwnd->_szTail, SIG_CTHEMEWND_TAIL, ARRAYSIZE(pwnd->_szTail)) != 0) ) { pwnd = THEMEWND_REJECT; } } } } } return pwnd; } //-------------------------------------------------------------------------// // retrieves CThemeWnd instance from window or ancestors. CThemeWnd* CThemeWnd::FromHdc( HDC hdc, int cAncestors ) { HWND hwnd = NULL; for( hwnd = WindowFromDC(hdc); cAncestors >=0 && IsWindow(hwnd); cAncestors--, hwnd = GetParent(hwnd) ) { CThemeWnd* pwnd = FromHwnd(hwnd); if( VALID_THEMEWND(pwnd) ) { return pwnd; } } return NULL; } //-------------------------------------------------------------------------// // Static wrapper: attaches a CThemeWnd instance to the specified window. CThemeWnd* CThemeWnd::Attach( HWND hwnd, IN OUT OPTIONAL NCEVALUATE* pnce ) { LogEntryNC(L"Attach"); #ifdef LOGGING //---- remember first window (app window) hooked for ShutDownCheck() ---- //---- this is only for BoundsChecker (tm) runs for finding leaks ---- if (! g_hwndFirstHooked) { if ((GetMenu(hwnd)) && (! GetParent(hwnd))) g_hwndFirstHooked = hwnd; } #endif CThemeWnd* pwnd = NULL; // Note: Important not to do anything here that causes // a window message to be posted or sent to the window: could // mean tying ourselves up in a recursive knot (see _ThemeDefWindowProc). pwnd = FromHwnd( hwnd ); if( NULL == pwnd ) { HTHEME hTheme = NULL; NCEVALUATE nce; // copy any IN params from NCEVALUATE struct if( !pnce ) { ZeroMemory(&nce, sizeof(nce)); pnce = &nce; } ULONG ulTargetFlags = _Evaluate( hwnd, pnce ); // Anything worth theming? if( TESTFLAG(ulTargetFlags, TWCF_NCTHEMETARGETMASK) ) { hTheme = _AcquireThemeHandle( hwnd, &ulTargetFlags ); if( NULL == hTheme ) { Fail(hwnd); } } else { // reject windows with untargeted a Reject(hwnd, pnce->fExile); } if( NULL != hTheme ) { // Yes, create a real nctheme object for the window if( (pwnd = new CThemeWnd) != NULL ) { if( !pwnd->_AttachInstance( hwnd, hTheme, ulTargetFlags, pnce->pvWndCompat ) ) { pwnd->Release(); pwnd = NULL; } } else // cleanup hTheme if CThemeWnd creation failed { CloseThemeData(hTheme); } } } LogExitNC(L"Attach"); return pwnd; } //-------------------------------------------------------------------------// // Instance method: attaches the CThemeWnd object to the specified window. BOOL CThemeWnd::_AttachInstance( HWND hwnd, HTHEME hTheme, ULONG ulTargetFlags, PVOID pvWndCompat ) { if( _fCritSectsInit || NT_SUCCESS(RtlInitializeCriticalSection( &_cswm )) ) { Log(LOG_NCATTACH, L"_AttachInstance: Nonclient attached to hwnd=0x%x", hwnd); _fCritSectsInit = TRUE; _hwnd = hwnd; _hTheme = hTheme; _fClassFlags = ulTargetFlags; _fFrameThemed = TESTFLAG( ulTargetFlags, TWCF_FRAME|TWCF_TOOLFRAME ); return SetProp( hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_NONCLIENT)), this ); } return FALSE; } //-------------------------------------------------------------------------// void CThemeWnd::RemoveWindowProperties(HWND hwnd, BOOL fDestroying) { //---- remove properties that require theme or hooks ---- RemoveProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_HTHEME))); if (fDestroying) { // Help apps by cleaning up the dialog texture. RemoveProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_DLGTEXTURING))); //---- remove all remaining theme properties ---- ApplyStringProp(hwnd, NULL, GetThemeAtom(THEMEATOM_SUBIDLIST)); ApplyStringProp(hwnd, NULL, GetThemeAtom(THEMEATOM_SUBAPPNAME)); //---- notify appinfo (foreign tracking, preview) ---- g_pAppInfo->OnWindowDestroyed(hwnd); } else { //---- only do this if hwnd is not being destroyed ---- ClearExStyleBits(hwnd); } } //-------------------------------------------------------------------------// // Static wrapper: detaches and destroys the CThemeWnd instance attached to the indicated // window void CThemeWnd::Detach( HWND hwnd, DWORD dwDisposition ) { LogEntryNC(L"Detach"); // DO NOT GENERATE ANY WINDOW MESSAGES FROM THIS FUNCTION!!! // (unless cleaning up frame). // Prevent message threads from detaching when unhook thread (DetachAll) is executing... if( !UNHOOKING() || TESTFLAG(dwDisposition, HMD_BULKDETACH) ) { CThemeWnd* pwnd = FromHwnd( hwnd ); if( pwnd ) // nonclient tagged { if( VALID_THEMEWND(pwnd) ) { // only one thread flips the _fDetached bit and proceeds through // instance detatch and object free. Otherwise, object can be freed // simultaneously on two different threads, // e.g. (1) message thread and (2) UIAH_UNHOOK thread (ouch! scotthan). if( !InterlockedCompareExchange( (LONG*)&pwnd->_fDetached, TRUE, FALSE ) ) { pwnd->_DetachInstance( dwDisposition ); pwnd->Release(); } } else { RemoveProp( hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_NONCLIENT)) ); } } if (hwnd) { RemoveWindowProperties( hwnd, ((dwDisposition & HMD_WINDOWDESTROY) != 0) ); } } LogExitNC(L"Detach"); } //-------------------------------------------------------------------------// // Instance method: detaches the CThemeWnd object from the specified window. BOOL CThemeWnd::_DetachInstance( DWORD dwDisposition ) { HWND hwnd = _hwnd; // untheme maxed MDI child sysbuttons. ThemeMDIMenuButtons(FALSE, FALSE); // Here's our last chance to ensure frame theme is withdrawn cleanly. if( (IsFrameThemed() || IsRevoked(RF_REGION)) && AssignedFrameRgn() && !TESTFLAG(dwDisposition, HMD_PROCESSDETACH|HMD_WINDOWDESTROY)) { RemoveFrameTheme( FTF_REDRAW ); } //SPEW_THEMEWND( pwnd, 0, TEXT("UxTheme - Detaching and deleting themewnd: %s\n") ); DetachScrollBars( hwnd ); _hwnd = _hwndMDIClient = NULL; UnloadMdiBtns(); _CloseTheme(); Log(LOG_NCATTACH, L"_DetachInstance: Nonclient detached to hwnd=0x%x", hwnd); RemoveProp( hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_NONCLIENT)) ); return TRUE; } //-------------------------------------------------------------------------// // Ensures that the specified window will not be themed during its lifetime BOOL CThemeWnd::Reject( HWND hwnd, BOOL fExile ) { // set a 'nil' tag on the window return hwnd ? SetProp( hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_NONCLIENT)), fExile ? THEMEWND_EXILE : THEMEWND_REJECT ) : FALSE; } //-------------------------------------------------------------------------// // Ensures that the specified window will not be themed during its lifetime BOOL CThemeWnd::Fail( HWND hwnd ) { // set a failure tag on the window return hwnd ? SetProp( hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_NONCLIENT)), THEMEWND_FAILURE ) : FALSE; } //-------------------------------------------------------------------------// // Revokes theming on a themed window BOOL CThemeWnd::Revoke() { // Warning Will Robinson: After we detach, the CThemeWnd::_hwnd // and related members will be reset, so save this on the stack. BOOL fRet = TRUE; HWND hwnd = _hwnd; if( !IsRevoked(RF_INREVOKE) ) { EnterRevoke(); _dwRevokeFlags &= ~RF_DEFER; Detach( hwnd, HMD_REVOKE ); fRet = Reject( hwnd, TRUE ); LeaveRevoke(); } return fRet; } //-------------------------------------------------------------------------// // cookie passed to EnumChildWindows callback for CThemeWnd::DetachAll typedef struct { DWORD dwProcessId; DWORD dwDisposition; }DETACHALL; //-------------------------------------------------------------------------// // EnumChildWindows callback for CThemeWnd::DetachAll BOOL CThemeWnd::_DetachDesktopWindowsCB( HWND hwnd, LPARAM lParam ) { DETACHALL* pda = (DETACHALL*)lParam; // detach this window if( IsWindowProcess( hwnd, pda->dwProcessId ) ) { //---- clear the nonclient theme ---- CThemeWnd::Detach(hwnd, HMD_THEMEDETACH|pda->dwDisposition); if( !TESTFLAG(pda->dwDisposition, HMD_PROCESSDETACH) ) { //---- clear the client theme now, so that we can invalidate ---- //---- all old theme handles after this. ---- SafeSendMessage(hwnd, WM_THEMECHANGED, (WPARAM)-1, 0); Log(LOG_TMHANDLE, L"Did SEND of WM_THEMECHANGED to client hwnd=0x%x", hwnd); } } return TRUE; } //-------------------------------------------------------------------------// // Detaches all themed windows managed by this process. void CThemeWnd::DetachAll( DWORD dwDisposition ) { DETACHALL da; da.dwProcessId = GetCurrentProcessId(); da.dwDisposition = dwDisposition; da.dwDisposition |= HMD_BULKDETACH; //---- this will enum all windows for this process (all desktops, all child levels) ---- EnumProcessWindows( _DetachDesktopWindowsCB, (LPARAM)&da ); } //-------------------------------------------------------------------------// HTHEME CThemeWnd::_AcquireThemeHandle( HWND hwnd, ULONG* pfClassFlags ) { HTHEME hTheme = ::OpenNcThemeData( hwnd, L"Window" ); if( NULL == hTheme ) { if( pfClassFlags ) { if( TESTFLAG(*pfClassFlags, TWCF_ANY) ) (*pfClassFlags) &= ~TWCF_ALL; else *pfClassFlags = 0; } } //---- Did OpenNcThemeData() discover a new theme ---- if (g_pAppInfo->HasThemeChanged()) { //---- IMPORTANT: we must refresh our theme metrics now, ---- //---- BEFORE we do our nonclient layout calcs & build a region window ---- AcquireNcThemeMetrics(); } return hTheme; } //-------------------------------------------------------------------------// // CThemeWnd::SetFrameTheme // // Initiates theming of the frame. void CThemeWnd::SetFrameTheme( IN ULONG dwFlags, IN OPTIONAL WINDOWINFO* pwi ) { LogEntryNC(L"SetFrameTheme"); ASSERT(TestCF( TWCF_FRAME|TWCF_TOOLFRAME )); InitLameResources(); DWORD fSwp = SWP_NOZORDER|SWP_NOACTIVATE; RECT rcWnd = {0}; BOOL bSwp = FALSE; if( !TESTFLAG( dwFlags, FTF_NOMODIFYPLACEMENT ) ) { GetWindowRect( _hwnd, &rcWnd ); fSwp |= (SWP_NOSIZE|SWP_NOMOVE/*|SWP_FRAMECHANGED 341700: this flag causes some apps to crash on WINDOWPOSCHANGED*/); bSwp = TRUE; } // Generate a WM_WINDOWPOSCHANGING message to // force a SetWindowRgn + frame repaint. if( TESTFLAG(dwFlags, FTF_REDRAW) ) { fSwp |= SWP_DRAWFRAME; } else { fSwp |= SWP_NOSENDCHANGING; } // theme MDI menubar buttons _hwndMDIClient = _FindMDIClient(_hwnd); if( _hwndMDIClient ) { ThemeMDIMenuButtons(TRUE, FALSE); } // Kick frame region update. _fFrameThemed = TRUE; // we invoked SetFrameTheme. Must be set BEFORE SetWindowPos.so we handle NCCALCSIZE properly. SetDirtyFrameRgn(TRUE, TRUE); // ensure region assembly on non-resizing windows and dlgs. if( !TESTFLAG( dwFlags, FTF_NOMODIFYPLACEMENT ) && bSwp ) { _ScreenToParent( _hwnd, &rcWnd ); SetWindowPos( _hwnd, NULL, rcWnd.left, rcWnd.top, RECTWIDTH(&rcWnd), RECTHEIGHT(&rcWnd), fSwp ); } LogExitNC(L"SetFrameTheme"); } //-------------------------------------------------------------------------// void CThemeWnd::_FreeRegionHandles() { #ifdef DEBUG if( _hrgnWnd ) { SPEW_RGNRECT(NCTF_RGNWND, TEXT("_FreeRegionHandles() - deleting window region"), _hrgnWnd, -1 ); } #endif DEBUG SAFE_DELETE_GDIOBJ(_hrgnWnd); for( int i = 0; i < cFRAMEPARTS; i++ ) { #ifdef DEBUG if( _rghrgnParts[i] ) { SPEW_RGNRECT(NCTF_RGNWND, TEXT("_FreeRegionHandles() - deleting component region"), _rghrgnParts[i], _ncwm.rgframeparts[i] ); } if( _rghrgnSizingTemplates[i] ) { SPEW_RGNRECT(NCTF_RGNWND, TEXT("_FreeRegionHandles() - deleting template region"), _rghrgnSizingTemplates[i], _ncwm.rgframeparts[i] ); } #endif DEBUG SAFE_DELETE_GDIOBJ(_rghrgnParts[i]); SAFE_DELETE_GDIOBJ(_rghrgnSizingTemplates[i]); } } //-------------------------------------------------------------------------// // CThemeWnd::RemoveFrameTheme // // Initiates theming of the frame. This method will not free the // theme handle nor update the theme index. void CThemeWnd::RemoveFrameTheme( ULONG dwFlags ) { LogEntryNC(L"RemoveFrameTheme"); ASSERT(TestCF( TWCF_FRAME|TWCF_TOOLFRAME )); _fFrameThemed = FALSE; // we're reverting SetFrameTheme ClearRenderedNcPart(RNCF_ALL); // Remove region if( AssignedFrameRgn() && !TESTFLAG(dwFlags, FTF_NOMODIFYRGN) ) { _fAssignedFrameRgn = FALSE; _AssignRgn( NULL, dwFlags ); _FreeRegionHandles(); } // Force redraw if( TESTFLAG(dwFlags, FTF_REDRAW) ) InvalidateRect( _hwnd, NULL, TRUE ); ClearLameResources(); LogExitNC(L"RemoveFrameTheme"); } //-------------------------------------------------------------------------// BOOL CThemeWnd::IsNcThemed() { if( _hTheme != NULL && (IsRevoked(RF_DEFER) || !IsRevoked(RF_INREVOKE|RF_TYPEMASK)) && TestCF(TWCF_ANY & TWCF_NCTHEMETARGETMASK) ) { if( TestCF(TWCF_FRAME|TWCF_TOOLFRAME) ) { // if we're a frame window, we should be properly initialized // w/ SetFrameTheme() return _fFrameThemed; } return TRUE; } return FALSE; } //-------------------------------------------------------------------------// BOOL CThemeWnd::IsFrameThemed() { return IsNcThemed() && _fFrameThemed && (AssignedFrameRgn() ? TRUE : TestCF( TWCF_FRAME|TWCF_TOOLFRAME )); } //-------------------------------------------------------------------------// void CThemeWnd::SetDirtyFrameRgn( BOOL fDirty, BOOL fFrameChanged ) { _fDirtyFrameRgn = fDirty; Log(LOG_NCATTACH, L"SetDirtyFrameRgn: fDirty=%d, fFrameChanged=%d", fDirty, fFrameChanged); if( fFrameChanged ) // assure a region update despite no size change. { _sizeRgn.cx = _sizeRgn.cy = -1; } } //-------------------------------------------------------------------------// // CThemeWnd::CreateCompositeRgn() - assembles a composite region from // non-client segment regions sized to fill the specified window rectangle. // HRGN CThemeWnd::CreateCompositeRgn( IN const NCWNDMET* pncwm, OUT HRGN rghrgnParts[], OUT HRGN rghrgnTemplates[] ) { ASSERT( pncwm->fFrame == TRUE ); // shouldn't be here unless we're a frame window HRGN hrgnWnd = NULL, hrgnContent = NULL; HRGN rghrgn[cFRAMEPARTS] = {0}; int i; if( pncwm->fFullMaxed ) { // All full-screen maximized windows get a region, which is used to clip // the window to the current monitor. The window region for a maximized // window consists of the maxcaption region combined with a rect region // corresponding to the content area. RECT rcFullCaption = pncwm->rcW0[NCRC_CAPTION]; rcFullCaption.top += pncwm->cnBorders; rcFullCaption.left += pncwm->cnBorders; rcFullCaption.right -= pncwm->cnBorders; if( SUCCEEDED(GetThemeBackgroundRegion(_hTheme, NULL, pncwm->rgframeparts[iCAPTION], pncwm->framestate, &rcFullCaption, &rghrgn[iCAPTION])) ) { SPEW_RGNRECT(NCTF_RGNWND, TEXT("CreateCompositeRgn() maximized caption rgn"), rghrgn[iCAPTION], pncwm->rgframeparts[iCAPTION] ); AddToCompositeRgn(&hrgnWnd, rghrgn[iCAPTION], 0, 0); if( !IsRectEmpty( &pncwm->rcW0[NCRC_CONTENT] ) ) { // remainder of full-maxed frame region is the content area (client+menubar+scrollbars), // and is always rectangular hrgnContent = CreateRectRgnIndirect( &pncwm->rcW0[NCRC_CONTENT] ); SPEW_RGNRECT(NCTF_RGNWND, TEXT("CreateCompositeRgn() maximized frame content rgn"), hrgnContent, 0 ); AddToCompositeRgn(&hrgnWnd, hrgnContent, 0, 0); SAFE_DELETE_GDIOBJ(hrgnContent); } } } else { // Normal windows consist of either a stand-alone frame part, or a frame // part plus a caption part. In the first case, the window region is // the frame region. In the second case, the window region is a composite // of the frame and caption rects. for( i = 0; i < ARRAYSIZE(pncwm->rgframeparts); i++ ) { if( (iCAPTION == i || !pncwm->fMin) && !IsRectEmpty( &pncwm->rcW0[NCRC_FRAMEFIRST + i] ) ) { if( _IsNcPartTransparent(pncwm->rgframeparts[i], _nctmCurrent) ) { if( FAILED(GetThemeBackgroundRegion( _hTheme, NULL, pncwm->rgframeparts[i], pncwm->framestate, &pncwm->rcW0[NCRC_FRAMEFIRST+i], &rghrgn[i] )) ) { rghrgn[i] = NULL; } } else { rghrgn[i] = CreateRectRgnIndirect( &pncwm->rcW0[NCRC_FRAMEFIRST + i] ); } } if( rghrgn[i] != NULL ) { SPEW_RGNRECT(NCTF_RGNWND, TEXT("CreateCompositeRgn() frame subrgn"), rghrgn[i], pncwm->rgframeparts[i] ); AddToCompositeRgn(&hrgnWnd, rghrgn[i], 0, 0); } } // don't forget window content area (client+menubar+scrollbars), which is always rectangular if( !pncwm->fMin && !IsRectEmpty( &pncwm->rcW0[NCRC_CONTENT] ) ) { hrgnContent = CreateRectRgnIndirect( &pncwm->rcW0[NCRC_CONTENT] ); SPEW_RGNRECT(NCTF_RGNWND, TEXT("CreateCompositeRgn() normal frame content rgn"), hrgnContent, 0 ); AddToCompositeRgn(&hrgnWnd, hrgnContent, 0, 0); SAFE_DELETE_GDIOBJ(hrgnContent); } } // copy subregions back to caller CopyMemory( rghrgnParts, rghrgn, sizeof(rghrgn) ); // extract frame resizing templates ZeroMemory( rghrgn, sizeof(rghrgn) ); // reuse region array for( i = 0; i < cFRAMEPARTS; i++ ) { const RECT* prc = &pncwm->rcW0[NCRC_FRAMEFIRST + i]; if( VALID_WINDOWPART(pncwm->rgsizehitparts[i]) && !IsRectEmpty( prc ) ) { if( SUCCEEDED(GetThemeBackgroundRegion( _hTheme, NULL, pncwm->rgsizehitparts[i], pncwm->framestate, prc, &rghrgn[i])) ) { SPEW_RGNRECT(NCTF_RGNWND, TEXT("CreateCompositeRgn() sizing template"), rghrgn[i], pncwm->rgframeparts[i] ); } } } CopyMemory( rghrgnTemplates, rghrgn, sizeof(rghrgn) ); return hrgnWnd; } //-------------------------------------------------------------------------// void CThemeWnd::AssignFrameRgn( BOOL fAssign, DWORD dwFlags ) { if( fAssign ) { NCWNDMET* pncwm = NULL; NCTHEMEMET nctm = {0}; if( GetNcWindowMetrics( NULL, &pncwm, &nctm, 0 ) ) { // should we set up a window region on this frame? if( pncwm->fFrame ) { if( _ShouldAssignFrameRgn( pncwm, nctm ) ) { if( (_sizeRgn.cx != RECTWIDTH(&pncwm->rcW0[NCRC_WINDOW]) || _sizeRgn.cy != RECTHEIGHT(&pncwm->rcW0[NCRC_WINDOW])) ) { HRGN hrgnWnd = NULL; HRGN rghrgnParts[cFRAMEPARTS] = {0}; HRGN rghrgnTemplates[cFRAMEPARTS] = {0}; if( (hrgnWnd = CreateCompositeRgn( pncwm, rghrgnParts, rghrgnTemplates )) != NULL ) { _sizeRgn.cx = RECTWIDTH(&pncwm->rcW0[NCRC_WINDOW]); _sizeRgn.cy = RECTHEIGHT(&pncwm->rcW0[NCRC_WINDOW]); // cache all of our regions for fast hit-testing. _FreeRegionHandles(); _hrgnWnd = _DupRgn( hrgnWnd ); // dup this one cuz after _AssignRgn, we don't own it. CopyMemory( _rghrgnParts, rghrgnParts, sizeof(_rghrgnParts) ); CopyMemory( _rghrgnSizingTemplates, rghrgnTemplates, sizeof(_rghrgnSizingTemplates) ); // assign the region _AssignRgn( hrgnWnd, dwFlags ); } } } // otherwise, if we've assigned a region, make sure we remove it. else if( AssignedFrameRgn() ) { fAssign = FALSE; } } } } if( !fAssign ) { _AssignRgn( NULL, dwFlags ); FillMemory(&_sizeRgn, sizeof(_sizeRgn), 0xFF); _FreeRegionHandles(); } SetDirtyFrameRgn(FALSE); // make sure we reset this in case we didn't hit _AssignRgn. } //-------------------------------------------------------------------------// // CThemeWnd::_AssignRgn() - assigns the specified region // to the window, prevents recursion (SetWindowRgn w/ bRedraw == TRUE // generates WM_WINDOWPOSCHANGING, WM_NCCALCSIZE, && WM_NCPAINT). // void CThemeWnd::_AssignRgn( HRGN hrgn, DWORD dwFlags ) { if( TESTFLAG(dwFlags, FTF_NOMODIFYRGN) ) { _fAssignedFrameRgn = FALSE; } else if( !IsWindowInDestroy(_hwnd) ) { // Assign the new region. _fAssigningFrameRgn = TRUE; SPEW_RGNRECT(NCTF_RGNWND, TEXT("_AssignRgn() rect"), hrgn, -1 ); _fAssignedFrameRgn = SetWindowRgn( _hwnd, hrgn, TESTFLAG(dwFlags, FTF_REDRAW) ) != 0; _fAssigningFrameRgn = FALSE; } SetDirtyFrameRgn(FALSE); } //-------------------------------------------------------------------------// // CThemeWnd::GetNcWindowMetrics // // Computes internal per-window theme metrics. // BOOL CThemeWnd::GetNcWindowMetrics( IN OPTIONAL LPCRECT prcWnd, OUT OPTIONAL NCWNDMET** ppncwm, OUT OPTIONAL NCTHEMEMET* pnctm, IN DWORD dwOptions ) { LogEntryNC(L"GetNcWindowMetrics"); NCTHEMEMET nctm; BOOL bRet = FALSE; BOOL fMenuBar = _ncwm.cyMenu != 0; WINDOWPARTS rgframeparts[cFRAMEPARTS]; CopyMemory( rgframeparts, _ncwm.rgframeparts, sizeof(rgframeparts) ); // fetch per-theme metrics; we're going to need theme throughout if (TESTFLAG(dwOptions, NCWMF_PREVIEW)) { _LoadNcThemeMetrics(_hwnd, &nctm); } else if( !GetCurrentNcThemeMetrics( &nctm ) ) { goto exit; } if( pnctm ) *pnctm = nctm; if( !_ncwm.fValid || prcWnd != NULL ) dwOptions |= NCWMF_RECOMPUTE; if( TESTFLAG(dwOptions, NCWMF_RECOMPUTE) ) { // get caption text size before entering critsec (sends WM_GETTEXTLENGTH, WM_GETTEXT). SIZE sizeCaptionText = {0}; HFONT hfCaption = NULL; HWND hwndMDIActive = NULL; // Do rough determination of whether or not we're a frame window and need to compute text metrics. // We'll finalize this later BOOL fFrame, fSmallFrame; if( _ncwm.fValid ) { fFrame = TESTFLAG( CThemeWnd::EvaluateStyle(_ncwm.dwStyle, _ncwm.dwExStyle), TWCF_FRAME|TWCF_TOOLFRAME ); fSmallFrame = TESTFLAG( CThemeWnd::EvaluateStyle(_ncwm.dwStyle, _ncwm.dwExStyle), TWCF_TOOLFRAME ); } else { fFrame = TestCF(TWCF_FRAME|TWCF_TOOLFRAME); fSmallFrame = TestCF(TWCF_TOOLFRAME); } // Compute text metrics outside of critical section (sends WM_GETTEXT); if( fFrame && _fFrameThemed ) { hfCaption = NcGetCaptionFont( fSmallFrame ); _GetNcCaptionTextSize( _hTheme, _hwnd, hfCaption, &sizeCaptionText ); } // Retrieve active MDI sibling outside of critical section (sends WM_MDIGETACTIVE); if( TESTFLAG(GetWindowLong(_hwnd, GWL_EXSTYLE), WS_EX_MDICHILD) ) { hwndMDIActive = _MDIGetActive( GetParent(_hwnd) ); } ASSERT(_fCritSectsInit); EnterCriticalSection( &_cswm ); ZeroMemory( &_ncwm, sizeof(_ncwm) ); if( (bRet = _GetWindowMetrics( _hwnd, hwndMDIActive, &_ncwm )) != FALSE ) { _ComputeNcWindowStatus( _hwnd, _ncwm.dwWindowStatus, &_ncwm ); // if window RECT is provided by the caller, stuff it now. if( prcWnd ) { _ncwm.rcS0[NCRC_WINDOW] = *prcWnd; SetRectEmpty( &_ncwm.rcS0[NCRC_CLIENT] ); } // stuff caption text size _ncwm.sizeCaptionText = sizeCaptionText; _ncwm.hfCaption = hfCaption; // retrieve frame metrics. if( _GetNcFrameMetrics( _hwnd, _hTheme, nctm, _ncwm ) ) { if( _ncwm.fFrame ) { // user32!SetMenu has been called, or the caption or frame part has changed // So ensure frame region update. if( (_ncwm.cyMenu == 0 && fMenuBar) || (_ncwm.cyMenu > 0 && !fMenuBar) || memcmp( rgframeparts, _ncwm.rgframeparts, sizeof(rgframeparts) ) ) { SetDirtyFrameRgn(TRUE, TRUE); } // Compute NC button placement AcquireFrameIcon(_ncwm.dwStyle, _ncwm.dwExStyle, FALSE); #ifdef THEMED_NCBTNMETRICS _GetClassicNcBtnMetrics( &_ncwm, _hAppIcon, _MNCanClose(_hwnd), FALSE ); #else THEMED_NCBTNMETRICS _GetNcBtnMetrics( &_ncwm, &nctm, _hAppIcon, _MNCanClose(_hwnd) ); #endif THEMED_NCBTNMETRICS // Determine the caption margin for lame button metrics. _GetNcCaptionMargins( _hTheme, nctm, _ncwm ); _GetNcCaptionTextRect( &_ncwm ); if( _ncwm.fFrame ) { GetLameButtonMetrics( &_ncwm, &sizeCaptionText ); } } // Compute window-relative metrics // // If passed a window rect, base offsets on current window rect. // This is done to ensure preview window's (_hwnd) fake child windows are rendered correctly. RECT rcWnd = _ncwm.rcS0[NCRC_WINDOW]; if( prcWnd ) { if( _hwnd ) GetWindowRect( _hwnd, &rcWnd ); // for an incoming window rect, assign the computed client rect. _ncwm.rcS0[NCRC_CLIENT] = _ncwm.rcS0[NCRC_UXCLIENT]; } for( int i = NCRC_FIRST; i < NCRC_COUNT; i++ ) { _ncwm.rcW0[i] = _ncwm.rcS0[i]; OffsetRect( &_ncwm.rcW0[i], -rcWnd.left, -rcWnd.top ); } // All base computations are done; mark valid. _ncwm.fValid = TRUE; } } LeaveCriticalSection( &_cswm ); } if( ppncwm ) { *ppncwm = &_ncwm; } bRet = TRUE; exit: LogExitNC(L"GetNcWindowMetrics"); return bRet; } //-------------------------------------------------------------------------// void CThemeWnd::ReleaseNcWindowMetrics( IN NCWNDMET* pncwm ) { LeaveCriticalSection( &_cswm ); } //-------------------------------------------------------------------------// inline COLORREF _GetNcCaptionTextColor( FRAMESTATES iStateId ) { return GetSysColor( FS_ACTIVE == iStateId ? COLOR_CAPTIONTEXT : COLOR_INACTIVECAPTIONTEXT ); } //-------------------------------------------------------------------------// // Get CTLCOLOR brush for solid fills void _GetBrushesForPart(HTHEME hTheme, int iPart, HBITMAP* phbm, HBRUSH* phbr) { int nBgType; *phbm = NULL; *phbr = NULL; // Get CTLCOLOR brush for solid fills HRESULT hr = GetThemeEnumValue( hTheme, iPart, 0, TMT_BGTYPE, &nBgType ); if( SUCCEEDED( hr )) { if (BT_BORDERFILL == nBgType) { int nFillType; hr = GetThemeEnumValue( hTheme, iPart, 0, TMT_FILLTYPE, &nFillType ); if (SUCCEEDED( hr ) && FT_SOLID == nFillType) { COLORREF cr; hr = GetThemeColor( hTheme, iPart, 0, TMT_FILLCOLOR, &cr); *phbr = CreateSolidBrush(cr); } else { ASSERTMSG(FALSE, "Themes: The theme file specified an invalid fill type for dialog boxes"); } } else if (BT_IMAGEFILE == nBgType) { HDC hdc = GetWindowDC(NULL); if ( hdc ) { hr = GetThemeBitmap(hTheme, hdc, iPart, 0, NULL, phbm); if (SUCCEEDED(hr)) { *phbr = CreatePatternBrush(*phbm); } ReleaseDC(NULL, hdc); } } } } //-------------------------------------------------------------------------// // // Chooses appropriate hit testing parts for the various Nc area // void _GetNcSizingTemplates( IN const NCTHEMEMET& nctm, IN OUT NCWNDMET& ncwm ) // window metric block. dwStyle, dwExStyle, rcS0[NCRC_WINDOW] members are required. { FillMemory( ncwm.rgsizehitparts, sizeof(ncwm.rgsizehitparts), BOGUS_WINDOWPART ); // No need on windows without frames if( !ncwm.fFrame ) return; // minimized or full-screen maximized window if( ncwm.fMin || ncwm.fFullMaxed ) return; // No need on windows that aren't sizable if( !TESTFLAG(ncwm.dwStyle, WS_THICKFRAME) ) return; if( ncwm.fSmallFrame) { if (nctm.fSmCapSizingTemplate) ncwm.rgsizehitparts[iCAPTION] = WP_SMALLCAPTIONSIZINGTEMPLATE; if (nctm.fSmLeftSizingTemplate) ncwm.rgsizehitparts[iFRAMELEFT] = WP_SMALLFRAMELEFTSIZINGTEMPLATE; if (nctm.fSmRightSizingTemplate) ncwm.rgsizehitparts[iFRAMERIGHT] = WP_SMALLFRAMERIGHTSIZINGTEMPLATE; if (nctm.fSmBottomSizingTemplate) ncwm.rgsizehitparts[iFRAMEBOTTOM] = WP_SMALLFRAMEBOTTOMSIZINGTEMPLATE; } else { if (nctm.fCapSizingTemplate) ncwm.rgsizehitparts[iCAPTION] = WP_CAPTIONSIZINGTEMPLATE; if (nctm.fLeftSizingTemplate) ncwm.rgsizehitparts[iFRAMELEFT] = WP_FRAMELEFTSIZINGTEMPLATE; if (nctm.fRightSizingTemplate) ncwm.rgsizehitparts[iFRAMERIGHT] = WP_FRAMERIGHTSIZINGTEMPLATE; if (nctm.fBottomSizingTemplate) ncwm.rgsizehitparts[iFRAMEBOTTOM] = WP_FRAMEBOTTOMSIZINGTEMPLATE; } } //-------------------------------------------------------------------------// // // Computes theme metrics for frame window. // BOOL _GetNcFrameMetrics( IN OPTIONAL HWND hwnd, // window handle (required for multiline menubar calcs). IN HTHEME hTheme, // theme handle (required) IN const NCTHEMEMET& nctm, // theme metric block IN OUT NCWNDMET& ncwm ) // window metric block. dwStyle, dwExStyle, rcS0[NCRC_WINDOW] members are required. { LogEntryNC(L"_GetNcFrameMetrics"); ASSERT(hTheme); // recompute style class ncwm.dwStyleClass = CThemeWnd::EvaluateStyle( ncwm.dwStyle, ncwm.dwExStyle ); ncwm.cnBorders = _GetWindowBorders( ncwm.dwStyle, ncwm.dwExStyle ); // compute frame attributes, state ncwm.fFrame = TESTFLAG( ncwm.dwStyleClass, (TWCF_FRAME|TWCF_TOOLFRAME) ); ncwm.fSmallFrame = TESTFLAG( ncwm.dwStyleClass, TWCF_TOOLFRAME ); // compute frame and caption parts if( ncwm.fFrame ) { ncwm.rgframeparts[iFRAMEBOTTOM] = ncwm.rgframeparts[iFRAMELEFT] = ncwm.rgframeparts[iFRAMERIGHT] = ncwm.rgframeparts[iCAPTION] = BOGUS_WINDOWPART; if( ncwm.fMin ) // minimized window { ncwm.rgframeparts[iCAPTION] = WP_MINCAPTION; } else if( ncwm.fFullMaxed ) // full-screen maximized window { ncwm.rgframeparts[iCAPTION] = WP_MAXCAPTION; } else // normal or partial-screen maximized window with thick border { if( ncwm.fSmallFrame ) { ncwm.rgframeparts[iCAPTION] = WP_SMALLCAPTION; ncwm.rgframeparts[iFRAMELEFT] = WP_SMALLFRAMELEFT; ncwm.rgframeparts[iFRAMERIGHT] = WP_SMALLFRAMERIGHT; ncwm.rgframeparts[iFRAMEBOTTOM] = WP_SMALLFRAMEBOTTOM; } else { ncwm.rgframeparts[iCAPTION] = ncwm.fMaxed ? WP_MAXCAPTION : WP_CAPTION; ncwm.rgframeparts[iFRAMELEFT] = WP_FRAMELEFT; ncwm.rgframeparts[iFRAMERIGHT] = WP_FRAMERIGHT; ncwm.rgframeparts[iFRAMEBOTTOM] = WP_FRAMEBOTTOM; } } // stash caption text color. ncwm.rgbCaption = _GetNcCaptionTextColor( ncwm.framestate ); // retrieve sizing templates. _GetNcSizingTemplates( nctm, ncwm ); } //-----------------------------------------------------------// // Frame metrics // // Frame area includes 'skin' boundaries, // menu, integrated caption and client edge. // // Independent of the frame is the separate caption seg, // scrollbars, and sizebox //-----------------------------------------------------------// if( ncwm.fFrame ) // frame windows only { // Initialize positions of main frame components... // Content rect: area bounded by frame theme. // Client rect: area contained in content rect that excludes all nonclient // elements (viz, scrollbars, menubar, inside edges). // Caption rect: pertains to minimized and maximized windows, // and normal windows if the theme defines a caption part ncwm.rcS0[NCRC_CAPTION] = ncwm.rcS0[NCRC_CONTENT] = ncwm.rcS0[NCRC_WINDOW]; SetRectEmpty( &ncwm.rcS0[NCRC_UXCLIENT] ); if( ncwm.fMin ) /* minimized frame */ { // zero out content, client rectangles. ncwm.rcS0[NCRC_CONTENT].right = ncwm.rcS0[NCRC_CONTENT].left; ncwm.rcS0[NCRC_CONTENT].bottom = ncwm.rcS0[NCRC_CONTENT].top; ncwm.rcS0[NCRC_CLIENT] = ncwm.rcS0[NCRC_UXCLIENT] = ncwm.rcS0[NCRC_CONTENT]; } else { NONCLIENTMETRICS ncm; if( NcGetNonclientMetrics( &ncm, FALSE ) ) { ncwm.rcS0[NCRC_FRAMEBOTTOM] = ncwm.rcS0[NCRC_FRAMELEFT] = ncwm.rcS0[NCRC_FRAMERIGHT] = ncwm.rcS0[NCRC_WINDOW]; // themed caption rect spans left, top, right bordersS // and 1 pixel edge below caption ncwm.rcS0[NCRC_CAPTION].bottom = ncwm.rcS0[NCRC_CAPTION].top + ncwm.cnBorders + (ncwm.fSmallFrame ? ncm.iSmCaptionHeight : ncm.iCaptionHeight) + 1 /* 1 pixel below caption */; // update the content and rects while we're here: InflateRect( &ncwm.rcS0[NCRC_CONTENT], -ncwm.cnBorders, -ncwm.cnBorders ); ncwm.rcS0[NCRC_CONTENT].top = ncwm.rcS0[NCRC_CAPTION].bottom; if( ncwm.rcS0[NCRC_CONTENT].bottom < ncwm.rcS0[NCRC_CONTENT].top ) ncwm.rcS0[NCRC_CONTENT].bottom = ncwm.rcS0[NCRC_CONTENT].top; // at this point the client rect is identical to the content rect (haven't computed menubar, scrollbars). ncwm.rcS0[NCRC_UXCLIENT] = ncwm.rcS0[NCRC_CONTENT]; // bottom border segment. ncwm.rcS0[NCRC_FRAMEBOTTOM].top = ncwm.rcS0[NCRC_FRAMEBOTTOM].bottom - ncwm.cnBorders; // side border segments ncwm.rcS0[NCRC_FRAMELEFT].top = ncwm.rcS0[NCRC_FRAMERIGHT].top = ncwm.rcS0[NCRC_CAPTION].bottom; ncwm.rcS0[NCRC_FRAMELEFT].bottom = ncwm.rcS0[NCRC_FRAMERIGHT].bottom = ncwm.rcS0[NCRC_FRAMEBOTTOM].top; ncwm.rcS0[NCRC_FRAMELEFT].right = ncwm.rcS0[NCRC_FRAMELEFT].left + ncwm.cnBorders; ncwm.rcS0[NCRC_FRAMERIGHT].left = ncwm.rcS0[NCRC_FRAMERIGHT].right - ncwm.cnBorders; } } } else // frameless windows with scrollbars and/or client-edge: { // Non-frame windows ncwm.rcS0[NCRC_UXCLIENT] = ncwm.rcS0[NCRC_WINDOW]; InflateRect( &ncwm.rcS0[NCRC_UXCLIENT], -ncwm.cnBorders, -ncwm.cnBorders ); ncwm.rcS0[NCRC_CONTENT] = ncwm.rcS0[NCRC_UXCLIENT]; } // Menubar if( !(ncwm.fMin || TESTFLAG( ncwm.dwStyle, WS_CHILD )) ) // child windows don't have menubars { // Menubar offsets (for painting) ncwm.cnMenuOffsetTop = ncwm.rcS0[NCRC_CONTENT].top - ncwm.rcS0[NCRC_WINDOW].top; ncwm.cnMenuOffsetLeft = ncwm.rcS0[NCRC_CONTENT].left - ncwm.rcS0[NCRC_WINDOW].left; ncwm.cnMenuOffsetRight = ncwm.rcS0[NCRC_WINDOW].right - ncwm.rcS0[NCRC_CONTENT].right; if( hwnd ) { // calc menubar does the right thing for multiline menubars ncwm.cyMenu = CalcMenuBar( hwnd, ncwm.cnMenuOffsetLeft, ncwm.cnMenuOffsetRight, ncwm.cnMenuOffsetTop, &ncwm.rcS0[NCRC_WINDOW] ); } else { // no window (e.g. preview) == no menu, meaning don't call CalcMenuBar. // we emulate computations best we can: ncwm.cyMenu = NcGetSystemMetrics( SM_CYMENUSIZE ); } // CalcMenuBar and SM_CYMENUSIZE are 1 pixel short of reality. if( ncwm.cyMenu ) ncwm.cyMenu += nctm.dyMenuBar; // Menubar rect (for hit-testing and clipping) SetRect( &ncwm.rcS0[NCRC_MENUBAR], ncwm.rcS0[NCRC_CONTENT].left, ncwm.rcS0[NCRC_CONTENT].top, ncwm.rcS0[NCRC_CONTENT].right, min(ncwm.rcS0[NCRC_CONTENT].bottom, ncwm.rcS0[NCRC_CONTENT].top + ncwm.cyMenu) ); ncwm.rcS0[NCRC_UXCLIENT].top = ncwm.rcS0[NCRC_MENUBAR].bottom; } // Client Edge. if( !ncwm.fMin && TESTFLAG(ncwm.dwExStyle, WS_EX_CLIENTEDGE) ) { CopyRect( &ncwm.rcS0[NCRC_CLIENTEDGE], &ncwm.rcS0[NCRC_UXCLIENT] ); InflateRect( &ncwm.rcS0[NCRC_UXCLIENT], -NcGetSystemMetrics( SM_CXEDGE ), -NcGetSystemMetrics( SM_CYEDGE )); } //-----------------------------------------------------------// // Scrollbars and sizebox/gripper //-----------------------------------------------------------// if( !ncwm.fMin ) { // horizontal scroll bar. if( TESTFLAG(ncwm.dwStyle, WS_HSCROLL) ) { ncwm.rcS0[NCRC_HSCROLL] = ncwm.rcS0[NCRC_UXCLIENT]; ncwm.rcS0[NCRC_HSCROLL].top = ncwm.rcS0[NCRC_UXCLIENT].bottom = ncwm.rcS0[NCRC_HSCROLL].bottom - NcGetSystemMetrics( SM_CYHSCROLL ); if( IsRectEmpty( &ncwm.rcS0[NCRC_CLIENT] ) /* this happens in preview */ ) { ncwm.rcS0[NCRC_HSCROLL].left = ncwm.rcS0[NCRC_UXCLIENT].left; ncwm.rcS0[NCRC_HSCROLL].right = ncwm.rcS0[NCRC_UXCLIENT].right; } else { ncwm.rcS0[NCRC_HSCROLL].left = ncwm.rcS0[NCRC_CLIENT].left; ncwm.rcS0[NCRC_HSCROLL].right = ncwm.rcS0[NCRC_CLIENT].right; } } // vertical scroll bar if( TESTFLAG(ncwm.dwStyle, WS_VSCROLL) ) { ncwm.rcS0[NCRC_VSCROLL] = ncwm.rcS0[NCRC_UXCLIENT]; if( TESTFLAG(ncwm.dwExStyle, WS_EX_LAYOUTRTL) ^ TESTFLAG(ncwm.dwExStyle, WS_EX_LEFTSCROLLBAR) ) { ncwm.rcS0[NCRC_VSCROLL].right = ncwm.rcS0[NCRC_UXCLIENT].left = ncwm.rcS0[NCRC_VSCROLL].left + NcGetSystemMetrics( SM_CXVSCROLL ); // Adjust for horz scroll, gripper if( TESTFLAG(ncwm.dwStyle, WS_HSCROLL) ) { ncwm.rcS0[NCRC_SIZEBOX]= ncwm.rcS0[NCRC_HSCROLL]; ncwm.rcS0[NCRC_SIZEBOX].right = ncwm.rcS0[NCRC_HSCROLL].left = ncwm.rcS0[NCRC_UXCLIENT].left; } } else { ncwm.rcS0[NCRC_VSCROLL].left = ncwm.rcS0[NCRC_UXCLIENT].right = ncwm.rcS0[NCRC_VSCROLL].right - NcGetSystemMetrics( SM_CXVSCROLL ); // Adjust for horz scroll, gripper if( TESTFLAG(ncwm.dwStyle, WS_HSCROLL) ) { ncwm.rcS0[NCRC_SIZEBOX]= ncwm.rcS0[NCRC_HSCROLL]; ncwm.rcS0[NCRC_SIZEBOX].left = ncwm.rcS0[NCRC_HSCROLL].right = ncwm.rcS0[NCRC_UXCLIENT].right; } } if( IsRectEmpty( &ncwm.rcS0[NCRC_CLIENT] ) /* this happens in preview */ ) { ncwm.rcS0[NCRC_VSCROLL].top = ncwm.rcS0[NCRC_UXCLIENT].top; ncwm.rcS0[NCRC_VSCROLL].bottom = ncwm.rcS0[NCRC_UXCLIENT].bottom; } else { ncwm.rcS0[NCRC_VSCROLL].top = ncwm.rcS0[NCRC_CLIENT].top; ncwm.rcS0[NCRC_VSCROLL].bottom = ncwm.rcS0[NCRC_CLIENT].bottom; } } } LogExitNC(L"_GetNcFrameMetrics"); return TRUE; } #define EXT_TRACK_VERT 0x01 #define EXT_TRACK_HORZ 0x02 //-------------------------------------------------------------------------// void _GetNcBtnHitTestRect( IN const NCWNDMET* pncwm, IN UINT uHitcode, BOOL fWindowRelative, OUT LPRECT prcHit ) { const RECT* prcBtn = NULL; int dxLeft = 0; // button's left side delta int dxRight = 0; // button's right side delta // adjust hitrect to classic-look caption bar strip: RECT rcHit = fWindowRelative ? pncwm->rcW0[NCRC_CAPTION] : pncwm->rcS0[NCRC_CAPTION]; rcHit.top += pncwm->cnBorders; rcHit.left += pncwm->cnBorders; rcHit.right -= pncwm->cnBorders; rcHit.bottom -= 1; // determine which button we're working with, how to extend the left, right sides. switch( uHitcode ) { case HTMINBUTTON: prcBtn = fWindowRelative ? &pncwm->rcW0[NCRC_MINBTN] : &pncwm->rcS0[NCRC_MINBTN]; dxLeft = -1; break; case HTMAXBUTTON: prcBtn = fWindowRelative ? &pncwm->rcW0[NCRC_MAXBTN] : &pncwm->rcS0[NCRC_MAXBTN]; dxRight = 1; break; case HTHELP: prcBtn = fWindowRelative ? &pncwm->rcW0[NCRC_HELPBTN] : &pncwm->rcS0[NCRC_HELPBTN]; dxLeft = -1; dxRight = 1; break; case HTCLOSE: prcBtn = fWindowRelative ? &pncwm->rcW0[NCRC_CLOSEBTN] : &pncwm->rcS0[NCRC_CLOSEBTN]; dxLeft = -1; dxRight = rcHit.right - prcBtn->right; break; case HTSYSMENU: prcBtn = fWindowRelative ? &pncwm->rcW0[NCRC_SYSBTN] : &pncwm->rcS0[NCRC_SYSBTN]; dxLeft = rcHit.left - prcBtn->left; dxRight = 1; break; } if( prcBtn ) { *prcHit = *prcBtn; if( !IsRectEmpty( prcBtn ) ) { rcHit.left = prcBtn->left + dxLeft; rcHit.right = prcBtn->right + dxRight; *prcHit = rcHit; } } else { SetRectEmpty( prcHit ); } } //-------------------------------------------------------------------------// // wraps alloc, retrieval of window text LPWSTR _AllocWindowText( IN HWND hwnd ) { LPWSTR pszRet = NULL; if (hwnd && IsWindow(hwnd)) { if( (pszRet = new WCHAR[MAX_PATH]) != NULL ) { int cch; if( (cch = InternalGetWindowText(hwnd, pszRet, MAX_PATH)) <= 0 ) { __try // some wndprocs can't handle an early WM_GETTEXT (eg.310700). { cch = GetWindowText(hwnd, pszRet, MAX_PATH); } __except(EXCEPTION_EXECUTE_HANDLER) { cch = 0; } } if( !cch ) { SAFE_DELETE_ARRAY(pszRet); // delete and zero pointer } } } return pszRet; } //-------------------------------------------------------------------------// // _GetNcCaptionMargins() - computes a margin from the window ULC based on the // offsets in the theme and the location of enabled caption buttons. The left // margin is to the right of the last left-aligned button, and the right margin // is to the left of the first right-aligned button. // BOOL _GetNcCaptionMargins( IN HTHEME hTheme, IN const NCTHEMEMET& nctm, IN OUT NCWNDMET& ncwm ) { ZeroMemory( &ncwm.CaptionMargins, sizeof(ncwm.CaptionMargins) ); if( ncwm.fFrame ) { // assign per-window CaptinMargins, hfCaption values if( ncwm.fSmallFrame ) { ncwm.CaptionMargins = nctm.marSmCaptionText; } else { if( ncwm.fMaxed ) { ncwm.CaptionMargins = nctm.marMaxCaptionText; } else if( ncwm.fMin ) { ncwm.CaptionMargins = nctm.marMinCaptionText; } else { ncwm.CaptionMargins = nctm.marCaptionText; } } ncwm.hfCaption = NcGetCaptionFont(ncwm.fSmallFrame); RECT rcContainer = ncwm.rcS0[NCRC_CAPTION]; RECT *prcBtn = &ncwm.rcS0[NCBTNFIRST]; rcContainer.left += ncwm.cnBorders; rcContainer.right -= ncwm.cnBorders; // sysmenu icon, if present, is the leftmost limit if( !IsRectEmpty( &ncwm.rcS0[NCRC_SYSBTN] ) ) { rcContainer.left = ncwm.rcS0[NCRC_SYSBTN].right; } // Compute our rightmost limit for( UINT cRects = NCBTNRECTS; cRects; --cRects, ++prcBtn ) { if (!IsRectEmpty(prcBtn)) { if( prcBtn->left < rcContainer.right ) { rcContainer.right = prcBtn->left; } } } if( rcContainer.right < rcContainer.left ) { rcContainer.right = rcContainer.left; } // final captions margins are adjusted to accommodate buttons. ncwm.CaptionMargins.cxLeftWidth += (rcContainer.left - ncwm.rcS0[NCRC_CAPTION].left); ncwm.CaptionMargins.cxRightWidth += (ncwm.rcS0[NCRC_CAPTION].right - rcContainer.right); return TRUE; } return FALSE; } //-------------------------------------------------------------------------// BOOL _GetNcCaptionTextSize( HTHEME hTheme, HWND hwnd, HFONT hf, OUT SIZE* psizeCaption ) { BOOL fRet = FALSE; LPWSTR pszCaption = _AllocWindowText( hwnd ); psizeCaption->cx = psizeCaption->cy = 0; if( pszCaption ) { HDC hdc = GetWindowDC(hwnd); if( hdc ) { //---- select font ---- HFONT hf0 = (HFONT)SelectObject(hdc, hf); //---- let theme mgr do the calculation ---- RECT rcExtent; HRESULT hr = GetThemeTextExtent( hTheme, hdc, WP_CAPTION, 0, pszCaption, lstrlen(pszCaption), 0, NULL, &rcExtent ); //---- store result in "psizeCaption ---- if (SUCCEEDED(hr)) { psizeCaption->cx = WIDTH(rcExtent); psizeCaption->cy = HEIGHT(rcExtent); } //---- clean up ---- SelectObject(hdc, hf0); ReleaseDC(hwnd, hdc); } SAFE_DELETE_ARRAY(pszCaption); } return fRet; } //-------------------------------------------------------------------------// // Retrieves position of available area for caption text, in window-relative // coordinates BOOL _GetNcCaptionTextRect( IN OUT NCWNDMET* pncwm ) { pncwm->rcS0[NCRC_CAPTIONTEXT] = pncwm->rcS0[NCRC_CAPTION]; // accommodate classic top sizing border: pncwm->rcS0[NCRC_CAPTIONTEXT].top += pncwm->cnBorders; // Assign left, right based on resp. caption margins pncwm->rcS0[NCRC_CAPTIONTEXT].left += pncwm->CaptionMargins.cxLeftWidth; pncwm->rcS0[NCRC_CAPTIONTEXT].right -= pncwm->CaptionMargins.cxRightWidth; // vertically center the text between margins int cyPadding = (RECTHEIGHT(&pncwm->rcS0[NCRC_CAPTIONTEXT]) - pncwm->sizeCaptionText.cy)/2; pncwm->rcS0[NCRC_CAPTIONTEXT].top += cyPadding; pncwm->rcS0[NCRC_CAPTIONTEXT].bottom -= cyPadding; return TRUE; } //-------------------------------------------------------------------------// // retrieve the window icon HICON CThemeWnd::AcquireFrameIcon( DWORD dwStyle, DWORD dwExStyle, BOOL fWinIniChange ) { if( _hAppIcon != NULL ) { if( fWinIniChange ) { _hAppIcon = NULL; } } if( !TESTFLAG(dwStyle, WS_SYSMENU) || TESTFLAG(dwExStyle, WS_EX_TOOLWINDOW) ) { // return nil value without throwing away cached icon handle; // this may be a transient style change. return NULL; } NONCLIENTMETRICS ncm = {0}; NcGetNonclientMetrics( &ncm, FALSE ); BOOL fPerferLargeIcon = ((30 < ncm.iCaptionHeight) ? TRUE : FALSE); if( NULL == _hAppIcon && NULL == (_hAppIcon = _GetWindowIcon(_hwnd, fPerferLargeIcon)) ) { if ( HAS_CAPTIONBAR(dwStyle) && ((dwStyle & (WS_BORDER|WS_DLGFRAME)) != WS_DLGFRAME) && !TESTFLAG(dwExStyle, WS_EX_DLGMODALFRAME) ) { // If we still can't get an icon and the window has // SYSMENU set, then they get the default winlogo icon _hAppIcon = LoadIcon(NULL, IDI_WINLOGO); } } return _hAppIcon; } //-------------------------------------------------------------------------// void _CopyInflateRect( LPRECT prcDst, LPCRECT prcSrc, int cx, int cy) { prcDst->left = prcSrc->left - cx; prcDst->right = prcSrc->right + cx; prcDst->top = prcSrc->top - cy; prcDst->bottom = prcSrc->bottom + cy; } //-------------------------------------------------------------------------// // CThemeWnd::ScreenToWindow() - transforms points from screen coords to // window coords. // void CThemeWnd::ScreenToWindow( LPPOINT prgPts, UINT cPts ) { RECT rcWnd; if( GetWindowRect( _hwnd, &rcWnd ) ) { for( UINT i = 0; i < cPts; i++ ) { prgPts[i].x -= rcWnd.left; prgPts[i].y -= rcWnd.top; } } } //-------------------------------------------------------------------------// // CThemeWnd::ScreenToWindow() - transforms non-empty rectangles from // screen coords to window coords. // void CThemeWnd::ScreenToWindowRect( LPRECT prc ) { if( !IsRectEmpty(prc) ) ScreenToWindow( (LPPOINT)prc, 2 ); } //-------------------------------------------------------------------------// // CThemeWnd::InitWindowMetrics() // // initializes theme resources void CThemeWnd::InitWindowMetrics() { ZeroMemory( &_ncwm, sizeof(_ncwm) ); } //-------------------------------------------------------------------------// BOOL _fClassicNcBtnMetricsReset = TRUE; //-------------------------------------------------------------------------// // computes classic button position BOOL _GetClassicNcBtnMetrics( IN OPTIONAL NCWNDMET* pncwm, IN HICON hAppIcon, IN OPTIONAL BOOL fCanClose, BOOL fRefresh ) { static int cxEdge, cyEdge; static int cxBtn, cyBtn, cxSmBtn, cySmBtn; static RECT rcClose, rcMin, rcMax, rcHelp, rcSys; static RECT rcSmClose; static BOOL fInit = FALSE; if( _fClassicNcBtnMetricsReset || fRefresh ) { cxBtn = NcGetSystemMetrics( SM_CXSIZE ); cyBtn = NcGetSystemMetrics( SM_CYSIZE ); cxSmBtn = NcGetSystemMetrics( SM_CXSMSIZE ); cySmBtn = NcGetSystemMetrics( SM_CYSMSIZE ); cxEdge = NcGetSystemMetrics( SM_CXEDGE ); cyEdge = NcGetSystemMetrics( SM_CYEDGE ); // common top, w/ zero v-offset rcClose.top = rcMin.top = rcMax.top = rcHelp.top = rcSys.top = rcSmClose.top = 0; // common bottom, w/ zero v-offset rcClose.bottom = rcMin.bottom = rcMax.bottom = rcHelp.bottom = rcClose.top + (cyBtn - (cyEdge * 2)); rcSmClose.bottom= (cySmBtn - (cyEdge * 2)); // sysmenu icon bottom rcSys.bottom = rcSys.top + NcGetSystemMetrics(SM_CYSMICON); // close, min, max left, right (as offsets from container's right boundary) rcClose.right = -cxEdge; rcClose.left = rcClose.right - (cxBtn - cxEdge); rcMax.right = rcClose.left - cxEdge; rcMax.left = rcMax.right - (cxBtn - cxEdge); rcHelp = rcMax; rcMin.right = rcMax.left; rcMin.left = rcMin.right - (cxBtn - cxEdge); // appicon left, right (as offsets from container's left boundary) rcSys.left = cxEdge; rcSys.right = rcSys.left + NcGetSystemMetrics(SM_CXSMICON); // toolwindow close, left, right rcSmClose.right = -cxEdge; rcSmClose.left = rcSmClose.right - (cxSmBtn - cxEdge); _fClassicNcBtnMetricsReset = FALSE; } if( !_fClassicNcBtnMetricsReset && pncwm && pncwm->fFrame && TESTFLAG(pncwm->dwStyle, WS_SYSMENU) ) { NONCLIENTMETRICS ncm; if( NcGetNonclientMetrics( &ncm, FALSE ) ) { const RECT* prcBox = &pncwm->rcS0[NCRC_CAPTION]; int cnLOffset = prcBox->left + pncwm->cnBorders; int cnROffset = prcBox->right - pncwm->cnBorders; int cnCtrOffset = pncwm->cnBorders + prcBox->top + (pncwm->fSmallFrame ? (ncm.iCaptionHeight - RECTHEIGHT(&rcClose))/2 : (ncm.iSmCaptionHeight - RECTHEIGHT(&rcSmClose))/2); // assign outbound rectangles. // vertically center w/ respect to classic caption area, // horizontally position w/ respect to respective container boundary. // close button pncwm->rcS0[NCRC_CLOSEBTN] = pncwm->fSmallFrame ? rcSmClose : rcClose; OffsetRect( &pncwm->rcS0[NCRC_CLOSEBTN], cnROffset, cnCtrOffset ); pncwm->rawCloseBtnState = fCanClose ? CBS_NORMAL : CBS_DISABLED; // (1) min/max/help/appicons not displayed for toolwindows // (2) min/max btns mutually exclusive w/ context help btn if( !TESTFLAG(pncwm->dwExStyle, WS_EX_TOOLWINDOW) ) { // min, max if( TESTFLAG(pncwm->dwStyle, WS_MINIMIZEBOX|WS_MAXIMIZEBOX) ) { pncwm->rcS0[NCRC_MINBTN] = rcMin; OffsetRect( &pncwm->rcS0[NCRC_MINBTN], cnROffset, cnCtrOffset ); pncwm->rcS0[NCRC_MAXBTN] = rcMax; OffsetRect( &pncwm->rcS0[NCRC_MAXBTN], cnROffset, cnCtrOffset ); pncwm->iMaxButtonPart = pncwm->fMaxed ? WP_RESTOREBUTTON : WP_MAXBUTTON; pncwm->iMinButtonPart = pncwm->fMin ? WP_RESTOREBUTTON : WP_MINBUTTON; pncwm->rawMaxBtnState = TESTFLAG(pncwm->dwStyle, WS_MAXIMIZEBOX) ? CBS_NORMAL : CBS_DISABLED; pncwm->rawMinBtnState = TESTFLAG(pncwm->dwStyle, WS_MINIMIZEBOX) ? CBS_NORMAL : CBS_DISABLED; } // help btn else if( TESTFLAG(pncwm->dwExStyle, WS_EX_CONTEXTHELP) ) { pncwm->rcS0[NCRC_HELPBTN] = rcHelp; OffsetRect( &pncwm->rcS0[NCRC_HELPBTN], cnROffset, cnCtrOffset ); } if( hAppIcon ) { // sysmenu icon pncwm->rcS0[NCRC_SYSBTN] = rcSys; OffsetRect( &pncwm->rcS0[NCRC_SYSBTN], cnLOffset, pncwm->cnBorders + prcBox->top + (ncm.iCaptionHeight - RECTHEIGHT(&rcSys))/2 ); } } return TRUE; } return FALSE; } return fInit; } //-------------------------------------------------------------------------// // computes classic button position BOOL _GetNcBtnMetrics( IN OUT NCWNDMET* pncwm, IN const NCTHEMEMET* pnctm, IN HICON hAppIcon, IN OPTIONAL BOOL fCanClose ) { BOOL fRet = TRUE; if( pncwm && pncwm->fFrame && TESTFLAG(pncwm->dwStyle, WS_SYSMENU) ) { NONCLIENTMETRICS ncm; fRet = NcGetNonclientMetrics( &ncm, FALSE ); if( fRet ) { // (1) compute baseline rectangles int cxEdge = NcGetSystemMetrics( SM_CXEDGE ); int cyEdge = NcGetSystemMetrics( SM_CYEDGE ); int cyBtn = NcGetSystemMetrics( SM_CYSIZE ); int cxBtn = MulDiv( cyBtn, pnctm->sizeBtn.cx, pnctm->sizeBtn.cy ); int cySmBtn = NcGetSystemMetrics( SM_CYSMSIZE ); int cxSmBtn = MulDiv( cySmBtn, pnctm->sizeSmBtn.cx, pnctm->sizeSmBtn.cy ); // remove padding from x,y cyBtn -= (cyEdge * 2); cxBtn -= (cyEdge * 2); cySmBtn -= (cyEdge * 2); cxSmBtn -= (cyEdge * 2); RECT rcClose, rcMin, rcMax, rcHelp, rcSys, rcSmClose; // common top, w/ zero v-offset rcClose.top = rcMin.top = rcMax.top = rcHelp.top = rcSys.top = rcSmClose.top = 0; // common bottom, w/ zero v-offset rcClose.bottom = rcMin.bottom = rcMax.bottom = rcHelp.bottom = max( rcClose.top, rcClose.top + cyBtn ); rcSmClose.bottom = max( rcSmClose.top, cySmBtn ); // sysmenu icon bottom rcSys.bottom = rcSys.top + NcGetSystemMetrics(SM_CYSMICON); // close, min, max left, right (as offsets from container's right boundary) rcClose.right = -cxEdge; rcClose.left = rcClose.right - cxBtn; rcMax.right = rcClose.left - cxEdge; rcMax.left = rcMax.right - cxBtn; rcHelp = rcMax; rcMin.right = rcMax.left - cxEdge; rcMin.left = rcMin.right - cxBtn; // appicon left, right (as offsets from container's left boundary) rcSys.left = cxEdge; rcSys.right = rcSys.left + NcGetSystemMetrics(SM_CXSMICON); // toolwindow close, left, right rcSmClose.right = -cxEdge; rcSmClose.left = rcSmClose.right - cxSmBtn; const RECT* prcBox = &pncwm->rcS0[NCRC_CAPTION]; int cnLOffset = prcBox->left + pncwm->cnBorders; int cnROffset = prcBox->right - pncwm->cnBorders; int cnCtrOffset = pncwm->cnBorders + prcBox->top + (pncwm->fSmallFrame ? (ncm.iCaptionHeight - RECTHEIGHT(&rcClose))/2 : (ncm.iSmCaptionHeight - RECTHEIGHT(&rcSmClose))/2); // (2) assign outbound rectangles. // vertically center w/ respect to classic caption area, // horizontally position w/ respect to respective container boundary. // close button pncwm->rcS0[NCRC_CLOSEBTN] = pncwm->fSmallFrame ? rcSmClose : rcClose; OffsetRect( &pncwm->rcS0[NCRC_CLOSEBTN], cnROffset, cnCtrOffset ); pncwm->rawCloseBtnState = fCanClose ? CBS_NORMAL : CBS_DISABLED; // (1) min/max/help/appicons not displayed for toolwindows // (2) min/max btns mutually exclusive w/ context help btn if( !TESTFLAG(pncwm->dwExStyle, WS_EX_TOOLWINDOW) ) { // min, max if( TESTFLAG(pncwm->dwStyle, WS_MINIMIZEBOX|WS_MAXIMIZEBOX) ) { pncwm->rcS0[NCRC_MINBTN] = rcMin; OffsetRect( &pncwm->rcS0[NCRC_MINBTN], cnROffset, cnCtrOffset ); pncwm->rcS0[NCRC_MAXBTN] = rcMax; OffsetRect( &pncwm->rcS0[NCRC_MAXBTN], cnROffset, cnCtrOffset ); pncwm->iMaxButtonPart = pncwm->fMaxed ? WP_RESTOREBUTTON : WP_MAXBUTTON; pncwm->iMinButtonPart = pncwm->fMin ? WP_RESTOREBUTTON : WP_MINBUTTON; pncwm->rawMaxBtnState = TESTFLAG(pncwm->dwStyle, WS_MAXIMIZEBOX) ? CBS_NORMAL : CBS_DISABLED; pncwm->rawMinBtnState = TESTFLAG(pncwm->dwStyle, WS_MINIMIZEBOX) ? CBS_NORMAL : CBS_DISABLED; } // help btn else if( TESTFLAG(pncwm->dwExStyle, WS_EX_CONTEXTHELP) ) { pncwm->rcS0[NCRC_HELPBTN] = rcHelp; OffsetRect( &pncwm->rcS0[NCRC_HELPBTN], cnROffset, cnCtrOffset ); } if( hAppIcon ) { // sysmenu icon pncwm->rcS0[NCRC_SYSBTN] = rcSys; OffsetRect( &pncwm->rcS0[NCRC_SYSBTN], cnLOffset, pncwm->cnBorders + prcBox->top + (ncm.iCaptionHeight - RECTHEIGHT(&rcSys))/2 ); } } } } return fRet; } //-------------------------------------------------------------------------// // CThemeWnd::NcBackgroundHitTest() - hit test the Caption or Frame part // WORD CThemeWnd::NcBackgroundHitTest( POINT ptHit, LPCRECT prcWnd, DWORD dwStyle, DWORD dwExStyle, FRAMESTATES fs, const WINDOWPARTS rgiParts[], const WINDOWPARTS rgiTemplates[], const RECT rgrcParts[] ) { WORD hitcode = HTNOWHERE; HRESULT hr = E_FAIL; eFRAMEPARTS iPartHit = (eFRAMEPARTS)-1; // do a standard rect hit test: for( int i = 0; i < cFRAMEPARTS; i++ ) { if( _StrictPtInRect(&rgrcParts[i], ptHit) ) { iPartHit = (eFRAMEPARTS)i; break; } } if( iPartHit >= 0 ) { BOOL fResizing = TESTFLAG(dwStyle, WS_THICKFRAME); DWORD dwHTFlags = fResizing ? HTTB_RESIZINGBORDER : HTTB_FIXEDBORDER; RECT rcHit = rgrcParts[iPartHit]; switch( iPartHit ) { case iCAPTION: // Ensure caption rect and test point are zero-relative to // the correct origin (if we have a window region, // this would be window origin, otherwise, it's the part origin.) if( _hrgnWnd != NULL ) rcHit = *prcWnd; if( fResizing ) dwHTFlags &= ~HTTB_RESIZINGBORDER_BOTTOM; break; case iFRAMEBOTTOM: if( fResizing ) dwHTFlags &= ~HTTB_RESIZINGBORDER_TOP; break; case iFRAMELEFT: if( fResizing ) dwHTFlags = HTTB_RESIZINGBORDER_LEFT; break; case iFRAMERIGHT: if( fResizing ) dwHTFlags = HTTB_RESIZINGBORDER_RIGHT; break; } ptHit.x -= prcWnd->left; ptHit.y -= prcWnd->top; OffsetRect( &rcHit, -prcWnd->left, -prcWnd->top ); // Here our assumption is that the hit testing for the template // is "as good" or "better" than the rectangles checking applied // to the caption part. So we do one or the other. There are // situations where you would need to do both (if the template // were outside the window region and you were able to get USER to // send you NcHitTest messages for it). For those situations // you would need to call both so that you can distinguish between // a mouse hit over the caption "client" area vs. over the // outside-transparent area. if( VALID_WINDOWPART(rgiTemplates[iPartHit]) ) { hr = HitTestThemeBackground( _hTheme, NULL, rgiTemplates[iPartHit], fs, dwHTFlags | (fResizing ? HTTB_SIZINGTEMPLATE : 0), &rcHit, _rghrgnSizingTemplates[iPartHit], ptHit, &hitcode ); } else { hr = HitTestThemeBackground( _hTheme, NULL, rgiParts[iPartHit], fs, dwHTFlags | (fResizing ? HTTB_SYSTEMSIZINGMARGINS : 0), &rcHit, _hrgnWnd, ptHit, &hitcode ); } if( SUCCEEDED(hr) ) { if( iCAPTION == iPartHit && (HTCLIENT == hitcode || HTBORDER == hitcode) ) hitcode = HTCAPTION; } } if ( FAILED(hr) ) { hitcode = HTNOWHERE; } return hitcode; } //-------------------------------------------------------------------------// // CThemeWnd::TrackFrameButton() - track the mouse over the caption buttons, // pressing/releasing as appropriate. Return back SC_* command to report or 0 // if the mouse was released off of the button. // BOOL CThemeWnd::TrackFrameButton( HWND hwnd, INT iHitCode, OUT OPTIONAL WPARAM* puSysCmd, BOOL fHottrack ) { int iStateId, iNewStateId; int iPartId = -1; UINT cmd = 0; MSG msg = {0}; LPRECT prcBtnPaint = NULL; RECT rcBtnTrack; HDC hdc; if (puSysCmd) { *puSysCmd = 0; } // map iHitCode to the correct part number switch (iHitCode) { case HTHELP: cmd = SC_CONTEXTHELP; iPartId = WP_HELPBUTTON; prcBtnPaint = &_ncwm.rcW0[NCRC_HELPBTN]; break; case HTCLOSE: cmd = SC_CLOSE; iPartId = _ncwm.fSmallFrame ? WP_SMALLCLOSEBUTTON : WP_CLOSEBUTTON; prcBtnPaint = &_ncwm.rcW0[NCRC_CLOSEBTN]; break; case HTMINBUTTON: cmd = _ncwm.fMin ? SC_RESTORE : SC_MINIMIZE; iPartId = _ncwm.iMinButtonPart; prcBtnPaint = &_ncwm.rcW0[NCRC_MINBTN]; break; case HTMAXBUTTON: cmd = _ncwm.fMaxed ? SC_RESTORE : SC_MAXIMIZE; iPartId = _ncwm.iMaxButtonPart; prcBtnPaint = &_ncwm.rcW0[NCRC_MAXBTN]; break; case HTSYSMENU: if (puSysCmd) { *puSysCmd = SC_MOUSEMENU | iHitCode; } return TRUE; } // If we didn't recognize the hit code there's nothing to track if (iPartId >= 0 ) { // Get the window DC, in window coords hdc = _GetNonclientDC(_hwnd, NULL); if ( hdc ) { // Don't paint in the window's content area, clip to the content area ExcludeClipRect( hdc, _ncwm.rcW0[NCRC_CONTENT].left, _ncwm.rcW0[NCRC_CONTENT].top, _ncwm.rcW0[NCRC_CONTENT].right, _ncwm.rcW0[NCRC_CONTENT].bottom ); // Calculate the tracking rect. We track a larger button rect when maximized // but paint into the normal sized rect. rcBtnTrack = *prcBtnPaint; _GetNcBtnHitTestRect( &_ncwm, iHitCode, TRUE, &rcBtnTrack ); // when tracking MDI child window frame buttons, clip to their // parent rect. if ( TESTFLAG(GetWindowLong(hwnd, GWL_EXSTYLE), WS_EX_MDICHILD) ) { RECT rcMDIClient; GetWindowRect(GetParent(hwnd), &rcMDIClient); ScreenToWindowRect(&rcMDIClient); InflateRect(&rcMDIClient, -NcGetSystemMetrics(SM_CXEDGE), -NcGetSystemMetrics(SM_CYEDGE)); IntersectClipRect(hdc, rcMDIClient.left, rcMDIClient.top, rcMDIClient.right, rcMDIClient.bottom); } if (fHottrack) { // draw the button hot if the mouse is over it iStateId = (iHitCode == _htHot) ? SBS_HOT : CBS_NORMAL; } else { // draw the button depressed iStateId = SBS_PUSHED; } iStateId = MAKE_BTNSTATE(_ncwm.framestate, iStateId); NcDrawThemeBackground(_hTheme, hdc, iPartId, iStateId, prcBtnPaint, 0); // TODO NotifyWinEvent(EVENT_OBJECT_STATECHANGE, pwnd, OBJID_TITLEBAR, iButton, 0); if ( !fHottrack ) { BOOL fTrack, fMouseUp = FALSE; SetCapture(hwnd); // take mouse capture do // mouse button tracking loop { fTrack = FALSE; // Let's go to sleep, to be awakened only on a mouse message placed in our // thread's queue. switch (MsgWaitForMultipleObjectsEx(0, NULL, INFINITE /*why consume CPU processing a timeout when we don't have to?*/, QS_MOUSE, MWMO_INPUTAVAILABLE)) { case WAIT_OBJECT_0: // a mouse message or important system event has been queued if (PeekMessage(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE)) { // PeekMessage returns a point in screen relative coords. Mirror the // point it this is a RTL window. Translate the point to window coords. if ( TESTFLAG(_ncwm.dwExStyle, WS_EX_LAYOUTRTL) ) { // mirror the point to hittest correctly MIRROR_POINT(_ncwm.rcS0[NCRC_WINDOW], msg.pt); } ScreenToWindow( &msg.pt, 1 ); if (msg.message == WM_LBUTTONUP) { ReleaseCapture(); fMouseUp = TRUE; } else if ((msg.message == WM_MOUSEMOVE) && cmd) { iNewStateId = MAKE_BTNSTATE(_ncwm.framestate, PtInRect(&rcBtnTrack, msg.pt) ? SBS_PUSHED : SBS_NORMAL); if (iStateId != iNewStateId) { iStateId = iNewStateId; NcDrawThemeBackground(_hTheme, hdc, iPartId, iStateId, prcBtnPaint, 0); // TODO NotifyWinEvent(EVENT_OBJECT_STATECHANGE, pwnd, OBJID_TITLEBAR, iButton, 0); } fTrack = TRUE; } } else { // Check loss of capture. This can happen if we loose activation // via alt-tab and may not have received a WM_CAPTURECHANGED message if (GetCapture() != hwnd) { break; } } // Dequeue CAPTURECHANGED if (PeekMessage(&msg, NULL, WM_CAPTURECHANGED, WM_CAPTURECHANGED, PM_REMOVE) || fMouseUp) { break; } fTrack = TRUE; // go back to sleep until the next mouse event break; default: break; } } while (fTrack); // draw button in normal state if it is not in that state already iNewStateId = MAKE_BTNSTATE(_ncwm.framestate, CBS_NORMAL); if (iStateId != iNewStateId) { NcDrawThemeBackground(_hTheme, hdc, iPartId, iNewStateId, prcBtnPaint, 0); } // if we did not end up on a button return 0 if( puSysCmd && (*puSysCmd = cmd) != 0 ) { // TODO NotifyWinEvent(EVENT_OBJECT_STATECHANGE, pwnd, OBJID_TITLEBAR, iButton, 0); // If mouse wasn't released over the button, cancel the command. if( !(fMouseUp && PtInRect(&rcBtnTrack, msg.pt)) ) *puSysCmd = 0; } } // Done with DC now ReleaseDC(_hwnd, hdc); } } return TRUE; } //-------------------------------------------------------------------------// DWORD GetTextAlignFlags(HTHEME hTheme, IN NCWNDMET* pncwm, BOOL fReverse) { CONTENTALIGNMENT contentAlignment = CA_LEFT; DWORD dwAlignFlags = 0; //---- compute text alignment ---- GetThemeInt(hTheme, pncwm->rgframeparts[iCAPTION], pncwm->framestate, TMT_CONTENTALIGNMENT, (int *)&contentAlignment); if (fReverse) { //---- reverse alignment ---- switch(contentAlignment) { default: case CA_LEFT: dwAlignFlags |= DT_RIGHT; break; case CA_CENTER: dwAlignFlags |= DT_CENTER; break; case CA_RIGHT: dwAlignFlags |= DT_LEFT; break; } } else { //---- normal alignment ---- switch(contentAlignment) { default: case CA_LEFT: dwAlignFlags |= DT_LEFT; break; case CA_CENTER: dwAlignFlags |= DT_CENTER; break; case CA_RIGHT: dwAlignFlags |= DT_RIGHT; break; } } return dwAlignFlags; } //-------------------------------------------------------------------------// void _BorderRect( HDC hdc, COLORREF rgb, LPCRECT prc, int cxBorder, int cyBorder ) { COLORREF rgbSave = SetBkColor( hdc, rgb ); RECT rc = *prc; // bottom border rc = *prc; rc.top = prc->bottom - cyBorder; ExtTextOut( hdc, rc.left, rc.top, ETO_OPAQUE, &rc, NULL, 0, NULL ); // right border rc = *prc; rc.left = prc->right - cxBorder; ExtTextOut( hdc, rc.left, rc.top, ETO_OPAQUE, &rc, NULL, 0, NULL ); // left border rc = *prc; rc.right = prc->left + cxBorder; ExtTextOut( hdc, rc.left, rc.top, ETO_OPAQUE, &rc, NULL, 0, NULL ); // top border rc = *prc; rc.bottom = prc->top + cyBorder; ExtTextOut( hdc, rc.left, rc.top, ETO_OPAQUE, &rc, NULL, 0, NULL ); SetBkColor( hdc, rgbSave ); } //-------------------------------------------------------------------------// void _DrawWindowEdges( HDC hdc, NCWNDMET* pncwm, BOOL fIsFrame ) { // non-frame window edge & border if( !fIsFrame ) { RECT rcWnd = pncwm->rcW0[NCRC_WINDOW]; int cxBorder = NcGetSystemMetrics(SM_CXBORDER), cyBorder = NcGetSystemMetrics(SM_CYBORDER); // static, window edge if( TESTFLAG(pncwm->dwExStyle, WS_EX_WINDOWEDGE) ) { RECT rcClip = rcWnd; InflateRect( &rcClip, -pncwm->cnBorders, -pncwm->cnBorders ); ExcludeClipRect( hdc, rcClip.left, rcClip.top, rcClip.right, rcClip.bottom ); DrawEdge( hdc, &rcWnd, EDGE_RAISED, BF_RECT | BF_ADJUST | BF_MIDDLE); SelectClipRgn( hdc, NULL ); } else if( TESTFLAG(pncwm->dwExStyle, WS_EX_STATICEDGE) ) { DrawEdge( hdc, &rcWnd, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST ); } // Normal border else if( TESTFLAG(pncwm->dwStyle, WS_BORDER) ) { _BorderRect( hdc, GetSysColor( COLOR_WINDOWFRAME), &rcWnd, cxBorder, cyBorder ); } } // client edge if( TESTFLAG(pncwm->dwExStyle, WS_EX_CLIENTEDGE) ) { #ifdef _TEST_CLIENTEDGE_ HBRUSH hbr = CreateSolidBrush( RGB(255,0,255) ); FillRect(hdc, &ncwm.rcW0[NCRC_CLIENTEDGE], hbr); DeleteObject(hbr); #else _TEST_CLIENTEDGE_ DrawEdge( hdc, &pncwm->rcW0[NCRC_CLIENTEDGE], EDGE_SUNKEN, BF_RECT | BF_ADJUST); #endif _TEST_CLIENTEDGE_ } } //-------------------------------------------------------------------------// void CThemeWnd::NcPaintCaption( IN HDC hdcOut, IN NCWNDMET* pncwm, IN BOOL fBuffered, IN DWORD dwCaptionFlags, // draw caption flags (DC_xxx, winuser.h) IN DTBGOPTS* pdtbopts ) { ASSERT(hdcOut); ASSERT(pncwm); ASSERT(pncwm->fFrame); ASSERT(HAS_CAPTIONBAR(pncwm->dwStyle)); DWORD dwOldAlign = 0; // caption text implies caption background if( TESTFLAG( dwCaptionFlags, DC_TEXT|DC_ICON ) || 0 == dwCaptionFlags ) { dwCaptionFlags = DC_ENTIRECAPTION; } if( dwCaptionFlags != DC_ENTIRECAPTION #if defined(DEBUG) && defined(DEBUG_NCPAINT) || TESTFLAG( _NcTraceFlags, NCTF_NCPAINT ) #endif DEBUG ) { fBuffered = FALSE; } // create caption double buffer HBITMAP hbmBuf = fBuffered ? CreateCompatibleBitmap(hdcOut, RECTWIDTH(&pncwm->rcW0[NCRC_CAPTION]), RECTHEIGHT(&pncwm->rcW0[NCRC_CAPTION])) : NULL; if( !fBuffered || hbmBuf ) { HDC hdc = fBuffered ? CreateCompatibleDC(hdcOut) : hdcOut; if( hdc ) { //--- DO NOT EXIT FROM WITHIN THIS CONDITIONAL ---// EnterNcThemePaint(); HBITMAP hbm0 = fBuffered ? (HBITMAP)SelectObject(hdc, hbmBuf) : NULL; if( TESTFLAG( dwCaptionFlags, DC_BACKGROUND ) ) { // Draw caption background RECT rcBkgnd = pncwm->rcW0[NCRC_CAPTION]; if( pncwm->fFullMaxed ) { rcBkgnd.top += pncwm->cnBorders; rcBkgnd.left += pncwm->cnBorders; rcBkgnd.right -= pncwm->cnBorders; } NcDrawThemeBackgroundEx( _hTheme, hdc, pncwm->rgframeparts[iCAPTION], pncwm->framestate, &rcBkgnd, pdtbopts ); } if( TESTFLAG( dwCaptionFlags, DC_BUTTONS ) ) { // Draw standard caption buttons if (!IsRectEmpty(&pncwm->rcW0[NCRC_CLOSEBTN])) { NcDrawThemeBackground( _hTheme, hdc, pncwm->fSmallFrame ? WP_SMALLCLOSEBUTTON : WP_CLOSEBUTTON, MAKE_BTNSTATE(pncwm->framestate, pncwm->rawCloseBtnState), &pncwm->rcW0[NCRC_CLOSEBTN], 0); } if (!IsRectEmpty(&pncwm->rcW0[NCRC_MAXBTN])) { NcDrawThemeBackground(_hTheme, hdc, pncwm->iMaxButtonPart, MAKE_BTNSTATE(pncwm->framestate, pncwm->rawMaxBtnState), &pncwm->rcW0[NCRC_MAXBTN], 0); } if (!IsRectEmpty(&pncwm->rcW0[NCRC_MINBTN])) { NcDrawThemeBackground( _hTheme, hdc, pncwm->iMinButtonPart, MAKE_BTNSTATE(pncwm->framestate, pncwm->rawMinBtnState), &pncwm->rcW0[NCRC_MINBTN], 0); } if (!IsRectEmpty(&pncwm->rcW0[NCRC_HELPBTN])) NcDrawThemeBackground(_hTheme, hdc, WP_HELPBUTTON, MAKE_BTNSTATE(pncwm->framestate, CBS_NORMAL), &pncwm->rcW0[NCRC_HELPBTN], 0); } // Draw sysmenu icon if( TESTFLAG( dwCaptionFlags, DC_ICON ) ) { if (!IsRectEmpty(&pncwm->rcW0[NCRC_SYSBTN]) && _hAppIcon) { #define MAX_APPICON_RETRIES 1 int cRetries = 0; DWORD dwLayout = GetLayout(hdc); if( GDI_ERROR != dwLayout && TESTFLAG(dwLayout, LAYOUT_RTL) ) { SetLayout(hdc, dwLayout|LAYOUT_BITMAPORIENTATIONPRESERVED); } do { // note: we don't draw sysmenu icon mirrored if( DrawIconEx(hdc, pncwm->rcW0[NCRC_SYSBTN].left, pncwm->rcW0[NCRC_SYSBTN].top, _hAppIcon, RECTWIDTH(&pncwm->rcW0[NCRC_SYSBTN]), RECTHEIGHT(&pncwm->rcW0[NCRC_SYSBTN]), 0, NULL, DI_NORMAL)) { break; // success; done } // failure; try recycling the handle if( _hAppIcon && GetLastError() == ERROR_INVALID_CURSOR_HANDLE ) { _hAppIcon = NULL; AcquireFrameIcon( pncwm->dwStyle, pncwm->dwExStyle, FALSE ); if( (++cRetries) > MAX_APPICON_RETRIES ) { _hAppIcon = NULL; // failed to retrieve a new icon handle; bail for good. } } } while( _hAppIcon && cRetries <= MAX_APPICON_RETRIES ); if( GDI_ERROR != dwLayout ) { SetLayout(hdc, dwLayout); } } } if( TESTFLAG( dwCaptionFlags, DC_TEXT ) ) { // Draw caption text HFONT hf0 = NULL; DWORD dwDTFlags = DT_SINGLELINE | DT_NOPREFIX | DT_END_ELLIPSIS; BOOL fSelFont = FALSE; LPWSTR pszText = _AllocWindowText(_hwnd); if( pszText && *pszText ) { // Compute frame text rect if( pncwm->hfCaption ) { hf0 = (HFONT)SelectObject( hdc, pncwm->hfCaption ); fSelFont = TRUE; } //---- compute text alignment ---- BOOL fReverse = TESTFLAG(_ncwm.dwExStyle, WS_EX_RIGHT); dwDTFlags |= GetTextAlignFlags(_hTheme, pncwm, fReverse); } //---- adjust text align for WS_EX_RTLREADING ---- if (TESTFLAG(_ncwm.dwExStyle, WS_EX_RTLREADING)) dwOldAlign = SetTextAlign(hdc, TA_RTLREADING | GetTextAlign(hdc)); if( pszText && *pszText ) { //---- set options for DrawThemeText() ---- DTTOPTS DttOpts = {sizeof(DttOpts)}; DttOpts.dwFlags = DTT_TEXTCOLOR; DttOpts.crText = pncwm->rgbCaption; Log(LOG_RFBUG, L"Drawing Caption Text: left=%d, state=%d, text=%s", pncwm->rcW0[NCRC_CAPTIONTEXT].left, pncwm->framestate, pszText); //---- draw the caption text ---- DrawThemeTextEx(_hTheme, hdc, pncwm->rgframeparts[iCAPTION], pncwm->framestate, pszText, -1, dwDTFlags, &pncwm->rcW0[NCRC_CAPTIONTEXT], &DttOpts); } //---- free the text, if temp. allocated ---- SAFE_DELETE_ARRAY(pszText) //---- draw the "Comments?" text ---- SetBkMode( hdc, TRANSPARENT ); SetTextColor( hdc, pncwm->rgbCaption ); DrawLameButton(hdc, pncwm); //---- restore the text align ---- if (TESTFLAG(_ncwm.dwExStyle, WS_EX_RTLREADING)) SetTextAlign(hdc, dwOldAlign); if( fSelFont ) { SelectObject(hdc, hf0); } } if( hdc != hdcOut ) { // Slap the bits on the output DC. BitBlt( hdcOut, pncwm->rcW0[NCRC_CAPTION].left, pncwm->rcW0[NCRC_CAPTION].top, WIDTH(pncwm->rcW0[NCRC_CAPTION]), HEIGHT(pncwm->rcW0[NCRC_CAPTION]), hdc, 0, 0, SRCCOPY ); SelectObject(hdc, hbm0); DeleteDC(hdc); } LeaveNcThemePaint(); } DeleteObject( hbmBuf ); } if( IsWindowVisible(_hwnd) ) { SetRenderedNcPart(RNCF_CAPTION); } } //-------------------------------------------------------------------------// // CThemeWnd::NcPaint() - NC painting worker // void CThemeWnd::NcPaint( IN OPTIONAL HDC hdcIn, IN ULONG dwFlags, IN OPTIONAL HRGN hrgnUpdate, IN OPTIONAL NCPAINTOVERIDE* pncpo) { NCTHEMEMET nctm; NCWNDMET* pncwm = NULL; HDC hdc = NULL; if( _cLockRedraw > 0 ) return; // Compute all metrics before painting: if (pncpo) // preview override { ASSERT(hdcIn); hdc = hdcIn; pncwm = pncpo->pncwm; nctm = pncpo->nctm; } else // live window { if( !GetNcWindowMetrics( NULL, &pncwm, &nctm, NCWMF_RECOMPUTE ) ) return; // Ensure status bits reflect caller's intention for frame state if( dwFlags != NCPF_DEFAULT ) { _ComputeNcWindowStatus( _hwnd, TESTFLAG(dwFlags, NCPF_ACTIVEFRAME) ? WS_ACTIVECAPTION : 0, pncwm ); } hdc = hdcIn ? hdcIn : _GetNonclientDC( _hwnd, hrgnUpdate ); if (! hdc) { //---- don't assert here since stress (out of memory) could cause a legit failure ---- Log(LOG_ALWAYS, L"call to GetDCEx() for nonclient painting failed"); } } if( hdc != NULL ) { //--- DO NOT EXIT FROM WITHIN THIS CONDITIONAL ---// BEGIN_DEBUG_NCPAINT(); EnterNcThemePaint(); // Clip to content rect (alleviates flicker in menubar and scrollbars as we paint background) RECT rcClip; rcClip = pncwm->rcW0[NCRC_CONTENT]; if( TESTFLAG(pncwm->dwExStyle, WS_EX_LAYOUTRTL) ) { // mirror the clip rect relative to the window rect // and apply that as the clipping region for the dc MIRROR_RECT(pncwm->rcW0[NCRC_WINDOW], rcClip); } ExcludeClipRect( hdc, rcClip.left, rcClip.top, rcClip.right, rcClip.bottom ); if( pncwm->fFrame ) { //---- DrawThemeBackgroundEx() options ---- DTBGOPTS dtbopts = {sizeof(dtbopts)}; DTBGOPTS *pdtbopts = NULL; // if not drawing preview, set "draw solid" option if(!pncpo) { // Because of the interleaving of NCPAINT and SetWindowRgn, drawing solid results // in some flicker and transparency bleed. Commenting this out for now [scotthan] //dtbopts.dwFlags |= DTBG_DRAWSOLID; pdtbopts = &dtbopts; } // Frame Background if( pncwm->fMin ) { NcDrawThemeBackgroundEx( _hTheme, hdc, WP_MINCAPTION, pncwm->framestate, &pncwm->rcW0[NCRC_CAPTION], pdtbopts ) ; } else if( !pncwm->fFullMaxed ) { NcDrawThemeBackgroundEx( _hTheme, hdc, pncwm->rgframeparts[iFRAMELEFT], pncwm->framestate, &pncwm->rcW0[NCRC_FRAMELEFT], pdtbopts ); NcDrawThemeBackgroundEx( _hTheme, hdc, pncwm->rgframeparts[iFRAMERIGHT], pncwm->framestate, &pncwm->rcW0[NCRC_FRAMERIGHT], pdtbopts ); NcDrawThemeBackgroundEx( _hTheme, hdc, pncwm->rgframeparts[iFRAMEBOTTOM], pncwm->framestate, &pncwm->rcW0[NCRC_FRAMEBOTTOM], pdtbopts ); } SetRenderedNcPart(RNCF_FRAME); // Caption NcPaintCaption( hdc, pncwm, !(pncwm->fMin || pncwm->fFullMaxed || pncpo), DC_ENTIRECAPTION, pdtbopts ); } // Clip to client rect SelectClipRgn( hdc, NULL ); // Menubar if( !(pncwm->fMin || TESTFLAG(pncwm->dwStyle, WS_CHILD)) && !IsRectEmpty(&pncwm->rcW0[NCRC_MENUBAR]) ) { RECT rcMenuBar = pncwm->rcW0[NCRC_MENUBAR]; BOOL fClip = RECTHEIGHT(&rcMenuBar) < pncwm->cyMenu; if( fClip ) { IntersectClipRect( hdc, rcMenuBar.left, rcMenuBar.top, rcMenuBar.right, rcMenuBar.bottom ); } PaintMenuBar( _hwnd, hdc, pncwm->cnMenuOffsetLeft, pncwm->cnMenuOffsetRight, pncwm->cnMenuOffsetTop, TESTFLAG(pncwm->framestate, FS_ACTIVE) ? PMB_ACTIVE : 0 ); // deal with unpainted menubar pixels: if( nctm.dyMenuBar > 0 && RECTHEIGHT(&pncwm->rcW0[NCRC_MENUBAR]) >= pncwm->cyMenu ) { rcMenuBar.top = rcMenuBar.bottom - nctm.dyMenuBar; COLORREF rgbBk = SetBkColor( hdc, GetSysColor(COLOR_MENU) ); ExtTextOut(hdc, rcMenuBar.left, rcMenuBar.top, ETO_OPAQUE, &rcMenuBar, NULL, 0, NULL ); SetBkColor( hdc, rgbBk ); } if( fClip ) SelectClipRgn( hdc, NULL ); } // Scrollbars if( !pncwm->fMin ) { // Draw static, window, client edges. _DrawWindowEdges( hdc, pncwm, pncwm->fFrame ); RECT rcVScroll = pncwm->rcW0[NCRC_VSCROLL]; if ( TESTFLAG(pncwm->dwExStyle, WS_EX_LAYOUTRTL) ) { MIRROR_RECT(pncwm->rcW0[NCRC_WINDOW], rcVScroll); } if( TESTFLAG(pncwm->dwStyle, WS_VSCROLL) && ( HasRenderedNcPart(RNCF_SCROLLBAR) || RectVisible(hdc, &rcVScroll)) ) { if( TESTFLAG(pncwm->dwStyle, WS_HSCROLL) ) { // Draw sizebox. RECT rcSizeBox = pncwm->rcW0[NCRC_SIZEBOX]; if ( TESTFLAG(pncwm->dwExStyle, WS_EX_LAYOUTRTL) ) { MIRROR_RECT(pncwm->rcW0[NCRC_WINDOW], rcSizeBox); } DrawSizeBox( _hwnd, hdc, rcSizeBox.left, rcSizeBox.top ); } DrawScrollBar( _hwnd, hdc, pncpo ? &pncwm->rcW0[NCRC_VSCROLL]: NULL, TRUE /*vertical*/ ); SetRenderedNcPart( RNCF_SCROLLBAR ); } if( TESTFLAG(pncwm->dwStyle, WS_HSCROLL) && ( HasRenderedNcPart(RNCF_SCROLLBAR) || RectVisible(hdc, &pncwm->rcW0[NCRC_HSCROLL])) ) { DrawScrollBar( _hwnd, hdc, pncpo ? &pncwm->rcW0[NCRC_HSCROLL] : NULL, FALSE /*vertical*/ ); SetRenderedNcPart( RNCF_SCROLLBAR ); } } if (pncpo || hdcIn) { SelectClipRgn( hdc, NULL ); } else { ReleaseDC( _hwnd, hdc ); } LeaveNcThemePaint(); END_DEBUG_NCPAINT(); } } //-------------------------------------------------------------------------// // WM_STYLECHANGED themewnd instance handler void CThemeWnd::StyleChanged( UINT iGWL, DWORD dwOld, DWORD dwNew ) { DWORD dwStyleOld, dwStyleNew, dwExStyleOld, dwExStyleNew; switch( iGWL ) { case GWL_STYLE: dwStyleOld = dwOld; dwStyleNew = dwNew; dwExStyleOld = dwExStyleNew = GetWindowLong(_hwnd, GWL_EXSTYLE); break; case GWL_EXSTYLE: dwExStyleOld = dwOld; dwExStyleNew = dwNew; dwStyleOld = dwStyleNew = GetWindowLong(_hwnd, GWL_STYLE); break; default: return; } DWORD fClassFlagsOld = CThemeWnd::EvaluateStyle( dwStyleOld, dwExStyleOld); DWORD fClassFlagsNew = CThemeWnd::EvaluateStyle( dwStyleNew, dwExStyleNew); // Update theme class flags. // Always keep the scrollbar class flag if the window had it initially. User // flips scroll styles on and off without corresponding style change notification. _fClassFlags = fClassFlagsNew | (_fClassFlags & TWCF_SCROLLBARS); _fFrameThemed = TESTFLAG( _fClassFlags, TWCF_FRAME|TWCF_TOOLFRAME ); // Are we losing the frame? if( TESTFLAG( fClassFlagsOld, TWCF_FRAME|TWCF_TOOLFRAME ) && !TESTFLAG( fClassFlagsNew, TWCF_FRAME|TWCF_TOOLFRAME ) ) { ThemeMDIMenuButtons(FALSE, FALSE); if( AssignedFrameRgn() ) { AssignFrameRgn(FALSE /*strip off frame rgn*/, FTF_REDRAW); } } // Are we gaining a frame? else if( TESTFLAG( fClassFlagsNew, TWCF_FRAME|TWCF_TOOLFRAME ) && !TESTFLAG( fClassFlagsOld, TWCF_FRAME|TWCF_TOOLFRAME ) ) { SetFrameTheme(0, NULL); } // Freshen window metrics GetNcWindowMetrics( NULL, NULL, NULL, NCWMF_RECOMPUTE ); } //-------------------------------------------------------------------------// // ThemeDefWindowProc message handlers //-------------------------------------------------------------------------// //-------------------------------------------------------------------------// // WM_THEMECHANGED post-wndproc msg handler LRESULT CALLBACK OnOwpPostThemeChanged( CThemeWnd* pwnd, THEME_MSG *ptm ) { if (IS_THEME_CHANGE_TARGET(ptm->lParam)) { //---- avoid redundant retheming (except for SetWindowTheme() calls) if ((HTHEME(*pwnd) == _nctmCurrent.hTheme) && (! (ptm->lParam & WTC_CUSTOMTHEME))) { Log(LOG_NCATTACH, L"OnOwpPostThemeChanged, just kicking the frame"); //---- window got correct theme thru _XXXWindowProc() from sethook ---- //---- we just need to redraw the frame for all to be right ---- if (pwnd->IsFrameThemed()) { //---- attach the region to the window now ---- pwnd->SetFrameTheme(FTF_REDRAW, NULL); } } else { Log(LOG_NCATTACH, L"OnOwpPostThemeChanged, calling Full ::ChangeTheme()"); //---- its a real, app/system theme change ---- pwnd->ChangeTheme( ptm ); } } MsgHandled( ptm ); return 1L; } //-------------------------------------------------------------------------// void CThemeWnd::ChangeTheme( THEME_MSG* ptm ) { if( _hTheme ) // hwnd attached for previous theme { // do a lightweight detach from current theme _DetachInstance( HMD_CHANGETHEME ); } if( IsAppThemed() ) // new theme is active { // retrieve window client rect, style bits. WINDOWINFO wi; wi.cbSize = sizeof(wi); GetWindowInfo( ptm->hwnd, &wi ); ULONG ulTargetFlags = EvaluateStyle( wi.dwStyle, wi.dwExStyle ); // If the window is themable if( TESTFLAG(ulTargetFlags, TWCF_NCTHEMETARGETMASK) ) { // Open the new theme HTHEME hTheme = ::OpenNcThemeData( ptm->hwnd, L"Window" ); if( hTheme ) { // do a lightweight attach if( _AttachInstance( ptm->hwnd, hTheme, ulTargetFlags, NULL ) ) { // reattach scrollbars if( TESTFLAG( ulTargetFlags, TWCF_SCROLLBARS ) ) { AttachScrollBars(ptm->hwnd); } if (IsFrameThemed()) { //---- attach the region to the window now ---- SetFrameTheme(FTF_REDRAW, NULL); } } else { CloseThemeData( hTheme ); } } } } if (! _hTheme) // if an hwnd is no longer attached { // Left without a theme handle: This means either we failed to open a new theme handle or // failed to evaulate as a target, no new theme, etc. RemoveWindowProperties(ptm->hwnd, FALSE); //---- release our CThemeWnd obj so it doesn't leak (addref-protected by caller) ---- Release(); } } //-------------------------------------------------------------------------// BOOL IsPropertySheetChild(HWND hDlg) { while(hDlg) { ULONG ulFlags = HandleToUlong(GetProp(hDlg, MAKEINTATOM(GetThemeAtom(THEMEATOM_DLGTEXTURING)))); if( ETDT_ENABLETAB == (ulFlags & ETDT_ENABLETAB) /* all bits in this mask are required */ ) { return TRUE; } hDlg = GetAncestor(hDlg, GA_PARENT); } return FALSE; } //--------------------------------------------------------------------------- void PrintClientNotHandled(HWND hwnd) { ATOM aIsPrinting = GetThemeAtom(THEMEATOM_PRINTING); DWORD dw = PtrToUlong(GetProp(hwnd, (PCTSTR)aIsPrinting)); if (dw == PRINTING_ASKING) SetProp(hwnd, (PCTSTR)aIsPrinting, (HANDLE)PRINTING_WINDOWDIDNOTHANDLE); } //--------------------------------------------------------------------------- HBRUSH GetDialogColor(HWND hwnd, NCTHEMEMET &nctm) { HBRUSH hbr = NULL; // if this is a PROPSHEET child or the app called // EnableThemeDialogTexture() on this hwnd, we'll use the tab background. if (IsPropertySheetChild(hwnd)) { hbr = nctm.hbrTabDialog; } if( NULL == hbr ) { hbr = GetSysColorBrush(COLOR_3DFACE); } return hbr; } //--------------------------------------------------------------------------- LRESULT CALLBACK OnDdpPrint(CThemeWnd* pwnd, THEME_MSG* ptm) { LRESULT lRet = 0L; if (!ptm->lRet) { if (pwnd->HasProcessedEraseBk()) { RECT rc; HDC hdc = (HDC)ptm->wParam; NCTHEMEMET nctm; if( GetCurrentNcThemeMetrics( &nctm )) { HBRUSH hbr = GetDialogColor(*pwnd, nctm); if (hbr) { POINT pt; if (GetClipBox(hdc, &rc) == NULLREGION) GetClientRect(*pwnd, &rc); SetBrushOrgEx(hdc, -rc.left, -rc.top, &pt); FillRect(hdc, &rc, hbr); SetBrushOrgEx(hdc, pt.x, pt.y, NULL); lRet = (LRESULT)1; MsgHandled( ptm ); } } } else { PrintClientNotHandled(*pwnd); } } return lRet; } //--------------------------------------------------------------------------- LRESULT CALLBACK OnDdpCtlColor(CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = 0L; if (!ptm->lRet && pwnd->HasProcessedEraseBk()) { NCTHEMEMET nctm; if( GetCurrentNcThemeMetrics( &nctm )) { HBRUSH hbr = GetDialogColor(*pwnd, nctm); if (hbr) { RECT rc; HDC hdc = (HDC)ptm->wParam; GetWindowRect(((HWND)ptm->lParam), &rc); MapWindowPoints(NULL, *pwnd, (POINT*)&rc, 2); SetBkMode(hdc, TRANSPARENT); SetBrushOrgEx(hdc, -rc.left, -rc.top, NULL); // the hdc's default background color needs to be set // for for those controls that insist on using OPAQUE SetBkColor(hdc, GetSysColor(COLOR_BTNFACE)); lRet = (LRESULT)hbr; MsgHandled( ptm ); } } } return lRet; } //-------------------------------------------------------------------------// // WM_CTLCOLORxxx defwindowproc override handler LRESULT CALLBACK OnDdpPostCtlColor( CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = 0L; if (!ptm->lRet) { // This is sent to the parent in the case of WM_CTLCOLORMSGBOX, but to the // dialog itself in the case of a WM_CTLCOLORDLG. This gets both. CThemeWnd* pwndDlg = CThemeWnd::FromHwnd((HWND)ptm->lParam); // WM_CTLCOLORMSGBOX is sent for Both the dialog AND the static // control inside. So we need to sniff: Are we talking to a dialog or a // control. the pwnd is associated with the dialog, but not the control if (pwndDlg && VALID_THEMEWND(pwndDlg)) { if (IsPropertySheetChild(*pwnd)) { NCTHEMEMET nctm; if( GetCurrentNcThemeMetrics( &nctm )) { HBRUSH hbr = GetDialogColor(*pwndDlg, nctm); if (hbr) { lRet = (LRESULT) hbr; pwndDlg->ProcessedEraseBk(TRUE); MsgHandled(ptm); } } } } else { // If we're talking to a control, forward to the control handler // because we have to offset the brush lRet = OnDdpCtlColor(pwnd, ptm ); } } return lRet; } //-------------------------------------------------------------------------// LRESULT CALLBACK OnDwpPrintClient( CThemeWnd* pwnd, THEME_MSG *ptm ) { PrintClientNotHandled(*pwnd); return 0; } //---- Non-Client ---- //-------------------------------------------------------------------------// // WM_NCPAINT pre-wndmproc msg handler LRESULT CALLBACK OnOwpPreNcPaint( CThemeWnd* pwnd, THEME_MSG *ptm ) { NcPaintWindow_Add(*pwnd); if( !pwnd->InNcPaint() ) { pwnd->ClearRenderedNcPart(RNCF_ALL); } pwnd->EnterNcPaint(); return 0L; } //-------------------------------------------------------------------------// // WM_NCPAINT DefWindowProc msg handler LRESULT CALLBACK OnDwpNcPaint( CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = 0L; if( !pwnd->IsNcThemed() ) return lRet; if( IsWindowVisible(*pwnd) ) { pwnd->NcPaint( NULL, NCPF_DEFAULT, 1 == ptm->wParam ? NULL : (HRGN)ptm->wParam, NULL ); } MsgHandled( ptm ); return lRet; } //-------------------------------------------------------------------------// // WM_NCPAINT post-wndmproc msg handler LRESULT CALLBACK OnOwpPostNcPaint( CThemeWnd* pwnd, THEME_MSG *ptm ) { pwnd->LeaveNcPaint(); NcPaintWindow_Remove(); return 0L; } //-------------------------------------------------------------------------// // WM_PRINT DefWindowProc msg handler LRESULT CALLBACK OnDwpPrint( CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = DoMsgDefault(ptm); if( !pwnd->IsNcThemed() ) return lRet; if( ptm->lParam & PRF_NONCLIENT ) { int iLayoutSave = GDI_ERROR; HDC hdc = (HDC)ptm->wParam; if (TESTFLAG(GetWindowLong(*pwnd, GWL_EXSTYLE), WS_EX_LAYOUTRTL)) { // AnimateWindow sends WM_PRINT with an unmirrored memory hdc iLayoutSave = SetLayout(hdc, LAYOUT_RTL); } pwnd->NcPaint( (HDC)ptm->wParam, NCPF_DEFAULT, NULL, NULL ); if (iLayoutSave != GDI_ERROR) { SetLayout(hdc, iLayoutSave); } } return lRet; } //-------------------------------------------------------------------------// // WM_NCUAHDRAWCAPTION DefWindowProc msg handler LRESULT CALLBACK OnDwpNcThemeDrawCaption( CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = 0L; if( !pwnd->IsNcThemed() || !pwnd->HasRenderedNcPart(RNCF_CAPTION) ) return lRet; NCWNDMET* pncwm; if( pwnd->GetNcWindowMetrics( NULL, &pncwm, NULL, NCWMF_RECOMPUTE ) ) { HDC hdc = _GetNonclientDC( *pwnd, NULL ); if( hdc ) { DTBGOPTS dtbo; dtbo.dwSize = sizeof(dtbo); dtbo.dwFlags = DTBG_DRAWSOLID; pwnd->NcPaintCaption( hdc, pncwm, TRUE, (DWORD)ptm->wParam, &dtbo ); ReleaseDC( *pwnd, hdc ); MsgHandled( ptm ); } } return lRet; } //-------------------------------------------------------------------------// // WM_NCUAHDRAWFRAME DefWindowProc msg handler LRESULT CALLBACK OnDwpNcThemeDrawFrame( CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = 0L; if( !pwnd->IsNcThemed() || !pwnd->HasRenderedNcPart(RNCF_FRAME) ) return lRet; pwnd->NcPaint( (HDC)ptm->wParam, ptm->lParam & DF_ACTIVE ? NCPF_ACTIVEFRAME : NCPF_INACTIVEFRAME, NULL, NULL ); MsgHandled( ptm ); return lRet; } //-------------------------------------------------------------------------// CMdiBtns* CThemeWnd::LoadMdiBtns( IN OPTIONAL HDC hdc, IN OPTIONAL UINT uSysCmd ) { if( NULL == _pMdiBtns && NULL == (_pMdiBtns = new CMdiBtns) ) { return NULL; } return _pMdiBtns->Load( _hTheme, hdc, uSysCmd ) ? _pMdiBtns : NULL; } //-------------------------------------------------------------------------// void CThemeWnd::UnloadMdiBtns( IN OPTIONAL UINT uSysCmd ) { SAFE_DELETE(_pMdiBtns); } //-------------------------------------------------------------------------// // WM_MEASUREITEM pre-wndproc msg handler LRESULT CALLBACK OnOwpPreMeasureItem( CThemeWnd* pwnd, THEME_MSG *ptm ) { if( pwnd->IsNcThemed() && IsWindow(pwnd->GetMDIClient()) ) { MEASUREITEMSTRUCT* pmis = (MEASUREITEMSTRUCT*)ptm->lParam; CMdiBtns* pBtns = pwnd->LoadMdiBtns( NULL, pmis->itemID ); if( pBtns ) { if( pBtns->Measure( *pwnd, pmis ) ) { MsgHandled(ptm); return TRUE; } } } return FALSE; } //-------------------------------------------------------------------------// // WM_DRAWITEM pre-wndproc msg handler LRESULT CALLBACK OnOwpPreDrawItem( CThemeWnd* pwnd, THEME_MSG *ptm ) { if( pwnd->IsNcThemed() && IsWindow(pwnd->GetMDIClient()) ) { DRAWITEMSTRUCT* pdis = (DRAWITEMSTRUCT*)ptm->lParam; CMdiBtns* pBtns = pwnd->LoadMdiBtns( NULL, pdis->itemID ); if( pBtns ) { if( pBtns->Draw( *pwnd, pdis ) ) { MsgHandled(ptm); return TRUE; } } } return FALSE; } //-------------------------------------------------------------------------// // WM_MENUCHAR pre-wndproc msg handler LRESULT CALLBACK OnOwpPreMenuChar( CThemeWnd* pwnd, THEME_MSG *ptm ) { // Route MENUCHAR messages relating to themed MDI buttons to // DefWindowProc (some apps assume all owner-drawn menuitems // belong to themselves). HWND hwndMDIClient = pwnd->GetMDIClient(); if( pwnd->IsNcThemed() && IsWindow(hwndMDIClient)) { if( LOWORD(ptm->wParam) == TEXT('-') ) { BOOL fMaxedChild; HWND hwndActive = _MDIGetActive(hwndMDIClient, &fMaxedChild ); if( hwndActive && fMaxedChild ) { MsgHandled(ptm); return DefFrameProc(ptm->hwnd, hwndMDIClient, ptm->uMsg, ptm->wParam, ptm->lParam); } } } return 0L; } //-------------------------------------------------------------------------// // WM_NCHITTEST DefWindowProc msg handler LRESULT CALLBACK OnDwpNcHitTest( CThemeWnd* pwnd, THEME_MSG *ptm ) { if( !pwnd->IsNcThemed() ) return DoMsgDefault( ptm ); NCTHEMEMET nctm; NCWNDMET* pncwm; POINT pt; MAKEPOINT( pt, ptm->lParam ); MsgHandled( ptm ); if( pwnd->GetNcWindowMetrics( NULL, &pncwm, &nctm, 0 ) ) { if( _StrictPtInRect( &pncwm->rcS0[NCRC_CLIENT], pt ) ) return HTCLIENT; if( _StrictPtInRect( &pncwm->rcS0[NCRC_HSCROLL], pt ) ) return HTHSCROLL; if( _StrictPtInRect( &pncwm->rcS0[NCRC_SIZEBOX], pt ) ) { if (SizeBoxHwnd(*pwnd) && !TESTFLAG(pncwm->dwExStyle, WS_EX_LEFTSCROLLBAR)) { return TESTFLAG(pncwm->dwExStyle, WS_EX_LAYOUTRTL) ? HTBOTTOMLEFT : HTBOTTOMRIGHT; } else { return HTGROWBOX; } } if ( TESTFLAG(pncwm->dwExStyle, WS_EX_LAYOUTRTL) ) { // mirror the point to hittest correctly MIRROR_POINT(pncwm->rcS0[NCRC_WINDOW], pt); } if( _StrictPtInRect( &pncwm->rcS0[NCRC_VSCROLL], pt ) ) return HTVSCROLL; if( _StrictPtInRect( &pncwm->rcS0[NCRC_MENUBAR], pt ) ) return HTMENU; if( pncwm->fFrame ) { RECT rcButton; // ---- close button ---- _GetNcBtnHitTestRect( pncwm, HTCLOSE, FALSE, &rcButton ); if ( _StrictPtInRect( &rcButton, pt ) ) { return HTCLOSE; } // ---- minimize button ---- _GetNcBtnHitTestRect( pncwm, HTMINBUTTON, FALSE, &rcButton ); if ( _StrictPtInRect( &rcButton, pt ) ) { return HTMINBUTTON; } // ---- maximize button ---- _GetNcBtnHitTestRect( pncwm, HTMAXBUTTON, FALSE, &rcButton ); if ( _StrictPtInRect( &rcButton, pt ) ) { return HTMAXBUTTON; } // ---- sys menu ---- _GetNcBtnHitTestRect( pncwm, HTSYSMENU, FALSE, &rcButton ); if ( _StrictPtInRect( &rcButton, pt ) ) { return HTSYSMENU; } // ---- help button ---- _GetNcBtnHitTestRect( pncwm, HTHELP, FALSE, &rcButton ); if ( _StrictPtInRect( &rcButton, pt ) ) { return HTHELP; } #ifdef LAME_BUTTON if ( TESTFLAG(pncwm->dwExStyle, WS_EX_LAMEBUTTON) ) { if ( _StrictPtInRect( &pncwm->rcS0[NCRC_LAMEBTN], pt ) ) return HTLAMEBUTTON; } #endif // LAME_BUTTON // don't need a mirrored point for the remaining hittests MAKEPOINT( pt, ptm->lParam ); if( !_StrictPtInRect( &pncwm->rcS0[NCRC_CONTENT], pt ) ) { if( pncwm->fMin || pncwm->fMaxed ) { if( _StrictPtInRect( &pncwm->rcS0[NCRC_CAPTION], pt ) ) return HTCAPTION; } //---- combined caption/frame case ---- return pwnd->NcBackgroundHitTest( pt, &pncwm->rcS0[NCRC_WINDOW], pncwm->dwStyle, pncwm->dwExStyle, pncwm->framestate, pncwm->rgframeparts, pncwm->rgsizehitparts, pncwm->rcS0 + NCRC_FRAMEFIRST ); } } } return DoMsgDefault( ptm ); } //-------------------------------------------------------------------------// // WM_WINDOWPOSCHANGING pre-wndproc override handler LRESULT CALLBACK OnOwpPreWindowPosChanging( CThemeWnd* pwnd, THEME_MSG *ptm ) { if( pwnd->IsFrameThemed() ) { // Suppress WM_WINDOWPOSCHANGING from being sent to wndproc if it // was generated by us calling SetWindowRgn. // Many apps (e.g. Adobe Acrobat Reader, Photoshop dialogs, etc) that handle // WM_NCCALCSIZE, WM_WINDOWPOSCHANGING and/or WM_WINDOWPOSCHANGED are not // reentrant on their handlers for these messages, and therefore botch the // recursion induced by our SetWindowRgn call when we post-process // WM_WINDOWPOSCHANGED. // There is no reason that a theme-complient wndproc should ever know that // it's window(s) host a region managed by the system. if( pwnd->AssigningFrameRgn() ) { MsgHandled(ptm); return DefWindowProc(ptm->hwnd, ptm->uMsg, ptm->wParam, ptm->lParam); } } return 0L; } //-------------------------------------------------------------------------// // WM_WINDOWPOSCHANGED pre-wndproc override handler LRESULT CALLBACK OnOwpPreWindowPosChanged( CThemeWnd* pwnd, THEME_MSG *ptm ) { if( pwnd->IsFrameThemed() ) { // Suppress WM_WINDOWPOSCHANGING from being sent to wndproc if it // was generated by us calling SetWindowRgn. // Many apps (e.g. Adobe Acrobat Reader, Photoshop dialogs, etc) that handle // WM_NCCALCSIZE, WM_WINDOWPOSCHANGING and/or WM_WINDOWPOSCHANGED are not // reentrant on their handlers for these messages, and therefore botch the // recursion induced by our SetWindowRgn call when we post-process // WM_WINDOWPOSCHANGED. // There is no reason that a theme-complient wndproc should ever know that // it's window(s) host a region managed by the system. if( pwnd->AssigningFrameRgn() ) { MsgHandled(ptm); return DefWindowProc(ptm->hwnd, ptm->uMsg, ptm->wParam, ptm->lParam); } } return 0L; } //-------------------------------------------------------------------------// // WM_WINDOWPOSCHANGED message handler inline LRESULT WindowPosChangedWorker( CThemeWnd* pwnd, THEME_MSG *ptm ) { if( pwnd->IsRevoked(RF_DEFER) ) { if( !pwnd->IsRevoked(RF_INREVOKE) ) { pwnd->Revoke(); // don't touch PWND after this! } } else if( pwnd->IsNcThemed() && !IsWindowInDestroy(*pwnd) ) { // If were not resizing, update the window region. if( pwnd->IsFrameThemed() ) { NCWNDMET* pncwm = NULL; NCTHEMEMET nctm = {0}; // Freshen per-window metrics if( !pwnd->AssigningFrameRgn() ) { WINDOWPOS *pWndPos = (WINDOWPOS*) ptm->lParam; // Freshen this window's per-window metrics pwnd->GetNcWindowMetrics( NULL, &pncwm, &nctm, NCWMF_RECOMPUTE ); // Freshen window metrics for nc-themed children (e.g., MDI child frames) EnumChildWindows( *pwnd, _FreshenThemeMetricsCB, NULL ); if( !TESTFLAG(pWndPos->flags, SWP_NOSIZE) || pwnd->DirtyFrameRgn() || TESTFLAG(pWndPos->flags, SWP_FRAMECHANGED) ) { if( pWndPos->cx > 0 && pWndPos->cy > 0 ) { pwnd->AssignFrameRgn( TRUE, FTF_REDRAW ); } } } } _MDIUpdate( *pwnd, ((WINDOWPOS*) ptm->lParam)->flags); } return 0L; } //-------------------------------------------------------------------------// // WM_WINDOWPOSCHANGED post-wndproc override handler // // Note: we'll handle this post-wndproc for normal, client-side wndprocs LRESULT CALLBACK OnOwpPostWindowPosChanged( CThemeWnd* pwnd, THEME_MSG *ptm ) { if( !IsServerSideWindow(ptm->hwnd) ) { return WindowPosChangedWorker( pwnd, ptm ); } return 0L; } //-------------------------------------------------------------------------// // WM_WINDOWPOSCHANGED DefWindowProc override handler. // // Note: we'll handle this in DefWindowProc only for windows with win32k-based // wndprocs, which are deprived of OWP callbacks. LRESULT CALLBACK OnDwpWindowPosChanged( CThemeWnd* pwnd, THEME_MSG *ptm ) { if( IsServerSideWindow(ptm->hwnd) ) { WindowPosChangedWorker( pwnd, ptm ); } return 0L; } //-------------------------------------------------------------------------// // WM_NACTIVATE DefWindowProc msg handler LRESULT CALLBACK OnDwpNcActivate( CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = 1L; if( pwnd->IsNcThemed() ) { // We need to forward on. The DWP remembers the state // and MFC apps (for one) need this as well // but we don't want to actually paint, so lock the window ptm->lParam = (LPARAM)-1; lRet = DoMsgDefault(ptm); pwnd->NcPaint( NULL, ptm->wParam ? NCPF_ACTIVEFRAME : NCPF_INACTIVEFRAME, NULL, NULL ); MsgHandled(ptm); } return lRet; } //-------------------------------------------------------------------------// BOOL CThemeWnd::ShouldTrackFrameButton( UINT uHitcode ) { switch(uHitcode) { case HTHELP: return TESTFLAG(_ncwm.dwExStyle, WS_EX_CONTEXTHELP); case HTMAXBUTTON: if( !TESTFLAG(_ncwm.dwStyle, WS_MAXIMIZEBOX) || (CBS_DISABLED == _ncwm.rawMaxBtnState && FS_ACTIVE == _ncwm.framestate) ) { break; } return TRUE; case HTMINBUTTON: if( !TESTFLAG(_ncwm.dwStyle, WS_MINIMIZEBOX) || (CBS_DISABLED == _ncwm.rawMinBtnState && FS_ACTIVE == _ncwm.framestate) ) { break; } return TRUE; case HTCLOSE: if( !_MNCanClose(_hwnd) || (CBS_DISABLED == _ncwm.rawCloseBtnState && FS_ACTIVE == _ncwm.framestate) ) { break; } return TRUE; case HTSYSMENU: return TESTFLAG(_ncwm.dwStyle, WS_SYSMENU); } return FALSE; } //-------------------------------------------------------------------------// // WM_NCLBUTTONDOWN DefWindowProc msg handler LRESULT CALLBACK OnDwpNcLButtonDown( CThemeWnd* pwnd, THEME_MSG *ptm ) { WPARAM uSysCmd = 0; MsgHandled( ptm ); switch( ptm->wParam /* hittest code */ ) { case HTHELP: case HTMAXBUTTON: case HTMINBUTTON: case HTCLOSE: case HTSYSMENU: if( pwnd->ShouldTrackFrameButton(ptm->wParam) ) { if( pwnd->HasRenderedNcPart(RNCF_CAPTION) ) { POINT pt; MAKEPOINT( pt, ptm->lParam ); if( !pwnd->TrackFrameButton( *pwnd, (int)ptm->wParam, &uSysCmd ) ) { return DoMsgDefault( ptm ); } } else { return DoMsgDefault( ptm ); } } break; case HTHSCROLL: case HTVSCROLL: if( pwnd->HasRenderedNcPart(RNCF_SCROLLBAR) ) { uSysCmd = ptm->wParam | ((ptm->wParam == HTVSCROLL) ? SC_HSCROLL:SC_VSCROLL); break; } // fall thru default: return DoMsgDefault( ptm ); } // TODO USER will ignore system command if it is disabled on system menu here, // don't know why. Imitating the code caused standard min/max/close buttons to // render so be careful. if( uSysCmd != 0 ) { SendMessage( *pwnd, WM_SYSCOMMAND, uSysCmd, ptm->lParam ); } return 0L; } //-------------------------------------------------------------------------// // WM_NCMOUSEMOVE DefWindowProc msg handler LRESULT CALLBACK OnDwpNcMouseMove(CThemeWnd* pwnd, THEME_MSG *ptm) { LRESULT lRet = DoMsgDefault(ptm); int htHotLast = pwnd->GetNcHotItem(); int htHot; // // If the mouse has just entered the NC area, request // that we be notified when it leaves. // if (htHotLast == HTERROR) { TRACKMOUSEEVENT tme; tme.cbSize = sizeof(tme); tme.dwFlags = TME_LEAVE | TME_NONCLIENT; tme.hwndTrack = *pwnd; tme.dwHoverTime = 0; TrackMouseEvent(&tme); } // // Filter out the NC elements we don't care about hottracking. And only // track the element if we've previously rendered it. Some apps handle // painting non-client elements by handling ncpaint. They may not expect // that we now hottrack. // if ( (IsHTFrameButton(ptm->wParam) && pwnd->HasRenderedNcPart(RNCF_CAPTION) && pwnd->ShouldTrackFrameButton(ptm->wParam)) || (IsHTScrollBar(ptm->wParam) && pwnd->HasRenderedNcPart(RNCF_SCROLLBAR)) ) { htHot = (int)ptm->wParam; } else { htHot = HTNOWHERE; } // // anything to do? // if ((htHot != htHotLast) || IsHTScrollBar(htHot) || IsHTScrollBar(htHotLast)) { POINT pt; MAKEPOINT( pt, ptm->lParam ); // // save the hittest code of the NC element the mouse is // currently over // pwnd->SetNcHotItem(htHot); // // Determine what should be repainted because the mouse // is no longer over it // if ( IsHTFrameButton(htHotLast) && pwnd->HasRenderedNcPart(RNCF_CAPTION) ) { pwnd->TrackFrameButton(*pwnd, htHotLast, NULL, TRUE); } else if ( IsHTScrollBar(htHotLast) && pwnd->HasRenderedNcPart(RNCF_SCROLLBAR) ) { ScrollBar_MouseMove(*pwnd, (htHot == htHotLast) ? &pt : NULL, (htHotLast == HTVSCROLL) ? TRUE : FALSE); } // // Determine what should be repainted because the mouse // is now over it // if ( IsHTFrameButton(htHot) && pwnd->HasRenderedNcPart(RNCF_CAPTION) ) { pwnd->TrackFrameButton(*pwnd, htHot, NULL, TRUE); } else if ( IsHTScrollBar(htHot) && pwnd->HasRenderedNcPart(RNCF_SCROLLBAR) ) { ScrollBar_MouseMove(*pwnd, &pt, (htHot == HTVSCROLL) ? TRUE : FALSE); } } return lRet; } //-------------------------------------------------------------------------// // WM_NCMOUSELEAVE DefWindowProc msg handler LRESULT CALLBACK OnDwpNcMouseLeave(CThemeWnd* pwnd, THEME_MSG *ptm) { LRESULT lRet = DoMsgDefault(ptm); int htHot = pwnd->GetNcHotItem(); // // the mouse has left NC area, nothing should be drawn in the // hot state anymore // pwnd->SetNcHotItem(HTERROR); if ( IsHTFrameButton(htHot) && pwnd->ShouldTrackFrameButton(htHot) && pwnd->HasRenderedNcPart(RNCF_CAPTION) ) { pwnd->TrackFrameButton(*pwnd, htHot, NULL, TRUE); } else if ( IsHTScrollBar(htHot) && pwnd->HasRenderedNcPart(RNCF_SCROLLBAR) ) { ScrollBar_MouseMove(*pwnd, NULL, (htHot == HTVSCROLL) ? TRUE : FALSE); } return lRet; } //-------------------------------------------------------------------------// // WM_CONTEXTMENU DefWindowProc msg handler LRESULT CALLBACK OnDwpContextMenu(CThemeWnd* pwnd, THEME_MSG *ptm) { NCWNDMET* pncwm; POINT pt; MAKEPOINT( pt, ptm->lParam ); MsgHandled( ptm ); if( pwnd->GetNcWindowMetrics( NULL, &pncwm, NULL, 0 ) ) { if ( TESTFLAG(pncwm->dwExStyle, WS_EX_LAYOUTRTL) ) { // mirror the point to hittest correctly MIRROR_POINT(pncwm->rcS0[NCRC_WINDOW], pt); } if( _StrictPtInRect( &pncwm->rcS0[NCRC_HSCROLL], pt ) ) { ScrollBar_Menu(*pwnd, *pwnd, ptm->lParam, FALSE); return 0; } if( _StrictPtInRect( &pncwm->rcS0[NCRC_VSCROLL], pt ) ) { ScrollBar_Menu(*pwnd, *pwnd, ptm->lParam, TRUE); return 0; } } return DoMsgDefault( ptm ); } //-------------------------------------------------------------------------// // WM_SYSCOMMAND DefWindowProc msg handler LRESULT CALLBACK OnDwpSysCommand( CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = 0L; switch( ptm->wParam & ~0x0F ) { // Handle scroll commands case SC_VSCROLL: case SC_HSCROLL: HandleScrollCmd( *pwnd, ptm->wParam, ptm->lParam ); MsgHandled( ptm ); return lRet; } return DoMsgDefault( ptm ); } //-------------------------------------------------------------------------// // MDI menubar button theme/untheme wrapper void CThemeWnd::ThemeMDIMenuButtons( BOOL fTheme, BOOL fRedraw ) { // Verify we're an MDI frame with a maximized mdi child if( _hwndMDIClient && !IsWindowInDestroy(_hwndMDIClient) ) { BOOL fMaxed = FALSE; HWND hwndActive = _MDIGetActive( _hwndMDIClient, &fMaxed ); if( hwndActive && fMaxed ) { ModifyMDIMenubar(fTheme, fRedraw ); } } } //-------------------------------------------------------------------------// // MDI menubar button theme/untheme worker void CThemeWnd::ModifyMDIMenubar( BOOL fTheme, BOOL fRedraw ) { _fThemedMDIBtns = FALSE; if( IsFrameThemed() || !fTheme ) { MENUBARINFO mbi; mbi.cbSize = sizeof(mbi); if( GetMenuBarInfo( _hwnd, OBJID_MENU, 0, &mbi ) ) { _NcTraceMsg( NCTF_MDIBUTTONS, TEXT("ModifyMDIMenubar: GetMenuBarInfo() returns hMenu: %08lX, hwndMenu: %08lX"), mbi.hMenu, mbi.hwndMenu ); int cItems = GetMenuItemCount( mbi.hMenu ); int cThemedItems = 0; int cRedraw = 0; _NcTraceMsg( NCTF_MDIBUTTONS, TEXT("ModifyMDIMenubar: on entry, GetMenuItemCount(hMenu = %08lX) returns %d"), mbi.hMenu, cItems ); if( cItems > 0 ) { for( int i = cItems - 1; i >= 0 && cThemedItems < MDIBTNCOUNT; i-- ) { MENUITEMINFO mii; mii.cbSize = sizeof(mii); mii.fMask = MIIM_ID|MIIM_STATE|MIIM_FTYPE|MIIM_BITMAP; if( GetMenuItemInfo( mbi.hMenu, i, TRUE, &mii ) ) { _NcTraceMsg( NCTF_MDIBUTTONS, TEXT("GetMenuItemInfo by pos (%d) returns ID %04lX"), i, mii.wID ); switch( mii.wID ) { case SC_RESTORE: case SC_MINIMIZE: case SC_CLOSE: { BOOL fThemed = TESTFLAG(mii.fType, MFT_OWNERDRAW); if( (fThemed && fTheme) || (fThemed == fTheme) ) { cThemedItems = MDIBTNCOUNT; // one item is already done, assume all to be. } else { CMdiBtns* pBtns = LoadMdiBtns( NULL, mii.wID ); if( pBtns ) { if( pBtns->ThemeItem( mbi.hMenu, i, &mii, fTheme ) ) { cThemedItems++; cRedraw++; _NcTraceMsg( NCTF_MDIBUTTONS, TEXT("ModifyMDIMenubar: on entry, GetMenuItemCount(hMenu = %08lX) returns %d"), mbi.hMenu, GetMenuItemCount(mbi.hMenu) ); } } } break; } } } } } if( cThemedItems ) { _fThemedMDIBtns = fTheme; if( fRedraw && cRedraw ) { DrawMenuBar( _hwnd ); } } _NcTraceMsg( NCTF_MDIBUTTONS, TEXT("ModifyMDIMenubar: Modified %d menu items, exiting"), cThemedItems ); } } } //-------------------------------------------------------------------------// BOOL CThemeWnd::_PreDefWindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plRet ) { if (uMsg == WM_PRINTCLIENT) { PrintClientNotHandled(hwnd); } return FALSE; } //-------------------------------------------------------------------------// BOOL CThemeWnd::_PostDlgProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plRet ) { switch( uMsg ) { case WM_PRINTCLIENT: { PrintClientNotHandled(hwnd); } break; } return FALSE; } //-------------------------------------------------------------------------// // Handles Defwindowproc post-processing for unthemed windows. BOOL CThemeWnd::_PostWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plRet ) { switch( uMsg ) { // Special-case WM_SYSCOMMAND for MDI frame window updates case WM_WINDOWPOSCHANGED: if( lParam /* don't trust this */) { _MDIUpdate( hwnd, ((WINDOWPOS*) lParam)->flags); } break; case WM_MDISETMENU: { HWND hwndActive = _MDIGetActive(hwnd); if( hwndActive ) _MDIChildUpdateParent( hwndActive, TRUE ); break; } } return FALSE; } //-------------------------------------------------------------------------// // WM_CREATE post-wndproc msg handler LRESULT CALLBACK OnOwpPostCreate( CThemeWnd* pwnd, THEME_MSG *ptm ) { if( -1 != ptm->lRet ) { if( pwnd->TestCF( TWCF_FRAME|TWCF_TOOLFRAME )) { DWORD dwFTFlags = FTF_CREATE; CREATESTRUCT* pcs = (CREATESTRUCT*)ptm->lParam; if( pcs ) { // don't resize dialogs until post-WM_INITDIALOG if( pwnd->TestCF(TWCF_DIALOG) ) { dwFTFlags |= FTF_NOMODIFYPLACEMENT; } pwnd->SetFrameTheme( dwFTFlags, NULL ); MsgHandled(ptm); } } } return 0L; } //--------------------------------------------------------------------------- // WM_INITDIALOG post defdialogproc handler LRESULT CALLBACK OnDdpPostInitDialog(CThemeWnd* pwnd, THEME_MSG* ptm) { LRESULT lRet = ptm->lRet; // Do this sequence for dialogs only if( pwnd->TestCF( TWCF_DIALOG ) && pwnd->TestCF( TWCF_FRAME|TWCF_TOOLFRAME ) ) { DWORD dwFTFlags = FTF_CREATE; pwnd->SetFrameTheme( dwFTFlags, NULL ); MsgHandled(ptm); } return lRet; } //-------------------------------------------------------------------------// // WM_STYLECHANGING/WM_SYTLECHANGED Pre DefWindowProc msg handler LRESULT CALLBACK OnOwpPreStyleChange( CThemeWnd* pwnd, THEME_MSG *ptm ) { // Allow this message to arrive at detination WndProc? if ( pwnd->SuppressingStyleMsgs() ) { MsgHandled(ptm); return DefWindowProc(ptm->hwnd, ptm->uMsg, ptm->wParam, ptm->lParam); } return 0L; } //-------------------------------------------------------------------------// // WM_SYTLECHANGED DefWindowProc msg handler LRESULT CALLBACK OnDwpStyleChanged( CThemeWnd* pwnd, THEME_MSG *ptm ) { pwnd->StyleChanged((UINT)ptm->wParam, ((STYLESTRUCT*)ptm->lParam)->styleOld, ((STYLESTRUCT*)ptm->lParam)->styleNew ); return 0L; } //-------------------------------------------------------------------------// // WM_SETTINGCHANGE post-wndproc handler LRESULT CALLBACK OnOwpPostSettingChange( CThemeWnd* pwnd, THEME_MSG *ptm ) { /*ignore theme setting change process refresh*/ if( SPI_SETNONCLIENTMETRICS == ptm->wParam && !pwnd->InThemeSettingChange() ) { // recompute per-theme metrics. EnterCriticalSection( &_csThemeMet ); // force refresh of NONCLIENTMETRICS cache. NcGetNonclientMetrics( NULL, TRUE ); LeaveCriticalSection( &_csThemeMet ); pwnd->UnloadMdiBtns(); // recycle frame icon handle; current one is no longer valid. pwnd->AcquireFrameIcon( GetWindowLong(*pwnd, GWL_STYLE), GetWindowLong(*pwnd, GWL_EXSTYLE), TRUE ); // frame windows should be invalidated. if( pwnd->IsFrameThemed() ) { SetWindowPos( *pwnd, NULL, 0,0,0,0, SWP_DRAWFRAME| SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE ); } } return 0L; } //-------------------------------------------------------------------------// // WM_SETTEXT DefWindowProc msg handler LRESULT CALLBACK OnDwpSetText( CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = 0L; if( pwnd->IsFrameThemed() ) { // prevent ourselves from painting as we call on RealDefWindowProc() // to cache the new window text. pwnd->LockRedraw( TRUE ); lRet = DoMsgDefault(ptm); pwnd->LockRedraw( FALSE ); } return lRet; } //-------------------------------------------------------------------------// // WM_SETICON DefWindowProc msg handler LRESULT CALLBACK OnDwpSetIcon( CThemeWnd* pwnd, THEME_MSG *ptm ) { LRESULT lRet = 0L; // invalidate our app icon handle, force re-acquire. pwnd->SetFrameIcon(NULL); // call on RealDefWindowProc to cache the icon lRet = DoMsgDefault( ptm ); // RealDefWindowProc won't call send a WM_NCUAHDRAWCAPTION for large icons if( ICON_BIG == ptm->wParam && pwnd->IsFrameThemed() ) { NCWNDMET* pncwm; if( pwnd->GetNcWindowMetrics( NULL, &pncwm, NULL, NCWMF_RECOMPUTE ) ) { HDC hdc = _GetNonclientDC( *pwnd, NULL ); if( hdc ) { DTBGOPTS dtbo; dtbo.dwSize = sizeof(dtbo); dtbo.dwFlags = DTBG_DRAWSOLID; pwnd->NcPaintCaption( hdc, pncwm, TRUE, (DWORD)DC_ICON, &dtbo ); ReleaseDC( *pwnd, hdc ); } } } return lRet; } //-------------------------------------------------------------------------// #define NCPREV_CLASS TEXT("NCPreviewFakeWindow") //-------------------------------------------------------------------------// BOOL _fPreviewSysMetrics = FALSE; //-------------------------------------------------------------------------// void _NcSetPreviewMetrics( BOOL fPreview ) { BOOL fPrev = _fPreviewSysMetrics; _fPreviewSysMetrics = fPreview; if( fPreview != fPrev ) { // make sure we reset button metrics if something has changed _fClassicNcBtnMetricsReset = TRUE; } } //-------------------------------------------------------------------------// inline BOOL _NcUsingPreviewMetrics() { return _fPreviewSysMetrics; } //-------------------------------------------------------------------------// BOOL NcGetNonclientMetrics( OUT OPTIONAL NONCLIENTMETRICS* pncm, BOOL fRefresh ) { BOOL fRet = FALSE; CInternalNonclientMetrics *pincm = NULL; EnterCriticalSection( &_csNcSysMet ); // Feed off a static instance of NONCLIENTMETRICS to reduce call overhead. if( _NcUsingPreviewMetrics() ) { // hand off preview metrics and get out. pincm = &_incmPreview; } else { if( _incmCurrent.Acquire( fRefresh ) ) { pincm = &_incmCurrent; } } if( pincm ) { if( pncm ) { *pncm = pincm->GetNcm(); } fRet = TRUE; } LeaveCriticalSection( &_csNcSysMet ); return fRet; } //-------------------------------------------------------------------------// HFONT NcGetCaptionFont( BOOL fSmallCaption ) { EnterCriticalSection( &_csNcSysMet ); HFONT hf = _NcUsingPreviewMetrics() ? _incmPreview.GetFont( fSmallCaption ) : _incmCurrent.GetFont( fSmallCaption ); LeaveCriticalSection( &_csNcSysMet ); return hf; } //-------------------------------------------------------------------------// void NcClearNonclientMetrics() { _incmCurrent.Clear(); } //-------------------------------------------------------------------------// int NcGetSystemMetrics(int nIndex) { if( _NcUsingPreviewMetrics() ) { int iValue; const NONCLIENTMETRICS& ncmPreview = _incmPreview.GetNcm(); switch (nIndex) { case SM_CXHSCROLL: // fall through case SM_CXVSCROLL: iValue = ncmPreview.iScrollWidth; break; case SM_CYHSCROLL: // fall through case SM_CYVSCROLL: iValue = ncmPreview.iScrollHeight; break; case SM_CXSIZE: iValue = ncmPreview.iCaptionWidth; break; case SM_CYSIZE: iValue = ncmPreview.iCaptionHeight; break; case SM_CYCAPTION: iValue = ncmPreview.iCaptionHeight + 1; break; case SM_CXSMSIZE: iValue = ncmPreview.iSmCaptionWidth; break; case SM_CYSMSIZE: iValue = ncmPreview.iSmCaptionHeight; break; case SM_CXMENUSIZE: iValue = ncmPreview.iMenuWidth; break; case SM_CYMENUSIZE: iValue = ncmPreview.iMenuHeight; break; default: iValue = ClassicGetSystemMetrics(nIndex); break; } return iValue; } else { return ClassicGetSystemMetrics(nIndex); } } //-------------------------------------------------------------------------// // _InternalGetSystemMetrics() - Themed implementation of GetSystemMetrics(). // int _InternalGetSystemMetrics( int iMetric, BOOL& fHandled ) { int iRet = 0; int* plSysMet = NULL; NCTHEMEMET nctm; switch( iMetric ) { case SM_CXSIZE: plSysMet = &nctm.theme_sysmets.cxBtn; break; case SM_CXSMSIZE: plSysMet = &nctm.theme_sysmets.cxSmBtn; break; } if( plSysMet && GetCurrentNcThemeMetrics( &nctm ) && nctm.hTheme != NULL && nctm.theme_sysmets.fValid ) { iRet = *plSysMet; fHandled = TRUE; /*was missing (doh! - 408190)*/ } return iRet; } //-------------------------------------------------------------------------// // _InternalSystemParametersInfo() - Themed implementation of SystemParametersInfo(). // // return value of FALSE interpreted by caller as not handled. BOOL _InternalSystemParametersInfo( IN UINT uiAction, IN UINT uiParam, IN OUT PVOID pvParam, IN UINT fWinIni, IN BOOL fUnicode, BOOL& fHandled ) { SYSTEMPARAMETERSINFO pfnDefault = fUnicode ? ClassicSystemParametersInfoW : ClassicSystemParametersInfoA;\ BOOL fRet = pfnDefault( uiAction, uiParam, pvParam, fWinIni ); fHandled = TRUE; if( SPI_GETNONCLIENTMETRICS == uiAction && fRet ) { NCTHEMEMET nctm; if( GetCurrentNcThemeMetrics( &nctm ) && nctm.hTheme != NULL && nctm.theme_sysmets.fValid ) { NONCLIENTMETRICS* pncm = (NONCLIENTMETRICS*)pvParam; pncm->iCaptionWidth = nctm.theme_sysmets.cxBtn; } } return fRet; } //-------------------------------------------------------------------------// THEMEAPI DrawNCWindow(CThemeWnd* pThemeWnd, HWND hwndFake, HDC hdc, DWORD dwFlags, LPRECT prc, NONCLIENTMETRICS* pncm, COLORREF* prgb) { // Build up Overide structure NCPAINTOVERIDE ncpo; pThemeWnd->GetNcWindowMetrics( prc, &ncpo.pncwm, &ncpo.nctm, NCWMF_RECOMPUTE|NCWMF_PREVIEW ); // Force window to look active if (dwFlags & NCPREV_ACTIVEWINDOW) { ncpo.pncwm->framestate = FS_ACTIVE; ncpo.pncwm->rawCloseBtnState = ncpo.pncwm->rawMaxBtnState = ncpo.pncwm->rawMinBtnState = CBS_NORMAL; } ncpo.pncwm->rgbCaption = prgb[FS_ACTIVE == ncpo.pncwm->framestate ? COLOR_CAPTIONTEXT : COLOR_INACTIVECAPTIONTEXT]; ncpo.pncwm->dwStyle &= ~WS_SIZEBOX; // Paint the beautiful visual styled window pThemeWnd->NcPaint(hdc, NCPF_DEFAULT, NULL, &ncpo); COLORREF rgbBk = prgb[(dwFlags & NCPREV_MESSAGEBOX) ? COLOR_3DFACE : COLOR_WINDOW]; HBRUSH hbrBack = CreateSolidBrush(rgbBk); FillRect(hdc, &ncpo.pncwm->rcW0[NCRC_CLIENT], hbrBack); DeleteObject(hbrBack); WCHAR szText[MAX_PATH]; // Draw client area HFONT hfont = CreateFont(-MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72), 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, L"MS Shell Dlg"); if (hfont) { if (dwFlags & NCPREV_MESSAGEBOX) { HTHEME htheme = OpenThemeData( hwndFake, L"Button" ); int offsetX = ((ncpo.pncwm->rcW0[NCRC_CLIENT].right + ncpo.pncwm->rcW0[NCRC_CLIENT].left) / 2) - 40; int offsetY = ((ncpo.pncwm->rcW0[NCRC_CLIENT].bottom + ncpo.pncwm->rcW0[NCRC_CLIENT].top) / 2) - 15; RECT rcButton = { offsetX, offsetY, offsetX + 80, offsetY + 30 }; NcDrawThemeBackground(htheme, hdc, BP_PUSHBUTTON, PBS_DEFAULTED, &rcButton, 0); RECT rcContent; GetThemeBackgroundContentRect(htheme, hdc, BP_PUSHBUTTON, PBS_DEFAULTED, &rcButton, &rcContent); LoadString(g_hInst, IDS_OKBUTTON, szText, ARRAYSIZE(szText)); if (szText[0]) { HFONT hfontOld = (HFONT)SelectObject(hdc, hfont); DrawThemeText(htheme, hdc, BP_PUSHBUTTON, PBS_DEFAULTED, szText, lstrlen(szText), DT_CENTER | DT_VCENTER | DT_SINGLELINE, 0, &rcContent); SelectObject(hdc, hfontOld); } CloseThemeData(htheme); } else if (dwFlags & NCPREV_ACTIVEWINDOW) { HTHEME htheme = OpenThemeData( hwndFake, L"Button" ); RECT rcButton = ncpo.pncwm->rcW0[NCRC_CLIENT]; LoadString(g_hInst, IDS_WINDOWTEXT, szText, ARRAYSIZE(szText)); if (szText[0]) { HFONT hfontOld = (HFONT)SelectObject(hdc, hfont); DTTOPTS DttOpts = {sizeof(DttOpts)}; DttOpts.dwFlags = DTT_TEXTCOLOR; DttOpts.crText = prgb[COLOR_WINDOWTEXT]; DrawThemeTextEx(htheme, hdc, BP_PUSHBUTTON, PBS_DEFAULTED, szText, lstrlen(szText), DT_SINGLELINE, &rcButton, &DttOpts); SelectObject(hdc, hfontOld); } CloseThemeData(htheme); } } DeleteObject(hfont); ClearNcThemeMetrics(&ncpo.nctm); return S_OK; } //-------------------------------------------------------------------------// THEMEAPI DrawNCPreview(HDC hdc, DWORD dwFlags, LPRECT prc, LPCWSTR pszVSPath, LPCWSTR pszVSColor, LPCWSTR pszVSSize, NONCLIENTMETRICS* pncm, COLORREF* prgb) { WNDCLASS wc; // Create a fake Window and attach NC themeing to it if (!GetClassInfo(g_hInst, NCPREV_CLASS, &wc)) { wc.style = 0; wc.lpfnWndProc = DefWindowProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = g_hInst; wc.hIcon = NULL; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)(COLOR_3DFACE+1); wc.lpszMenuName = NULL; wc.lpszClassName = NCPREV_CLASS; if (!RegisterClass(&wc)) return FALSE; } _incmPreview = *pncm; _incmPreview._fPreview = TRUE; _NcSetPreviewMetrics( TRUE ); DWORD dwExStyle = WS_EX_DLGMODALFRAME | ((dwFlags & NCPREV_RTL) ? WS_EX_RTLREADING : 0); HWND hwndFake = CreateWindowEx(dwExStyle, NCPREV_CLASS, L"", 0, 0, 0, RECTWIDTH(prc), RECTHEIGHT(prc), NULL, NULL, g_hInst, NULL); if (hwndFake) { HTHEMEFILE htFile = NULL; WCHAR szCurVSPath[MAX_PATH]; WCHAR szCurVSColor[MAX_PATH]; WCHAR szCurVSSize[MAX_PATH]; GetCurrentThemeName(szCurVSPath, ARRAYSIZE(szCurVSPath), szCurVSColor, ARRAYSIZE(szCurVSColor), szCurVSSize, ARRAYSIZE(szCurVSSize)); if ((lstrcmp(szCurVSPath, pszVSPath) != 0) || (lstrcmp(szCurVSColor, pszVSColor) != 0) || (lstrcmp(szCurVSSize, pszVSSize) != 0)) { HRESULT hr = OpenThemeFile(pszVSPath, pszVSColor, pszVSSize, &htFile, FALSE); if (SUCCEEDED(hr)) { //---- first, detach from the normal theme ---- CThemeWnd::Detach(hwndFake, FALSE); //---- apply the preview theme ---- hr = ApplyTheme(htFile, 0, hwndFake); } } //---- attach to the preview theme ---- CThemeWnd* pThemeWnd = CThemeWnd::Attach(hwndFake); if (VALID_THEMEWND(pThemeWnd)) { struct { DWORD dwNcPrev; UINT uIDStr; DWORD dwFlags; RECT rc; } fakeWindow[]= { {NCPREV_INACTIVEWINDOW, IDS_INACTIVEWINDOW, 0, { prc->left, prc->top, prc->right - 17, prc->bottom - 20 }}, {NCPREV_ACTIVEWINDOW, IDS_ACTIVEWINDOW, NCPREV_ACTIVEWINDOW, { prc->left + 10, prc->top + 22, prc->right, prc->bottom }}, {NCPREV_MESSAGEBOX, IDS_MESSAGEBOX, NCPREV_ACTIVEWINDOW | NCPREV_MESSAGEBOX, { prc->left + (RECTWIDTH(prc)/2) - 75, prc->top + (RECTHEIGHT(prc)/2) - 50 + 22, prc->left + (RECTWIDTH(prc)/2) + 75, prc->top + (RECTHEIGHT(prc)/2) + 50 + 22}}}; WCHAR szWindowName[MAX_PATH]; for (int i = 0; i < ARRAYSIZE(fakeWindow); i++) { if (dwFlags & fakeWindow[i].dwNcPrev) { LoadString(g_hInst, fakeWindow[i].uIDStr, szWindowName, ARRAYSIZE(szWindowName)); SetWindowText(hwndFake, szWindowName); if (fakeWindow[i].dwNcPrev & NCPREV_MESSAGEBOX) { SetWindowLongPtr(hwndFake, GWL_STYLE, WS_TILED | WS_CAPTION | WS_SYSMENU); } else { SetWindowLongPtr(hwndFake, GWL_STYLE, WS_TILEDWINDOW | WS_VSCROLL); } DrawNCWindow(pThemeWnd, hwndFake, hdc, fakeWindow[i].dwFlags, &fakeWindow[i].rc, pncm, prgb); } } // Clean Up CThemeWnd::Detach(hwndFake, 0); } if (htFile) { CloseThemeFile(htFile); //---- clear the preview hold on the theme file ---- ApplyTheme(NULL, 0, hwndFake); } DestroyWindow(hwndFake); } _NcSetPreviewMetrics( FALSE ); _incmPreview.Clear(); return S_OK; } //-------------------------------------------------------------------------// // CMdiBtns impl //-------------------------------------------------------------------------// //-------------------------------------------------------------------------// // ctor CMdiBtns::CMdiBtns() { ZeroMemory( _rgBtns, sizeof(_rgBtns) ); _rgBtns[0].wID = SC_CLOSE; _rgBtns[1].wID = SC_RESTORE; _rgBtns[2].wID = SC_MINIMIZE; } //-------------------------------------------------------------------------// // Helper: button lookup based on syscmd ID. CMdiBtns::MDIBTN* CMdiBtns::_FindBtn( UINT wID ) { for( int i = 0; i < ARRAYSIZE(_rgBtns); i++ ) { if( wID == _rgBtns[i].wID ) { return (_rgBtns + i); } } return NULL; } //-------------------------------------------------------------------------// // Acquires MDI button resources,.computes metrics BOOL CMdiBtns::Load( HTHEME hTheme, IN OPTIONAL HDC hdc, UINT uSysCmd ) { // if caller wants all buttons loaded, call recursively. if( 0 == uSysCmd ) { return Load( hTheme, hdc, SC_CLOSE ) && Load( hTheme, hdc, SC_RESTORE ) && Load( hTheme, hdc, SC_MINIMIZE ); } MDIBTN* pBtn = _FindBtn( uSysCmd ); if( pBtn && !VALID_WINDOWPART(pBtn->iPartId) /*only if necessary*/ ) { // select appropriate window part WINDOWPARTS iPartId = BOGUS_WINDOWPART; switch( uSysCmd ) { case SC_CLOSE: iPartId = WP_MDICLOSEBUTTON; break; case SC_RESTORE: iPartId = WP_MDIRESTOREBUTTON; break; case SC_MINIMIZE: iPartId = WP_MDIMINBUTTON; break; } if( VALID_WINDOWPART(iPartId) ) { if( IsThemePartDefined( hTheme, iPartId, 0) ) { // Retrieve sizing type, defaulting to 'stretch'. if( FAILED( GetThemeInt( hTheme, iPartId, 0, TMT_SIZINGTYPE, (int*)&pBtn->sizingType ) ) ) { pBtn->sizingType = ST_STRETCH; } // if 'truesize', retrieve the size. if( ST_TRUESIZE == pBtn->sizingType ) { // If no DC provided, base size on screen DC of default monitor. HDC hdcSize = hdc; if( NULL == hdcSize ) { hdcSize = GetDC(NULL); } if( FAILED( GetThemePartSize( hTheme, hdc, iPartId, 0, NULL, TS_TRUE, &pBtn->size ) ) ) { pBtn->sizingType = ST_STRETCH; } if( hdcSize != hdc ) { ReleaseDC(NULL, hdcSize); } } // not 'truesize'; use system metrics for MDI buttons if( pBtn->sizingType != ST_TRUESIZE ) { pBtn->size.cx = NcGetSystemMetrics( SM_CXMENUSIZE ); pBtn->size.cy = NcGetSystemMetrics( SM_CYMENUSIZE ); } // assign button attributes pBtn->iPartId = iPartId; } } } return pBtn != NULL && VALID_WINDOWPART(pBtn->iPartId); } //-------------------------------------------------------------------------// // Releases MDI button resources,.resets metrics void CMdiBtns::Unload( IN OPTIONAL UINT uSysCmd ) { // if caller wants all buttons unloaded, call recursively. if( 0 == uSysCmd ) { Unload( SC_CLOSE ); Unload( SC_RESTORE ); Unload( SC_MINIMIZE ); return; } MDIBTN* pBtn = _FindBtn( uSysCmd ); if( pBtn ) { SAFE_DELETE_GDIOBJ(pBtn->hbmTheme); ZeroMemory(pBtn, sizeof(*pBtn)); // restore our zeroed syscommand value pBtn->wID = uSysCmd; } } //-------------------------------------------------------------------------// // Theme/untheme MDI frame menubar's Minimize, Restore, Close menu items. BOOL CMdiBtns::ThemeItem( HMENU hMenu, int iPos, MENUITEMINFO* pmii, BOOL fTheme ) { // To theme, we simply make the item owner draw. To untheme, // we restore it to system-drawn. BOOL fRet = FALSE; MDIBTN* pBtn = _FindBtn( pmii->wID ); if( pBtn && pmii && hMenu ) { if( fTheme ) { // save off previous menuitem type, bitmap pBtn->fTypePrev = pmii->fType; pBtn->hbmPrev = pmii->hbmpItem; pmii->fType &= ~MFT_BITMAP; pmii->fType |= MFT_OWNERDRAW|MFT_RIGHTJUSTIFY; pmii->hbmpItem = NULL; } else { // restore menuitem type, bitmap pmii->fType = pBtn->fTypePrev|MFT_RIGHTJUSTIFY /*409042 - force right-justify on the way out*/; pmii->hbmpItem = pBtn->hbmPrev; } pmii->fMask = MIIM_FTYPE; fRet = SetMenuItemInfo( hMenu, iPos, TRUE, pmii ); if( !fRet || !fTheme ) { pBtn->fTypePrev = 0; pBtn->hbmPrev = NULL; } } return fRet; } //-------------------------------------------------------------------------// // Computes button state identifier from Win32 owner draw state CLOSEBUTTONSTATES CMdiBtns::_CalcState( ULONG ulOwnerDrawAction, ULONG ulOwnerDrawState ) { CLOSEBUTTONSTATES iStateId = CBS_NORMAL; if( TESTFLAG(ulOwnerDrawState, ODS_DISABLED|ODS_GRAYED|ODS_INACTIVE) ) { iStateId = CBS_DISABLED; } else if( TESTFLAG(ulOwnerDrawState, ODS_SELECTED) ) { iStateId = CBS_PUSHED; } else if( TESTFLAG(ulOwnerDrawState, ODS_HOTLIGHT) ) { iStateId = CBS_HOT; } return iStateId; } //-------------------------------------------------------------------------// // MDI sys button WM_DRAWITEM handler BOOL CMdiBtns::Measure( HTHEME hTheme, MEASUREITEMSTRUCT* pmis ) { MDIBTN* pBtn = _FindBtn( pmis->itemID ); if( pBtn && VALID_WINDOWPART(pBtn->iPartId) ) { pmis->itemWidth = pBtn->size.cx; pmis->itemHeight = pBtn->size.cy; return TRUE; } return FALSE; } //-------------------------------------------------------------------------// // MDI sys button WM_DRAWITEM handler BOOL CMdiBtns::Draw( HTHEME hTheme, DRAWITEMSTRUCT* pdis ) { MDIBTN* pBtn = _FindBtn( pdis->itemID ); if( pBtn && VALID_WINDOWPART(pBtn->iPartId) ) { return SUCCEEDED(NcDrawThemeBackground( hTheme, pdis->hDC, pBtn->iPartId, _CalcState( pdis->itemAction, pdis->itemState ), &pdis->rcItem, 0 )); } return FALSE; } //-------------------------------------------------------------------------//// // "Comments?" link in caption bar, known as the PHellyar (lame) button //-------------------------------------------------------------------------// #ifdef LAME_BUTTON //-------------------------------------------------------------------------// WCHAR g_szLameText[50] = {0}; //-------------------------------------------------------------------------// #define SZ_LAMETEXT_SUBKEY TEXT("Control Panel\\Desktop") #define SZ_LAMETEXT_VALUE TEXT("LameButtonText") #define SZ_LAMETEXT_DEFAULT TEXT("Comments?") #define CLR_LAMETEXT RGB(91, 171, 245) //-------------------------------------------------------------------------// void InitLameText() { CCurrentUser hkeyCurrentUser(KEY_READ); HKEY hkLame; HRESULT hr = E_FAIL; if ( RegOpenKeyEx(hkeyCurrentUser, SZ_LAMETEXT_SUBKEY, 0, KEY_QUERY_VALUE, &hkLame) == ERROR_SUCCESS ) { hr = RegistryStrRead(hkLame, SZ_LAMETEXT_VALUE, g_szLameText, ARRAYSIZE(g_szLameText)); RegCloseKey(hkLame); } if ( FAILED(hr) ) { lstrcpy(g_szLameText, SZ_LAMETEXT_DEFAULT); } } //-------------------------------------------------------------------------// VOID CThemeWnd::InitLameResources() { // // Using GetWindowInfo here bc GetWindowLong masks // out the WS_EX_LAMEBUTTON bit. // SAFE_DELETE_GDIOBJ(_hFontLame); WINDOWINFO wi = {0}; wi.cbSize = sizeof(wi); if ( GetWindowInfo(_hwnd, &wi) && TESTFLAG(wi.dwExStyle, WS_EX_LAMEBUTTON) ) { SIZE sizeLame; HFONT hfCaption = NcGetCaptionFont(TESTFLAG(wi.dwExStyle, WS_EX_TOOLWINDOW)); if( hfCaption != NULL ) { LOGFONT lfLame; if( GetObject( hfCaption, sizeof(lfLame), &lfLame ) ) { lfLame.lfHeight -= (lfLame.lfHeight > 0) ? 2 : -2; lfLame.lfUnderline = TRUE; lfLame.lfWeight = FW_THIN; HFONT hFontLame = CreateFontIndirect(&lfLame); if ( hFontLame != NULL ) { HDC hdc = GetWindowDC(_hwnd); if ( hdc != NULL ) { SelectObject(hdc, hFontLame); if (GetTextExtentPoint32(hdc, g_szLameText, lstrlen(g_szLameText), &sizeLame)) { _hFontLame = hFontLame; hFontLame = NULL; // don't free at end of this function _sizeLame = sizeLame; } ReleaseDC(_hwnd, hdc); } } if (hFontLame) // didn't assign this font DeleteObject(hFontLame); } } } } //-------------------------------------------------------------------------// VOID CThemeWnd::ClearLameResources() { SAFE_DELETE_GDIOBJ(_hFontLame); ZeroMemory( &_sizeLame, sizeof(_sizeLame) ); } //-------------------------------------------------------------------------// inline VOID CThemeWnd::DrawLameButton(HDC hdc, IN const NCWNDMET* pncwm) { if ( TESTFLAG(pncwm->dwExStyle, WS_EX_LAMEBUTTON) && _hFontLame ) { Log(LOG_RFBUG, L"DrawLameButton; _hFontLame=0x%x", _hFontLame); HFONT hFontSave = (HFONT)SelectObject(hdc, _hFontLame); COLORREF clrSave = SetTextColor(hdc, CLR_LAMETEXT); DrawText(hdc, g_szLameText, lstrlen(g_szLameText), (LPRECT)&pncwm->rcW0[NCRC_LAMEBTN], DT_LEFT | DT_SINGLELINE); SetTextColor(hdc, clrSave); SelectObject(hdc, hFontSave); } } //-------------------------------------------------------------------------// VOID CThemeWnd::GetLameButtonMetrics( NCWNDMET* pncwm, const SIZE* psizeCaption ) { if( TESTFLAG(pncwm->dwExStyle, WS_EX_LAMEBUTTON) && _hFontLame ) { BOOL fLameOn; RECT rcCaptionText = pncwm->rcS0[NCRC_CAPTIONTEXT]; RECT* prcButton = &pncwm->rcS0[NCRC_LAMEBTN]; int cxPad = NcGetSystemMetrics(SM_CXEDGE) * 2; // Enough room to draw the lame button link? fLameOn = RECTWIDTH(&rcCaptionText) > psizeCaption->cx + cxPad + // between caption, lame text _sizeLame.cx + cxPad; // between lame text, nearest button; //---- compute lame button alignment ---- BOOL fReverse = TRUE; // normally, lame goes on right side //---- WS_EX_RIGHT wants the opposite ---- if (TESTFLAG(_ncwm.dwExStyle, WS_EX_RIGHT)) fReverse = FALSE; DWORD dwFlags = GetTextAlignFlags(_hTheme, &_ncwm, fReverse); //---- turn off lame button for center captions ---- if (dwFlags & DT_CENTER) fLameOn = FALSE; if ( fLameOn ) { CopyRect(prcButton, &rcCaptionText); //---- note: pMargins already includes the theme specified ---- //---- CaptionMargins (which scale with DPI) and the ---- //---- icon and buttons widths ---- if(dwFlags & DT_RIGHT) // put lame on right { prcButton->left = (prcButton->right - _sizeLame.cx) - cxPad ; //---- adjust margins to remove lame area ---- pncwm->CaptionMargins.cxRightWidth -= _sizeLame.cx; } else // put lame on left { prcButton->right = (prcButton->left + _sizeLame.cx) + cxPad; //---- adjust margins to remove lame area ---- pncwm->CaptionMargins.cxLeftWidth += _sizeLame.cx; } // vertically center the text between margins prcButton->top += (RECTHEIGHT(&rcCaptionText) - _sizeLame.cy)/2; prcButton->bottom = prcButton->top + _sizeLame.cy; } } } #endif // LAME_BUTTON #ifdef DEBUG //-------------------------------------------------------------------------// void CDECL _NcTraceMsg( ULONG uFlags, LPCTSTR pszFmt, ...) { if( TESTFLAG(_NcTraceFlags, uFlags) || NCTF_ALWAYS == uFlags ) { va_list args; va_start(args, pszFmt); TCHAR szSpew[2048]; wvsprintf(szSpew, pszFmt, args); OutputDebugString(szSpew); OutputDebugString(TEXT("\n")); va_end(args); } } //-------------------------------------------------------------------------// void INIT_THEMEWND_DBG( CThemeWnd* pwnd ) { if( IsWindow( *pwnd ) ) { GetWindowText( *pwnd, pwnd->_szCaption, ARRAYSIZE(pwnd->_szCaption) ); GetClassName( *pwnd, pwnd->_szWndClass, ARRAYSIZE(pwnd->_szWndClass) ); } } //-------------------------------------------------------------------------// void CThemeWnd::Spew( DWORD dwSpewFlags, LPCTSTR pszFmt, LPCTSTR pszClassList ) { if( pszClassList && *pszClassList ) { if( !_tcsstr( pszClassList, _szWndClass ) ) return; } TCHAR szInfo[MAX_PATH*2]; TCHAR szMsg[MAX_PATH*2]; wsprintf( szInfo, TEXT("%08lX -'%s' ('%s') cf: %08lX"), _hwnd, _szCaption, _szWndClass, _fClassFlags ); wsprintf( szMsg, pszFmt, szInfo ); Log(LOG_NCATTACH, szMsg ); } typedef struct { DWORD dwProcessId; DWORD dwThreadId; DWORD dwSpewFlags; LPCTSTR pszFmt; LPCTSTR pszClassList; } SPEW_ALL; //-------------------------------------------------------------------------// BOOL _SpewAllEnumCB( HWND hwnd, LPARAM lParam ) { SPEW_ALL* psa = (SPEW_ALL*)lParam; if( IsWindowProcess( hwnd, psa->dwProcessId ) ) { CThemeWnd* pwnd = CThemeWnd::FromHwnd( hwnd ); if( VALID_THEMEWND(pwnd) ) pwnd->Spew( psa->dwSpewFlags, psa->pszFmt ); } return TRUE; } //-------------------------------------------------------------------------// void CThemeWnd::SpewAll( DWORD dwSpewFlags, LPCTSTR pszFmt, LPCTSTR pszClassList ) { SPEW_ALL sa; sa.dwThreadId = GetCurrentThreadId(); sa.dwProcessId = GetCurrentProcessId(); sa.dwSpewFlags = dwSpewFlags; sa.pszFmt = pszFmt; sa.pszClassList = pszClassList; //---- this will enum all windows for this process (all desktops, all child levels) ---- EnumProcessWindows( _SpewAllEnumCB, (LPARAM)&sa ); } //-------------------------------------------------------------------------// void CThemeWnd::SpewLeaks() { if( _cObj > 0 ) { Log(LOG_NCATTACH, L"LEAK WARNING: %d CThemeWnd instances outstanding.", _cObj ); } } //-------------------------------------------------------------------------// void SPEW_RECT( ULONG ulTrace, LPCTSTR pszMsg, LPCRECT prc ) { LPCTSTR pszFmt = TEXT("%s: {L:%d,T:%d,R:%d,B:%d}, (%d x %d)"); WCHAR szMsg[1024]; wsprintfW( szMsg, pszFmt, pszMsg, prc->left, prc->top, prc->right, prc->bottom, RECTWIDTH(prc), RECTHEIGHT(prc) ); _NcTraceMsg(ulTrace, szMsg); } //-------------------------------------------------------------------------// void SPEW_MARGINS( ULONG ulTrace, LPCTSTR pszMsg, LPCRECT prcParent, LPCRECT prcChild ) { LPCTSTR pszFmt = TEXT("%s: {L:%d,T:%d,R:%d,B:%d}"); WCHAR szMsg[1024]; wsprintfW( szMsg, pszFmt, pszMsg, prcChild->left - prcParent->left, prcChild->top - prcParent->top, prcParent->right - prcChild->right, prcParent->bottom - prcChild->bottom ); _NcTraceMsg(ulTrace, szMsg); } //-------------------------------------------------------------------------// void SPEW_RGNRECT( ULONG ulTrace, LPCTSTR pszMsg, HRGN hrgn, int iPartID ) { RECT rc; if( NULLREGION == GetRgnBox( hrgn, &rc ) ) FillMemory( &rc, sizeof(&rc), static_cast(-1) ); _NcTraceMsg( ulTrace, TEXT("Region %08lX for partID[%d]:\n\t"), hrgn, iPartID ); SPEW_RECT( ulTrace, pszMsg, &rc ); } //-------------------------------------------------------------------------// void SPEW_WINDOWINFO( ULONG ulTrace, WINDOWINFO* pwi ) { SPEW_RECT(ulTrace, TEXT("->wi.rcWindow"), &pwi->rcWindow ); SPEW_RECT(ulTrace, TEXT("->wi.rcClient"), &pwi->rcClient ); _NcTraceMsg(ulTrace, TEXT("->wi.dwStyle: %08lX"), pwi->dwStyle ); _NcTraceMsg(ulTrace, TEXT("->wi.dwExStyle: %08lX"), pwi->dwExStyle ); _NcTraceMsg(ulTrace, TEXT("->wi.dwWindowStatus: %08lX"), pwi->dwWindowStatus ); _NcTraceMsg(ulTrace, TEXT("->wi.cxWindowBorders: %d"), pwi->cxWindowBorders ); _NcTraceMsg(ulTrace, TEXT("->wi.cyWindowBorders: %d"), pwi->cyWindowBorders ); } //-------------------------------------------------------------------------// void SPEW_NCWNDMET( ULONG ulTrace, LPCTSTR pszMsg, NCWNDMET* pncwm ) { _NcTraceMsg(ulTrace, TEXT("\n%s - Spewing NCWNDMET @ %08lx..."), pszMsg, pncwm ); _NcTraceMsg(ulTrace, TEXT("->fValid: %d"), pncwm->fValid ); _NcTraceMsg(ulTrace, TEXT("->dwStyle: %08lX"), pncwm->dwStyle ); _NcTraceMsg(ulTrace, TEXT("->dwExStyle: %08lX"), pncwm->dwExStyle ); _NcTraceMsg(ulTrace, TEXT("->dwWindowStatus: %08lX"), pncwm->dwWindowStatus ); _NcTraceMsg(ulTrace, TEXT("->fFrame: %d"), pncwm->fFrame ); _NcTraceMsg(ulTrace, TEXT("->fSmallFrame: %d"), pncwm->fSmallFrame ); _NcTraceMsg(ulTrace, TEXT("->iFRAMEBOTTOM %d"), pncwm->rgframeparts[iFRAMEBOTTOM] ); _NcTraceMsg(ulTrace, TEXT("->iFRAMELEFT: %d"), pncwm->rgframeparts[iFRAMELEFT] ); _NcTraceMsg(ulTrace, TEXT("->iFRAMERIGHT: %d"), pncwm->rgframeparts[iFRAMERIGHT] ); _NcTraceMsg(ulTrace, TEXT("->framestate: %d"), pncwm->framestate ); _NcTraceMsg(ulTrace, TEXT("->iMinButtonPart: %d"), pncwm->iMinButtonPart); _NcTraceMsg(ulTrace, TEXT("->iMaxButtonPart: %d"), pncwm->iMaxButtonPart); _NcTraceMsg(ulTrace, TEXT("->rawCloseBtnState: %d"), pncwm->rawCloseBtnState); _NcTraceMsg(ulTrace, TEXT("->rawMinBtnState: %d"), pncwm->rawMinBtnState); _NcTraceMsg(ulTrace, TEXT("->rawMaxBtnState: %d"), pncwm->rawMaxBtnState); _NcTraceMsg(ulTrace, TEXT("->cyMenu: %d"), pncwm->cyMenu ); _NcTraceMsg(ulTrace, TEXT("->cnMenuOffsetLeft: %d"), pncwm->cnMenuOffsetLeft ); _NcTraceMsg(ulTrace, TEXT("->cnMenuOffsetRight: %d"), pncwm->cnMenuOffsetRight ); _NcTraceMsg(ulTrace, TEXT("->cnMenuOffsetTop: %d"), pncwm->cnMenuOffsetTop ); _NcTraceMsg(ulTrace, TEXT("->cnBorders: %d"), pncwm->cnBorders ); _NcTraceMsg(ulTrace, TEXT("->CaptionMargins: (%d,%d,%d,%d)"), pncwm->CaptionMargins ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_WINDOW] "), &pncwm->rcS0[NCRC_WINDOW] ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_CLIENT] "), &pncwm->rcS0[NCRC_CLIENT] ); SPEW_MARGINS(ulTrace, TEXT("Window-Client margins"), &pncwm->rcS0[NCRC_WINDOW], &pncwm->rcS0[NCRC_CLIENT] ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_CONTENT] "), &pncwm->rcS0[NCRC_CONTENT] ); SPEW_MARGINS(ulTrace, TEXT("Window-Content margins"), &pncwm->rcS0[NCRC_WINDOW], &pncwm->rcS0[NCRC_CONTENT]); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_MENUBAR] "), &pncwm->rcS0[NCRC_MENUBAR] ); SPEW_MARGINS(ulTrace, TEXT("Window-Menubar margins"), &pncwm->rcS0[NCRC_WINDOW], &pncwm->rcS0[NCRC_MENUBAR]); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_CAPTION] "), &pncwm->rcS0[NCRC_CAPTION] ); SPEW_MARGINS(ulTrace, TEXT("Window-Caption margins"), &pncwm->rcS0[NCRC_WINDOW], &pncwm->rcS0[NCRC_CAPTION]); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_FRAMELEFT] "), &pncwm->rcS0[NCRC_FRAMELEFT] ); SPEW_MARGINS(ulTrace, TEXT("Window-FrameLeft margins"), &pncwm->rcS0[NCRC_WINDOW], &pncwm->rcS0[NCRC_FRAMELEFT]); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_FRAMERIGHT]"), &pncwm->rcS0[NCRC_FRAMERIGHT] ); SPEW_MARGINS(ulTrace, TEXT("Window-FrameRight margins"), &pncwm->rcS0[NCRC_WINDOW], &pncwm->rcS0[NCRC_FRAMERIGHT]); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_FRAMEBOTTOM]"), &pncwm->rcS0[NCRC_FRAMEBOTTOM] ); SPEW_MARGINS(ulTrace, TEXT("Window-FrameBottom margins"), &pncwm->rcS0[NCRC_WINDOW], &pncwm->rcS0[NCRC_FRAMEBOTTOM]); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_CLIENTEDGE]"), &pncwm->rcS0[NCRC_CLIENTEDGE] ); SPEW_MARGINS(ulTrace, TEXT("Window-ClientEdge margins"), &pncwm->rcS0[NCRC_WINDOW], &pncwm->rcS0[NCRC_CLIENTEDGE]); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_HSCROLL] "), &pncwm->rcS0[NCRC_HSCROLL] ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_VSCROLL] "), &pncwm->rcS0[NCRC_VSCROLL] ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_SIZEBOX] "), &pncwm->rcS0[NCRC_SIZEBOX] ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_CLOSEBTN] "), &pncwm->rcS0[NCRC_CLOSEBTN] ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_MINBTN] "), &pncwm->rcS0[NCRC_MINBTN] ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_MAXBTN] "), &pncwm->rcS0[NCRC_MAXBTN] ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_SYSBTN] "), &pncwm->rcS0[NCRC_SYSBTN] ); SPEW_RECT(ulTrace, TEXT("->rcS0[NCRC_HELPBTN] "), &pncwm->rcS0[NCRC_HELPBTN] ); #ifdef LAME_BUTTON SPEW_RECT(ulTrace, TEXT("rcLame"), &pncwm->rcS0[NCRC_LAMEBTN] ); #endif // LAME_BUTTON } //-------------------------------------------------------------------------// void SPEW_THEMEMSG( ULONG ulTrace, LPCTSTR pszMsg, THEME_MSG* ptm ) { _NcTraceMsg(ulTrace, TEXT("%s hwnd: %08lX, uMsg: %04lX, handled?: %d"), pszMsg, (ptm)->hwnd, (ptm)->uMsg, (ptm)->fHandled ); } //-------------------------------------------------------------------------// void SPEW_SCROLLINFO( LPCTSTR pszMsg, HWND hwnd, LPCSCROLLINFO psi ) { #ifdef _ENABLE_SCROLL_SPEW_ _NcTraceMsg(ulTrace, L"%s for HWND %08lX...\ncbSize: %d\nfMask: %08lX\nnMin: %d\nnMax: %d\nnPage: %d\nnPos: %d", pszMsg, hwnd, psi->cbSize, psi->fMask, psi->nMin, psi->nMax, psi->nPage, psi->nPos ); #endif _ENABLE_SCROLL_SPEW_ } #if defined(DEBUG_NCPAINT) static int _cPaintSleep = 10; void _DebugBackground( HDC hdc, COLORREF rgb, const RECT *prc ) { // paint some indicator stuff COLORREF rgb0 = SetBkColor( hdc, rgb ); SPEW_RECT( NCTF_ALWAYS, TEXT("\tprc"), prc ); ExtTextOut( hdc, prc->left, prc->top, ETO_OPAQUE, prc, NULL, 0, NULL ); Sleep(_cPaintSleep); SetBkColor( hdc, rgb0 ); } //-------------------------------------------------------------------------// HRESULT _DebugDrawThemeBackground( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *prc, OPTIONAL const RECT* prcClip ) { if( TESTFLAG( _NcTraceFlags, NCTF_NCPAINT ) ) { _NcTraceMsg( NCTF_ALWAYS, TEXT("DrawThemeBackground( hTheme = %08lX, hdc = %08lX, iPartId = %d, iStateId = %d"), hTheme, hdc, iPartId, iStateId ); _DebugBackground( hdc, RGBDEBUGBKGND, prc ); } // paint the real background. HRESULT hr = DrawThemeBackground( hTheme, hdc, iPartId, iStateId, prc, prcClip ); if( TESTFLAG( _NcTraceFlags, NCTF_NCPAINT ) ) { Sleep(_cPaintSleep); } return hr; } //-------------------------------------------------------------------------// HRESULT _DebugDrawThemeBackgroundEx( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *prc, OPTIONAL const DTBGOPTS *pOptions ) { if( TESTFLAG( _NcTraceFlags, NCTF_NCPAINT ) ) { _NcTraceMsg( NCTF_ALWAYS, TEXT("DrawThemeBackground( hTheme = %08lX, hdc = %08lX, iPartId = %d, iStateId = %d"), hTheme, hdc, iPartId, iStateId ); _DebugBackground( hdc, RGBDEBUGBKGND, prc ); } // paint the real background. HRESULT hr = DrawThemeBackgroundEx( hTheme, hdc, iPartId, iStateId, prc, pOptions ); if( TESTFLAG( _NcTraceFlags, NCTF_NCPAINT ) ) { Sleep(_cPaintSleep); } return hr; } //-------------------------------------------------------------------------// void NcDebugClipRgn( HDC hdc, COLORREF rgbPaint ) { if( TESTFLAG( _NcTraceFlags, NCTF_NCPAINT ) ) { HRGN hrgn = CreateRectRgn(0,0,1,1); if( hrgn ) { if( GetClipRgn( hdc, hrgn ) > 0 ) { HBRUSH hbr = CreateSolidBrush(rgbPaint); FillRgn( hdc, hrgn, hbr ); DeleteObject(hbr); Sleep(_cPaintSleep); } DeleteObject(hrgn); } } } #endif //defined(DEBUG_NCPAINT) #endif DEBUG