src/thirdparty/mfc/afxglobals.cpp

   1 // This is a part of the Microsoft Foundation Classes C++ library.
   2 // Copyright (C) Microsoft Corporation
   3 // All rights reserved.
   4 //
   5 // This source code is only intended as a supplement to the
   6 // Microsoft Foundation Classes Reference and related
   7 // electronic documentation provided with the library.
   8 // See these sources for detailed information regarding the
   9 // Microsoft Foundation Classes product.
  10
  11 #include "stdafx.h"
  12 #include "comdef.h"
  13 // #include "afxcontrolbarutil.h"
  14 #include "afxglobals.h"
  15
  16 #pragma warning(disable:4995 4996)
  17
  18 #if defined(__INTEL_COMPILER)
  19 #pragma warning(disable:810)
  20 #endif
  21
  22 #if 0
  23 #include "afxvisualmanager.h"
  24 #include "afxkeyboardmanager.h"
  25 #include "afxmenuhash.h"
  26 #include "afxtoolbar.h"
  27 #include "afxmenuimages.h"
  28 #include "afxpaneframewnd.h"
  29 #include "afxdockingmanager.h"
  30 #include "afxvisualmanageroffice2007.h"
  31 #include "afxribbonres.h"
  32
  33 #include "afxframewndex.h"
  34 #include "afxmdiframewndex.h"
  35 #include "afxoleipframewndex.h"
  36 #include "afxoledocipframewndex.h"
  37 #include "afxmdichildwndex.h"
  38 #endif
  39
  40 extern CObList afxAllToolBars;
  41
  42 BOOL CMemDC::m_bUseMemoryDC = TRUE;
  43
  44 #if (_MSC_VER == 1700)
  45
  46 #define AFX_FONT_NAME_OFFICE       _T("Tahoma")
  47 #define AFX_FONT_NAME_OFFICE_2007  _T("Segoe UI")
  48 #define AFX_FONT_NAME_DEFAULT      _T("MS Sans Serif")
  49 #define AFX_FONT_NAME_VERT         _T("Arial")
  50 #define AFX_FONT_NAME_MARLETT      _T("Marlett")
  51
  52 CMemDC::CMemDC(CDC& dc, CWnd* pWnd) :
  53         m_dc(dc), m_bMemDC(FALSE), m_hBufferedPaint(NULL), m_pOldBmp(NULL)
  54 {
  55         ASSERT_VALID(pWnd);
  56
  57         pWnd->GetClientRect(m_rect);
  58
  59         m_rect.right += pWnd->GetScrollPos(SB_HORZ);
  60         m_rect.bottom += pWnd->GetScrollPos(SB_VERT);
  61
  62         HDC hdcPaint = NULL;
  63
  64         if (!GetGlobalData()->m_bBufferedPaintInited)
  65         {
  66                 BufferedPaintInit();
  67                 GetGlobalData()->m_bBufferedPaintInited = TRUE;
  68         }
  69
  70         m_hBufferedPaint = BeginBufferedPaint(dc.GetSafeHdc(), m_rect, BPBF_TOPDOWNDIB, NULL, &hdcPaint);
  71
  72         if (m_hBufferedPaint != NULL && hdcPaint != NULL)
  73         {
  74                 m_bMemDC = TRUE;
  75                 m_dcMem.Attach(hdcPaint);
  76         }
  77         }
  78
  79 CMemDC::CMemDC(CDC& dc, const CRect& rect) :
  80         m_dc(dc), m_bMemDC(FALSE), m_hBufferedPaint(NULL), m_pOldBmp(NULL), m_rect(rect)
  81 {
  82         ASSERT(!m_rect.IsRectEmpty());
  83
  84         HDC hdcPaint = NULL;
  85
  86         if (!GetGlobalData()->m_bBufferedPaintInited)
  87         {
  88                 BufferedPaintInit();
  89                 GetGlobalData()->m_bBufferedPaintInited = TRUE;
  90         }
  91
  92         m_hBufferedPaint = BeginBufferedPaint(dc.GetSafeHdc(), m_rect, BPBF_TOPDOWNDIB, NULL, &hdcPaint);
  93
  94         if (m_hBufferedPaint != NULL && hdcPaint != NULL)
  95         {
  96                 m_bMemDC = TRUE;
  97                 m_dcMem.Attach(hdcPaint);
  98         }
  99 }
 100
 101 CMemDC::~CMemDC()
 102 {
 103         if (m_hBufferedPaint != NULL)
 104         {
 105                 m_dcMem.Detach();
 106                 EndBufferedPaint(m_hBufferedPaint, TRUE);
 107         }
 108 }
 109
 110 static int CALLBACK FontFamilyProcFonts(const LOGFONT FAR* lplf, const TEXTMETRIC FAR* /*lptm*/, ULONG /*ulFontType*/, LPARAM lParam)
 111 {
 112         ENSURE(lplf != NULL);
 113         ENSURE(lParam != NULL);
 114
 115         CString strFont = lplf->lfFaceName;
 116         return strFont.CollateNoCase((LPCTSTR) lParam) == 0 ? 0 : 1;
 117 }
 118
 119 /////////////////////////////////////////////////////////////////////////////
 120 // Cached system metrics, etc
 121 AFX_GLOBAL_DATA afxGlobalData;
 122
 123 #ifdef _AFXDLL
 124 // Reference count on global data
 125 DWORD g_dwAfxGlobalDataRef = 0;
 126 #endif
 127
 128 AFX_GLOBAL_DATA::AFX_GLOBAL_DATA()
 129 {
 130         m_bInitialized = FALSE;
 131         m_bIsRibbonImageScale = TRUE;
 132
 133         // Cached system values(updated in CWnd::OnSysColorChange)
 134         hbrBtnShadow = NULL;
 135         hbrBtnHilite = NULL;
 136         hbrWindow = NULL;
 137
 138         m_hcurStretch = NULL;
 139         m_hcurStretchVert = NULL;
 140         m_hcurHand = NULL;
 141         m_hcurSizeAll = NULL;
 142         m_hiconTool = NULL;
 143         m_hiconLink = NULL;
 144         m_hiconColors = NULL;
 145         m_hcurMoveTab = NULL;
 146         m_hcurNoMoveTab = NULL;
 147
 148         m_bUseSystemFont = FALSE;
 149         m_bDontReduceFontHeight = FALSE;
 150         m_bInSettingChange = FALSE;
 151
 152         m_bIsRTL = FALSE;
 153         m_bBufferedPaintInited = FALSE;
 154
 155         m_nDragFrameThicknessFloat = 4;  // pixels
 156         m_nDragFrameThicknessDock = 3;   // pixels
 157
 158         m_nAutoHideToolBarSpacing = 14; // pixels
 159         m_nAutoHideToolBarMargin  = 4;  // pixels
 160
 161         m_nCoveredMainWndClientAreaPercent = 50; // percents
 162
 163         m_nMaxToolTipWidth = -1;
 164         m_bIsBlackHighContrast = FALSE;
 165         m_bIsWhiteHighContrast = FALSE;
 166
 167         m_bUseBuiltIn32BitIcons = TRUE;
 168
 169 #ifndef _AFXDLL
 170         Initialize();
 171 #endif
 172 }
 173
 174 // Initialization code
 175 void AFX_GLOBAL_DATA::Initialize()
 176 {
 177         if (m_bInitialized)
 178         {
 179                 return;
 180         }
 181
 182         OSVERSIONINFOEX osvi = { sizeof(osvi), HIBYTE(_WIN32_WINNT_WIN7), LOBYTE(_WIN32_WINNT_WIN7) };
 183
 184         // The condition mask specifies to test for the OS major/minor versions using greater than or equal.
 185         DWORDLONG const dwlConditionMask = VerSetConditionMask(VerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_MINORVERSION, VER_GREATER_EQUAL);
 186
 187         bIsWindows7 = VerifyVersionInfo(&osvi, VER_MAJORVERSION | VER_MINORVERSION, dwlConditionMask);
 188
 189         bIsRemoteSession = GetSystemMetrics(SM_REMOTESESSION);
 190
 191         UpdateSysColors();
 192         UpdateFonts();
 193         OnSettingChange();
 194         EnableAccessibilitySupport();
 195 }
 196
 197 AFX_GLOBAL_DATA::~AFX_GLOBAL_DATA()
 198 {
 199         CleanUp();
 200 }
 201
 202 void AFX_GLOBAL_DATA::UpdateFonts()
 203 {
 204         CWindowDC dc(NULL);
 205         m_dblRibbonImageScale = dc.GetDeviceCaps(LOGPIXELSX) / 96.0f;
 206
 207         if (m_dblRibbonImageScale > 1. && m_dblRibbonImageScale < 1.1)
 208         {
 209                 m_dblRibbonImageScale = 1.;
 210         }
 211
 212         if (fontRegular.GetSafeHandle() != NULL)
 213         {
 214                 ::DeleteObject(fontRegular.Detach());
 215         }
 216
 217         if (fontTooltip.GetSafeHandle() != NULL)
 218         {
 219                 ::DeleteObject(fontTooltip.Detach());
 220         }
 221
 222         if (fontBold.GetSafeHandle() != NULL)
 223         {
 224                 ::DeleteObject(fontBold.Detach());
 225         }
 226
 227         if (fontDefaultGUIBold.GetSafeHandle() != NULL)
 228         {
 229                 ::DeleteObject(fontDefaultGUIBold.Detach());
 230         }
 231
 232         if (fontUnderline.GetSafeHandle() != NULL)
 233         {
 234                 ::DeleteObject(fontUnderline.Detach());
 235         }
 236
 237         if (fontDefaultGUIUnderline.GetSafeHandle() != NULL)
 238         {
 239                 ::DeleteObject(fontDefaultGUIUnderline.Detach());
 240         }
 241
 242         if (fontVert.GetSafeHandle() != NULL)
 243         {
 244                 ::DeleteObject(fontVert.Detach());
 245         }
 246
 247         if (fontVertCaption.GetSafeHandle() != NULL)
 248         {
 249                 ::DeleteObject(fontVertCaption.Detach());
 250         }
 251
 252         if (fontMarlett.GetSafeHandle() != NULL)
 253         {
 254                 ::DeleteObject(fontMarlett.Detach());
 255         }
 256
 257         if (fontSmall.GetSafeHandle() != NULL)
 258         {
 259                 ::DeleteObject(fontSmall.Detach());
 260         }
 261
 262         // Initialize fonts:
 263
 264         NONCLIENTMETRICS info;
 265         info.cbSize = sizeof(info);
 266         GetNonClientMetrics (info);
 267
 268         LOGFONT lf;
 269         memset(&lf, 0, sizeof(LOGFONT));
 270
 271         lf.lfCharSet = (BYTE) GetTextCharsetInfo(dc.GetSafeHdc(), NULL, 0);
 272
 273         lf.lfHeight = info.lfMenuFont.lfHeight;
 274         lf.lfWeight = info.lfMenuFont.lfWeight;
 275         lf.lfItalic = info.lfMenuFont.lfItalic;
 276
 277         //------------------
 278         // Adjust font size:
 279         //------------------
 280         int nFontHeight = lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight;
 281         if (nFontHeight <= 12)
 282         {
 283                 nFontHeight = 11;
 284         }
 285         else if (!m_bDontReduceFontHeight)
 286         {
 287                 nFontHeight--;
 288         }
 289
 290         lf.lfHeight = (lf.lfHeight < 0) ? -nFontHeight : nFontHeight;
 291
 292         // Check if we should use system font
 293         lstrcpy(lf.lfFaceName, info.lfMenuFont.lfFaceName);
 294
 295         BOOL fUseSystemFont = m_bUseSystemFont || (info.lfMenuFont.lfCharSet > SYMBOL_CHARSET);
 296         if (!fUseSystemFont)
 297         {
 298                 // Check for "Segoe UI" or "Tahoma" font existance:
 299                 if (::EnumFontFamilies(dc.GetSafeHdc(), NULL, FontFamilyProcFonts, (LPARAM)(LPCTSTR) AFX_FONT_NAME_OFFICE_2007) == 0)
 300                 {
 301                         // Found! Use MS Office 2007 font!
 302                         lstrcpy(lf.lfFaceName, AFX_FONT_NAME_OFFICE_2007);
 303                         lf.lfQuality = 5 /*CLEARTYPE_QUALITY*/;
 304                 }
 305                 else if (::EnumFontFamilies(dc.GetSafeHdc(), NULL, FontFamilyProcFonts, (LPARAM)(LPCTSTR) AFX_FONT_NAME_OFFICE) == 0)
 306                 {
 307                         // Found! Use MS Office font!
 308                         lstrcpy(lf.lfFaceName, AFX_FONT_NAME_OFFICE);
 309                 }
 310                 else
 311                 {
 312                         // Not found. Use default font:
 313                         lstrcpy(lf.lfFaceName, AFX_FONT_NAME_DEFAULT);
 314                 }
 315         }
 316
 317         fontRegular.CreateFontIndirect(&lf);
 318
 319         // Create small font:
 320         LONG lfHeightSaved = lf.lfHeight;
 321
 322         lf.lfHeight = (long)((1. + abs(lf.lfHeight)) * 2 / 3);
 323         if (lfHeightSaved < 0)
 324         {
 325                 lf.lfHeight = -lf.lfHeight;
 326         }
 327
 328         fontSmall.CreateFontIndirect(&lf);
 329         lf.lfHeight = lfHeightSaved;
 330
 331         // Create tooltip font:
 332         NONCLIENTMETRICS ncm;
 333         ncm.cbSize = sizeof(ncm);
 334         GetNonClientMetrics (ncm);
 335
 336         lf.lfItalic = ncm.lfStatusFont.lfItalic;
 337         lf.lfWeight = ncm.lfStatusFont.lfWeight;
 338         fontTooltip.CreateFontIndirect(&lf);
 339
 340         lf.lfItalic = info.lfMenuFont.lfItalic;
 341         lf.lfWeight = info.lfMenuFont.lfWeight;
 342
 343         // Create "underline" font:
 344         lf.lfUnderline = TRUE;
 345         fontUnderline.CreateFontIndirect(&lf);
 346         lf.lfUnderline = FALSE;
 347
 348         // Create bold font:
 349         lf.lfWeight = FW_BOLD;
 350         fontBold.CreateFontIndirect(&lf);
 351
 352         // Create Marlett font:
 353         BYTE bCharSet = lf.lfCharSet;
 354         lf.lfWeight = info.lfMenuFont.lfWeight;
 355         lf.lfCharSet = SYMBOL_CHARSET;
 356         lf.lfWeight = 0;
 357         lf.lfHeight = ::GetSystemMetrics(SM_CYMENUCHECK) - 1;
 358         lstrcpy(lf.lfFaceName, AFX_FONT_NAME_MARLETT);
 359
 360         fontMarlett.CreateFontIndirect(&lf);
 361         lf.lfCharSet = bCharSet; // Restore charset
 362
 363         // Create vertical font:
 364         CFont font;
 365         if (font.CreateStockObject(DEFAULT_GUI_FONT))
 366         {
 367                 if (font.GetLogFont(&lf) != 0)
 368                 {
 369                         lf.lfOrientation = 900;
 370                         lf.lfEscapement = 2700;
 371
 372                         lf.lfHeight = info.lfMenuFont.lfHeight;
 373                         lf.lfWeight = info.lfMenuFont.lfWeight;
 374                         lf.lfItalic = info.lfMenuFont.lfItalic;
 375
 376                         {
 377                                 lstrcpy(lf.lfFaceName, AFX_FONT_NAME_VERT);
 378                         }
 379
 380                         fontVert.CreateFontIndirect(&lf);
 381
 382                         lf.lfEscapement = 900;
 383                         fontVertCaption.CreateFontIndirect(&lf);
 384                 }
 385         }
 386
 387         // Create dialog underline and bold fonts:
 388         CFont* pDefaultGUIFont = CFont::FromHandle((HFONT) GetStockObject(DEFAULT_GUI_FONT));
 389         ASSERT_VALID(pDefaultGUIFont);
 390         pDefaultGUIFont->GetLogFont(&lf);
 391
 392         lf.lfUnderline = TRUE;
 393         fontDefaultGUIUnderline.CreateFontIndirect(&lf);
 394         lf.lfUnderline = FALSE;
 395
 396         lf.lfWeight = FW_BOLD;
 397         fontDefaultGUIBold.CreateFontIndirect(&lf);
 398
 399         UpdateTextMetrics();
 400
 401 #if 0
 402         // Notify toolbars about font changing:
 403         for (POSITION posTlb = afxAllToolBars.GetHeadPosition(); posTlb != NULL;)
 404         {
 405                 CMFCToolBar* pToolBar = (CMFCToolBar*) afxAllToolBars.GetNext(posTlb);
 406                 ENSURE(pToolBar != NULL);
 407
 408                 if (CWnd::FromHandlePermanent(pToolBar->m_hWnd) != NULL)
 409                 {
 410                         ASSERT_VALID(pToolBar);
 411                         pToolBar->OnGlobalFontsChanged();
 412                 }
 413         }
 414 #endif
 415 }
 416
 417 static BOOL CALLBACK InfoEnumProc( HMONITOR hMonitor, HDC /*hdcMonitor*/, LPRECT /*lprcMonitor*/, LPARAM dwData)
 418 {
 419         CRect* pRect = (CRect*) dwData;
 420
 421         MONITORINFO mi;
 422         mi.cbSize = sizeof(MONITORINFO);
 423
 424         if (GetMonitorInfo(hMonitor, &mi))
 425         {
 426                 CRect rectMon = mi.rcWork;
 427
 428                 pRect->left = min(pRect->left, rectMon.left);
 429                 pRect->right = max(pRect->right, rectMon.right);
 430                 pRect->top = min(pRect->top, rectMon.top);
 431                 pRect->bottom = max(pRect->bottom, rectMon.bottom);
 432         }
 433
 434         return TRUE;
 435 }
 436
 437 void AFX_GLOBAL_DATA::OnSettingChange()
 438 {
 439         m_bInSettingChange = TRUE;
 440
 441         m_sizeSmallIcon.cx = ::GetSystemMetrics(SM_CXSMICON);
 442         m_sizeSmallIcon.cy = ::GetSystemMetrics(SM_CYSMICON);
 443
 444         m_rectVirtual.SetRectEmpty();
 445
 446         if (!EnumDisplayMonitors(NULL, NULL, InfoEnumProc, (LPARAM) &m_rectVirtual))
 447         {
 448                 ::SystemParametersInfo(SPI_GETWORKAREA, 0, &m_rectVirtual, 0);
 449         }
 450
 451         // Get system menu animation type:
 452         m_bMenuAnimation = FALSE;
 453         m_bMenuFadeEffect = FALSE;
 454
 455         if (!bIsRemoteSession)
 456         {
 457                 ::SystemParametersInfo(SPI_GETMENUANIMATION, 0, &m_bMenuAnimation, 0);
 458
 459                 if (m_bMenuAnimation)
 460                 {
 461                         ::SystemParametersInfo(SPI_GETMENUFADE, 0, &m_bMenuFadeEffect, 0);
 462                 }
 463         }
 464
 465         m_nShellAutohideBars = 0;
 466         m_bRefreshAutohideBars = TRUE;
 467
 468         ::SystemParametersInfo(SPI_GETMENUUNDERLINES, 0, &m_bSysUnderlineKeyboardShortcuts, 0);
 469         m_bUnderlineKeyboardShortcuts = m_bSysUnderlineKeyboardShortcuts;
 470
 471         m_bInSettingChange = FALSE;
 472 }
 473
 474 void AFX_GLOBAL_DATA::UpdateSysColors()
 475 {
 476         m_bIsBlackHighContrast = ::GetSysColor(COLOR_3DLIGHT) == RGB(255, 255, 255) && ::GetSysColor(COLOR_3DFACE) == RGB(0, 0, 0);
 477         m_bIsWhiteHighContrast = ::GetSysColor(COLOR_3DDKSHADOW) == RGB(0, 0, 0) && ::GetSysColor(COLOR_3DFACE) == RGB(255, 255, 255);
 478
 479         CWindowDC dc(NULL);
 480         m_nBitsPerPixel = dc.GetDeviceCaps(BITSPIXEL);
 481
 482         clrBarFace = clrBtnFace = ::GetSysColor(COLOR_BTNFACE);
 483         clrBarShadow = clrBtnShadow = ::GetSysColor(COLOR_BTNSHADOW);
 484         clrBarDkShadow = clrBtnDkShadow = ::GetSysColor(COLOR_3DDKSHADOW);
 485         clrBarLight = clrBtnLight = ::GetSysColor(COLOR_3DLIGHT);
 486         clrBarHilite = clrBtnHilite = ::GetSysColor(COLOR_BTNHIGHLIGHT);
 487         clrBarText = clrBtnText = ::GetSysColor(COLOR_BTNTEXT);
 488         clrGrayedText = ::GetSysColor(COLOR_GRAYTEXT);
 489         clrWindowFrame = ::GetSysColor(COLOR_WINDOWFRAME);
 490
 491         clrHilite = ::GetSysColor(COLOR_HIGHLIGHT);
 492         clrTextHilite = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
 493
 494         clrBarWindow = clrWindow = ::GetSysColor(COLOR_WINDOW);
 495         clrWindowText = ::GetSysColor(COLOR_WINDOWTEXT);
 496
 497         clrCaptionText = ::GetSysColor(COLOR_CAPTIONTEXT);
 498         clrMenuText = ::GetSysColor(COLOR_MENUTEXT);
 499
 500         clrActiveCaption = ::GetSysColor(COLOR_ACTIVECAPTION);
 501         clrInactiveCaption = ::GetSysColor(COLOR_INACTIVECAPTION);
 502
 503         clrActiveCaptionGradient = ::GetSysColor(COLOR_GRADIENTACTIVECAPTION);
 504         clrInactiveCaptionGradient = ::GetSysColor(COLOR_GRADIENTINACTIVECAPTION);
 505
 506         clrActiveBorder = ::GetSysColor(COLOR_ACTIVEBORDER);
 507         clrInactiveBorder = ::GetSysColor(COLOR_INACTIVEBORDER);
 508
 509         clrInactiveCaptionText = ::GetSysColor(COLOR_INACTIVECAPTIONTEXT);
 510
 511         if (m_bIsBlackHighContrast)
 512         {
 513                 clrHotLinkNormalText = clrWindowText;
 514                 clrHotLinkHoveredText = clrWindowText;
 515                 clrHotLinkVisitedText = clrWindowText;
 516         }
 517         else
 518         {
 519                 clrHotLinkNormalText = ::GetSysColor(COLOR_HOTLIGHT);
 520                 clrHotLinkHoveredText = RGB(0, 0, 255);   // Bright blue
 521                 clrHotLinkVisitedText = RGB(128, 0, 128); // Violet
 522         }
 523
 524         hbrBtnShadow = ::GetSysColorBrush(COLOR_BTNSHADOW);
 525         ENSURE(hbrBtnShadow != NULL);
 526
 527         hbrBtnHilite = ::GetSysColorBrush(COLOR_BTNHIGHLIGHT);
 528         ENSURE(hbrBtnHilite != NULL);
 529
 530         hbrWindow = ::GetSysColorBrush(COLOR_WINDOW);
 531         ENSURE(hbrWindow != NULL);
 532
 533         brBtnFace.DeleteObject();
 534         brBtnFace.CreateSolidBrush(clrBtnFace);
 535
 536         brBarFace.DeleteObject();
 537         brBarFace.CreateSolidBrush(clrBarFace);
 538
 539         brActiveCaption.DeleteObject();
 540         brActiveCaption.CreateSolidBrush(clrActiveCaption);
 541
 542         brInactiveCaption.DeleteObject();
 543         brInactiveCaption.CreateSolidBrush(clrInactiveCaption);
 544
 545         brHilite.DeleteObject();
 546         brHilite.CreateSolidBrush(clrHilite);
 547
 548         brBlack.DeleteObject();
 549         brBlack.CreateSolidBrush(clrBtnDkShadow);
 550
 551         brWindow.DeleteObject();
 552         brWindow.CreateSolidBrush(clrWindow);
 553
 554         penHilite.DeleteObject();
 555         penHilite.CreatePen(PS_SOLID, 1, afxGlobalData.clrHilite);
 556
 557         penBarFace.DeleteObject();
 558         penBarFace.CreatePen(PS_SOLID, 1, afxGlobalData.clrBarFace);
 559
 560         penBarShadow.DeleteObject();
 561         penBarShadow.CreatePen(PS_SOLID, 1, afxGlobalData.clrBarShadow);
 562
 563         if (brLight.GetSafeHandle())
 564         {
 565                 brLight.DeleteObject();
 566         }
 567
 568         if (m_nBitsPerPixel > 8)
 569         {
 570                 COLORREF clrLight = RGB(GetRValue(clrBtnFace) +((GetRValue(clrBtnHilite) - GetRValue(clrBtnFace)) / 2 ),
 571                         GetGValue(clrBtnFace) +((GetGValue(clrBtnHilite) - GetGValue(clrBtnFace)) / 2),
 572                         GetBValue(clrBtnFace) +((GetBValue(clrBtnHilite) - GetBValue(clrBtnFace)) / 2));
 573
 574                 brLight.CreateSolidBrush(clrLight);
 575         }
 576         else
 577         {
 578                 HBITMAP hbmGray = CreateDitherBitmap(dc.GetSafeHdc());
 579                 ENSURE(hbmGray != NULL);
 580
 581                 CBitmap bmp;
 582                 bmp.Attach(hbmGray);
 583
 584                 brLight.CreatePatternBrush(&bmp);
 585         }
 586
 587 //      CMenuImages::CleanUp();
 588 //      CDockingManager::m_bSDParamsModified = TRUE;
 589 }
 590
 591 BOOL AFX_GLOBAL_DATA::SetMenuFont(LPLOGFONT lpLogFont, BOOL bHorz)
 592 {
 593         ENSURE(lpLogFont != NULL);
 594
 595         if (bHorz)
 596         {
 597                 // Create regular font:
 598                 fontRegular.DeleteObject();
 599                 if (!fontRegular.CreateFontIndirect(lpLogFont))
 600                 {
 601                         ASSERT(FALSE);
 602                         return FALSE;
 603                 }
 604
 605                 // Create underline font:
 606                 lpLogFont->lfUnderline = TRUE;
 607                 fontUnderline.DeleteObject();
 608                 fontUnderline.CreateFontIndirect(lpLogFont);
 609                 lpLogFont->lfUnderline = FALSE;
 610
 611                 // Create bold font(used in the default menu items):
 612                 long lSavedWeight = lpLogFont->lfWeight;
 613                 lpLogFont->lfWeight = 700;
 614
 615                 fontBold.DeleteObject();
 616                 BOOL bResult = fontBold.CreateFontIndirect(lpLogFont);
 617
 618                 lpLogFont->lfWeight = lSavedWeight; // Restore weight
 619
 620                 if (!bResult)
 621                 {
 622                         ASSERT(FALSE);
 623                         return FALSE;
 624                 }
 625         }
 626         else // Vertical font
 627         {
 628                 fontVert.DeleteObject();
 629                 if (!fontVert.CreateFontIndirect(lpLogFont))
 630                 {
 631                         ASSERT(FALSE);
 632                         return FALSE;
 633                 }
 634         }
 635
 636         UpdateTextMetrics();
 637         return TRUE;
 638 }
 639
 640 void AFX_GLOBAL_DATA::UpdateTextMetrics()
 641 {
 642         CWindowDC dc(NULL);
 643
 644         CFont* pOldFont = dc.SelectObject(&fontRegular);
 645         ENSURE(pOldFont != NULL);
 646
 647         TEXTMETRIC tm;
 648         dc.GetTextMetrics(&tm);
 649
 650         int nExtra = tm.tmHeight < 15 ? 2 : 5;
 651
 652         m_nTextHeightHorz = tm.tmHeight + nExtra;
 653         m_nTextWidthHorz = tm.tmMaxCharWidth + nExtra;
 654
 655         dc.SelectObject(&fontVert);
 656         dc.GetTextMetrics(&tm);
 657
 658         nExtra = tm.tmHeight < 15 ? 2 : 5;
 659
 660         m_nTextHeightVert = tm.tmHeight + nExtra;
 661         m_nTextWidthVert = tm.tmMaxCharWidth + nExtra;
 662
 663         dc.SelectObject(pOldFont);
 664 }
 665
 666 HBITMAP AFX_GLOBAL_DATA::CreateDitherBitmap(HDC hDC)
 667 {
 668         struct  // BITMAPINFO with 16 colors
 669         {
 670                 BITMAPINFOHEADER bmiHeader;
 671                 RGBQUAD      bmiColors[16];
 672         }
 673         bmi;
 674         memset(&bmi, 0, sizeof(bmi));
 675
 676         bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 677         bmi.bmiHeader.biWidth = 8;
 678         bmi.bmiHeader.biHeight = 8;
 679         bmi.bmiHeader.biPlanes = 1;
 680         bmi.bmiHeader.biBitCount = 1;
 681         bmi.bmiHeader.biCompression = BI_RGB;
 682
 683         COLORREF clr = afxGlobalData.clrBtnFace;
 684
 685         bmi.bmiColors[0].rgbBlue = GetBValue(clr);
 686         bmi.bmiColors[0].rgbGreen = GetGValue(clr);
 687         bmi.bmiColors[0].rgbRed = GetRValue(clr);
 688
 689         clr = ::GetSysColor(COLOR_BTNHIGHLIGHT);
 690         bmi.bmiColors[1].rgbBlue = GetBValue(clr);
 691         bmi.bmiColors[1].rgbGreen = GetGValue(clr);
 692         bmi.bmiColors[1].rgbRed = GetRValue(clr);
 693
 694         // initialize the brushes
 695         long patGray[8];
 696         for (int i = 0; i < 8; i++)
 697                 patGray[i] = (i & 1) ? 0xAAAA5555L : 0x5555AAAAL;
 698
 699         HBITMAP hbm = CreateDIBitmap(hDC, &bmi.bmiHeader, CBM_INIT, (LPBYTE)patGray, (LPBITMAPINFO)&bmi, DIB_RGB_COLORS);
 700         return hbm;
 701 }
 702
 703 ITaskbarList* AFX_GLOBAL_DATA::GetITaskbarList()
 704 {
 705         // Backward-compatibility wrapper
 706         CWinApp* pApp = AfxGetApp();
 707         if (pApp != NULL)
 708         {
 709                 return pApp->GetITaskbarList();
 710         }
 711
 712         return NULL;
 713 }
 714
 715 ITaskbarList3* AFX_GLOBAL_DATA::GetITaskbarList3()
 716 {
 717         // Backward-compatibility wrapper
 718         CWinApp* pApp = AfxGetApp();
 719         if (pApp != NULL)
 720         {
 721                 return pApp->GetITaskbarList3();
 722         }
 723
 724         return NULL;
 725 }
 726
 727 void AFX_GLOBAL_DATA::CleanUp()
 728 {
 729         if (brLight.GetSafeHandle())
 730         {
 731                 brLight.DeleteObject();
 732         }
 733
 734         // cleanup fonts:
 735         fontRegular.DeleteObject();
 736         fontBold.DeleteObject();
 737         fontUnderline.DeleteObject();
 738         fontVert.DeleteObject();
 739         fontVertCaption.DeleteObject();
 740         fontTooltip.DeleteObject();
 741
 742         if (m_bBufferedPaintInited)
 743         {
 744                 BufferedPaintUnInit();
 745                 m_bBufferedPaintInited = FALSE;
 746         }
 747
 748         if (m_hinstDwmapiDLL != NULL)
 749         {
 750                 ::FreeLibrary(m_hinstDwmapiDLL);
 751                 m_hinstDwmapiDLL = NULL;
 752         }
 753
 754         m_bEnableAccessibility = FALSE;
 755 }
 756
 757 void ControlBarCleanUp()
 758 {
 759         if (afxGlobalData.m_bInitialized)
 760         {
 761                 afxGlobalData.CleanUp();
 762         }
 763
 764 //      afxMenuHash.CleanUp();
 765
 766 //      CMFCToolBar::CleanUpImages();
 767 //      CMenuImages::CleanUp();
 768
 769 //      if (GetCmdMgr() != NULL)
 770 //      {
 771 //              GetCmdMgr()->CleanUp();
 772 //      }
 773
 774 //      CKeyboardManager::CleanUp();
 775
 776         // Destroy visualization manager:
 777 //      CMFCVisualManager::DestroyInstance(TRUE /* bAutoDestroyOnly */);
 778 //      CMFCVisualManagerOffice2007::CleanStyle();
 779 }
 780
 781 #ifdef _AFXDLL
 782 void AfxGlobalsAddRef()
 783 {
 784         InterlockedIncrement(&g_dwAfxGlobalDataRef);
 785 }
 786
 787 void AfxGlobalsRelease()
 788 {
 789         InterlockedDecrement(&g_dwAfxGlobalDataRef);
 790         if (g_dwAfxGlobalDataRef == 0)
 791         {
 792                 ControlBarCleanUp();
 793         }
 794 }
 795 #endif
 796
 797 BOOL AFX_GLOBAL_DATA::DrawParentBackground(CWnd* pWnd, CDC* pDC, LPRECT rectClip)
 798 {
 799         ASSERT_VALID(pDC);
 800         ASSERT_VALID(pWnd);
 801
 802         BOOL bRes = FALSE;
 803
 804         CRgn rgn;
 805         if (rectClip != NULL)
 806         {
 807                 rgn.CreateRectRgnIndirect(rectClip);
 808                 pDC->SelectClipRgn(&rgn);
 809         }
 810
 811         CWnd* pParent = pWnd->GetParent();
 812         ASSERT_VALID(pParent);
 813
 814         // In Windows XP, we need to call DrawThemeParentBackground function to implement
 815         // transparent controls
 816         bRes = DrawThemeParentBackground(pWnd->GetSafeHwnd(), pDC->GetSafeHdc(), rectClip) == S_OK;
 817
 818         if (!bRes)
 819         {
 820                 CPoint pt(0, 0);
 821                 pWnd->MapWindowPoints(pParent, &pt, 1);
 822                 pt = pDC->OffsetWindowOrg(pt.x, pt.y);
 823
 824                 bRes = (BOOL) pParent->SendMessage(WM_ERASEBKGND, (WPARAM)pDC->m_hDC);
 825
 826                 pDC->SetWindowOrg(pt.x, pt.y);
 827         }
 828
 829         pDC->SelectClipRgn(NULL);
 830
 831         return bRes;
 832 }
 833
 834 CFrameWnd* AFX_CDECL AFXGetParentFrame(const CWnd* pWnd)
 835 {
 836         if (pWnd->GetSafeHwnd() == NULL)
 837         {
 838                 return NULL;
 839         }
 840         ASSERT_VALID(pWnd);
 841
 842         const CWnd* pParentWnd = pWnd;
 843
 844         while (pParentWnd != NULL)
 845         {
 846 //              if (pParentWnd->IsKindOf(RUNTIME_CLASS(CPaneFrameWnd)))
 847 ////            {
 848 //                      CPaneFrameWnd* pMiniFrame = DYNAMIC_DOWNCAST(CPaneFrameWnd, pParentWnd);
 849 //                      pParentWnd = pMiniFrame->GetParent();
 850 //              }
 851 //              else
 852                 {
 853                         pParentWnd = pParentWnd->GetParent();
 854                 }
 855
 856                 if (pParentWnd == NULL)
 857                 {
 858                         return NULL;
 859                 }
 860
 861                 if (pParentWnd->IsFrameWnd())
 862                 {
 863                         return(CFrameWnd*)pParentWnd;
 864                 }
 865         }
 866
 867         return NULL;
 868 }
 869
 870 COLORREF AFX_GLOBAL_DATA::GetColor(int nColor)
 871 {
 872         switch(nColor)
 873         {
 874                 case COLOR_BTNFACE:             return clrBtnFace;
 875                 case COLOR_BTNSHADOW:           return clrBtnShadow;
 876                 case COLOR_3DDKSHADOW:          return clrBtnDkShadow;
 877                 case COLOR_3DLIGHT:             return clrBtnLight;
 878                 case COLOR_BTNHIGHLIGHT:        return clrBtnHilite;
 879                 case COLOR_BTNTEXT:             return clrBtnText;
 880                 case COLOR_GRAYTEXT:            return clrGrayedText;
 881                 case COLOR_WINDOWFRAME:         return clrWindowFrame;
 882
 883                 case COLOR_HIGHLIGHT:           return clrHilite;
 884                 case COLOR_HIGHLIGHTTEXT:       return clrTextHilite;
 885
 886                 case COLOR_WINDOW:              return clrWindow;
 887                 case COLOR_WINDOWTEXT:          return clrWindowText;
 888
 889                 case COLOR_CAPTIONTEXT:         return clrCaptionText;
 890                 case COLOR_MENUTEXT:            return clrMenuText;
 891
 892                 case COLOR_ACTIVECAPTION:       return clrActiveCaption;
 893                 case COLOR_INACTIVECAPTION:     return clrInactiveCaption;
 894
 895                 case COLOR_ACTIVEBORDER:        return clrActiveBorder;
 896                 case COLOR_INACTIVEBORDER:      return clrInactiveBorder;
 897
 898                 case COLOR_INACTIVECAPTIONTEXT: return clrInactiveCaptionText;
 899         }
 900
 901         return ::GetSysColor(nColor);
 902 }
 903
 904 BOOL AFX_GLOBAL_DATA::SetLayeredAttrib(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags)
 905 {
 906         return(::SetLayeredWindowAttributes(hwnd, crKey, bAlpha, dwFlags));
 907 }
 908
 909 void AFX_GLOBAL_DATA::EnableAccessibilitySupport(BOOL bEnable/* = TRUE*/)
 910 {
 911         m_bEnableAccessibility = bEnable;
 912 }
 913
 914 CString AFX_GLOBAL_DATA::RegisterWindowClass(LPCTSTR lpszClassNamePrefix)
 915 {
 916         ENSURE(lpszClassNamePrefix != NULL);
 917
 918         // Register a new window class:
 919         HINSTANCE hInst = AfxGetInstanceHandle();
 920         UINT uiClassStyle = CS_DBLCLKS;
 921         HCURSOR hCursor = ::LoadCursor(NULL, IDC_ARROW);
 922         HBRUSH hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 923
 924         CString strClassName;
 925         strClassName.Format(_T("%s:%x:%x:%x:%x"), lpszClassNamePrefix, (UINT_PTR)hInst, uiClassStyle, (UINT_PTR)hCursor, (UINT_PTR)hbrBackground);
 926
 927         // See if the class already exists:
 928         WNDCLASS wndcls;
 929         if (::GetClassInfo(hInst, strClassName, &wndcls))
 930         {
 931                 // Already registered, assert everything is good:
 932                 ASSERT(wndcls.style == uiClassStyle);
 933         }
 934         else
 935         {
 936                 // Otherwise we need to register a new class:
 937                 wndcls.style = uiClassStyle;
 938                 wndcls.lpfnWndProc = ::DefWindowProc;
 939                 wndcls.cbClsExtra = wndcls.cbWndExtra = 0;
 940                 wndcls.hInstance = hInst;
 941                 wndcls.hIcon = NULL;
 942                 wndcls.hCursor = hCursor;
 943                 wndcls.hbrBackground = hbrBackground;
 944                 wndcls.lpszMenuName = NULL;
 945                 wndcls.lpszClassName = strClassName;
 946
 947                 if (!AfxRegisterClass(&wndcls))
 948                 {
 949                         AfxThrowResourceException();
 950                 }
 951         }
 952
 953         return strClassName;
 954 }
 955
 956 BOOL AFX_GLOBAL_DATA::ExcludeTag(CString& strBuffer, LPCTSTR lpszTag, CString& strTag, BOOL bIsCharsList /* = FALSE*/)
 957 {
 958         const int iBufLen = strBuffer.GetLength();
 959
 960         CString strTagStart = _T("<");
 961         strTagStart += lpszTag;
 962         strTagStart += _T(">");
 963
 964         const int iTagStartLen = strTagStart.GetLength();
 965
 966         int iStart = -1;
 967
 968         int iIndexStart = strBuffer.Find(strTagStart);
 969         if (iIndexStart < 0)
 970         {
 971                 return FALSE;
 972         }
 973
 974         iStart = iIndexStart + iTagStartLen;
 975
 976         CString strTagEnd = _T("</");
 977         strTagEnd += lpszTag;
 978         strTagEnd += _T('>');
 979
 980         const int iTagEndLen = strTagEnd.GetLength();
 981
 982         int iIndexEnd =  -1;
 983         int nBalanse = 1;
 984         for (int i = iStart; i < iBufLen - iTagEndLen + 1; i ++)
 985         {
 986                 if (strBuffer [i] != '<')
 987                 {
 988                         continue;
 989                 }
 990
 991                 if (i < iBufLen - iTagStartLen && _tcsncmp(strBuffer.Mid(i), strTagStart, iTagStartLen) == 0)
 992                 {
 993                         i += iTagStartLen - 1;
 994                         nBalanse ++;
 995                         continue;
 996                 }
 997
 998                 if (_tcsncmp(strBuffer.Mid(i), strTagEnd, iTagEndLen) == 0)
 999                 {
1000                         nBalanse --;
1001                         if (nBalanse == 0)
1002                         {
1003                                 iIndexEnd = i;
1004                                 break;
1005                         }
1006
1007                         i += iTagEndLen - 1;
1008                 }
1009         }
1010
1011         if (iIndexEnd == -1 || iStart > iIndexEnd)
1012         {
1013                 return FALSE;
1014         }
1015
1016         strTag = strBuffer.Mid(iStart, iIndexEnd - iStart);
1017         strTag.TrimLeft();
1018         strTag.TrimRight();
1019
1020         strBuffer.Delete(iIndexStart, iIndexEnd + iTagEndLen - iIndexStart);
1021
1022         if (bIsCharsList)
1023         {
1024                 if (strTag.GetLength() > 1 && strTag [0] == _T('\"'))
1025                 {
1026                         strTag = strTag.Mid(1, strTag.GetLength() - 2);
1027                 }
1028
1029                 strTag.Replace(_T("\\t"), _T("\t"));
1030                 strTag.Replace(_T("\\n"), _T("\n"));
1031                 strTag.Replace(_T("\\r"), _T("\r"));
1032                 strTag.Replace(_T("\\b"), _T("\b"));
1033                 strTag.Replace(_T("LT"), _T("<"));
1034                 strTag.Replace(_T("GT"), _T(">"));
1035                 strTag.Replace(_T("AMP"), _T("&"));
1036         }
1037
1038         return TRUE;
1039 }
1040
1041 BOOL AFX_GLOBAL_DATA::IsDwmCompositionEnabled()
1042 {
1043         // It appears that DwmIsCompositionEnabled can fail if called and
1044         // then called again after a very short time, so use a static var
1045         // so the last obtained value is returned if the method fails.
1046         static BOOL bEnabled = FALSE;
1047         DwmIsCompositionEnabled(&bEnabled);
1048         return bEnabled;
1049 }
1050
1051 BOOL AFX_GLOBAL_DATA::DrawTextOnGlass(HTHEME hTheme, CDC* pDC, int iPartId, int iStateId, CString strText, CRect rect, DWORD dwFlags, int nGlowSize, COLORREF clrText)
1052 {
1053         if (hTheme == NULL || !IsDwmCompositionEnabled())
1054         {
1055                 pDC->DrawText(strText, rect, dwFlags);
1056                 return FALSE;
1057         }
1058
1059         CComBSTR bstmp = (LPCTSTR)strText;
1060
1061         wchar_t* wbuf = new wchar_t[bstmp.Length() + 1];
1062         wcscpy_s(wbuf, bstmp.Length() + 1, bstmp);
1063
1064         DTTOPTS dto;
1065         memset(&dto, 0, sizeof(DTTOPTS));
1066         dto.dwSize = sizeof(DTTOPTS);
1067         dto.dwFlags = DTT_COMPOSITED;
1068
1069         if (nGlowSize > 0)
1070         {
1071                 dto.dwFlags |= DTT_GLOWSIZE;
1072                 dto.iGlowSize = nGlowSize;
1073         }
1074
1075         if (clrText != (COLORREF)-1)
1076         {
1077                 dto.dwFlags |= DTT_TEXTCOLOR;
1078                 dto.crText = clrText;
1079         }
1080
1081         DrawThemeTextEx(hTheme, pDC->GetSafeHdc(), iPartId, iStateId, wbuf, -1, dwFlags, rect, &dto);
1082
1083         delete [] wbuf;
1084
1085         return TRUE;
1086 }
1087
1088 HCURSOR AFX_GLOBAL_DATA::GetHandCursor()
1089 {
1090         if (m_hcurHand == NULL)
1091         {
1092 #pragma warning(push)
1093 #pragma warning(disable: 4302) // 'type cast' : truncation from 'LPSTR' to 'WORD'
1094                 m_hcurHand = ::LoadCursorW(NULL, MAKEINTRESOURCEW(IDC_HAND));
1095 #pragma warning(pop)
1096         }
1097
1098         return m_hcurHand;
1099 }
1100
1101 BOOL AFX_GLOBAL_DATA::Resume()
1102 {
1103         if (m_bEnableAccessibility)
1104         {
1105                 EnableAccessibilitySupport();
1106         }
1107
1108 //      CMFCVisualManagerOffice2007::Style style = CMFCVisualManagerOffice2007::GetStyle();
1109 //      CMFCVisualManagerOffice2007::CleanStyle ();
1110
1111 //      if (CMFCVisualManager::m_pRTIDefault != NULL)
1112 //      {
1113 //              CMFCVisualManagerOffice2007::SetStyle(style);
1114 //              CMFCVisualManager::SetDefaultManager (CMFCVisualManager::m_pRTIDefault);
1115 //      }
1116
1117         return TRUE;
1118 }
1119
1120 BOOL AFX_GLOBAL_DATA::GetNonClientMetrics (NONCLIENTMETRICS& info)
1121 {
1122         struct AFX_OLDNONCLIENTMETRICS
1123         {
1124                 UINT    cbSize;
1125                 int     iBorderWidth;
1126                 int     iScrollWidth;
1127                 int     iScrollHeight;
1128                 int     iCaptionWidth;
1129                 int     iCaptionHeight;
1130                 LOGFONT lfCaptionFont;
1131                 int     iSmCaptionWidth;
1132                 int     iSmCaptionHeight;
1133                 LOGFONT lfSmCaptionFont;
1134                 int     iMenuWidth;
1135                 int     iMenuHeight;
1136                 LOGFONT lfMenuFont;
1137                 LOGFONT lfStatusFont;
1138                 LOGFONT lfMessageFont;
1139         };
1140
1141         if (!bIsWindows7)
1142         {
1143                 info.cbSize = sizeof(AFX_OLDNONCLIENTMETRICS);
1144         }
1145
1146         return ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, info.cbSize, &info, 0);
1147 }
1148
1149
1150 BOOL AFXAPI AfxIsExtendedFrameClass(CWnd* pWnd)
1151 {
1152         ENSURE( pWnd );
1153 #if 0
1154         if (pWnd->IsKindOf(RUNTIME_CLASS(CFrameWndEx)))
1155         {
1156                 return TRUE;
1157         }
1158         if (pWnd->IsKindOf(RUNTIME_CLASS(CMDIFrameWndEx)))
1159         {
1160                 return TRUE;
1161         }
1162         if (pWnd->IsKindOf(RUNTIME_CLASS(COleIPFrameWndEx)))
1163         {
1164                 return TRUE;
1165         }
1166         if (pWnd->IsKindOf(RUNTIME_CLASS(COleDocIPFrameWndEx)))
1167         {
1168                 return TRUE;
1169         }
1170         if (pWnd->IsKindOf(RUNTIME_CLASS(CMDIChildWndEx)))
1171         {
1172                 return TRUE;
1173         }
1174 #endif
1175         return FALSE;
1176 }
1177
1178
1179 BOOL AFXAPI AfxIsMFCToolBar(CWnd* pWnd)
1180 {
1181         ENSURE( pWnd );
1182 //      if (pWnd->IsKindOf(RUNTIME_CLASS(CMFCToolBar)))
1183 //      {
1184 //              return TRUE;
1185 //      }
1186         return FALSE;
1187 }
1188
1189 HRESULT AFX_GLOBAL_DATA::ShellCreateItemFromParsingName(PCWSTR pszPath, IBindCtx *pbc, REFIID riid, void **ppv)
1190 {
1191         return SHCreateItemFromParsingName(pszPath, pbc, riid, ppv);
1192 }
1193
1194 #else
1195
1196 static const CString strOfficeFontName = _T("Tahoma");
1197 static const CString strOffice2007FontName = _T("Segoe UI");
1198 static const CString strDefaultFontName = _T("MS Sans Serif");
1199 static const CString strVertFontName = _T("Arial");
1200 static const CString strMarlettFontName = _T("Marlett");
1201
1202 HINSTANCE AFX_GLOBAL_DATA::m_hinstD2DDLL = NULL;
1203 HINSTANCE AFX_GLOBAL_DATA::m_hinstDWriteDLL = NULL;
1204
1205 ID2D1Factory* AFX_GLOBAL_DATA::m_pDirect2dFactory = NULL;
1206 IDWriteFactory* AFX_GLOBAL_DATA::m_pWriteFactory = NULL;
1207 IWICImagingFactory* AFX_GLOBAL_DATA::m_pWicFactory = NULL;
1208
1209 D2D1MAKEROTATEMATRIX AFX_GLOBAL_DATA::m_pfD2D1MakeRotateMatrix = NULL;
1210
1211 BOOL AFX_GLOBAL_DATA::m_bD2DInitialized = FALSE;
1212
1213 CMemDC::CMemDC(CDC& dc, CWnd* pWnd) :
1214         m_dc(dc), m_bMemDC(FALSE), m_hBufferedPaint(NULL), m_pOldBmp(NULL)
1215 {
1216         ASSERT_VALID(pWnd);
1217
1218         pWnd->GetClientRect(m_rect);
1219
1220         m_rect.right += pWnd->GetScrollPos(SB_HORZ);
1221         m_rect.bottom += pWnd->GetScrollPos(SB_VERT);
1222
1223         if (afxGlobalData.m_pfBeginBufferedPaint != NULL && afxGlobalData.m_pfEndBufferedPaint != NULL)
1224         {
1225                 HDC hdcPaint = NULL;
1226
1227                 if (!afxGlobalData.m_bBufferedPaintInited && afxGlobalData.m_pfBufferedPaintInit != NULL && afxGlobalData.m_pfBufferedPaintUnInit != NULL)
1228                 {
1229                         afxGlobalData.m_pfBufferedPaintInit();
1230                         afxGlobalData.m_bBufferedPaintInited = TRUE;
1231                 }
1232
1233                 m_hBufferedPaint = (*afxGlobalData.m_pfBeginBufferedPaint)(dc.GetSafeHdc(), m_rect, AFX_BPBF_TOPDOWNDIB, NULL, &hdcPaint);
1234
1235                 if (m_hBufferedPaint != NULL && hdcPaint != NULL)
1236                 {
1237                         m_bMemDC = TRUE;
1238                         m_dcMem.Attach(hdcPaint);
1239                 }
1240         }
1241         else
1242         {
1243                 if (m_bUseMemoryDC && m_dcMem.CreateCompatibleDC(&m_dc) && m_bmp.CreateCompatibleBitmap(&m_dc, m_rect.Width(), m_rect.Height()))
1244                 {
1245                         //-------------------------------------------------------------
1246                         // Off-screen DC successfully created. Better paint to it then!
1247                         //-------------------------------------------------------------
1248                         m_bMemDC = TRUE;
1249                         m_pOldBmp = m_dcMem.SelectObject(&m_bmp);
1250                 }
1251         }
1252 }
1253
1254 CMemDC::CMemDC(CDC& dc, const CRect& rect) :
1255         m_dc(dc), m_bMemDC(FALSE), m_hBufferedPaint(NULL), m_pOldBmp(NULL), m_rect(rect)
1256 {
1257         ASSERT(!m_rect.IsRectEmpty());
1258
1259         if (afxGlobalData.m_pfBeginBufferedPaint != NULL && afxGlobalData.m_pfEndBufferedPaint != NULL)
1260         {
1261                 HDC hdcPaint = NULL;
1262
1263                 if (!afxGlobalData.m_bBufferedPaintInited && afxGlobalData.m_pfBufferedPaintInit != NULL && afxGlobalData.m_pfBufferedPaintUnInit != NULL)
1264                 {
1265                         afxGlobalData.m_pfBufferedPaintInit();
1266                         afxGlobalData.m_bBufferedPaintInited = TRUE;
1267                 }
1268
1269                 m_hBufferedPaint = (*afxGlobalData.m_pfBeginBufferedPaint)(dc.GetSafeHdc(), m_rect, AFX_BPBF_TOPDOWNDIB, NULL, &hdcPaint);
1270
1271                 if (m_hBufferedPaint != NULL && hdcPaint != NULL)
1272                 {
1273                         m_bMemDC = TRUE;
1274                         m_dcMem.Attach(hdcPaint);
1275                 }
1276         }
1277         else
1278         {
1279                 if (m_bUseMemoryDC && m_dcMem.CreateCompatibleDC(&m_dc) && m_bmp.CreateCompatibleBitmap(&m_dc, m_rect.Width(), m_rect.Height()))
1280                 {
1281                         //-------------------------------------------------------------
1282                         // Off-screen DC successfully created. Better paint to it then!
1283                         //-------------------------------------------------------------
1284                         m_bMemDC = TRUE;
1285                         m_pOldBmp = m_dcMem.SelectObject(&m_bmp);
1286                 }
1287         }
1288 }
1289
1290 CMemDC::~CMemDC()
1291 {
1292         if (m_hBufferedPaint != NULL)
1293         {
1294                 m_dcMem.Detach();
1295                 (*afxGlobalData.m_pfEndBufferedPaint)(m_hBufferedPaint, TRUE);
1296         }
1297         else if (m_bMemDC)
1298         {
1299                 //--------------------------------------
1300                 // Copy the results to the on-screen DC:
1301                 //--------------------------------------
1302                 CRect rectClip;
1303                 int nClipType = m_dc.GetClipBox(rectClip);
1304
1305                 if (nClipType != NULLREGION)
1306                 {
1307                         if (nClipType != SIMPLEREGION)
1308                         {
1309                                 rectClip = m_rect;
1310                         }
1311
1312                         m_dc.BitBlt(rectClip.left, rectClip.top, rectClip.Width(), rectClip.Height(), &m_dcMem, rectClip.left, rectClip.top, SRCCOPY);
1313                 }
1314
1315                 m_dcMem.SelectObject(m_pOldBmp);
1316         }
1317 }
1318
1319 static int CALLBACK FontFamalyProcFonts(const LOGFONT FAR* lplf, const TEXTMETRIC FAR* /*lptm*/, ULONG /*ulFontType*/, LPARAM lParam)
1320 {
1321         ENSURE(lplf != NULL);
1322         ENSURE(lParam != NULL);
1323
1324         CString strFont = lplf->lfFaceName;
1325         return strFont.CollateNoCase((LPCTSTR) lParam) == 0 ? 0 : 1;
1326 }
1327
1328 /////////////////////////////////////////////////////////////////////////////
1329 // DLL Load Helper
1330
1331 inline HMODULE AfxLoadSystemLibraryUsingFullPath(_In_z_ const WCHAR *pszLibrary)
1332 {
1333         WCHAR wszLoadPath[MAX_PATH+1];
1334         if (::GetSystemDirectoryW(wszLoadPath, _countof(wszLoadPath)) == 0)
1335         {
1336                 return NULL;
1337         }
1338
1339         if (wszLoadPath[wcslen(wszLoadPath)-1] != L'\\')
1340         {
1341                 if (wcscat_s(wszLoadPath, _countof(wszLoadPath), L"\\") != 0)
1342                 {
1343                         return NULL;
1344                 }
1345         }
1346
1347         if (wcscat_s(wszLoadPath, _countof(wszLoadPath), pszLibrary) != 0)
1348         {
1349                 return NULL;
1350         }
1351
1352         return(::AfxCtxLoadLibraryW(wszLoadPath));
1353 }
1354
1355 /////////////////////////////////////////////////////////////////////////////
1356 // Cached system metrics, etc
1357 AFX_GLOBAL_DATA afxGlobalData;
1358
1359 #ifdef _AFXDLL
1360 // Reference count on global data
1361 DWORD g_dwAfxGlobalDataRef = 0;
1362 #endif
1363
1364 // Initialization code
1365 AFX_GLOBAL_DATA::AFX_GLOBAL_DATA()
1366 {
1367         // Detect the kind of OS:
1368         OSVERSIONINFO osvi;
1369         osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1370
1371         ::GetVersionEx(&osvi);
1372
1373         bIsRemoteSession = GetSystemMetrics(SM_REMOTESESSION);
1374
1375         bIsWindowsVista = (osvi.dwMajorVersion >= 6);
1376         bIsWindows7 = (osvi.dwMajorVersion == 6) && (osvi.dwMinorVersion >= 1) || (osvi.dwMajorVersion > 6) ;
1377         bDisableAero = FALSE;
1378
1379         m_bIsRibbonImageScale = TRUE;
1380
1381         // Cached system values(updated in CWnd::OnSysColorChange)
1382         hbrBtnShadow = NULL;
1383         hbrBtnHilite = NULL;
1384         hbrWindow = NULL;
1385
1386         UpdateSysColors();
1387
1388         m_hinstUXThemeDLL = ::AfxCtxLoadLibraryW(L"UxTheme.dll");
1389         if (m_hinstUXThemeDLL != NULL)
1390         {
1391                 m_pfDrawThemeBackground = (DRAWTHEMEPARENTBACKGROUND)::GetProcAddress(m_hinstUXThemeDLL, "DrawThemeParentBackground");
1392                 m_pfDrawThemeTextEx = (DRAWTHEMETEXTEX)::GetProcAddress(m_hinstUXThemeDLL, "DrawThemeTextEx");
1393
1394                 m_pfBufferedPaintInit = (BUFFEREDPAINTINIT)::GetProcAddress(m_hinstUXThemeDLL, "BufferedPaintInit");
1395                 m_pfBufferedPaintUnInit = (BUFFEREDPAINTUNINIT)::GetProcAddress(m_hinstUXThemeDLL, "BufferedPaintUnInit");
1396
1397                 m_pfBeginBufferedPaint = (BEGINBUFFEREDPAINT)::GetProcAddress(m_hinstUXThemeDLL, "BeginBufferedPaint");
1398                 m_pfEndBufferedPaint = (ENDBUFFEREDPAINT)::GetProcAddress(m_hinstUXThemeDLL, "EndBufferedPaint");
1399         }
1400         else
1401         {
1402                 m_pfDrawThemeBackground = NULL;
1403                 m_pfDrawThemeTextEx = NULL;
1404
1405                 m_pfBufferedPaintInit = NULL;
1406                 m_pfBufferedPaintUnInit = NULL;
1407
1408                 m_pfBeginBufferedPaint = NULL;
1409                 m_pfEndBufferedPaint = NULL;
1410         }
1411
1412         m_hinstDwmapiDLL = AfxLoadSystemLibraryUsingFullPath(L"dwmapi.dll");
1413         if (m_hinstDwmapiDLL != NULL)
1414         {
1415                 m_pfDwmExtendFrameIntoClientArea = (DWMEXTENDFRAMEINTOCLIENTAREA)::GetProcAddress(m_hinstDwmapiDLL, "DwmExtendFrameIntoClientArea");
1416                 m_pfDwmDefWindowProc = (DWMDEFWINDOWPROC) ::GetProcAddress(m_hinstDwmapiDLL, "DwmDefWindowProc");
1417                 m_pfDwmIsCompositionEnabled = (DWMISCOMPOSITIONENABLED)::GetProcAddress(m_hinstDwmapiDLL, "DwmIsCompositionEnabled");
1418         }
1419         else
1420         {
1421                 m_pfDwmExtendFrameIntoClientArea = NULL;
1422                 m_pfDwmDefWindowProc = NULL;
1423                 m_pfDwmIsCompositionEnabled = NULL;
1424         }
1425
1426         m_hcurStretch = NULL;
1427         m_hcurStretchVert = NULL;
1428         m_hcurHand = NULL;
1429         m_hcurSizeAll = NULL;
1430         m_hiconTool = NULL;
1431         m_hiconLink = NULL;
1432         m_hiconColors = NULL;
1433         m_hcurMoveTab = NULL;
1434         m_hcurNoMoveTab = NULL;
1435
1436         m_bUseSystemFont = FALSE;
1437         m_bInSettingChange = FALSE;
1438
1439         UpdateFonts();
1440         OnSettingChange();
1441
1442         m_bIsRTL = FALSE;
1443         m_bBufferedPaintInited = FALSE;
1444
1445         m_nDragFrameThicknessFloat = 4;  // pixels
1446         m_nDragFrameThicknessDock = 3;   // pixels
1447
1448         m_nAutoHideToolBarSpacing = 14; // pixels
1449         m_nAutoHideToolBarMargin  = 4;  // pixels
1450
1451         m_nCoveredMainWndClientAreaPercent = 50; // percents
1452
1453         m_nMaxToolTipWidth = -1;
1454         m_bIsBlackHighContrast = FALSE;
1455         m_bIsWhiteHighContrast = FALSE;
1456
1457         m_bUseBuiltIn32BitIcons = TRUE;
1458
1459         m_bComInitialized = FALSE;
1460
1461         m_pTaskbarList = NULL;
1462         m_pTaskbarList3 = NULL;
1463         m_bTaskBarInterfacesAvailable = TRUE;
1464
1465         EnableAccessibilitySupport();
1466 }
1467
1468 AFX_GLOBAL_DATA::~AFX_GLOBAL_DATA()
1469 {
1470         CleanUp();
1471 }
1472
1473 void AFX_GLOBAL_DATA::UpdateFonts()
1474 {
1475         CWindowDC dc(NULL);
1476         m_dblRibbonImageScale = dc.GetDeviceCaps(LOGPIXELSX) / 96.0f;
1477
1478         if (m_dblRibbonImageScale > 1. && m_dblRibbonImageScale < 1.1)
1479         {
1480                 m_dblRibbonImageScale = 1.;
1481         }
1482
1483         if (fontRegular.GetSafeHandle() != NULL)
1484         {
1485                 ::DeleteObject(fontRegular.Detach());
1486         }
1487
1488         if (fontTooltip.GetSafeHandle() != NULL)
1489         {
1490                 ::DeleteObject(fontTooltip.Detach());
1491         }
1492
1493         if (fontBold.GetSafeHandle() != NULL)
1494         {
1495                 ::DeleteObject(fontBold.Detach());
1496         }
1497
1498         if (fontDefaultGUIBold.GetSafeHandle() != NULL)
1499         {
1500                 ::DeleteObject(fontDefaultGUIBold.Detach());
1501         }
1502
1503         if (fontUnderline.GetSafeHandle() != NULL)
1504         {
1505                 ::DeleteObject(fontUnderline.Detach());
1506         }
1507
1508         if (fontDefaultGUIUnderline.GetSafeHandle() != NULL)
1509         {
1510                 ::DeleteObject(fontDefaultGUIUnderline.Detach());
1511         }
1512
1513         if (fontVert.GetSafeHandle() != NULL)
1514         {
1515                 ::DeleteObject(fontVert.Detach());
1516         }
1517
1518         if (fontVertCaption.GetSafeHandle() != NULL)
1519         {
1520                 ::DeleteObject(fontVertCaption.Detach());
1521         }
1522
1523         if (fontMarlett.GetSafeHandle() != NULL)
1524         {
1525                 ::DeleteObject(fontMarlett.Detach());
1526         }
1527
1528         if (fontSmall.GetSafeHandle() != NULL)
1529         {
1530                 ::DeleteObject(fontSmall.Detach());
1531         }
1532
1533         // Initialize fonts:
1534
1535         NONCLIENTMETRICS info;
1536         info.cbSize = sizeof(info);
1537         GetNonClientMetrics (info);
1538
1539         LOGFONT lf;
1540         memset(&lf, 0, sizeof(LOGFONT));
1541
1542         lf.lfCharSet = (BYTE) GetTextCharsetInfo(dc.GetSafeHdc(), NULL, 0);
1543
1544         lf.lfHeight = info.lfMenuFont.lfHeight;
1545         lf.lfWeight = info.lfMenuFont.lfWeight;
1546         lf.lfItalic = info.lfMenuFont.lfItalic;
1547
1548         //------------------
1549         // Adjust font size:
1550         //------------------
1551         int nFontHeight = lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight;
1552         if (nFontHeight <= 12)
1553         {
1554                 nFontHeight = 11;
1555         }
1556         else
1557         {
1558                 nFontHeight--;
1559         }
1560
1561         lf.lfHeight = (lf.lfHeight < 0) ? -nFontHeight : nFontHeight;
1562
1563         // Check if we should use system font
1564         lstrcpy(lf.lfFaceName, info.lfMenuFont.lfFaceName);
1565
1566         BOOL fUseSystemFont = m_bUseSystemFont || (info.lfMenuFont.lfCharSet > SYMBOL_CHARSET);
1567         if (!fUseSystemFont)
1568         {
1569                 // Check for "Segoe UI" or "Tahoma" font existance:
1570                 if (::EnumFontFamilies(dc.GetSafeHdc(), NULL, FontFamalyProcFonts, (LPARAM)(LPCTSTR) strOffice2007FontName) == 0)
1571                 {
1572                         // Found! Use MS Office 2007 font!
1573                         lstrcpy(lf.lfFaceName, strOffice2007FontName);
1574                         lf.lfQuality = 5 /*CLEARTYPE_QUALITY*/;
1575                 }
1576                 else if (::EnumFontFamilies(dc.GetSafeHdc(), NULL, FontFamalyProcFonts, (LPARAM)(LPCTSTR) strOfficeFontName) == 0)
1577                 {
1578                         // Found! Use MS Office font!
1579                         lstrcpy(lf.lfFaceName, strOfficeFontName);
1580                 }
1581                 else
1582                 {
1583                         // Not found. Use default font:
1584                         lstrcpy(lf.lfFaceName, strDefaultFontName);
1585                 }
1586         }
1587
1588         fontRegular.CreateFontIndirect(&lf);
1589
1590         // Create small font:
1591         LONG lfHeightSaved = lf.lfHeight;
1592
1593         lf.lfHeight = (long)((1. + abs(lf.lfHeight)) * 2 / 3);
1594         if (lfHeightSaved < 0)
1595         {
1596                 lf.lfHeight = -lf.lfHeight;
1597         }
1598
1599         fontSmall.CreateFontIndirect(&lf);
1600         lf.lfHeight = lfHeightSaved;
1601
1602         // Create tooltip font:
1603         NONCLIENTMETRICS ncm;
1604         ncm.cbSize = sizeof(ncm);
1605         GetNonClientMetrics (ncm);
1606
1607         lf.lfItalic = ncm.lfStatusFont.lfItalic;
1608         lf.lfWeight = ncm.lfStatusFont.lfWeight;
1609         fontTooltip.CreateFontIndirect(&lf);
1610
1611         lf.lfItalic = info.lfMenuFont.lfItalic;
1612         lf.lfWeight = info.lfMenuFont.lfWeight;
1613
1614         // Create "underline" font:
1615         lf.lfUnderline = TRUE;
1616         fontUnderline.CreateFontIndirect(&lf);
1617         lf.lfUnderline = FALSE;
1618
1619         // Create bold font:
1620         lf.lfWeight = FW_BOLD;
1621         fontBold.CreateFontIndirect(&lf);
1622
1623         // Create Marlett font:
1624         BYTE bCharSet = lf.lfCharSet;
1625         lf.lfWeight = info.lfMenuFont.lfWeight;
1626         lf.lfCharSet = SYMBOL_CHARSET;
1627         lf.lfWeight = 0;
1628         lf.lfHeight = ::GetSystemMetrics(SM_CYMENUCHECK) - 1;
1629         lstrcpy(lf.lfFaceName, strMarlettFontName);
1630
1631         fontMarlett.CreateFontIndirect(&lf);
1632         lf.lfCharSet = bCharSet; // Restore charset
1633
1634         // Create vertical font:
1635         CFont font;
1636         if (font.CreateStockObject(DEFAULT_GUI_FONT))
1637         {
1638                 if (font.GetLogFont(&lf) != 0)
1639                 {
1640                         lf.lfOrientation = 900;
1641                         lf.lfEscapement = 2700;
1642
1643                         lf.lfHeight = info.lfMenuFont.lfHeight;
1644                         lf.lfWeight = info.lfMenuFont.lfWeight;
1645                         lf.lfItalic = info.lfMenuFont.lfItalic;
1646
1647                         {
1648                                 lstrcpy(lf.lfFaceName, strVertFontName);
1649                         }
1650
1651                         fontVert.CreateFontIndirect(&lf);
1652
1653                         lf.lfEscapement = 900;
1654                         fontVertCaption.CreateFontIndirect(&lf);
1655                 }
1656         }
1657
1658         // Create dialog underline and bold fonts:
1659         CFont* pDefaultGUIFont = CFont::FromHandle((HFONT) GetStockObject(DEFAULT_GUI_FONT));
1660         ASSERT_VALID(pDefaultGUIFont);
1661         pDefaultGUIFont->GetLogFont(&lf);
1662
1663         lf.lfUnderline = TRUE;
1664         fontDefaultGUIUnderline.CreateFontIndirect(&lf);
1665         lf.lfUnderline = FALSE;
1666
1667         lf.lfWeight = FW_BOLD;
1668         fontDefaultGUIBold.CreateFontIndirect(&lf);
1669
1670         UpdateTextMetrics();
1671
1672 #if 0
1673         // Notify toolbars about font changing:
1674         for (POSITION posTlb = afxAllToolBars.GetHeadPosition(); posTlb != NULL;)
1675         {
1676                 CMFCToolBar* pToolBar = (CMFCToolBar*) afxAllToolBars.GetNext(posTlb);
1677                 ENSURE(pToolBar != NULL);
1678
1679                 if (CWnd::FromHandlePermanent(pToolBar->m_hWnd) != NULL)
1680                 {
1681                         ASSERT_VALID(pToolBar);
1682                         pToolBar->OnGlobalFontsChanged();
1683                 }
1684         }
1685 #endif
1686 }
1687
1688 static BOOL CALLBACK InfoEnumProc( HMONITOR hMonitor, HDC /*hdcMonitor*/, LPRECT /*lprcMonitor*/, LPARAM dwData)
1689 {
1690         CRect* pRect = (CRect*) dwData;
1691
1692         MONITORINFO mi;
1693         mi.cbSize = sizeof(MONITORINFO);
1694
1695         if (GetMonitorInfo(hMonitor, &mi))
1696         {
1697                 CRect rectMon = mi.rcWork;
1698
1699                 pRect->left = min(pRect->left, rectMon.left);
1700                 pRect->right = max(pRect->right, rectMon.right);
1701                 pRect->top = min(pRect->top, rectMon.top);
1702                 pRect->bottom = max(pRect->bottom, rectMon.bottom);
1703         }
1704
1705         return TRUE;
1706 }
1707
1708 void AFX_GLOBAL_DATA::OnSettingChange()
1709 {
1710         m_bInSettingChange = TRUE;
1711
1712         m_sizeSmallIcon.cx = ::GetSystemMetrics(SM_CXSMICON);
1713         m_sizeSmallIcon.cy = ::GetSystemMetrics(SM_CYSMICON);
1714
1715         m_rectVirtual.SetRectEmpty();
1716
1717         if (!EnumDisplayMonitors(NULL, NULL, InfoEnumProc, (LPARAM) &m_rectVirtual))
1718         {
1719                 ::SystemParametersInfo(SPI_GETWORKAREA, 0, &m_rectVirtual, 0);
1720         }
1721
1722         // Get system menu animation type:
1723         m_bMenuAnimation = FALSE;
1724         m_bMenuFadeEffect = FALSE;
1725
1726         if (!bIsRemoteSession)
1727         {
1728                 ::SystemParametersInfo(SPI_GETMENUANIMATION, 0, &m_bMenuAnimation, 0);
1729
1730                 if (m_bMenuAnimation)
1731                 {
1732                         ::SystemParametersInfo(SPI_GETMENUFADE, 0, &m_bMenuFadeEffect, 0);
1733                 }
1734         }
1735
1736         m_nShellAutohideBars = 0;
1737         m_bRefreshAutohideBars = TRUE;
1738
1739         ::SystemParametersInfo(SPI_GETMENUUNDERLINES, 0, &m_bSysUnderlineKeyboardShortcuts, 0);
1740         m_bUnderlineKeyboardShortcuts = m_bSysUnderlineKeyboardShortcuts;
1741
1742         m_bInSettingChange = FALSE;
1743 }
1744
1745 void AFX_GLOBAL_DATA::UpdateSysColors()
1746 {
1747         m_bIsBlackHighContrast = ::GetSysColor(COLOR_3DLIGHT) == RGB(255, 255, 255) && ::GetSysColor(COLOR_3DFACE) == RGB(0, 0, 0);
1748         m_bIsWhiteHighContrast = ::GetSysColor(COLOR_3DDKSHADOW) == RGB(0, 0, 0) && ::GetSysColor(COLOR_3DFACE) == RGB(255, 255, 255);
1749
1750         CWindowDC dc(NULL);
1751         m_nBitsPerPixel = dc.GetDeviceCaps(BITSPIXEL);
1752
1753         clrBarFace = clrBtnFace = ::GetSysColor(COLOR_BTNFACE);
1754         clrBarShadow = clrBtnShadow = ::GetSysColor(COLOR_BTNSHADOW);
1755         clrBarDkShadow = clrBtnDkShadow = ::GetSysColor(COLOR_3DDKSHADOW);
1756         clrBarLight = clrBtnLight = ::GetSysColor(COLOR_3DLIGHT);
1757         clrBarHilite = clrBtnHilite = ::GetSysColor(COLOR_BTNHIGHLIGHT);
1758         clrBarText = clrBtnText = ::GetSysColor(COLOR_BTNTEXT);
1759         clrGrayedText = ::GetSysColor(COLOR_GRAYTEXT);
1760         clrWindowFrame = ::GetSysColor(COLOR_WINDOWFRAME);
1761
1762         clrHilite = ::GetSysColor(COLOR_HIGHLIGHT);
1763         clrTextHilite = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
1764
1765         clrBarWindow = clrWindow = ::GetSysColor(COLOR_WINDOW);
1766         clrWindowText = ::GetSysColor(COLOR_WINDOWTEXT);
1767
1768         clrCaptionText = ::GetSysColor(COLOR_CAPTIONTEXT);
1769         clrMenuText = ::GetSysColor(COLOR_MENUTEXT);
1770
1771         clrActiveCaption = ::GetSysColor(COLOR_ACTIVECAPTION);
1772         clrInactiveCaption = ::GetSysColor(COLOR_INACTIVECAPTION);
1773
1774         clrActiveCaptionGradient = ::GetSysColor(COLOR_GRADIENTACTIVECAPTION);
1775         clrInactiveCaptionGradient = ::GetSysColor(COLOR_GRADIENTINACTIVECAPTION);
1776
1777         clrActiveBorder = ::GetSysColor(COLOR_ACTIVEBORDER);
1778         clrInactiveBorder = ::GetSysColor(COLOR_INACTIVEBORDER);
1779
1780         clrInactiveCaptionText = ::GetSysColor(COLOR_INACTIVECAPTIONTEXT);
1781
1782         if (m_bIsBlackHighContrast)
1783         {
1784                 clrHotLinkNormalText = clrWindowText;
1785                 clrHotLinkHoveredText = clrWindowText;
1786                 clrHotLinkVisitedText = clrWindowText;
1787         }
1788         else
1789         {
1790                 clrHotLinkNormalText = ::GetSysColor(COLOR_HOTLIGHT);
1791                 clrHotLinkHoveredText = RGB(0, 0, 255);   // Bright blue
1792                 clrHotLinkVisitedText = RGB(128, 0, 128); // Violet
1793         }
1794
1795         hbrBtnShadow = ::GetSysColorBrush(COLOR_BTNSHADOW);
1796         ENSURE(hbrBtnShadow != NULL);
1797
1798         hbrBtnHilite = ::GetSysColorBrush(COLOR_BTNHIGHLIGHT);
1799         ENSURE(hbrBtnHilite != NULL);
1800
1801         hbrWindow = ::GetSysColorBrush(COLOR_WINDOW);
1802         ENSURE(hbrWindow != NULL);
1803
1804         brBtnFace.DeleteObject();
1805         brBtnFace.CreateSolidBrush(clrBtnFace);
1806
1807         brBarFace.DeleteObject();
1808         brBarFace.CreateSolidBrush(clrBarFace);
1809
1810         brActiveCaption.DeleteObject();
1811         brActiveCaption.CreateSolidBrush(clrActiveCaption);
1812
1813         brInactiveCaption.DeleteObject();
1814         brInactiveCaption.CreateSolidBrush(clrInactiveCaption);
1815
1816         brHilite.DeleteObject();
1817         brHilite.CreateSolidBrush(clrHilite);
1818
1819         brBlack.DeleteObject();
1820         brBlack.CreateSolidBrush(clrBtnDkShadow);
1821
1822         brWindow.DeleteObject();
1823         brWindow.CreateSolidBrush(clrWindow);
1824
1825         penHilite.DeleteObject();
1826         penHilite.CreatePen(PS_SOLID, 1, afxGlobalData.clrHilite);
1827
1828         penBarFace.DeleteObject();
1829         penBarFace.CreatePen(PS_SOLID, 1, afxGlobalData.clrBarFace);
1830
1831         penBarShadow.DeleteObject();
1832         penBarShadow.CreatePen(PS_SOLID, 1, afxGlobalData.clrBarShadow);
1833
1834         if (brLight.GetSafeHandle())
1835         {
1836                 brLight.DeleteObject();
1837         }
1838
1839         if (m_nBitsPerPixel > 8)
1840         {
1841                 COLORREF clrLight = RGB(GetRValue(clrBtnFace) +((GetRValue(clrBtnHilite) - GetRValue(clrBtnFace)) / 2 ),
1842                         GetGValue(clrBtnFace) +((GetGValue(clrBtnHilite) - GetGValue(clrBtnFace)) / 2),
1843                         GetBValue(clrBtnFace) +((GetBValue(clrBtnHilite) - GetBValue(clrBtnFace)) / 2));
1844
1845                 brLight.CreateSolidBrush(clrLight);
1846         }
1847         else
1848         {
1849                 HBITMAP hbmGray = CreateDitherBitmap(dc.GetSafeHdc());
1850                 ENSURE(hbmGray != NULL);
1851
1852                 CBitmap bmp;
1853                 bmp.Attach(hbmGray);
1854
1855                 brLight.CreatePatternBrush(&bmp);
1856         }
1857
1858 //      CMenuImages::CleanUp();
1859 //      CDockingManager::m_bSDParamsModified = TRUE;
1860 }
1861
1862 BOOL AFX_GLOBAL_DATA::SetMenuFont(LPLOGFONT lpLogFont, BOOL bHorz)
1863 {
1864         ENSURE(lpLogFont != NULL);
1865
1866         if (bHorz)
1867         {
1868                 // Create regular font:
1869                 fontRegular.DeleteObject();
1870                 if (!fontRegular.CreateFontIndirect(lpLogFont))
1871                 {
1872                         ASSERT(FALSE);
1873                         return FALSE;
1874                 }
1875
1876                 // Create underline font:
1877                 lpLogFont->lfUnderline = TRUE;
1878                 fontUnderline.DeleteObject();
1879                 fontUnderline.CreateFontIndirect(lpLogFont);
1880                 lpLogFont->lfUnderline = FALSE;
1881
1882                 // Create bold font(used in the default menu items):
1883                 long lSavedWeight = lpLogFont->lfWeight;
1884                 lpLogFont->lfWeight = 700;
1885
1886                 fontBold.DeleteObject();
1887                 BOOL bResult = fontBold.CreateFontIndirect(lpLogFont);
1888
1889                 lpLogFont->lfWeight = lSavedWeight; // Restore weight
1890
1891                 if (!bResult)
1892                 {
1893                         ASSERT(FALSE);
1894                         return FALSE;
1895                 }
1896         }
1897         else // Vertical font
1898         {
1899                 fontVert.DeleteObject();
1900                 if (!fontVert.CreateFontIndirect(lpLogFont))
1901                 {
1902                         ASSERT(FALSE);
1903                         return FALSE;
1904                 }
1905         }
1906
1907         UpdateTextMetrics();
1908         return TRUE;
1909 }
1910
1911 void AFX_GLOBAL_DATA::UpdateTextMetrics()
1912 {
1913         CWindowDC dc(NULL);
1914
1915         CFont* pOldFont = dc.SelectObject(&fontRegular);
1916         ENSURE(pOldFont != NULL);
1917
1918         TEXTMETRIC tm;
1919         dc.GetTextMetrics(&tm);
1920
1921         int nExtra = tm.tmHeight < 15 ? 2 : 5;
1922
1923         m_nTextHeightHorz = tm.tmHeight + nExtra;
1924         m_nTextWidthHorz = tm.tmMaxCharWidth + nExtra;
1925
1926         dc.SelectObject(&fontVert);
1927         dc.GetTextMetrics(&tm);
1928
1929         nExtra = tm.tmHeight < 15 ? 2 : 5;
1930
1931         m_nTextHeightVert = tm.tmHeight + nExtra;
1932         m_nTextWidthVert = tm.tmMaxCharWidth + nExtra;
1933
1934         dc.SelectObject(pOldFont);
1935 }
1936
1937 HBITMAP AFX_GLOBAL_DATA::CreateDitherBitmap(HDC hDC)
1938 {
1939         struct  // BITMAPINFO with 16 colors
1940         {
1941                 BITMAPINFOHEADER bmiHeader;
1942                 RGBQUAD      bmiColors[16];
1943         }
1944         bmi;
1945         memset(&bmi, 0, sizeof(bmi));
1946
1947         bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1948         bmi.bmiHeader.biWidth = 8;
1949         bmi.bmiHeader.biHeight = 8;
1950         bmi.bmiHeader.biPlanes = 1;
1951         bmi.bmiHeader.biBitCount = 1;
1952         bmi.bmiHeader.biCompression = BI_RGB;
1953
1954         COLORREF clr = afxGlobalData.clrBtnFace;
1955
1956         bmi.bmiColors[0].rgbBlue = GetBValue(clr);
1957         bmi.bmiColors[0].rgbGreen = GetGValue(clr);
1958         bmi.bmiColors[0].rgbRed = GetRValue(clr);
1959
1960         clr = ::GetSysColor(COLOR_BTNHIGHLIGHT);
1961         bmi.bmiColors[1].rgbBlue = GetBValue(clr);
1962         bmi.bmiColors[1].rgbGreen = GetGValue(clr);
1963         bmi.bmiColors[1].rgbRed = GetRValue(clr);
1964
1965         // initialize the brushes
1966         long patGray[8];
1967         for (int i = 0; i < 8; i++)
1968                 patGray[i] = (i & 1) ? 0xAAAA5555L : 0x5555AAAAL;
1969
1970         HBITMAP hbm = CreateDIBitmap(hDC, &bmi.bmiHeader, CBM_INIT, (LPBYTE)patGray, (LPBITMAPINFO)&bmi, DIB_RGB_COLORS);
1971         return hbm;
1972 }
1973
1974 #if (WINVER >= 0x0601)
1975 ITaskbarList* AFX_GLOBAL_DATA::GetITaskbarList()
1976 {
1977         HRESULT hr = S_OK;
1978
1979         if (!bIsWindows7 || !m_bTaskBarInterfacesAvailable)
1980         {
1981                 return NULL;
1982         }
1983
1984         if (m_pTaskbarList != NULL)
1985         {
1986                 return m_pTaskbarList;
1987         }
1988
1989         if (!m_bComInitialized)
1990         {
1991                 hr = CoInitialize(NULL);
1992                 if (SUCCEEDED(hr))
1993                 {
1994                         m_bComInitialized = TRUE;
1995                 }
1996         }
1997
1998         if (SUCCEEDED(hr))
1999         {
2000                 hr = CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&m_pTaskbarList));
2001         }
2002
2003         ASSERT(SUCCEEDED(hr));
2004         return m_pTaskbarList;
2005 }
2006
2007 ITaskbarList3* AFX_GLOBAL_DATA::GetITaskbarList3()
2008 {
2009         HRESULT hr = S_OK;
2010
2011         if (!bIsWindows7 || !m_bTaskBarInterfacesAvailable)
2012         {
2013                 return NULL;
2014         }
2015
2016         if (m_pTaskbarList3 != NULL)
2017         {
2018                 return m_pTaskbarList3;
2019         }
2020
2021         if (!m_bComInitialized)
2022         {
2023                 hr = CoInitialize(NULL);
2024                 if (SUCCEEDED(hr))
2025                 {
2026                         m_bComInitialized = TRUE;
2027                 }
2028         }
2029
2030         if (SUCCEEDED(hr))
2031         {
2032                 hr = CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&m_pTaskbarList3));
2033         }
2034
2035         ASSERT(SUCCEEDED(hr));
2036         return m_pTaskbarList3;
2037 }
2038
2039 void AFX_GLOBAL_DATA::ReleaseTaskBarRefs()
2040 {
2041         m_bTaskBarInterfacesAvailable = FALSE;
2042
2043         if (m_pTaskbarList != NULL)
2044         {
2045                 RELEASE(m_pTaskbarList);
2046                 m_pTaskbarList = NULL;
2047         }
2048
2049         if (m_pTaskbarList3 != NULL)
2050         {
2051                 RELEASE(m_pTaskbarList3);
2052                 m_pTaskbarList3 = NULL;
2053         }
2054 }
2055 #endif
2056
2057 void AFX_GLOBAL_DATA::CleanUp()
2058 {
2059         if (brLight.GetSafeHandle())
2060         {
2061                 brLight.DeleteObject();
2062         }
2063
2064         // cleanup fonts:
2065         fontRegular.DeleteObject();
2066         fontBold.DeleteObject();
2067         fontUnderline.DeleteObject();
2068         fontVert.DeleteObject();
2069         fontVertCaption.DeleteObject();
2070         fontTooltip.DeleteObject();
2071
2072         ReleaseTaskBarRefs();
2073         ReleaseD2DRefs();
2074
2075         if (m_bBufferedPaintInited && m_pfBufferedPaintUnInit != NULL)
2076         {
2077                 m_pfBufferedPaintUnInit();
2078                 m_bBufferedPaintInited = FALSE;
2079         }
2080
2081         if (m_hinstUXThemeDLL != NULL)
2082         {
2083                 ::FreeLibrary(m_hinstUXThemeDLL);
2084                 m_hinstUXThemeDLL = NULL;
2085         }
2086
2087         if (m_hinstDwmapiDLL != NULL)
2088         {
2089                 ::FreeLibrary(m_hinstDwmapiDLL);
2090                 m_hinstDwmapiDLL = NULL;
2091         }
2092
2093         m_bEnableAccessibility = FALSE;
2094
2095         if (m_bComInitialized)
2096         {
2097                 CoUninitialize();
2098                 m_bComInitialized = FALSE;
2099         }
2100 }
2101
2102 void ControlBarCleanUp()
2103 {
2104         afxGlobalData.CleanUp();
2105
2106 //      afxMenuHash.CleanUp();
2107
2108 //      CMFCToolBar::CleanUpImages();
2109 //      CMenuImages::CleanUp();
2110
2111 //      if (GetCmdMgr() != NULL)
2112 //      {
2113 //              GetCmdMgr()->CleanUp();
2114 //      }
2115
2116 //      CKeyboardManager::CleanUp();
2117
2118         // Destroy visualization manager:
2119 //      CMFCVisualManager::DestroyInstance(TRUE /* bAutoDestroyOnly */);
2120 //      CMFCVisualManagerOffice2007::CleanStyle();
2121 }
2122
2123 #ifdef _AFXDLL
2124 void AfxGlobalsAddRef()
2125 {
2126         g_dwAfxGlobalDataRef++;
2127 }
2128
2129 void AfxGlobalsRelease()
2130 {
2131         g_dwAfxGlobalDataRef--;
2132         if (g_dwAfxGlobalDataRef == 0)
2133         {
2134                 ControlBarCleanUp();
2135         }
2136 }
2137 #endif
2138
2139 BOOL AFX_GLOBAL_DATA::DrawParentBackground(CWnd* pWnd, CDC* pDC, LPRECT rectClip)
2140 {
2141         ASSERT_VALID(pDC);
2142         ASSERT_VALID(pWnd);
2143
2144         BOOL bRes = FALSE;
2145
2146         CRgn rgn;
2147         if (rectClip != NULL)
2148         {
2149                 rgn.CreateRectRgnIndirect(rectClip);
2150                 pDC->SelectClipRgn(&rgn);
2151         }
2152
2153         CWnd* pParent = pWnd->GetParent();
2154         ASSERT_VALID(pParent);
2155
2156         // In Windows XP, we need to call DrawThemeParentBackground function to implement
2157         // transparent controls
2158         if (m_pfDrawThemeBackground != NULL)
2159         {
2160                 bRes = (*m_pfDrawThemeBackground)(pWnd->GetSafeHwnd(), pDC->GetSafeHdc(), rectClip) == S_OK;
2161         }
2162
2163         if (!bRes)
2164         {
2165                 CPoint pt(0, 0);
2166                 pWnd->MapWindowPoints(pParent, &pt, 1);
2167                 pt = pDC->OffsetWindowOrg(pt.x, pt.y);
2168
2169                 bRes = (BOOL) pParent->SendMessage(WM_ERASEBKGND, (WPARAM)pDC->m_hDC);
2170
2171                 pDC->SetWindowOrg(pt.x, pt.y);
2172         }
2173
2174         pDC->SelectClipRgn(NULL);
2175
2176         return bRes;
2177 }
2178
2179 CFrameWnd* AFXGetParentFrame(const CWnd* pWnd)
2180 {
2181         if (pWnd->GetSafeHwnd() == NULL)
2182         {
2183                 return NULL;
2184         }
2185         ASSERT_VALID(pWnd);
2186
2187         const CWnd* pParentWnd = pWnd;
2188
2189         while (pParentWnd != NULL)
2190         {
2191 //              if (pParentWnd->IsKindOf(RUNTIME_CLASS(CPaneFrameWnd)))
2192 ////            {
2193 //                      CPaneFrameWnd* pMiniFrame = DYNAMIC_DOWNCAST(CPaneFrameWnd, pParentWnd);
2194 //                      pParentWnd = pMiniFrame->GetParent();
2195 //              }
2196 //              else
2197                 {
2198                         pParentWnd = pParentWnd->GetParent();
2199                 }
2200
2201                 if (pParentWnd == NULL)
2202                 {
2203                         return NULL;
2204                 }
2205
2206                 if (pParentWnd->IsFrameWnd())
2207                 {
2208                         return(CFrameWnd*)pParentWnd;
2209                 }
2210         }
2211
2212         return NULL;
2213 }
2214
2215 COLORREF AFX_GLOBAL_DATA::GetColor(int nColor)
2216 {
2217         switch(nColor)
2218         {
2219                 case COLOR_BTNFACE:             return clrBtnFace;
2220                 case COLOR_BTNSHADOW:           return clrBtnShadow;
2221                 case COLOR_3DDKSHADOW:          return clrBtnDkShadow;
2222                 case COLOR_3DLIGHT:             return clrBtnLight;
2223                 case COLOR_BTNHIGHLIGHT:        return clrBtnHilite;
2224                 case COLOR_BTNTEXT:             return clrBtnText;
2225                 case COLOR_GRAYTEXT:            return clrGrayedText;
2226                 case COLOR_WINDOWFRAME:         return clrWindowFrame;
2227
2228                 case COLOR_HIGHLIGHT:           return clrHilite;
2229                 case COLOR_HIGHLIGHTTEXT:       return clrTextHilite;
2230
2231                 case COLOR_WINDOW:              return clrWindow;
2232                 case COLOR_WINDOWTEXT:          return clrWindowText;
2233
2234                 case COLOR_CAPTIONTEXT:         return clrCaptionText;
2235                 case COLOR_MENUTEXT:            return clrMenuText;
2236
2237                 case COLOR_ACTIVECAPTION:       return clrActiveCaption;
2238                 case COLOR_INACTIVECAPTION:     return clrInactiveCaption;
2239
2240                 case COLOR_ACTIVEBORDER:        return clrActiveBorder;
2241                 case COLOR_INACTIVEBORDER:      return clrInactiveBorder;
2242
2243                 case COLOR_INACTIVECAPTIONTEXT: return clrInactiveCaptionText;
2244         }
2245
2246         return ::GetSysColor(nColor);
2247 }
2248
2249 BOOL AFX_GLOBAL_DATA::SetLayeredAttrib(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags)
2250 {
2251         return(::SetLayeredWindowAttributes(hwnd, crKey, bAlpha, dwFlags));
2252 }
2253
2254 void AFX_GLOBAL_DATA::EnableAccessibilitySupport(BOOL bEnable/* = TRUE*/)
2255 {
2256         m_bEnableAccessibility = bEnable;
2257 }
2258
2259 CString AFX_GLOBAL_DATA::RegisterWindowClass(LPCTSTR lpszClassNamePrefix)
2260 {
2261         ENSURE(lpszClassNamePrefix != NULL);
2262
2263         // Register a new window class:
2264         HINSTANCE hInst = AfxGetInstanceHandle();
2265         UINT uiClassStyle = CS_DBLCLKS;
2266         HCURSOR hCursor = ::LoadCursor(NULL, IDC_ARROW);
2267         HBRUSH hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2268
2269         CString strClassName;
2270         strClassName.Format(_T("%s:%x:%x:%x:%x"), lpszClassNamePrefix, (UINT_PTR)hInst, uiClassStyle, (UINT_PTR)hCursor, (UINT_PTR)hbrBackground);
2271
2272         // See if the class already exists:
2273         WNDCLASS wndcls;
2274         if (::GetClassInfo(hInst, strClassName, &wndcls))
2275         {
2276                 // Already registered, assert everything is good:
2277                 ASSERT(wndcls.style == uiClassStyle);
2278         }
2279         else
2280         {
2281                 // Otherwise we need to register a new class:
2282                 wndcls.style = uiClassStyle;
2283                 wndcls.lpfnWndProc = ::DefWindowProc;
2284                 wndcls.cbClsExtra = wndcls.cbWndExtra = 0;
2285                 wndcls.hInstance = hInst;
2286                 wndcls.hIcon = NULL;
2287                 wndcls.hCursor = hCursor;
2288                 wndcls.hbrBackground = hbrBackground;
2289                 wndcls.lpszMenuName = NULL;
2290                 wndcls.lpszClassName = strClassName;
2291
2292                 if (!AfxRegisterClass(&wndcls))
2293                 {
2294                         AfxThrowResourceException();
2295                 }
2296         }
2297
2298         return strClassName;
2299 }
2300
2301 BOOL AFX_GLOBAL_DATA::ExcludeTag(CString& strBuffer, LPCTSTR lpszTag, CString& strTag, BOOL bIsCharsList /* = FALSE*/)
2302 {
2303         const int iBufLen = strBuffer.GetLength();
2304
2305         CString strTagStart = _T("<");
2306         strTagStart += lpszTag;
2307         strTagStart += _T(">");
2308
2309         const int iTagStartLen = strTagStart.GetLength();
2310
2311         int iStart = -1;
2312
2313         int iIndexStart = strBuffer.Find(strTagStart);
2314         if (iIndexStart < 0)
2315         {
2316                 return FALSE;
2317         }
2318
2319         iStart = iIndexStart + iTagStartLen;
2320
2321         CString strTagEnd = _T("</");
2322         strTagEnd += lpszTag;
2323         strTagEnd += _T('>');
2324
2325         const int iTagEndLen = strTagEnd.GetLength();
2326
2327         int iIndexEnd =  -1;
2328         int nBalanse = 1;
2329         for (int i = iStart; i < iBufLen - iTagEndLen + 1; i ++)
2330         {
2331                 if (strBuffer [i] != '<')
2332                 {
2333                         continue;
2334                 }
2335
2336                 if (i < iBufLen - iTagStartLen && _tcsncmp(strBuffer.Mid(i), strTagStart, iTagStartLen) == 0)
2337                 {
2338                         i += iTagStartLen - 1;
2339                         nBalanse ++;
2340                         continue;
2341                 }
2342
2343                 if (_tcsncmp(strBuffer.Mid(i), strTagEnd, iTagEndLen) == 0)
2344                 {
2345                         nBalanse --;
2346                         if (nBalanse == 0)
2347                         {
2348                                 iIndexEnd = i;
2349                                 break;
2350                         }
2351
2352                         i += iTagEndLen - 1;
2353                 }
2354         }
2355
2356         if (iIndexEnd == -1 || iStart > iIndexEnd)
2357         {
2358                 return FALSE;
2359         }
2360
2361         strTag = strBuffer.Mid(iStart, iIndexEnd - iStart);
2362         strTag.TrimLeft();
2363         strTag.TrimRight();
2364
2365         strBuffer.Delete(iIndexStart, iIndexEnd + iTagEndLen - iIndexStart);
2366
2367         if (bIsCharsList)
2368         {
2369                 if (strTag.GetLength() > 1 && strTag [0] == _T('\"'))
2370                 {
2371                         strTag = strTag.Mid(1, strTag.GetLength() - 2);
2372                 }
2373
2374                 strTag.Replace(_T("\\t"), _T("\t"));
2375                 strTag.Replace(_T("\\n"), _T("\n"));
2376                 strTag.Replace(_T("\\r"), _T("\r"));
2377                 strTag.Replace(_T("\\b"), _T("\b"));
2378                 strTag.Replace(_T("LT"), _T("<"));
2379                 strTag.Replace(_T("GT"), _T(">"));
2380                 strTag.Replace(_T("AMP"), _T("&"));
2381         }
2382
2383         return TRUE;
2384 }
2385
2386 BOOL AFX_GLOBAL_DATA::DwmExtendFrameIntoClientArea(HWND hWnd, AFX_MARGINS* pMargins)
2387 {
2388         if (m_pfDwmExtendFrameIntoClientArea == NULL)
2389         {
2390                 return FALSE;
2391         }
2392
2393         HRESULT hres = (*m_pfDwmExtendFrameIntoClientArea)(hWnd, pMargins);
2394         return hres == S_OK;
2395 }
2396
2397 LRESULT AFX_GLOBAL_DATA::DwmDefWindowProc(HWND hWnd, UINT message, WPARAM wp, LPARAM lp)
2398 {
2399         if (m_pfDwmDefWindowProc == NULL)
2400         {
2401                 return(LRESULT)-1;
2402         }
2403
2404         LRESULT lres = 0;
2405         (*m_pfDwmDefWindowProc)(hWnd, message, wp, lp, &lres);
2406
2407         return lres;
2408 }
2409
2410 BOOL AFX_GLOBAL_DATA::DwmIsCompositionEnabled()
2411 {
2412         if (m_pfDwmIsCompositionEnabled == NULL || bDisableAero)
2413         {
2414                 return FALSE;
2415         }
2416
2417         BOOL bEnabled = FALSE;
2418
2419         (*m_pfDwmIsCompositionEnabled)(&bEnabled);
2420         return bEnabled;
2421 }
2422
2423 BOOL AFX_GLOBAL_DATA::DrawTextOnGlass(HTHEME hTheme, CDC* pDC, int iPartId, int iStateId, CString strText, CRect rect, DWORD dwFlags, int nGlowSize, COLORREF clrText)
2424 {
2425         //---- bits used in dwFlags of DTTOPTS ----
2426 #define AFX_DTT_TEXTCOLOR    (1UL << 0)      // crText has been specified
2427 #define AFX_DTT_BORDERCOLOR  (1UL << 1)      // crBorder has been specified
2428 #define AFX_DTT_SHADOWCOLOR  (1UL << 2)      // crShadow has been specified
2429 #define AFX_DTT_SHADOWTYPE   (1UL << 3)      // iTextShadowType has been specified
2430 #define AFX_DTT_SHADOWOFFSET (1UL << 4)      // ptShadowOffset has been specified
2431 #define AFX_DTT_BORDERSIZE   (1UL << 5)      // nBorderSize has been specified
2432 #define AFX_DTT_FONTPROP     (1UL << 6)      // iFontPropId has been specified
2433 #define AFX_DTT_COLORPROP    (1UL << 7)      // iColorPropId has been specified
2434 #define AFX_DTT_STATEID      (1UL << 8)      // IStateId has been specified
2435 #define AFX_DTT_CALCRECT     (1UL << 9)      // Use pRect as and in/out parameter
2436 #define AFX_DTT_APPLYOVERLAY (1UL << 10)     // fApplyOverlay has been specified
2437 #define AFX_DTT_GLOWSIZE     (1UL << 11)     // iGlowSize has been specified
2438 #define AFX_DTT_CALLBACK     (1UL << 12)     // pfnDrawTextCallback has been specified
2439 #define AFX_DTT_COMPOSITED   (1UL << 13)     // Draws text with antialiased alpha(needs a DIB section)
2440
2441         if (hTheme == NULL || m_pfDrawThemeTextEx == NULL || !DwmIsCompositionEnabled())
2442         {
2443                 pDC->DrawText(strText, rect, dwFlags);
2444                 return FALSE;
2445         }
2446
2447         CComBSTR bstmp = (LPCTSTR)strText;
2448
2449         wchar_t* wbuf = new wchar_t[bstmp.Length() + 1];
2450         wcscpy_s(wbuf, bstmp.Length() + 1, bstmp);
2451
2452         AFX_DTTOPTS dto;
2453         memset(&dto, 0, sizeof(AFX_DTTOPTS));
2454         dto.dwSize = sizeof(AFX_DTTOPTS);
2455         dto.dwFlags = AFX_DTT_COMPOSITED;
2456
2457         if (nGlowSize > 0)
2458         {
2459                 dto.dwFlags |= AFX_DTT_GLOWSIZE;
2460                 dto.iGlowSize = nGlowSize;
2461         }
2462
2463         if (clrText != (COLORREF)-1)
2464         {
2465                 dto.dwFlags |= AFX_DTT_TEXTCOLOR;
2466                 dto.crText = clrText;
2467         }
2468
2469         (*m_pfDrawThemeTextEx)(hTheme, pDC->GetSafeHdc(), iPartId, iStateId, wbuf, -1, dwFlags, rect, &dto);
2470
2471         delete [] wbuf;
2472
2473         return TRUE;
2474 }
2475
2476 HCURSOR AFX_GLOBAL_DATA::GetHandCursor()
2477 {
2478         if (m_hcurHand == NULL)
2479         {
2480                 m_hcurHand = ::LoadCursorW(NULL, MAKEINTRESOURCEW(IDC_HAND));
2481         }
2482
2483         return m_hcurHand;
2484 }
2485
2486 BOOL AFX_GLOBAL_DATA::Resume()
2487 {
2488         m_hinstUXThemeDLL = ::AfxCtxLoadLibraryW(L"UxTheme.dll");
2489
2490         if (m_hinstUXThemeDLL != NULL)
2491         {
2492                 m_pfDrawThemeBackground = (DRAWTHEMEPARENTBACKGROUND)::GetProcAddress (m_hinstUXThemeDLL, "DrawThemeParentBackground");
2493                 m_pfDrawThemeTextEx = (DRAWTHEMETEXTEX)::GetProcAddress (m_hinstUXThemeDLL, "DrawThemeTextEx");
2494                 m_pfBeginBufferedPaint = (BEGINBUFFEREDPAINT)::GetProcAddress (m_hinstUXThemeDLL, "BeginBufferedPaint");
2495                 m_pfEndBufferedPaint = (ENDBUFFEREDPAINT)::GetProcAddress (m_hinstUXThemeDLL, "EndBufferedPaint");
2496         }
2497         else
2498         {
2499                 m_pfDrawThemeBackground = NULL;
2500                 m_pfDrawThemeTextEx = NULL;
2501                 m_pfBeginBufferedPaint = NULL;
2502                 m_pfEndBufferedPaint = NULL;
2503         }
2504
2505         if (m_hinstDwmapiDLL != NULL)
2506         {
2507                 m_hinstDwmapiDLL = AfxLoadSystemLibraryUsingFullPath(L"dwmapi.dll");
2508                 ENSURE(m_hinstDwmapiDLL != NULL);
2509
2510                 m_pfDwmExtendFrameIntoClientArea = (DWMEXTENDFRAMEINTOCLIENTAREA)::GetProcAddress (m_hinstDwmapiDLL, "DwmExtendFrameIntoClientArea");
2511                 m_pfDwmDefWindowProc = (DWMDEFWINDOWPROC) ::GetProcAddress (m_hinstDwmapiDLL, "DwmDefWindowProc");
2512                 m_pfDwmIsCompositionEnabled = (DWMISCOMPOSITIONENABLED)::GetProcAddress (m_hinstDwmapiDLL, "DwmIsCompositionEnabled");
2513         }
2514
2515         if (m_bEnableAccessibility)
2516         {
2517                 EnableAccessibilitySupport();
2518         }
2519
2520 //      CMFCVisualManagerOffice2007::CleanStyle ();
2521
2522 //      if (CMFCVisualManager::m_pRTIDefault != NULL)
2523 //      {
2524 //              CMFCVisualManager::SetDefaultManager (CMFCVisualManager::m_pRTIDefault);
2525 //      }
2526
2527         return TRUE;
2528 }
2529
2530 BOOL AFX_GLOBAL_DATA::GetNonClientMetrics (NONCLIENTMETRICS& info)
2531 {
2532         struct AFX_OLDNONCLIENTMETRICS
2533         {
2534                 UINT    cbSize;
2535                 int     iBorderWidth;
2536                 int     iScrollWidth;
2537                 int     iScrollHeight;
2538                 int     iCaptionWidth;
2539                 int     iCaptionHeight;
2540                 LOGFONT lfCaptionFont;
2541                 int     iSmCaptionWidth;
2542                 int     iSmCaptionHeight;
2543                 LOGFONT lfSmCaptionFont;
2544                 int     iMenuWidth;
2545                 int     iMenuHeight;
2546                 LOGFONT lfMenuFont;
2547                 LOGFONT lfStatusFont;
2548                 LOGFONT lfMessageFont;
2549         };
2550
2551         if (_AfxGetComCtlVersion() < MAKELONG(1, 6))
2552         {
2553                 info.cbSize = sizeof(AFX_OLDNONCLIENTMETRICS);
2554         }
2555
2556         return ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, info.cbSize, &info, 0);
2557 }
2558
2559
2560 BOOL AFXAPI AfxIsExtendedFrameClass(CWnd* pWnd)
2561 {
2562         ENSURE( pWnd );
2563 #if 0
2564         if (pWnd->IsKindOf(RUNTIME_CLASS(CFrameWndEx)))
2565         {
2566                 return TRUE;
2567         }
2568         if (pWnd->IsKindOf(RUNTIME_CLASS(CMDIFrameWndEx)))
2569         {
2570                 return TRUE;
2571         }
2572         if (pWnd->IsKindOf(RUNTIME_CLASS(COleIPFrameWndEx)))
2573         {
2574                 return TRUE;
2575         }
2576         if (pWnd->IsKindOf(RUNTIME_CLASS(COleDocIPFrameWndEx)))
2577         {
2578                 return TRUE;
2579         }
2580         if (pWnd->IsKindOf(RUNTIME_CLASS(CMDIChildWndEx)))
2581         {
2582                 return TRUE;
2583         }
2584 #endif
2585         return FALSE;
2586 }
2587
2588
2589 BOOL AFXAPI AfxIsMFCToolBar(CWnd* pWnd)
2590 {
2591         ENSURE( pWnd );
2592 //      if (pWnd->IsKindOf(RUNTIME_CLASS(CMFCToolBar)))
2593 //      {
2594 //              return TRUE;
2595 //      }
2596         return FALSE;
2597 }
2598
2599 HRESULT AFX_GLOBAL_DATA::ShellCreateItemFromParsingName(PCWSTR pszPath, IBindCtx *pbc, REFIID riid, void **ppv)
2600 {
2601         static HMODULE hShellDll = AfxCtxLoadLibrary(_T("Shell32.dll"));
2602         ENSURE(hShellDll != NULL);
2603
2604         typedef HRESULT (__stdcall *PFNSHCREATEITEMFROMPARSINGNAME)(
2605                 PCWSTR,
2606                 IBindCtx*,
2607                 REFIID,
2608                 void**
2609                 );
2610
2611         PFNSHCREATEITEMFROMPARSINGNAME pSHCreateItemFromParsingName =
2612                 (PFNSHCREATEITEMFROMPARSINGNAME)GetProcAddress(hShellDll, "SHCreateItemFromParsingName");
2613         if (pSHCreateItemFromParsingName == NULL)
2614         {
2615                 return E_FAIL;
2616         }
2617
2618         return (*pSHCreateItemFromParsingName)(pszPath, pbc, riid, ppv);
2619 }
2620
2621 BOOL AFX_GLOBAL_DATA::InitD2D(D2D1_FACTORY_TYPE d2dFactoryType, DWRITE_FACTORY_TYPE writeFactoryType)
2622 {
2623         if (m_bD2DInitialized)
2624         {
2625                 return TRUE;
2626         }
2627
2628         HRESULT hr = S_OK;
2629
2630         if (!m_bComInitialized)
2631         {
2632                 hr = CoInitialize(NULL);
2633                 if (FAILED(hr))
2634                 {
2635                         return FALSE;
2636                 }
2637         }
2638
2639         m_bComInitialized = TRUE;
2640
2641         if ((m_hinstD2DDLL = AfxLoadSystemLibraryUsingFullPath(L"D2D1.dll")) == NULL)
2642         {
2643                 return FALSE;
2644         }
2645
2646         typedef HRESULT (WINAPI * D2D1CREATEFACTORY)(D2D1_FACTORY_TYPE factoryType, REFIID riid, CONST D2D1_FACTORY_OPTIONS *pFactoryOptions, void **ppIFactory);
2647         typedef HRESULT (WINAPI * DWRITECREATEFACTORY)(DWRITE_FACTORY_TYPE factoryType, REFIID riid, IUnknown **factory);
2648
2649         D2D1CREATEFACTORY pfD2D1CreateFactory = (D2D1CREATEFACTORY)::GetProcAddress(m_hinstD2DDLL, "D2D1CreateFactory");
2650         if (pfD2D1CreateFactory != NULL)
2651         {
2652                 hr = (*pfD2D1CreateFactory)(d2dFactoryType, __uuidof(ID2D1Factory),
2653                         NULL, reinterpret_cast<void **>(&m_pDirect2dFactory));
2654                 if (FAILED(hr))
2655                 {
2656                         m_pDirect2dFactory = NULL;
2657                         return FALSE;
2658                 }
2659         }
2660
2661         m_pfD2D1MakeRotateMatrix = (D2D1MAKEROTATEMATRIX)::GetProcAddress(m_hinstD2DDLL, "D2D1MakeRotateMatrix");
2662
2663         m_hinstDWriteDLL = AfxLoadSystemLibraryUsingFullPath(L"DWrite.dll");
2664         if (m_hinstDWriteDLL != NULL)
2665         {
2666                 DWRITECREATEFACTORY pfD2D1CreateFactory = (DWRITECREATEFACTORY)::GetProcAddress(m_hinstDWriteDLL, "DWriteCreateFactory");
2667                 if (pfD2D1CreateFactory != NULL)
2668                 {
2669                         hr = (*pfD2D1CreateFactory)(writeFactoryType, __uuidof(IDWriteFactory), (IUnknown**)&m_pWriteFactory);
2670                 }
2671         }
2672
2673         hr = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (LPVOID*)&m_pWicFactory);
2674
2675         m_bD2DInitialized = TRUE;
2676         return TRUE;
2677 }
2678
2679 void AFX_GLOBAL_DATA::ReleaseD2DRefs()
2680 {
2681         if (!m_bD2DInitialized)
2682         {
2683                 return;
2684         }
2685
2686         if (m_pDirect2dFactory != NULL)
2687         {
2688                 m_pDirect2dFactory->Release();
2689                 m_pDirect2dFactory = NULL;
2690         }
2691
2692         if (m_pWriteFactory != NULL)
2693         {
2694                 m_pWriteFactory->Release();
2695                 m_pWriteFactory = NULL;
2696         }
2697
2698         if (m_pWicFactory != NULL)
2699         {
2700                 m_pWicFactory->Release();
2701                 m_pWicFactory = NULL;
2702         }
2703
2704         if (m_hinstD2DDLL != NULL)
2705         {
2706                 ::FreeLibrary(m_hinstD2DDLL);
2707         }
2708
2709         if (m_hinstDWriteDLL != NULL)
2710         {
2711                 ::FreeLibrary(m_hinstDWriteDLL);
2712         }
2713
2714         m_bD2DInitialized = FALSE;
2715 }
2716
2717 #endif