|
1
|
1 #include "stdafx.h"
|
|
|
2 #include "DarkMode.h"
|
|
|
3 #include "DarkModeEx.h"
|
|
|
4 #include "win32_utility.h"
|
|
|
5 #include "win32_op.h"
|
|
|
6 #include "PaintUtils.h"
|
|
|
7 #include "ImplementOnFinalMessage.h"
|
|
|
8 #include <vsstyle.h>
|
|
|
9 #include "GDIUtils.h"
|
|
|
10 #include "CListControl.h"
|
|
|
11 #include "CListControl-Subst.h"
|
|
|
12 #include "ReStyleWnd.h"
|
|
|
13 #include <map>
|
|
|
14
|
|
|
15 // Allow scary undocumented ordinal-dll-export functions?
|
|
|
16 #define DARKMODE_ALLOW_HAX 1
|
|
|
17
|
|
|
18 #define DARKMODE_DEBUG 0
|
|
|
19
|
|
|
20 #if DARKMODE_DEBUG
|
|
|
21 #define DARKMODE_DEBUG_PRINT(...) PFC_DEBUG_PRINT("DarkMode: ", __VA_ARGS__)
|
|
|
22 #else
|
|
|
23 #define DARKMODE_DEBUG_PRINT(...)
|
|
|
24 #endif
|
|
|
25
|
|
|
26
|
|
|
27 #include <dwmapi.h>
|
|
|
28 #pragma comment(lib, "dwmapi.lib")
|
|
|
29
|
|
|
30 /*
|
|
|
31
|
|
|
32 ==== DARK MODE KNOWLEDGE BASE ====
|
|
|
33
|
|
|
34 == Generic window ==
|
|
|
35 UpdateTitleBar() to set title bar to black
|
|
|
36
|
|
|
37 == Dialog box ==
|
|
|
38 Use WM_CTLCOLORDLG, background of 0x383838
|
|
|
39 UpdateTitleBar() to set title bar to black
|
|
|
40
|
|
|
41 == Edit box ==
|
|
|
42 Use WM_CTLCOLOREDIT, background of 0x383838
|
|
|
43 ApplyDarkThemeCtrl() with "Explorer"
|
|
|
44
|
|
|
45 == Drop list combo ==
|
|
|
46 Method #1: ::SetWindowTheme(wnd, L"DarkMode_CFD", nullptr);
|
|
|
47 Method #2: ::SetWindowTheme(wnd, L"", L""); to obey WM_CTLCOLOR* but leaves oldstyle classic-colors button and breaks comboboxex
|
|
|
48
|
|
|
49 == Button ==
|
|
|
50 Use WM_CTLCOLORBTN, background of 0x383838
|
|
|
51 ApplyDarkThemeCtrl() with "Explorer"
|
|
|
52
|
|
|
53 == Scroll bar ==
|
|
|
54 ApplyDarkThemeCtrl() with "Explorer"
|
|
|
55 ^^ on either scrollbar or the window that implicitly creates scrollbars
|
|
|
56
|
|
|
57 == Header ==
|
|
|
58 ApplyDarkThemeCtrl() with "ItemsView"
|
|
|
59 Handle custom draw, override text color
|
|
|
60
|
|
|
61 == Tree view ==
|
|
|
62 ApplyDarkThemeCtrl() with "Explorer"
|
|
|
63 Set text/bk colors explicitly
|
|
|
64
|
|
|
65 Text color: 0xdedede
|
|
|
66 Background: 0x191919
|
|
|
67
|
|
|
68 Label-editing:
|
|
|
69 Pass WM_CTLCOLOR* to parent, shim TVM_EDITLABEL to pass theme to the editbox (not really necessary tho)
|
|
|
70
|
|
|
71
|
|
|
72 == Rebar ==
|
|
|
73 Can be beaten into working to some extent with a combination of:
|
|
|
74 * ::SetWindowTheme(toolbar, L"", L""); or else RB_SETTEXTCOLOR & REBARBANDINFO colors are disregarded
|
|
|
75 * Use RB_SETTEXTCOLOR / SetTextColor() + RB_SETBKCOLOR / SetBkColor() to override text/background colors
|
|
|
76 * Override WM_ERASEBKGND to draw band frames, RB_SETBKCOLOR doesn't seem to be thorough
|
|
|
77 * NM_CUSTOMDRAW on parent window to paint band labels & grippers without annoying glitches
|
|
|
78 NM_CUSTOMDRAW is buggy, doesn't hand you band indexes to query text, have to use hit tests to know what text to render
|
|
|
79
|
|
|
80 Solution: full custom draw
|
|
|
81
|
|
|
82
|
|
|
83 == Toolbar ==
|
|
|
84 Source: https://stackoverflow.com/questions/61271578/winapi-toolbar-text-color
|
|
|
85 Respects background color of its parent
|
|
|
86 Override text:
|
|
|
87 ::SetWindowTheme(toolbar, L"", L""); or else NM_CUSTOMDRAW color is disregarded
|
|
|
88 NM_CUSTOMDRAW handler:
|
|
|
89 switch (cd->nmcd.dwDrawStage) {
|
|
|
90 case CDDS_PREPAINT: return CDRF_NOTIFYITEMDRAW;
|
|
|
91 case CDDS_ITEMPREPAINT: cd->clrText = DarkMode::GetSysColor(COLOR_WINDOWTEXT); return CDRF_DODEFAULT;
|
|
|
92 }
|
|
|
93
|
|
|
94 == Tab control ==
|
|
|
95 Full custom draw, see CTabsHook
|
|
|
96
|
|
|
97 == List View ==
|
|
|
98 Dark scrollbars are shown only if using "Explorer" theme, but other stuff needs "ItemsView" theme???
|
|
|
99 Other projects shim Windows functions to bypass the above.
|
|
|
100 Avoid using List View, use libPPUI CListControl instead.
|
|
|
101
|
|
|
102 == List Box ==
|
|
|
103 Use WM_CTLCOLOR*
|
|
|
104
|
|
|
105 == Status Bar ==
|
|
|
106 Full custom draw
|
|
|
107
|
|
|
108 == Check box, radio button ==
|
|
|
109 SetWindowTheme(wnd, L"", L""); works but not 100% pretty, disabled text ugly in particular
|
|
|
110 Full custom draw preferred
|
|
|
111
|
|
|
112 == Group box ===
|
|
|
113 SetWindowTheme(wnd, L"", L""); works but not 100% pretty, disabled text ugly in particular
|
|
|
114 Full custom draw preferred (we don't do this).
|
|
|
115 Avoid disabling groupboxes / use something else.
|
|
|
116
|
|
|
117 ==== NOTES ====
|
|
|
118 AllowDarkModeForWindow() needs SetPreferredAppMode() to take effect, hence we implicitly call it
|
|
|
119 AllowDarkModeForWindow() must be called BEFORE SetWindowTheme() to take effect
|
|
|
120
|
|
|
121 It seems it is interchangeable to do:
|
|
|
122 AllowDarkModeForWindow(wnd, true); SetWindowTheme(wnd, L"foo", nullptr);
|
|
|
123 vs
|
|
|
124 SetWindowTheme(wnd, L"DarkMode_foo", nullptr)
|
|
|
125 But the latter doesn't require undocumented function calls and doesn't infect all menus with dark mode
|
|
|
126 */
|
|
|
127
|
|
|
128 namespace {
|
|
|
129 enum class PreferredAppMode
|
|
|
130 {
|
|
|
131 Default,
|
|
|
132 AllowDark,
|
|
|
133 ForceDark,
|
|
|
134 ForceLight,
|
|
|
135 Max
|
|
|
136 };
|
|
|
137
|
|
|
138 enum WINDOWCOMPOSITIONATTRIB
|
|
|
139 {
|
|
|
140 WCA_UNDEFINED = 0,
|
|
|
141 WCA_NCRENDERING_ENABLED = 1,
|
|
|
142 WCA_NCRENDERING_POLICY = 2,
|
|
|
143 WCA_TRANSITIONS_FORCEDISABLED = 3,
|
|
|
144 WCA_ALLOW_NCPAINT = 4,
|
|
|
145 WCA_CAPTION_BUTTON_BOUNDS = 5,
|
|
|
146 WCA_NONCLIENT_RTL_LAYOUT = 6,
|
|
|
147 WCA_FORCE_ICONIC_REPRESENTATION = 7,
|
|
|
148 WCA_EXTENDED_FRAME_BOUNDS = 8,
|
|
|
149 WCA_HAS_ICONIC_BITMAP = 9,
|
|
|
150 WCA_THEME_ATTRIBUTES = 10,
|
|
|
151 WCA_NCRENDERING_EXILED = 11,
|
|
|
152 WCA_NCADORNMENTINFO = 12,
|
|
|
153 WCA_EXCLUDED_FROM_LIVEPREVIEW = 13,
|
|
|
154 WCA_VIDEO_OVERLAY_ACTIVE = 14,
|
|
|
155 WCA_FORCE_ACTIVEWINDOW_APPEARANCE = 15,
|
|
|
156 WCA_DISALLOW_PEEK = 16,
|
|
|
157 WCA_CLOAK = 17,
|
|
|
158 WCA_CLOAKED = 18,
|
|
|
159 WCA_ACCENT_POLICY = 19,
|
|
|
160 WCA_FREEZE_REPRESENTATION = 20,
|
|
|
161 WCA_EVER_UNCLOAKED = 21,
|
|
|
162 WCA_VISUAL_OWNER = 22,
|
|
|
163 WCA_HOLOGRAPHIC = 23,
|
|
|
164 WCA_EXCLUDED_FROM_DDA = 24,
|
|
|
165 WCA_PASSIVEUPDATEMODE = 25,
|
|
|
166 WCA_USEDARKMODECOLORS = 26,
|
|
|
167 WCA_LAST = 27
|
|
|
168 };
|
|
|
169
|
|
|
170 struct WINDOWCOMPOSITIONATTRIBDATA
|
|
|
171 {
|
|
|
172 WINDOWCOMPOSITIONATTRIB Attrib;
|
|
|
173 PVOID pvData;
|
|
|
174 SIZE_T cbData;
|
|
|
175 };
|
|
|
176 #if DARKMODE_ALLOW_HAX
|
|
|
177 using fnAllowDarkModeForWindow = bool (WINAPI*)(HWND hWnd, bool allow); // ordinal 133
|
|
|
178 using fnSetPreferredAppMode = PreferredAppMode(WINAPI*)(PreferredAppMode appMode); // ordinal 135, since 1809
|
|
|
179 using fnFlushMenuThemes = void (WINAPI*)(); // ordinal 136
|
|
|
180 fnAllowDarkModeForWindow _AllowDarkModeForWindow = nullptr;
|
|
|
181 fnSetPreferredAppMode _SetPreferredAppMode = nullptr;
|
|
|
182 fnFlushMenuThemes _FlushMenuThemes = nullptr;
|
|
|
183
|
|
|
184 bool ImportsInited = false;
|
|
|
185
|
|
|
186 void InitImports() {
|
|
|
187 if (ImportsInited) return;
|
|
|
188 if (DarkMode::IsSupportedSystem()) {
|
|
|
189 HMODULE hUxtheme = LoadLibraryEx(L"uxtheme.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
|
|
|
190 if (hUxtheme) {
|
|
|
191 _AllowDarkModeForWindow = reinterpret_cast<fnAllowDarkModeForWindow>(GetProcAddress(hUxtheme, MAKEINTRESOURCEA(133)));
|
|
|
192 _SetPreferredAppMode = reinterpret_cast<fnSetPreferredAppMode>(GetProcAddress(hUxtheme, MAKEINTRESOURCEA(135)));
|
|
|
193 _FlushMenuThemes = reinterpret_cast<fnFlushMenuThemes>(GetProcAddress(hUxtheme, MAKEINTRESOURCEA(136)));
|
|
|
194 }
|
|
|
195 }
|
|
|
196 ImportsInited = true;
|
|
|
197 }
|
|
|
198 #endif
|
|
|
199 }
|
|
|
200
|
|
|
201
|
|
|
202
|
|
|
203 namespace DarkMode {
|
|
|
204 UINT msgSetDarkMode() {
|
|
|
205 // No need to threadguard this, should be main thread only, not much harm even if it's not
|
|
|
206 static UINT val = 0;
|
|
|
207 if (val == 0) val = RegisterWindowMessage(L"libPPUI:msgSetDarkMode");
|
|
|
208 return val;
|
|
|
209 }
|
|
|
210 bool IsSupportedSystem() {
|
|
|
211 return Win10BuildNumber() >= 17763 && !IsWine(); // require at least Win10 1809 / Server 2019
|
|
|
212 }
|
|
|
213 bool IsWindows11() {
|
|
|
214 return Win10BuildNumber() >= 22000;
|
|
|
215 }
|
|
|
216 bool QueryUserOption() {
|
|
|
217 DWORD v = 0;
|
|
|
218 DWORD cb = sizeof(v);
|
|
|
219 DWORD type = 0;
|
|
|
220 if (RegGetValue(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize", L"AppsUseLightTheme", RRF_RT_REG_DWORD, &type, &v, &cb) == 0) {
|
|
|
221 if (type == REG_DWORD) {
|
|
|
222 return v == 0;
|
|
|
223 }
|
|
|
224 }
|
|
|
225 return false;
|
|
|
226 }
|
|
|
227 void UpdateTitleBar(HWND hWnd, bool bDark) {
|
|
|
228 if (!IsSupportedSystem()) return;
|
|
|
229
|
|
|
230 CWindow wnd(hWnd);
|
|
|
231 DWORD style = wnd.GetStyle();
|
|
|
232 if ((style & WS_CAPTION) != WS_CAPTION) return;
|
|
|
233
|
|
|
234 #if 0
|
|
|
235 // Some apps do this - no idea why, doesn't work
|
|
|
236 // Kept for future reference
|
|
|
237 AllowDarkModeForWindow(hWnd, bDark);
|
|
|
238 SetProp(hWnd, L"UseImmersiveDarkModeColors", (HANDLE)(INT_PTR)(bDark ? TRUE : FALSE));
|
|
|
239 #endif
|
|
|
240
|
|
|
241 if (IsWindows11()) {
|
|
|
242 // DwmSetWindowAttribute()
|
|
|
243 // Windows 11 : works
|
|
|
244 // Windows 10 @ late 2021 : doesn't work
|
|
|
245 // Server 2019 : as good as SetWindowCompositionAttribute(), needs ModifyStyle() hack for full effect
|
|
|
246 BOOL arg = !!bDark;
|
|
|
247 DwmSetWindowAttribute(hWnd, 19 /*DWMWA_USE_IMMERSIVE_DARK_MODE*/, &arg, sizeof(arg));
|
|
|
248 } else {
|
|
|
249 // Windows 10 mode
|
|
|
250 using fnSetWindowCompositionAttribute = BOOL(WINAPI*)(HWND hWnd, WINDOWCOMPOSITIONATTRIBDATA*);
|
|
|
251 static fnSetWindowCompositionAttribute _SetWindowCompositionAttribute = reinterpret_cast<fnSetWindowCompositionAttribute>(GetProcAddress(GetModuleHandleW(L"user32.dll"), "SetWindowCompositionAttribute"));
|
|
|
252 if (_SetWindowCompositionAttribute != nullptr) {
|
|
|
253 BOOL dark = !!bDark;
|
|
|
254 WINDOWCOMPOSITIONATTRIBDATA data = { WCA_USEDARKMODECOLORS, &dark, sizeof(dark) };
|
|
|
255 _SetWindowCompositionAttribute(hWnd, &data);
|
|
|
256
|
|
|
257 // Neither of these fixes stuck titlebar (kept in here for future reference)
|
|
|
258 // ::RedrawWindow(hWnd, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_UPDATENOW);
|
|
|
259 // ::SetWindowPos(hWnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_DRAWFRAME);
|
|
|
260
|
|
|
261 // Apparently the least painful way to reliably fix stuck titlebar
|
|
|
262 // 2x SWP_FRAMECHANGED needed with actual style changes
|
|
|
263
|
|
|
264 if (style & WS_VISIBLE) { // Only do this if visible
|
|
|
265 wnd.ModifyStyle(WS_BORDER, 0, SWP_FRAMECHANGED);
|
|
|
266 wnd.ModifyStyle(0, WS_BORDER, SWP_FRAMECHANGED);
|
|
|
267 }
|
|
|
268
|
|
|
269 }
|
|
|
270 }
|
|
|
271 }
|
|
|
272
|
|
|
273 void ApplyDarkThemeCtrl2(HWND ctrl, bool bDark, const wchar_t* ThemeID_light, const wchar_t * ThemeID_dark) {
|
|
|
274 if (ctrl == NULL) return;
|
|
|
275 AllowDarkModeForWindow(ctrl, bDark);
|
|
|
276 if (bDark && IsSupportedSystem()) {
|
|
|
277 ::SetWindowTheme(ctrl, ThemeID_dark, NULL);
|
|
|
278 } else {
|
|
|
279 ::SetWindowTheme(ctrl, ThemeID_light, NULL);
|
|
|
280 }
|
|
|
281 }
|
|
|
282
|
|
|
283 void ApplyDarkThemeCtrl(HWND ctrl, bool bDark, const wchar_t* ThemeID) {
|
|
|
284 if ( ctrl == NULL ) return;
|
|
|
285 AllowDarkModeForWindow(ctrl, bDark);
|
|
|
286 if (bDark && IsSupportedSystem()) {
|
|
|
287 std::wstring temp = L"DarkMode_"; temp += ThemeID;
|
|
|
288 ::SetWindowTheme(ctrl, temp.c_str(), NULL);
|
|
|
289 } else {
|
|
|
290 ::SetWindowTheme(ctrl, ThemeID, NULL);
|
|
|
291 }
|
|
|
292 }
|
|
|
293
|
|
|
294 void DarkenEditLite(HWND ctrl) {
|
|
|
295 if (IsSupportedSystem()) {
|
|
|
296 ::SetWindowTheme(ctrl, L"DarkMode_Explorer", NULL);
|
|
|
297 }
|
|
|
298 }
|
|
|
299
|
|
|
300 void DarkenComboLite(HWND ctrl) {
|
|
|
301 if (IsSupportedSystem()) {
|
|
|
302 ::SetWindowTheme(ctrl, L"DarkMode_CFD", NULL);
|
|
|
303 }
|
|
|
304 }
|
|
|
305
|
|
|
306 bool IsDCDark(HDC dc_) {
|
|
|
307 CDCHandle dc(dc_);
|
|
|
308 return IsThemeDark(dc.GetTextColor(), dc.GetBkColor());
|
|
|
309 }
|
|
|
310 bool IsDialogDark(HWND dlg, UINT msgSend) {
|
|
|
311 CWindowDC dc(dlg);
|
|
|
312 dc.SetTextColor(0x000000);
|
|
|
313 dc.SetBkColor(0xFFFFFF);
|
|
|
314 ::SendMessage(dlg, msgSend, (WPARAM)dc.m_hDC, (LPARAM)dlg);
|
|
|
315 return IsDCDark(dc);
|
|
|
316 }
|
|
|
317
|
|
|
318 COLORREF GetSysColor(int idx, bool bDark) {
|
|
|
319 if (!bDark) return ::GetSysColor(idx);
|
|
|
320 switch (idx) {
|
|
|
321 case COLOR_MENU:
|
|
|
322 case COLOR_BTNFACE:
|
|
|
323 case COLOR_WINDOW:
|
|
|
324 case COLOR_MENUBAR:
|
|
|
325 // Explorer:
|
|
|
326 // return 0x383838;
|
|
|
327 return 0x202020;
|
|
|
328 case COLOR_BTNSHADOW:
|
|
|
329 return 0;
|
|
|
330 case COLOR_WINDOWTEXT:
|
|
|
331 case COLOR_MENUTEXT:
|
|
|
332 case COLOR_BTNTEXT:
|
|
|
333 case COLOR_CAPTIONTEXT:
|
|
|
334 // Explorer:
|
|
|
335 // return 0xdedede;
|
|
|
336 return 0xC0C0C0;
|
|
|
337 case COLOR_BTNHIGHLIGHT:
|
|
|
338 case COLOR_MENUHILIGHT:
|
|
|
339 return 0x383838;
|
|
|
340 case COLOR_HIGHLIGHT:
|
|
|
341 return 0x777777;
|
|
|
342 case COLOR_HIGHLIGHTTEXT:
|
|
|
343 return 0x101010;
|
|
|
344 case COLOR_GRAYTEXT:
|
|
|
345 return 0x777777;
|
|
|
346 case COLOR_HOTLIGHT:
|
|
|
347 return 0xd69c56;
|
|
|
348 default:
|
|
|
349 return ::GetSysColor(idx);
|
|
|
350 }
|
|
|
351 }
|
|
|
352 #if DARKMODE_ALLOW_HAX
|
|
|
353 void SetAppDarkMode(bool bDark) {
|
|
|
354 InitImports();
|
|
|
355
|
|
|
356 if (_SetPreferredAppMode != nullptr) {
|
|
|
357 static PreferredAppMode lastMode = PreferredAppMode::Default;
|
|
|
358 PreferredAppMode wantMode = bDark ? PreferredAppMode::ForceDark : PreferredAppMode::ForceLight;
|
|
|
359 if (lastMode != wantMode) {
|
|
|
360 _SetPreferredAppMode(wantMode);
|
|
|
361 lastMode = wantMode;
|
|
|
362 if (_FlushMenuThemes) _FlushMenuThemes();
|
|
|
363 }
|
|
|
364 }
|
|
|
365 }
|
|
|
366 #else
|
|
|
367 void SetAppDarkMode(bool) {}
|
|
|
368 #endif
|
|
|
369 #if DARKMODE_ALLOW_HAX
|
|
|
370 void AllowDarkModeForWindow(HWND wnd, bool bDark) {
|
|
|
371 InitImports();
|
|
|
372
|
|
|
373 if (_AllowDarkModeForWindow) _AllowDarkModeForWindow(wnd, bDark);
|
|
|
374 }
|
|
|
375 #else
|
|
|
376 void AllowDarkModeForWindow(HWND, bool) {}
|
|
|
377 #endif
|
|
|
378
|
|
|
379 bool IsThemeDark(COLORREF text, COLORREF background) {
|
|
|
380 if (!IsSupportedSystem() || IsHighContrast()) return false;
|
|
|
381 auto l_text = PaintUtils::Luminance(text);
|
|
|
382 auto l_bk = PaintUtils::Luminance(background);
|
|
|
383 if (l_text > l_bk) {
|
|
|
384 if (l_bk <= PaintUtils::Luminance(GetSysColor(COLOR_BTNFACE))) {
|
|
|
385 return true;
|
|
|
386 }
|
|
|
387 }
|
|
|
388 return false;
|
|
|
389 }
|
|
|
390
|
|
|
391 bool IsHighContrast() {
|
|
|
392 HIGHCONTRASTW highContrast = { sizeof(highContrast) };
|
|
|
393 if (SystemParametersInfoW(SPI_GETHIGHCONTRAST, sizeof(highContrast), &highContrast, FALSE))
|
|
|
394 return (highContrast.dwFlags & HCF_HIGHCONTRASTON) != 0;
|
|
|
395 return false;
|
|
|
396 }
|
|
|
397
|
|
|
398 static void DrawTab(CTabCtrl& tabs, CDCHandle dc, int iTab, bool selected, bool focused, const RECT * rcPaint) {
|
|
|
399 (void)focused;
|
|
|
400 PFC_ASSERT((tabs.GetStyle() & TCS_VERTICAL) == 0);
|
|
|
401
|
|
|
402 CRect rc;
|
|
|
403 if (!tabs.GetItemRect(iTab, rc)) return;
|
|
|
404
|
|
|
405 if ( rcPaint != nullptr ) {
|
|
|
406 CRect foo;
|
|
|
407 if (!foo.IntersectRect(rc, rcPaint)) return;
|
|
|
408 }
|
|
|
409 const int edgeCX = MulDiv(1, QueryScreenDPI_X(tabs), 120); // note: MulDiv() rounds up from +0.5, this will
|
|
|
410 const auto colorBackground = GetSysColor(selected ? COLOR_HIGHLIGHT : COLOR_BTNFACE);
|
|
|
411 const auto colorFrame = GetSysColor(COLOR_WINDOWFRAME);
|
|
|
412 dc.SetDCBrushColor(colorBackground);
|
|
|
413 dc.FillSolidRect(rc, colorBackground);
|
|
|
414
|
|
|
415 {
|
|
|
416 CPen pen;
|
|
|
417 WIN32_OP_D(pen.CreatePen(PS_SOLID, edgeCX, colorFrame));
|
|
|
418 SelectObjectScope scope(dc, pen);
|
|
|
419 dc.MoveTo(rc.left, rc.bottom);
|
|
|
420 dc.LineTo(rc.left, rc.top);
|
|
|
421 dc.LineTo(rc.right, rc.top);
|
|
|
422 dc.LineTo(rc.right, rc.bottom);
|
|
|
423 }
|
|
|
424
|
|
|
425 wchar_t text[512] = {};
|
|
|
426 TCITEM item = {};
|
|
|
427 item.mask = TCIF_TEXT;
|
|
|
428 item.pszText = text;
|
|
|
429 item.cchTextMax = (int)(std::size(text) - 1);
|
|
|
430 if (tabs.GetItem(iTab, &item)) {
|
|
|
431 SelectObjectScope fontScope(dc, tabs.GetFont());
|
|
|
432 dc.SetBkMode(TRANSPARENT);
|
|
|
433 dc.SetTextColor(GetSysColor(selected ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT));
|
|
|
434 dc.DrawText(text, (int)wcslen(text), rc, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
|
|
|
435 }
|
|
|
436 }
|
|
|
437
|
|
|
438 void PaintTabs(CTabCtrl tabs, CDCHandle dc, const RECT * rcPaint) {
|
|
|
439 CRect rcClient; tabs.GetClientRect(rcClient);
|
|
|
440 CRect rcArea = rcClient; tabs.AdjustRect(FALSE, rcArea);
|
|
|
441 int dx = rcClient.bottom - rcArea.bottom;
|
|
|
442 int dy = rcClient.right - rcArea.right;
|
|
|
443 CRect rcFrame = rcArea; rcFrame.InflateRect(dx/2, dy/2);
|
|
|
444 dc.SetDCBrushColor(GetSysColor(COLOR_WINDOWFRAME));
|
|
|
445 dc.FrameRect(rcFrame, (HBRUSH)GetStockObject(DC_BRUSH));
|
|
|
446 const int tabCount = tabs.GetItemCount();
|
|
|
447 const int tabSelected = tabs.GetCurSel();
|
|
|
448 const int tabFocused = tabs.GetCurFocus();
|
|
|
449 for (int iTab = 0; iTab < tabCount; ++iTab) {
|
|
|
450 if (iTab != tabSelected) DrawTab(tabs, dc, iTab, false, iTab == tabFocused, rcPaint);
|
|
|
451 }
|
|
|
452 if (tabSelected >= 0) DrawTab(tabs, dc, tabSelected, true, tabSelected == tabFocused, rcPaint);
|
|
|
453 }
|
|
|
454
|
|
|
455 void PaintTabsErase(CTabCtrl tabs, CDCHandle dc) {
|
|
|
456 CRect rcClient; WIN32_OP_D(tabs.GetClientRect(rcClient));
|
|
|
457 dc.FillSolidRect(&rcClient, GetSysColor(COLOR_BTNFACE));
|
|
|
458 }
|
|
|
459
|
|
|
460
|
|
|
461 // =================================================
|
|
|
462 // NM_CUSTOMDRAW handlers
|
|
|
463 // =================================================
|
|
|
464
|
|
|
465 // We keep a global list of HWNDs that require dark rendering, so dialogs can call DarkMode::OnCustomDraw() which deals with this nonsense behind the scenes
|
|
|
466 // This way there's no need to subclass parent windows at random
|
|
|
467
|
|
|
468 enum class whichDark_t {
|
|
|
469 none, toolbar
|
|
|
470 };
|
|
|
471
|
|
|
472 // readWriteLock used in case someone uses off-main-thread UI, though it should not really happen in real life
|
|
|
473 static pfc::readWriteLock lstDarkGuard;
|
|
|
474 static std::map<HWND, whichDark_t> lstDark;
|
|
|
475 static whichDark_t lstDark_query(HWND w) {
|
|
|
476 PFC_INSYNC_READ(lstDarkGuard);
|
|
|
477 auto iter = lstDark.find(w);
|
|
|
478 if (iter == lstDark.end()) return whichDark_t::none;
|
|
|
479 return iter->second;
|
|
|
480 }
|
|
|
481 static void lstDark_set(HWND w, whichDark_t which) {
|
|
|
482 PFC_INSYNC_WRITE(lstDarkGuard);
|
|
|
483 lstDark[w] = which;
|
|
|
484 }
|
|
|
485 static void lstDark_clear(HWND w) {
|
|
|
486 PFC_INSYNC_WRITE(lstDarkGuard);
|
|
|
487 lstDark.erase(w);
|
|
|
488 }
|
|
|
489
|
|
|
490 LRESULT CustomDrawToolbar(NMHDR* hdr) {
|
|
|
491 LPNMTBCUSTOMDRAW cd = reinterpret_cast<LPNMTBCUSTOMDRAW>(hdr);
|
|
|
492 switch (cd->nmcd.dwDrawStage) {
|
|
|
493 case CDDS_PREPAINT: return CDRF_NOTIFYITEMDRAW;
|
|
|
494 case CDDS_ITEMPREPAINT:
|
|
|
495 cd->clrText = DarkMode::GetSysColor(COLOR_WINDOWTEXT);
|
|
|
496 cd->clrBtnFace = DarkMode::GetSysColor(COLOR_BTNFACE);
|
|
|
497 cd->clrBtnHighlight = DarkMode::GetSysColor(COLOR_BTNHIGHLIGHT);
|
|
|
498 return CDRF_DODEFAULT;
|
|
|
499 default:
|
|
|
500 return CDRF_DODEFAULT;
|
|
|
501 }
|
|
|
502 }
|
|
|
503
|
|
|
504 LRESULT OnCustomDraw(int,NMHDR* hdr, BOOL& bHandled) {
|
|
|
505 switch (lstDark_query(hdr->hwndFrom)) {
|
|
|
506 case whichDark_t::toolbar:
|
|
|
507 bHandled = TRUE;
|
|
|
508 return CustomDrawToolbar(hdr);
|
|
|
509 default:
|
|
|
510 bHandled = FALSE; return 0;
|
|
|
511 }
|
|
|
512 }
|
|
|
513
|
|
|
514 namespace {
|
|
|
515
|
|
|
516 class CToolbarHook {
|
|
|
517 bool m_dark = false;
|
|
|
518 const bool m_explorerTheme;
|
|
|
519 CToolBarCtrl m_wnd;
|
|
|
520 public:
|
|
|
521 CToolbarHook(HWND wnd, bool initial, bool bExplorerTheme) : m_wnd(wnd), m_explorerTheme(bExplorerTheme) {
|
|
|
522 SetDark(initial);
|
|
|
523 }
|
|
|
524
|
|
|
525 void SetDark(bool v) {
|
|
|
526 if (m_dark == v) return;
|
|
|
527 m_dark = v;
|
|
|
528 if (v) {
|
|
|
529 lstDark_set(m_wnd, whichDark_t::toolbar);
|
|
|
530 if (m_explorerTheme) ::SetWindowTheme(m_wnd, L"", L""); // if we don't do this, NM_CUSTOMDRAW color overrides get disregarded
|
|
|
531 } else {
|
|
|
532 lstDark_clear(m_wnd);
|
|
|
533 if (m_explorerTheme) ::SetWindowTheme(m_wnd, L"Explorer", NULL);
|
|
|
534 }
|
|
|
535 m_wnd.Invalidate();
|
|
|
536
|
|
|
537 ApplyDarkThemeCtrl(m_wnd.GetToolTips(), v);
|
|
|
538 }
|
|
|
539 ~CToolbarHook() {
|
|
|
540 if (m_dark) lstDark_clear(m_wnd);
|
|
|
541 }
|
|
|
542
|
|
|
543 };
|
|
|
544
|
|
|
545 class CTabsHook : public CWindowImpl<CTabsHook, CTabCtrl> {
|
|
|
546 public:
|
|
|
547 CTabsHook(bool bDark = false) : m_dark(bDark) {}
|
|
|
548 BEGIN_MSG_MAP_EX(CTabsHook)
|
|
|
549 MSG_WM_PAINT(OnPaint)
|
|
|
550 MSG_WM_ERASEBKGND(OnEraseBkgnd)
|
|
|
551 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
552 END_MSG_MAP()
|
|
|
553
|
|
|
554 void SetDark(bool v = false);
|
|
|
555 private:
|
|
|
556 void OnPaint(CDCHandle);
|
|
|
557 BOOL OnEraseBkgnd(CDCHandle);
|
|
|
558
|
|
|
559 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
560 switch (wp) {
|
|
|
561 case 0: SetDark(false); break;
|
|
|
562 case 1: SetDark(true); break;
|
|
|
563 }
|
|
|
564 return 1;
|
|
|
565 }
|
|
|
566
|
|
|
567 bool m_dark = false;
|
|
|
568 };
|
|
|
569
|
|
|
570 void CTabsHook::OnPaint(CDCHandle target) {
|
|
|
571 if (!m_dark) { SetMsgHandled(FALSE); return; }
|
|
|
572 if (target) {
|
|
|
573 PaintTabs(m_hWnd, target);
|
|
|
574 } else {
|
|
|
575 CPaintDC dc(*this);
|
|
|
576 PaintTabs(m_hWnd, dc.m_hDC, &dc.m_ps.rcPaint);
|
|
|
577 }
|
|
|
578 }
|
|
|
579 BOOL CTabsHook::OnEraseBkgnd(CDCHandle dc) {
|
|
|
580 if (m_dark) {
|
|
|
581 PaintTabsErase(*this, dc);
|
|
|
582 return TRUE;
|
|
|
583 }
|
|
|
584 SetMsgHandled(FALSE);
|
|
|
585 return FALSE;
|
|
|
586 }
|
|
|
587
|
|
|
588 void CTabsHook::SetDark(bool v) {
|
|
|
589 m_dark = v;
|
|
|
590 if (m_hWnd != NULL) Invalidate();
|
|
|
591
|
|
|
592 ApplyDarkThemeCtrl(GetToolTips(), v);
|
|
|
593 }
|
|
|
594
|
|
|
595 class CTreeViewHook : public CWindowImpl<CTreeViewHook, CTreeViewCtrl> {
|
|
|
596 bool m_dark;
|
|
|
597 public:
|
|
|
598 CTreeViewHook(bool v) : m_dark(v) {}
|
|
|
599
|
|
|
600 BEGIN_MSG_MAP_EX(CTreeViewHook)
|
|
|
601 MESSAGE_RANGE_HANDLER_EX(WM_CTLCOLORMSGBOX, WM_CTLCOLORSTATIC, OnCtlColor)
|
|
|
602 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
603 MESSAGE_HANDLER_EX(TVM_EDITLABEL, OnEditLabel)
|
|
|
604 END_MSG_MAP()
|
|
|
605
|
|
|
606 LRESULT OnCtlColor(UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
|
607 return GetParent().SendMessage(uMsg, wParam, lParam);
|
|
|
608 }
|
|
|
609 LRESULT OnEditLabel(UINT, WPARAM, LPARAM) {
|
|
|
610 LRESULT ret = DefWindowProc();
|
|
|
611 if (ret != 0) {
|
|
|
612 HWND edit = (HWND) ret;
|
|
|
613 PFC_ASSERT( ::IsWindow(edit) );
|
|
|
614 ApplyDarkThemeCtrl( edit, m_dark );
|
|
|
615 }
|
|
|
616 return ret;
|
|
|
617 }
|
|
|
618 void SetDark(bool v) {
|
|
|
619 if (m_dark == v) return;
|
|
|
620 m_dark = v;
|
|
|
621 ApplyDark();
|
|
|
622 }
|
|
|
623 void ApplyDark() {
|
|
|
624 ApplyDarkThemeCtrl(m_hWnd, m_dark);
|
|
|
625 COLORREF bk = m_dark ? GetSysColor(COLOR_WINDOW) : (COLORREF)(-1);
|
|
|
626 COLORREF tx = m_dark ? GetSysColor(COLOR_WINDOWTEXT) : (COLORREF)(-1);
|
|
|
627 this->SetTextColor(tx); this->SetLineColor(tx);
|
|
|
628 this->SetBkColor(bk);
|
|
|
629
|
|
|
630 ApplyDarkThemeCtrl(GetToolTips(), m_dark);
|
|
|
631 }
|
|
|
632
|
|
|
633 void SubclassWindow(HWND wnd) {
|
|
|
634 WIN32_OP_D( __super::SubclassWindow(wnd) );
|
|
|
635 this->ApplyDark();
|
|
|
636 }
|
|
|
637
|
|
|
638 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
639 switch (wp) {
|
|
|
640 case 0: SetDark(false); break;
|
|
|
641 case 1: SetDark(true); break;
|
|
|
642 }
|
|
|
643 return 1;
|
|
|
644 }
|
|
|
645 };
|
|
|
646
|
|
|
647 class CDialogHook : public CWindowImpl<CDialogHook> {
|
|
|
648 bool m_enabled;
|
|
|
649 public:
|
|
|
650 CDialogHook(bool v) : m_enabled(v) {}
|
|
|
651
|
|
|
652 void SetDark(bool v) {
|
|
|
653 if (m_enabled == v) return;
|
|
|
654
|
|
|
655 // Important: PostMessage()'ing this caused bugs
|
|
|
656 SendMessage(WM_THEMECHANGED);
|
|
|
657
|
|
|
658 m_enabled = v;
|
|
|
659
|
|
|
660 // Ensure menu bar redraw with RDW_FRAME
|
|
|
661 RedrawWindow(NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME);
|
|
|
662 }
|
|
|
663
|
|
|
664 // Undocumented Windows menu drawing API
|
|
|
665 // Source: https://github.com/adzm/win32-custom-menubar-aero-theme
|
|
|
666
|
|
|
667 static constexpr unsigned WM_UAHDRAWMENU = 0x0091;
|
|
|
668 static constexpr unsigned WM_UAHDRAWMENUITEM = 0x0092;
|
|
|
669
|
|
|
670 typedef union tagUAHMENUITEMMETRICS
|
|
|
671 {
|
|
|
672 struct {
|
|
|
673 DWORD cx;
|
|
|
674 DWORD cy;
|
|
|
675 } rgsizeBar[2];
|
|
|
676 struct {
|
|
|
677 DWORD cx;
|
|
|
678 DWORD cy;
|
|
|
679 } rgsizePopup[4];
|
|
|
680 } UAHMENUITEMMETRICS;
|
|
|
681
|
|
|
682 typedef struct tagUAHMENUPOPUPMETRICS
|
|
|
683 {
|
|
|
684 DWORD rgcx[4];
|
|
|
685 DWORD fUpdateMaxWidths : 2;
|
|
|
686 } UAHMENUPOPUPMETRICS;
|
|
|
687
|
|
|
688 typedef struct tagUAHMENU
|
|
|
689 {
|
|
|
690 HMENU hmenu;
|
|
|
691 HDC hdc;
|
|
|
692 DWORD dwFlags;
|
|
|
693 } UAHMENU;
|
|
|
694
|
|
|
695 typedef struct tagUAHMENUITEM
|
|
|
696 {
|
|
|
697 int iPosition;
|
|
|
698 UAHMENUITEMMETRICS umim;
|
|
|
699 UAHMENUPOPUPMETRICS umpm;
|
|
|
700 } UAHMENUITEM;
|
|
|
701
|
|
|
702 typedef struct UAHDRAWMENUITEM
|
|
|
703 {
|
|
|
704 DRAWITEMSTRUCT dis;
|
|
|
705 UAHMENU um;
|
|
|
706 UAHMENUITEM umi;
|
|
|
707 } UAHDRAWMENUITEM;
|
|
|
708
|
|
|
709
|
|
|
710 BEGIN_MSG_MAP_EX(CDialogHook)
|
|
|
711 MSG_WM_CTLCOLORDLG(ctlColorCommon)
|
|
|
712 MSG_WM_CTLCOLORSTATIC(ctlColorCommon)
|
|
|
713 MSG_WM_CTLCOLOREDIT(ctlColorCommon)
|
|
|
714 MSG_WM_CTLCOLORBTN(ctlColorCommon)
|
|
|
715 MSG_WM_CTLCOLORLISTBOX(ctlColorCommon)
|
|
|
716 MSG_WM_CTLCOLORSCROLLBAR(ctlColorCommon)
|
|
|
717 NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, DarkMode::OnCustomDraw)
|
|
|
718 MESSAGE_HANDLER_EX(WM_UAHDRAWMENU, Handle_WM_UAHDRAWMENU)
|
|
|
719 MESSAGE_HANDLER_EX(WM_UAHDRAWMENUITEM, Handle_WM_UAHDRAWMENUITEM)
|
|
|
720 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
721 END_MSG_MAP()
|
|
|
722
|
|
|
723 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
724 switch (wp) {
|
|
|
725 case 0: SetDark(false); break;
|
|
|
726 case 1: SetDark(true); break;
|
|
|
727 }
|
|
|
728 return 1;
|
|
|
729 }
|
|
|
730
|
|
|
731 static COLORREF GetBkColor() { return DarkMode::GetSysColor(COLOR_WINDOW); }
|
|
|
732 static COLORREF GetTextColor() { return DarkMode::GetSysColor(COLOR_WINDOWTEXT); }
|
|
|
733
|
|
|
734 HBRUSH ctlColorDlg(CDCHandle dc, CWindow wnd) {
|
|
|
735 if (m_enabled && ::IsThemeDialogTextureEnabled(*this)) {
|
|
|
736 auto bkColor = DarkMode::GetSysColor(COLOR_HIGHLIGHT);
|
|
|
737 auto txColor = GetTextColor();
|
|
|
738
|
|
|
739 dc.SetTextColor(txColor);
|
|
|
740 dc.SetBkColor(bkColor);
|
|
|
741 dc.SetDCBrushColor(bkColor);
|
|
|
742 return (HBRUSH)GetStockObject(DC_BRUSH);
|
|
|
743 }
|
|
|
744 return ctlColorCommon(dc, wnd);
|
|
|
745 }
|
|
|
746
|
|
|
747 HBRUSH ctlColorCommon(CDCHandle dc, CWindow wnd) {
|
|
|
748 (void)wnd;
|
|
|
749 if (m_enabled) {
|
|
|
750 auto bkColor = GetBkColor();
|
|
|
751 auto txColor = GetTextColor();
|
|
|
752
|
|
|
753 dc.SetTextColor(txColor);
|
|
|
754 dc.SetBkColor(bkColor);
|
|
|
755 dc.SetDCBrushColor(bkColor);
|
|
|
756 return (HBRUSH)GetStockObject(DC_BRUSH);
|
|
|
757 }
|
|
|
758 SetMsgHandled(FALSE);
|
|
|
759 return NULL;
|
|
|
760 }
|
|
|
761 LRESULT Handle_WM_UAHDRAWMENU(UINT, WPARAM wParam, LPARAM lParam) {
|
|
|
762 if (!m_enabled) {
|
|
|
763 SetMsgHandled(FALSE);
|
|
|
764 return 0;
|
|
|
765 }
|
|
|
766 UAHMENU* pUDM = (UAHMENU*)lParam;
|
|
|
767 CRect rc;
|
|
|
768
|
|
|
769 MENUBARINFO mbi = { sizeof(mbi) };
|
|
|
770 WIN32_OP_D(GetMenuBarInfo(m_hWnd, OBJID_MENU, 0, &mbi));
|
|
|
771
|
|
|
772 CRect rcWindow;
|
|
|
773 WIN32_OP_D(GetWindowRect(rcWindow));
|
|
|
774
|
|
|
775 rc = mbi.rcBar;
|
|
|
776 OffsetRect(&rc, -rcWindow.left, -rcWindow.top);
|
|
|
777
|
|
|
778 rc.top -= 1;
|
|
|
779
|
|
|
780 CDCHandle dc(pUDM->hdc);
|
|
|
781 dc.FillSolidRect(rc, DarkMode::GetSysColor(COLOR_MENUBAR));
|
|
|
782 return 0;
|
|
|
783 }
|
|
|
784 LRESULT Handle_WM_UAHDRAWMENUITEM(UINT, WPARAM wParam, LPARAM lParam) {
|
|
|
785 if (!m_enabled) {
|
|
|
786 SetMsgHandled(FALSE);
|
|
|
787 return 0;
|
|
|
788 }
|
|
|
789
|
|
|
790 UAHDRAWMENUITEM* pUDMI = (UAHDRAWMENUITEM*)lParam;
|
|
|
791 CMenuHandle hMenu = pUDMI->um.hmenu;
|
|
|
792
|
|
|
793 CString menuString;
|
|
|
794 WIN32_OP_D(hMenu.GetMenuString(pUDMI->umi.iPosition, menuString, MF_BYPOSITION) > 0);
|
|
|
795
|
|
|
796 DWORD drawTextFlags = DT_CENTER | DT_SINGLELINE | DT_VCENTER;
|
|
|
797
|
|
|
798 int iTextStateID = MPI_NORMAL;
|
|
|
799 int iBackgroundStateID = MPI_NORMAL;
|
|
|
800 if ((pUDMI->dis.itemState & ODS_INACTIVE) | (pUDMI->dis.itemState & ODS_DEFAULT)) {
|
|
|
801 iTextStateID = MPI_NORMAL;
|
|
|
802 iBackgroundStateID = MPI_NORMAL;
|
|
|
803 }
|
|
|
804 if (pUDMI->dis.itemState & (ODS_HOTLIGHT|ODS_SELECTED)) {
|
|
|
805 iTextStateID = MPI_HOT;
|
|
|
806 iBackgroundStateID = MPI_HOT;
|
|
|
807 }
|
|
|
808 if (pUDMI->dis.itemState & (ODS_GRAYED|ODS_DISABLED)) {
|
|
|
809 iTextStateID = MPI_DISABLED;
|
|
|
810 iBackgroundStateID = MPI_DISABLED;
|
|
|
811 }
|
|
|
812 if (pUDMI->dis.itemState & ODS_NOACCEL) {
|
|
|
813 drawTextFlags |= DT_HIDEPREFIX;
|
|
|
814 }
|
|
|
815
|
|
|
816 if (m_menuTheme == NULL) {
|
|
|
817 m_menuTheme.OpenThemeData(m_hWnd, L"Menu");
|
|
|
818 }
|
|
|
819
|
|
|
820 CDCHandle dc(pUDMI->um.hdc);
|
|
|
821 switch (iBackgroundStateID) {
|
|
|
822 case MPI_NORMAL:
|
|
|
823 case MPI_DISABLED:
|
|
|
824 dc.FillSolidRect(&pUDMI->dis.rcItem, DarkMode::GetSysColor(COLOR_MENUBAR));
|
|
|
825 break;
|
|
|
826 case MPI_HOT:
|
|
|
827 case MPI_DISABLEDHOT:
|
|
|
828 dc.FillSolidRect(&pUDMI->dis.rcItem, DarkMode::GetSysColor(COLOR_MENUHILIGHT));
|
|
|
829 break;
|
|
|
830 default:
|
|
|
831 DrawThemeBackground(m_menuTheme, pUDMI->um.hdc, MENU_POPUPITEM, iBackgroundStateID, &pUDMI->dis.rcItem, nullptr);
|
|
|
832 break;
|
|
|
833 }
|
|
|
834 DTTOPTS dttopts = { sizeof(dttopts) };
|
|
|
835 if (iTextStateID == MPI_NORMAL || iTextStateID == MPI_HOT)
|
|
|
836 {
|
|
|
837 dttopts.dwFlags |= DTT_TEXTCOLOR;
|
|
|
838 dttopts.crText = DarkMode::GetSysColor(COLOR_WINDOWTEXT);
|
|
|
839 }
|
|
|
840 DrawThemeTextEx(m_menuTheme, dc, MENU_POPUPITEM, iTextStateID, menuString, menuString.GetLength(), drawTextFlags, &pUDMI->dis.rcItem, &dttopts);
|
|
|
841
|
|
|
842 return 0;
|
|
|
843 }
|
|
|
844 CTheme m_menuTheme;
|
|
|
845 };
|
|
|
846
|
|
|
847
|
|
|
848 class CStatusBarHook : public CWindowImpl<CStatusBarHook, CStatusBarCtrl> {
|
|
|
849 public:
|
|
|
850 CStatusBarHook(bool v = false) : m_dark(v) {}
|
|
|
851
|
|
|
852 BEGIN_MSG_MAP_EX(CStatusBarHook)
|
|
|
853 MSG_WM_ERASEBKGND(OnEraseBkgnd)
|
|
|
854 MSG_WM_PAINT(OnPaint)
|
|
|
855 MESSAGE_HANDLER_EX(SB_SETTEXT, OnSetText)
|
|
|
856 MESSAGE_HANDLER_EX(SB_SETICON, OnSetIcon)
|
|
|
857 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
858 END_MSG_MAP()
|
|
|
859
|
|
|
860 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
861 switch (wp) {
|
|
|
862 case 0: SetDark(false); break;
|
|
|
863 case 1: SetDark(true); break;
|
|
|
864 }
|
|
|
865 return 1;
|
|
|
866 }
|
|
|
867
|
|
|
868 void SetDark(bool v = true) {
|
|
|
869 if (m_dark != v) {
|
|
|
870 m_dark = v;
|
|
|
871 Invalidate();
|
|
|
872 ApplyDarkThemeCtrl(m_hWnd, v);
|
|
|
873 }
|
|
|
874 }
|
|
|
875
|
|
|
876 void SubclassWindow(HWND wnd) {
|
|
|
877 WIN32_OP_D(__super::SubclassWindow(wnd));
|
|
|
878 Invalidate();
|
|
|
879 ApplyDarkThemeCtrl(m_hWnd, m_dark);
|
|
|
880 }
|
|
|
881 LRESULT OnSetIcon(UINT, WPARAM wp, LPARAM lp) {
|
|
|
882 unsigned idx = (unsigned)wp;
|
|
|
883 if (idx < 32) {
|
|
|
884 CSize sz;
|
|
|
885 if (lp != 0) sz = GetIconSize((HICON)lp);
|
|
|
886 m_iconSizeCache[idx] = sz;
|
|
|
887 }
|
|
|
888 SetMsgHandled(FALSE);
|
|
|
889 return 0;
|
|
|
890 }
|
|
|
891 LRESULT OnSetText(UINT, WPARAM wp, LPARAM) {
|
|
|
892 // Status bar won't tell us about ownerdraw from GetText()
|
|
|
893 // Have to listen to relevant messages to know
|
|
|
894 unsigned idx = (unsigned)(wp & 0xFF);
|
|
|
895 if (idx < 32) {
|
|
|
896 uint32_t flag = 1 << idx;
|
|
|
897 if (wp & SBT_OWNERDRAW) {
|
|
|
898 m_ownerDrawMask |= flag;
|
|
|
899 } else {
|
|
|
900 m_ownerDrawMask &= ~flag;
|
|
|
901 }
|
|
|
902 }
|
|
|
903
|
|
|
904 SetMsgHandled(FALSE);
|
|
|
905 return 0;
|
|
|
906 }
|
|
|
907
|
|
|
908 void Paint(CDCHandle dc) {
|
|
|
909 CRect rcClient; WIN32_OP_D(GetClientRect(rcClient));
|
|
|
910 dc.FillSolidRect(rcClient, GetSysColor(COLOR_BTNFACE)); // Wine seems to not call our WM_ERASEBKGND handler, fill the background here too
|
|
|
911
|
|
|
912 dc.SelectFont(GetFont());
|
|
|
913 dc.SetBkMode(TRANSPARENT);
|
|
|
914 dc.SetTextColor(GetSysColor(COLOR_WINDOWTEXT));
|
|
|
915 CPen pen; pen.CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHIGHLIGHT));
|
|
|
916 dc.SelectPen(pen);
|
|
|
917 int count = this->GetParts(0, nullptr);
|
|
|
918 for (int iPart = 0; iPart < count; ++iPart) {
|
|
|
919 CRect rcPart;
|
|
|
920 this->GetRect(iPart, rcPart);
|
|
|
921 if (rcPart.left > 0) {
|
|
|
922 dc.MoveTo(rcPart.left, rcPart.top);
|
|
|
923 dc.LineTo(rcPart.left, rcPart.bottom);
|
|
|
924 }
|
|
|
925 int type = 0;
|
|
|
926 CString text;
|
|
|
927 this->GetText(iPart, text, &type);
|
|
|
928
|
|
|
929 HICON icon = this->GetIcon(iPart);
|
|
|
930 int iconMargin = 0;
|
|
|
931 if (icon != NULL && (unsigned)iPart < std::size(m_iconSizeCache)) {
|
|
|
932
|
|
|
933 auto size = m_iconSizeCache[iPart];
|
|
|
934
|
|
|
935 dc.DrawIconEx(rcPart.left + size.cx / 4, (rcPart.top + rcPart.bottom) / 2 - size.cy / 2, icon, size.cx, size.cy);
|
|
|
936 iconMargin = MulDiv(size.cx, 3, 2);
|
|
|
937 }
|
|
|
938
|
|
|
939 if (m_ownerDrawMask & (1 << iPart)) { // statusbar won't tell us about ownerdraw from GetText()
|
|
|
940 DRAWITEMSTRUCT ds = {};
|
|
|
941 ds.CtlType = ODT_STATIC;
|
|
|
942 ds.CtlID = this->GetDlgCtrlID();
|
|
|
943 ds.itemID = iPart;
|
|
|
944 ds.hwndItem = m_hWnd;
|
|
|
945 ds.hDC = dc;
|
|
|
946 ds.rcItem = rcPart;
|
|
|
947
|
|
|
948 DCStateScope scope(dc);
|
|
|
949 GetParent().SendMessage(WM_DRAWITEM, GetDlgCtrlID(), (LPARAM)&ds);
|
|
|
950 } else {
|
|
|
951 CRect rcText = rcPart;
|
|
|
952 int defMargin = rcText.Height() / 4;
|
|
|
953 int l = iconMargin > 0 ? iconMargin : defMargin;
|
|
|
954 int r = defMargin;
|
|
|
955 rcText.DeflateRect(l, 0, r, 0);
|
|
|
956 dc.DrawText(text, text.GetLength(), rcText, DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOPREFIX);
|
|
|
957 }
|
|
|
958
|
|
|
959 if (GetStyle() & SBARS_SIZEGRIP) {
|
|
|
960 CSize size;
|
|
|
961 auto theme = OpenThemeData(*this, L"status");
|
|
|
962 PFC_ASSERT(theme != NULL);
|
|
|
963 GetThemePartSize(theme, dc, SP_GRIPPER, 0, &rcClient, TS_DRAW, &size);
|
|
|
964 auto rc = rcClient;
|
|
|
965 rc.left = rc.right - size.cx;
|
|
|
966 rc.top = rc.bottom - size.cy;
|
|
|
967 DrawThemeBackground(theme, dc, SP_GRIPPER, 0, &rc, nullptr);
|
|
|
968 CloseThemeData(theme);
|
|
|
969 }
|
|
|
970 }
|
|
|
971 }
|
|
|
972
|
|
|
973 void OnPaint(CDCHandle target) {
|
|
|
974 if (!m_dark) { SetMsgHandled(FALSE); return; }
|
|
|
975 if (target) {
|
|
|
976 Paint(target);
|
|
|
977 } else {
|
|
|
978 CPaintDC dc(*this);
|
|
|
979 Paint(dc.m_hDC);
|
|
|
980 }
|
|
|
981 }
|
|
|
982
|
|
|
983 BOOL OnEraseBkgnd(CDCHandle dc) {
|
|
|
984 if (m_dark) {
|
|
|
985 CRect rc; WIN32_OP_D(GetClientRect(rc)); dc.FillSolidRect(rc, DarkMode::GetSysColor(COLOR_BTNFACE)); return TRUE;
|
|
|
986 }
|
|
|
987 SetMsgHandled(FALSE); return FALSE;
|
|
|
988 }
|
|
|
989
|
|
|
990 bool m_dark = false;
|
|
|
991
|
|
|
992 uint32_t m_ownerDrawMask = 0;
|
|
|
993 CSize m_iconSizeCache[32];
|
|
|
994 };
|
|
|
995
|
|
|
996 class CCheckBoxHook : public CWindowImpl<CCheckBoxHook, CButton> {
|
|
|
997 public:
|
|
|
998 CCheckBoxHook(bool v = false) : m_dark(v) {}
|
|
|
999
|
|
|
1000 BEGIN_MSG_MAP_EX(CCheckBoxHook)
|
|
|
1001 MSG_WM_PAINT(OnPaint)
|
|
|
1002 MSG_WM_PRINTCLIENT(OnPaint)
|
|
|
1003 MSG_WM_ERASEBKGND(OnEraseBkgnd)
|
|
|
1004 MSG_WM_UPDATEUISTATE(OnUpdateUIState)
|
|
|
1005
|
|
|
1006 // Note that checkbox implementation likes to paint on its own in response to events
|
|
|
1007 // instead of invalidating and handling WM_PAINT
|
|
|
1008 // We have to specifically trigger WM_PAINT to override their rendering with ours
|
|
|
1009 MESSAGE_HANDLER_EX(WM_SETFOCUS, OnMsgRedraw)
|
|
|
1010 MESSAGE_HANDLER_EX(WM_KILLFOCUS, OnMsgRedraw)
|
|
|
1011 MESSAGE_HANDLER_EX(WM_ENABLE, OnMsgRedraw)
|
|
|
1012 MESSAGE_HANDLER_EX(WM_SETTEXT, OnMsgRedraw)
|
|
|
1013
|
|
|
1014 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
1015 END_MSG_MAP()
|
|
|
1016
|
|
|
1017 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
1018 switch (wp) {
|
|
|
1019 case 0: SetDark(false); break;
|
|
|
1020 case 1: SetDark(true); break;
|
|
|
1021 }
|
|
|
1022 return 1;
|
|
|
1023 }
|
|
|
1024
|
|
|
1025 LRESULT OnMsgRedraw(UINT, WPARAM, LPARAM) {
|
|
|
1026 if ( m_dark ) {
|
|
|
1027 // PROBLEM:
|
|
|
1028 // Can't invalidate prior to their handling of the message
|
|
|
1029 // Causes bugs with specific chains of events - EnableWindow() followed immediately SetWindowText()
|
|
|
1030 LRESULT ret = DefWindowProc();
|
|
|
1031 Invalidate();
|
|
|
1032 return ret;
|
|
|
1033 }
|
|
|
1034 SetMsgHandled(FALSE); return 0;
|
|
|
1035 }
|
|
|
1036
|
|
|
1037 void OnUpdateUIState(WORD nAction, WORD nState) {
|
|
|
1038 (void)nAction;
|
|
|
1039 if ( m_dark && (nState & (UISF_HIDEACCEL | UISF_HIDEFOCUS)) != 0) {
|
|
|
1040 // PROBLEM:
|
|
|
1041 // Can't invalidate prior to their handling of the message
|
|
|
1042 // Causes bugs with specific chains of events - EnableWindow() followed immediately SetWindowText()
|
|
|
1043 DefWindowProc();
|
|
|
1044 Invalidate();
|
|
|
1045 return;
|
|
|
1046 }
|
|
|
1047 SetMsgHandled(FALSE);
|
|
|
1048 }
|
|
|
1049 void PaintHandler(CDCHandle dc) {
|
|
|
1050 CRect rcClient; WIN32_OP_D(GetClientRect(rcClient));
|
|
|
1051
|
|
|
1052 const bool bDisabled = !this->IsWindowEnabled();
|
|
|
1053
|
|
|
1054 dc.SetTextColor(DarkMode::GetSysColor(COLOR_BTNTEXT));
|
|
|
1055 dc.SetBkColor(DarkMode::GetSysColor(COLOR_BTNFACE));
|
|
|
1056 dc.SetBkMode(OPAQUE);
|
|
|
1057 dc.SelectFont(GetFont());
|
|
|
1058 GetParent().SendMessage(WM_CTLCOLORBTN, (WPARAM)dc.m_hDC, (LPARAM)m_hWnd);
|
|
|
1059 if (bDisabled) dc.SetTextColor(DarkMode::GetSysColor(COLOR_GRAYTEXT)); // override WM_CTLCOLORBTN
|
|
|
1060
|
|
|
1061 const DWORD btnStyle = GetStyle();
|
|
|
1062 const DWORD btnType = btnStyle & BS_TYPEMASK;
|
|
|
1063 const bool bRadio = (btnType == BS_RADIOBUTTON || btnType == BS_AUTORADIOBUTTON);
|
|
|
1064 const int part = bRadio ? BP_RADIOBUTTON : BP_CHECKBOX;
|
|
|
1065
|
|
|
1066 const auto ctrlState = GetState();
|
|
|
1067 const DWORD uiState = (DWORD)SendMessage(WM_QUERYUISTATE);
|
|
|
1068
|
|
|
1069
|
|
|
1070 const bool bChecked = (ctrlState & BST_CHECKED) != 0;
|
|
|
1071 const bool bMixed = (ctrlState & BST_INDETERMINATE) != 0;
|
|
|
1072 const bool bHot = (ctrlState & BST_HOT) != 0;
|
|
|
1073 const bool bFocus = (ctrlState & BST_FOCUS) != 0 && (uiState & UISF_HIDEFOCUS) == 0;
|
|
|
1074
|
|
|
1075 HTHEME theme = OpenThemeData(m_hWnd, L"button");
|
|
|
1076
|
|
|
1077 CRect rcCheckBox = rcClient;
|
|
|
1078 bool bDrawn = false;
|
|
|
1079 int margin = 0;
|
|
|
1080 if (theme != NULL && IsThemePartDefined(theme, part, 0)) {
|
|
|
1081 int state = 0;
|
|
|
1082 if (bDisabled) {
|
|
|
1083 if ( bChecked ) state = CBS_CHECKEDDISABLED;
|
|
|
1084 else if ( bMixed ) state = CBS_MIXEDDISABLED;
|
|
|
1085 else state = CBS_UNCHECKEDDISABLED;
|
|
|
1086 } else if (bHot) {
|
|
|
1087 if ( bChecked ) state = CBS_CHECKEDHOT;
|
|
|
1088 else if ( bMixed ) state = CBS_MIXEDHOT;
|
|
|
1089 else state = CBS_UNCHECKEDNORMAL;
|
|
|
1090 } else {
|
|
|
1091 if ( bChecked ) state = CBS_CHECKEDNORMAL;
|
|
|
1092 else if ( bMixed ) state = CBS_MIXEDNORMAL;
|
|
|
1093 else state = CBS_UNCHECKEDNORMAL;
|
|
|
1094 }
|
|
|
1095
|
|
|
1096 CSize size;
|
|
|
1097 if (SUCCEEDED(GetThemePartSize(theme, dc, part, state, rcCheckBox, TS_TRUE, &size))) {
|
|
|
1098 if (size.cx <= rcCheckBox.Width() && size.cy <= rcCheckBox.Height()) {
|
|
|
1099 CRect rc = rcCheckBox;
|
|
|
1100 margin = MulDiv(size.cx, 5, 4);
|
|
|
1101 // rc.left += (rc.Width() - size.cx) / 2;
|
|
|
1102 rc.top += (rc.Height() - size.cy) / 2;
|
|
|
1103 rc.right = rc.left + size.cx;
|
|
|
1104 rc.bottom = rc.top + size.cy;
|
|
|
1105 DrawThemeBackground(theme, dc, part, state, rc, &rc);
|
|
|
1106 bDrawn = true;
|
|
|
1107 }
|
|
|
1108 }
|
|
|
1109 }
|
|
|
1110 if (theme != NULL) CloseThemeData(theme);
|
|
|
1111 if (!bDrawn) {
|
|
|
1112 int stateEx = bRadio ? DFCS_BUTTONRADIO : DFCS_BUTTONCHECK;
|
|
|
1113 if (bChecked) stateEx |= DFCS_CHECKED;
|
|
|
1114 // FIX ME bMixed ?
|
|
|
1115 if (bDisabled) stateEx |= DFCS_INACTIVE;
|
|
|
1116 else if (bHot) stateEx |= DFCS_HOT;
|
|
|
1117
|
|
|
1118 const int dpi = GetDeviceCaps(dc, LOGPIXELSX);
|
|
|
1119 int w = MulDiv(16, dpi, 96);
|
|
|
1120
|
|
|
1121 CRect rc = rcCheckBox;
|
|
|
1122 if (rc.Width() > w) rc.right = rc.left + w;;
|
|
|
1123
|
|
|
1124 DrawFrameControl(dc, rc, DFC_BUTTON, stateEx);
|
|
|
1125 margin = MulDiv(20, dpi, 96);
|
|
|
1126 }
|
|
|
1127
|
|
|
1128 CString text;
|
|
|
1129 if (margin < rcClient.Width()) GetWindowText(text);
|
|
|
1130 if (!text.IsEmpty()) {
|
|
|
1131 CRect rcText = rcClient;
|
|
|
1132 rcText.left += margin;
|
|
|
1133 UINT dtFlags = DT_VCENTER;
|
|
|
1134 if (btnStyle & BS_MULTILINE) {
|
|
|
1135 dtFlags |= DT_WORDBREAK;
|
|
|
1136 } else {
|
|
|
1137 dtFlags |= DT_END_ELLIPSIS | DT_SINGLELINE;
|
|
|
1138 }
|
|
|
1139 dc.DrawText(text, text.GetLength(), rcText, dtFlags);
|
|
|
1140 if (bFocus) {
|
|
|
1141 dc.DrawText(text, text.GetLength(), rcText, DT_CALCRECT | dtFlags);
|
|
|
1142 dc.DrawFocusRect(rcText);
|
|
|
1143 }
|
|
|
1144 } else if (bFocus) {
|
|
|
1145 dc.DrawFocusRect(rcClient);
|
|
|
1146 }
|
|
|
1147 }
|
|
|
1148 void OnPaint(CDCHandle userDC, UINT flags = 0) {
|
|
|
1149 (void)flags;
|
|
|
1150 if (!m_dark) { SetMsgHandled(FALSE); return; }
|
|
|
1151 if (userDC) {
|
|
|
1152 PaintHandler(userDC);
|
|
|
1153 } else {
|
|
|
1154 CPaintDC dc(*this);
|
|
|
1155 PaintHandler(dc.m_hDC);
|
|
|
1156 }
|
|
|
1157 }
|
|
|
1158 BOOL OnEraseBkgnd(CDCHandle dc) {
|
|
|
1159 if (m_dark) {
|
|
|
1160 CRect rc; WIN32_OP_D(GetClientRect(rc));
|
|
|
1161
|
|
|
1162 dc.SetTextColor(DarkMode::GetSysColor(COLOR_BTNTEXT));
|
|
|
1163 dc.SetBkColor(DarkMode::GetSysColor(COLOR_BTNFACE));
|
|
|
1164 auto br = (HBRUSH)GetParent().SendMessage(WM_CTLCOLORSTATIC, (WPARAM)dc.m_hDC, (LPARAM)m_hWnd);
|
|
|
1165 if (br != NULL) {
|
|
|
1166 dc.FillRect(rc, br);
|
|
|
1167 } else {
|
|
|
1168 dc.FillSolidRect(rc, DarkMode::GetSysColor(COLOR_BTNFACE));
|
|
|
1169 }
|
|
|
1170 return TRUE;
|
|
|
1171 }
|
|
|
1172 SetMsgHandled(FALSE); return FALSE;
|
|
|
1173 }
|
|
|
1174
|
|
|
1175 void SetDark(bool v = true) {
|
|
|
1176 if (v != m_dark) {
|
|
|
1177 m_dark = v;
|
|
|
1178 Invalidate();
|
|
|
1179 ApplyDarkThemeCtrl(m_hWnd, m_dark);
|
|
|
1180 }
|
|
|
1181 }
|
|
|
1182
|
|
|
1183 void SubclassWindow(HWND wnd) {
|
|
|
1184 WIN32_OP_D(__super::SubclassWindow(wnd));
|
|
|
1185 ApplyDarkThemeCtrl(m_hWnd, m_dark);
|
|
|
1186 }
|
|
|
1187
|
|
|
1188 bool m_dark = false;
|
|
|
1189 };
|
|
|
1190
|
|
|
1191 class CGripperHook : public CWindowImpl<CGripperHook> {
|
|
|
1192 public:
|
|
|
1193 CGripperHook(bool v) : m_dark(v) {}
|
|
|
1194
|
|
|
1195 BEGIN_MSG_MAP_EX(CGRipperHook)
|
|
|
1196 MSG_WM_ERASEBKGND(OnEraseBkgnd)
|
|
|
1197 MSG_WM_PAINT(OnPaint)
|
|
|
1198 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
1199 END_MSG_MAP()
|
|
|
1200
|
|
|
1201 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
1202 switch (wp) {
|
|
|
1203 case 0: SetDark(false); break;
|
|
|
1204 case 1: SetDark(true); break;
|
|
|
1205 }
|
|
|
1206 return 1;
|
|
|
1207 }
|
|
|
1208
|
|
|
1209 void SetDark(bool v) {
|
|
|
1210 if (v != m_dark) {
|
|
|
1211 m_dark = v;
|
|
|
1212 ApplyDarkThemeCtrl(*this, m_dark);
|
|
|
1213 }
|
|
|
1214 }
|
|
|
1215
|
|
|
1216 void SubclassWindow(HWND wnd) {
|
|
|
1217 WIN32_OP_D(__super::SubclassWindow(wnd));
|
|
|
1218 ApplyDarkThemeCtrl(m_hWnd, m_dark);
|
|
|
1219 }
|
|
|
1220
|
|
|
1221 void PaintGripper(CDCHandle dc) {
|
|
|
1222 CRect rcClient; WIN32_OP_D(GetClientRect(rcClient));
|
|
|
1223 CSize size;
|
|
|
1224 auto theme = OpenThemeData(*this, L"status");
|
|
|
1225 PFC_ASSERT(theme != NULL);
|
|
|
1226 GetThemePartSize(theme, dc, SP_GRIPPER, 0, &rcClient, TS_DRAW, &size);
|
|
|
1227 auto rc = rcClient;
|
|
|
1228 rc.left = rc.right - size.cx;
|
|
|
1229 rc.top = rc.bottom - size.cy;
|
|
|
1230 DrawThemeBackground(theme, dc, SP_GRIPPER, 0, &rc, nullptr);
|
|
|
1231 CloseThemeData(theme);
|
|
|
1232 }
|
|
|
1233
|
|
|
1234 void OnPaint(CDCHandle dc) {
|
|
|
1235 if (!m_dark) { SetMsgHandled(FALSE); return; }
|
|
|
1236 if (dc) PaintGripper(dc);
|
|
|
1237 else {CPaintDC pdc(*this); PaintGripper(pdc.m_hDC);}
|
|
|
1238 }
|
|
|
1239
|
|
|
1240 BOOL OnEraseBkgnd(CDCHandle dc) {
|
|
|
1241 if (m_dark) {
|
|
|
1242 CRect rc; GetClientRect(rc);
|
|
|
1243 dc.FillSolidRect(rc, GetSysColor(COLOR_WINDOW));
|
|
|
1244 return TRUE;
|
|
|
1245 }
|
|
|
1246 SetMsgHandled(FALSE); return FALSE;
|
|
|
1247 }
|
|
|
1248 bool m_dark = false;
|
|
|
1249 };
|
|
|
1250
|
|
|
1251 class CReBarHook : public CWindowImpl<CReBarHook, CReBarCtrl> {
|
|
|
1252 bool m_dark;
|
|
|
1253 public:
|
|
|
1254 CReBarHook(bool v) : m_dark(v) {}
|
|
|
1255 BEGIN_MSG_MAP_EX(CReBarHook)
|
|
|
1256 MSG_WM_ERASEBKGND(OnEraseBkgnd)
|
|
|
1257 MSG_WM_DESTROY(OnDestroy)
|
|
|
1258 MSG_WM_PAINT(OnPaint)
|
|
|
1259 MSG_WM_PRINTCLIENT(OnPaint)
|
|
|
1260 NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, DarkMode::OnCustomDraw)
|
|
|
1261 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
1262 END_MSG_MAP()
|
|
|
1263
|
|
|
1264 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
1265 switch (wp) {
|
|
|
1266 case 0: SetDark(false); break;
|
|
|
1267 case 1: SetDark(true); break;
|
|
|
1268 }
|
|
|
1269 return 1;
|
|
|
1270 }
|
|
|
1271
|
|
|
1272 void OnPaint(CDCHandle target, unsigned flags = 0) {
|
|
|
1273 if (!m_dark) { SetMsgHandled(FALSE); return; }
|
|
|
1274 (void)flags;
|
|
|
1275 if (target) {
|
|
|
1276 HandlePaint(target);
|
|
|
1277 } else {
|
|
|
1278 CPaintDC pdc(*this);
|
|
|
1279 HandlePaint(pdc.m_hDC);
|
|
|
1280 }
|
|
|
1281 }
|
|
|
1282
|
|
|
1283 void HandlePaint(CDCHandle dc) {
|
|
|
1284 const int total = this->GetBandCount();
|
|
|
1285 for (int iBand = 0; iBand < total; ++iBand) {
|
|
|
1286 CRect rc;
|
|
|
1287 WIN32_OP_D(this->GetRect(iBand, rc));
|
|
|
1288
|
|
|
1289 wchar_t buffer[256] = {};
|
|
|
1290 REBARBANDINFO info = { sizeof(info) };
|
|
|
1291 info.fMask = RBBIM_TEXT | RBBIM_CHILD | RBBIM_STYLE;
|
|
|
1292 info.lpText = buffer; info.cch = (UINT)std::size(buffer);
|
|
|
1293 WIN32_OP_D(this->GetBandInfo(iBand, &info));
|
|
|
1294
|
|
|
1295 HFONT useFont;
|
|
|
1296 // Sadly overriding the font breaks the layout
|
|
|
1297 // MS implementation disregards fonts too
|
|
|
1298 // useFont = this->GetFont();
|
|
|
1299 useFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
|
|
|
1300 SelectObjectScope fontScope(dc, useFont);
|
|
|
1301 dc.SetTextColor(DarkMode::GetSysColor(COLOR_BTNTEXT));
|
|
|
1302 dc.SetBkMode(TRANSPARENT);
|
|
|
1303
|
|
|
1304 CRect rcText = rc;
|
|
|
1305 if ((info.fStyle & RBBS_NOGRIPPER) == 0) {
|
|
|
1306 auto color = PaintUtils::BlendColor(DarkMode::GetSysColor(COLOR_WINDOWFRAME), DarkMode::GetSysColor(COLOR_BTNFACE));
|
|
|
1307 dc.SetDCPenColor(color);
|
|
|
1308 SelectObjectScope penScope(dc, GetStockObject(DC_PEN));
|
|
|
1309 dc.MoveTo(rcText.TopLeft());
|
|
|
1310 dc.LineTo(CPoint(rcText.left, rcText.bottom));
|
|
|
1311 rcText.left += 6; // this should be DPI-scaled, only it's not because rebar layout isn't either
|
|
|
1312 } else {
|
|
|
1313 rcText.left += 2;
|
|
|
1314 }
|
|
|
1315 dc.DrawText(buffer, (int)wcslen(buffer), &rcText, DT_VCENTER | DT_LEFT | DT_SINGLELINE | DT_NOPREFIX);
|
|
|
1316 }
|
|
|
1317 }
|
|
|
1318
|
|
|
1319
|
|
|
1320 void OnDestroy() {
|
|
|
1321 SetMsgHandled(FALSE);
|
|
|
1322 }
|
|
|
1323 BOOL OnEraseBkgnd(CDCHandle dc) {
|
|
|
1324 if (m_dark) {
|
|
|
1325 CRect rc;
|
|
|
1326 WIN32_OP_D(GetClientRect(rc));
|
|
|
1327 dc.FillSolidRect(rc, DarkMode::GetSysColor(COLOR_BTNFACE));
|
|
|
1328 return TRUE;
|
|
|
1329 }
|
|
|
1330 SetMsgHandled(FALSE); return FALSE;
|
|
|
1331 }
|
|
|
1332 void SetDark(bool v) {
|
|
|
1333 if (v != m_dark) {
|
|
|
1334 m_dark = v; Apply();
|
|
|
1335 }
|
|
|
1336 }
|
|
|
1337 void Apply() {
|
|
|
1338 if (m_dark) {
|
|
|
1339 this->SetTextColor(DarkMode::GetSysColor(COLOR_WINDOWTEXT));
|
|
|
1340 this->SetBkColor(DarkMode::GetSysColor(COLOR_BTNFACE));
|
|
|
1341 } else {
|
|
|
1342 this->SetTextColor((COLORREF)-1);
|
|
|
1343 this->SetBkColor((COLORREF)-1);
|
|
|
1344 }
|
|
|
1345 Invalidate();
|
|
|
1346 }
|
|
|
1347 void SubclassWindow(HWND wnd) {
|
|
|
1348 WIN32_OP_D(__super::SubclassWindow(wnd));
|
|
|
1349 Apply();
|
|
|
1350 }
|
|
|
1351 };
|
|
|
1352
|
|
|
1353 class CStaticHook : public CWindowImpl<CStaticHook, CStatic> {
|
|
|
1354 bool m_dark;
|
|
|
1355 public:
|
|
|
1356 CStaticHook(bool v) : m_dark(v) {}
|
|
|
1357
|
|
|
1358 BEGIN_MSG_MAP_EX(CStaticHook)
|
|
|
1359 MSG_WM_PAINT(OnPaint)
|
|
|
1360 MESSAGE_HANDLER_EX(WM_ENABLE, OnMsgRedraw)
|
|
|
1361 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
1362 END_MSG_MAP()
|
|
|
1363
|
|
|
1364 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
1365 switch (wp) {
|
|
|
1366 case 0: SetDark(false); break;
|
|
|
1367 case 1: SetDark(true); break;
|
|
|
1368 }
|
|
|
1369 return 1;
|
|
|
1370 }
|
|
|
1371
|
|
|
1372 LRESULT OnMsgRedraw(UINT, WPARAM, LPARAM) {
|
|
|
1373 Invalidate();
|
|
|
1374 SetMsgHandled(FALSE);
|
|
|
1375 return 0;
|
|
|
1376 }
|
|
|
1377
|
|
|
1378 void SetDark(bool v) {
|
|
|
1379 if (m_dark != v) {
|
|
|
1380 m_dark = v;
|
|
|
1381 Invalidate();
|
|
|
1382 }
|
|
|
1383 }
|
|
|
1384
|
|
|
1385 void OnPaint(CDCHandle dc) {
|
|
|
1386 // ONLY override the dark+disabled or dark+icon behavior
|
|
|
1387 if (!m_dark || (this->IsWindowEnabled() && this->GetIcon() == NULL) ) {
|
|
|
1388 SetMsgHandled(FALSE); return;
|
|
|
1389 }
|
|
|
1390
|
|
|
1391 if (dc) HandlePaint(dc);
|
|
|
1392 else {
|
|
|
1393 CPaintDC pdc(*this); HandlePaint(pdc.m_hDC);
|
|
|
1394 }
|
|
|
1395 }
|
|
|
1396 void HandlePaint(CDCHandle dc) {
|
|
|
1397 CString str;
|
|
|
1398 CIconHandle icon = this->GetIcon();
|
|
|
1399 this->GetWindowTextW(str);
|
|
|
1400
|
|
|
1401 CRect rcClient;
|
|
|
1402 WIN32_OP_D(GetClientRect(rcClient));
|
|
|
1403
|
|
|
1404 const DWORD style = this->GetStyle();
|
|
|
1405
|
|
|
1406 dc.SelectFont(GetFont());
|
|
|
1407
|
|
|
1408 HBRUSH br = (HBRUSH) GetParent().SendMessage(WM_CTLCOLORSTATIC, (WPARAM)dc.m_hDC, (LPARAM)m_hWnd);;
|
|
|
1409 if (br == NULL) {
|
|
|
1410 dc.FillSolidRect(rcClient, DarkMode::GetSysColor(COLOR_WINDOW));
|
|
|
1411 } else {
|
|
|
1412 WIN32_OP_D(dc.FillRect(rcClient, br));
|
|
|
1413 }
|
|
|
1414
|
|
|
1415 if (icon != NULL) {
|
|
|
1416 dc.DrawIcon(0, 0, icon);
|
|
|
1417 } else {
|
|
|
1418 DWORD flags = 0;
|
|
|
1419 if (style & SS_SIMPLE) flags |= DT_SINGLELINE | DT_WORD_ELLIPSIS;
|
|
|
1420 else flags |= DT_WORDBREAK;
|
|
|
1421 if (style & SS_RIGHT) flags |= DT_RIGHT;
|
|
|
1422 else if (style & SS_CENTER) flags |= DT_CENTER;
|
|
|
1423
|
|
|
1424 dc.SetTextColor(DarkMode::GetSysColor(COLOR_GRAYTEXT));
|
|
|
1425 dc.SetBkMode(TRANSPARENT);
|
|
|
1426 dc.DrawText(str, str.GetLength(), rcClient, flags);
|
|
|
1427 }
|
|
|
1428 }
|
|
|
1429 };
|
|
|
1430
|
|
|
1431 class CUpDownHook : public CWindowImpl<CUpDownHook, CUpDownCtrl> {
|
|
|
1432 bool m_dark;
|
|
|
1433 public:
|
|
|
1434 CUpDownHook(bool v) : m_dark(v) {}
|
|
|
1435
|
|
|
1436 void SetDark(bool v) {
|
|
|
1437 if (v != m_dark) {
|
|
|
1438 m_dark = v; Invalidate();
|
|
|
1439 }
|
|
|
1440 }
|
|
|
1441
|
|
|
1442 BEGIN_MSG_MAP_EX(CUpDownHook)
|
|
|
1443 MSG_WM_PAINT(OnPaint)
|
|
|
1444 MSG_WM_PRINTCLIENT(OnPaint)
|
|
|
1445 MSG_WM_MOUSEMOVE(OnMouseMove)
|
|
|
1446 MSG_WM_LBUTTONDOWN(OnMouseBtn)
|
|
|
1447 MSG_WM_LBUTTONUP(OnMouseBtn)
|
|
|
1448 MSG_WM_MOUSELEAVE(OnMouseLeave)
|
|
|
1449 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
1450 END_MSG_MAP()
|
|
|
1451
|
|
|
1452 private:
|
|
|
1453 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
1454 switch (wp) {
|
|
|
1455 case 0: SetDark(false); break;
|
|
|
1456 case 1: SetDark(true); break;
|
|
|
1457 }
|
|
|
1458 return 1;
|
|
|
1459 }
|
|
|
1460
|
|
|
1461 struct layout_t {
|
|
|
1462 CRect whole, upper, lower;
|
|
|
1463 int yCenter;
|
|
|
1464 };
|
|
|
1465 layout_t Layout(CRect const & rcClient) {
|
|
|
1466 CRect rc = rcClient;
|
|
|
1467 rc.DeflateRect(1, 1);
|
|
|
1468 int yCenter = (rc.top + rc.bottom) / 2;
|
|
|
1469 layout_t ret;
|
|
|
1470 ret.yCenter = yCenter;
|
|
|
1471 ret.whole = rc;
|
|
|
1472 ret.upper = rc;
|
|
|
1473 ret.upper.bottom = yCenter;
|
|
|
1474 ret.lower = rc;
|
|
|
1475 ret.lower.top = yCenter;
|
|
|
1476 return ret;
|
|
|
1477 }
|
|
|
1478 layout_t Layout() {
|
|
|
1479 CRect rcClient; WIN32_OP_D(GetClientRect(rcClient)); return Layout(rcClient);
|
|
|
1480 }
|
|
|
1481 int m_hot = 0;
|
|
|
1482 bool m_btnDown = false;
|
|
|
1483 void SetHot(int iHot) {
|
|
|
1484 if (iHot != m_hot) {
|
|
|
1485 m_hot = iHot; Invalidate();
|
|
|
1486 }
|
|
|
1487 }
|
|
|
1488 void OnMouseLeave() {
|
|
|
1489 SetHot(0);
|
|
|
1490 SetMsgHandled(FALSE);
|
|
|
1491 }
|
|
|
1492 int HitTest(CPoint pt) {
|
|
|
1493 auto layout = Layout();
|
|
|
1494 if (layout.upper.PtInRect(pt)) return 1;
|
|
|
1495 else if (layout.lower.PtInRect(pt)) return 2;
|
|
|
1496 else return 0;
|
|
|
1497 }
|
|
|
1498 void OnMouseBtn(UINT flags, CPoint) {
|
|
|
1499 bool bDown = (flags & MK_LBUTTON) != 0;
|
|
|
1500 if (bDown != m_btnDown) {
|
|
|
1501 m_btnDown = bDown;
|
|
|
1502 Invalidate();
|
|
|
1503 }
|
|
|
1504 SetMsgHandled(FALSE);
|
|
|
1505 }
|
|
|
1506 void OnMouseMove(UINT, CPoint pt) {
|
|
|
1507 SetHot(HitTest(pt));
|
|
|
1508 SetMsgHandled(FALSE);
|
|
|
1509 }
|
|
|
1510 void OnPaint(CDCHandle target, unsigned flags = 0) {
|
|
|
1511 if (!m_dark) { SetMsgHandled(FALSE); return; }
|
|
|
1512 (void)flags;
|
|
|
1513 if (target) {
|
|
|
1514 HandlePaint(target);
|
|
|
1515 } else {
|
|
|
1516 CPaintDC pdc(*this);
|
|
|
1517 HandlePaint(pdc.m_hDC);
|
|
|
1518 }
|
|
|
1519 }
|
|
|
1520 void HandlePaint(CDCHandle dc) {
|
|
|
1521 // no corresponding getsyscolor values for this, hardcoded values taken from actual button control
|
|
|
1522 // + frame trying to fit edit control frame
|
|
|
1523 const COLORREF colorText = 0xFFFFFF;
|
|
|
1524 const COLORREF colorFrame = 0xFFFFFF;
|
|
|
1525 const COLORREF colorBk = 0x333333;
|
|
|
1526 const COLORREF colorHot = 0x454545;
|
|
|
1527 const COLORREF colorPressed = 0x666666;
|
|
|
1528
|
|
|
1529 CRect rcClient; WIN32_OP_D(GetClientRect(rcClient));
|
|
|
1530 auto layout = Layout(rcClient);
|
|
|
1531 dc.FillRect(rcClient, MakeTempBrush(dc, colorBk));
|
|
|
1532
|
|
|
1533 if (m_hot != 0) {
|
|
|
1534 auto color = m_btnDown ? colorPressed : colorHot;
|
|
|
1535 switch (m_hot) {
|
|
|
1536 case 1:
|
|
|
1537 dc.FillSolidRect(layout.upper, color);
|
|
|
1538 break;
|
|
|
1539 case 2:
|
|
|
1540 dc.FillSolidRect(layout.lower, color);
|
|
|
1541 break;
|
|
|
1542 }
|
|
|
1543 }
|
|
|
1544
|
|
|
1545 dc.FrameRect(layout.whole, MakeTempBrush(dc, colorFrame));
|
|
|
1546 dc.SetDCPenColor(colorFrame);
|
|
|
1547 dc.SelectPen((HPEN)GetStockObject(DC_PEN));
|
|
|
1548 dc.MoveTo(layout.whole.left, layout.yCenter);
|
|
|
1549 dc.LineTo(layout.whole.right, layout.yCenter);
|
|
|
1550
|
|
|
1551 CFontHandle f = GetFont();
|
|
|
1552 if (f == NULL) {
|
|
|
1553 auto buddy = this->GetBuddy();
|
|
|
1554 if ( buddy ) f = buddy.GetFont();
|
|
|
1555 }
|
|
|
1556 if (f == NULL) f = (HFONT) GetStockObject(DEFAULT_GUI_FONT);
|
|
|
1557 PFC_ASSERT(f != NULL);
|
|
|
1558 CFont font2;
|
|
|
1559 CreateScaledFont(font2, f, 0.5);
|
|
|
1560 SelectObjectScope selectFont(dc, font2);
|
|
|
1561 dc.SetBkMode(TRANSPARENT);
|
|
|
1562 dc.SetTextColor(colorText);
|
|
|
1563 dc.DrawText(L"˄", 1, layout.upper, DT_SINGLELINE | DT_VCENTER | DT_CENTER | DT_NOPREFIX);
|
|
|
1564 dc.DrawText(L"˅", 1, layout.lower, DT_SINGLELINE | DT_VCENTER | DT_CENTER | DT_NOPREFIX);
|
|
|
1565 }
|
|
|
1566 };
|
|
|
1567
|
|
|
1568 class CNCFrameHook : public CWindowImpl<CNCFrameHook, CWindow> {
|
|
|
1569 public:
|
|
|
1570 CNCFrameHook(bool dark) : m_dark(dark) {}
|
|
|
1571
|
|
|
1572 BEGIN_MSG_MAP_EX(CNCFrameHook)
|
|
|
1573 MESSAGE_HANDLER_EX(msgSetDarkMode(), OnSetDarkMode)
|
|
|
1574 MSG_WM_NCPAINT(OnNCPaint)
|
|
|
1575 END_MSG_MAP()
|
|
|
1576
|
|
|
1577 void SetDark(bool v) {
|
|
|
1578 if (v != m_dark) {
|
|
|
1579 m_dark = v; ApplyDark();
|
|
|
1580 }
|
|
|
1581 }
|
|
|
1582 BOOL SubclassWindow(HWND wnd) {
|
|
|
1583 auto rv = __super::SubclassWindow(wnd);
|
|
|
1584 if (rv) {
|
|
|
1585 ApplyDark();
|
|
|
1586 }
|
|
|
1587 return rv;
|
|
|
1588 }
|
|
|
1589 private:
|
|
|
1590 void OnNCPaint(HRGN rgn) {
|
|
|
1591 if (m_dark) {
|
|
|
1592 NCPaintDarkFrame(m_hWnd, rgn);
|
|
|
1593 return;
|
|
|
1594 }
|
|
|
1595 SetMsgHandled(FALSE);
|
|
|
1596 }
|
|
|
1597 void ApplyDark() {
|
|
|
1598 ApplyDarkThemeCtrl(m_hWnd, m_dark);
|
|
|
1599 Invalidate();
|
|
|
1600 }
|
|
|
1601 LRESULT OnSetDarkMode(UINT, WPARAM wp, LPARAM) {
|
|
|
1602 switch (wp) {
|
|
|
1603 case 0: SetDark(false); break;
|
|
|
1604 case 1: SetDark(true); break;
|
|
|
1605 }
|
|
|
1606 return 1;
|
|
|
1607 }
|
|
|
1608
|
|
|
1609 bool m_dark;
|
|
|
1610 };
|
|
|
1611 }
|
|
|
1612
|
|
|
1613 void CHooks::AddPopup(HWND wnd) {
|
|
|
1614 addOp( [wnd, this] {
|
|
|
1615 UpdateTitleBar(wnd, m_dark);
|
|
|
1616 } );
|
|
|
1617 }
|
|
|
1618
|
|
|
1619 void CHooks::AddDialogWithControls(HWND wnd) {
|
|
|
1620 AddDialog(wnd); AddControls(wnd);
|
|
|
1621 }
|
|
|
1622
|
|
|
1623 void CHooks::AddDialog(HWND wnd) {
|
|
|
1624
|
|
|
1625 {
|
|
|
1626 CWindow w(wnd);
|
|
|
1627 if ((w.GetStyle() & WS_CHILD) == 0) {
|
|
|
1628 AddPopup(wnd);
|
|
|
1629 }
|
|
|
1630 }
|
|
|
1631
|
|
|
1632 auto hook = new ImplementOnFinalMessage< CDialogHook > (m_dark);
|
|
|
1633 hook->SubclassWindow(wnd);
|
|
|
1634 AddCtrlMsg(wnd);
|
|
|
1635 }
|
|
|
1636 void CHooks::AddTabCtrl(HWND wnd) {
|
|
|
1637 auto hook = new ImplementOnFinalMessage<CTabsHook>(m_dark);
|
|
|
1638 hook->SubclassWindow(wnd);
|
|
|
1639 AddCtrlMsg(wnd);
|
|
|
1640 }
|
|
|
1641 void CHooks::AddComboBox(HWND wnd) {
|
|
|
1642 {
|
|
|
1643 CComboBox combo = wnd;
|
|
|
1644 COMBOBOXINFO info = {sizeof(info)};
|
|
|
1645 WIN32_OP_D( combo.GetComboBoxInfo(&info) );
|
|
|
1646 if (info.hwndList != NULL) {
|
|
|
1647 AddListBox( info.hwndList );
|
|
|
1648 }
|
|
|
1649 }
|
|
|
1650
|
|
|
1651 addOp([wnd, this] {
|
|
|
1652 SetWindowTheme(wnd, m_dark ? L"DarkMode_CFD" : L"Explorer", NULL);
|
|
|
1653 });
|
|
|
1654 }
|
|
|
1655 void CHooks::AddComboBoxEx(HWND wnd) {
|
|
|
1656 this->AddControls(wnd); // recurse to add the combo box
|
|
|
1657 }
|
|
|
1658 void CHooks::AddEditBox(HWND wnd) {
|
|
|
1659 #if 0 // Experimental
|
|
|
1660 auto hook = new ImplementOnFinalMessage<CNCFrameHook>(m_dark);
|
|
|
1661 hook->SubclassWindow( wnd );
|
|
|
1662 AddCtrlMsg( wnd );
|
|
|
1663 #else
|
|
|
1664 AddGeneric(wnd);
|
|
|
1665 #endif
|
|
|
1666 }
|
|
|
1667 void CHooks::AddButton(HWND wnd) {
|
|
|
1668 CButton btn(wnd);
|
|
|
1669 auto style = btn.GetButtonStyle();
|
|
|
1670 auto type = style & BS_TYPEMASK;
|
|
|
1671 if ((type == BS_CHECKBOX || type == BS_AUTOCHECKBOX || type == BS_RADIOBUTTON || type == BS_AUTORADIOBUTTON || type == BS_3STATE || type == BS_AUTO3STATE) && (style & BS_PUSHLIKE) == 0) {
|
|
|
1672 // MS checkbox implementation is terminally retarded and won't draw text in correct color
|
|
|
1673 // Subclass it and draw our own content
|
|
|
1674 // Other button types seem OK
|
|
|
1675 auto hook = new ImplementOnFinalMessage<CCheckBoxHook>(m_dark);
|
|
|
1676 hook->SubclassWindow(wnd);
|
|
|
1677 AddCtrlMsg(wnd);
|
|
|
1678 } else if (type == BS_GROUPBOX) {
|
|
|
1679 SetWindowTheme(wnd, L"", L"");
|
|
|
1680 // SNAFU: re-creation of other controls such as list boxes causes repaint bugs due to overlapping
|
|
|
1681 // Even though this is not a fault of the groupbox, fix it here - by defer-pushing all group boxes to the back
|
|
|
1682 // Can't move to back right away, breaks window enumeration
|
|
|
1683 m_lstMoveToBack.push_back(wnd);
|
|
|
1684 } else {
|
|
|
1685 AddGeneric(wnd);
|
|
|
1686 }
|
|
|
1687
|
|
|
1688 }
|
|
|
1689 void CHooks::AddGeneric(HWND wnd, const wchar_t * name) {
|
|
|
1690 this->addOp([wnd, this, name] {ApplyDarkThemeCtrl(wnd, m_dark, name); });
|
|
|
1691 }
|
|
|
1692 void CHooks::AddClassic(HWND wnd, const wchar_t* normalTheme) {
|
|
|
1693 this->addOp([wnd, this, normalTheme] {
|
|
|
1694 if (m_dark) ::SetWindowTheme(wnd, L"", L"");
|
|
|
1695 else ::SetWindowTheme(wnd, normalTheme, nullptr);
|
|
|
1696 });
|
|
|
1697 }
|
|
|
1698 void CHooks::AddStatusBar(HWND wnd) {
|
|
|
1699 auto hook = new ImplementOnFinalMessage<CStatusBarHook>(m_dark);
|
|
|
1700 hook->SubclassWindow(wnd);
|
|
|
1701 this->AddCtrlMsg(wnd);
|
|
|
1702 }
|
|
|
1703 void CHooks::AddScrollBar(HWND wnd) {
|
|
|
1704 CWindow w(wnd);
|
|
|
1705 if (w.GetStyle() & SBS_SIZEGRIP) {
|
|
|
1706 auto hook = new ImplementOnFinalMessage<CGripperHook>(m_dark);
|
|
|
1707 hook->SubclassWindow(wnd);
|
|
|
1708 this->AddCtrlMsg(wnd);
|
|
|
1709 } else {
|
|
|
1710 AddGeneric(wnd);
|
|
|
1711 }
|
|
|
1712 }
|
|
|
1713
|
|
|
1714 void CHooks::AddReBar(HWND wnd) {
|
|
|
1715 auto hook = new ImplementOnFinalMessage<CReBarHook>(m_dark);
|
|
|
1716 hook->SubclassWindow(wnd);
|
|
|
1717 this->AddCtrlMsg(wnd);
|
|
|
1718 }
|
|
|
1719
|
|
|
1720 void CHooks::AddToolBar(HWND wnd, bool bExplorerTheme) {
|
|
|
1721 // Not a subclass
|
|
|
1722 addObj(new CToolbarHook(wnd, m_dark, bExplorerTheme));
|
|
|
1723 }
|
|
|
1724
|
|
|
1725 void CHooks::AddStatic(HWND wnd) {
|
|
|
1726 auto hook = new ImplementOnFinalMessage<CStaticHook>(m_dark);
|
|
|
1727 hook->SubclassWindow(wnd);
|
|
|
1728 this->AddCtrlMsg(wnd);
|
|
|
1729 }
|
|
|
1730
|
|
|
1731 void CHooks::AddUpDown(HWND wnd) {
|
|
|
1732 auto hook = new ImplementOnFinalMessage<CUpDownHook>(m_dark);
|
|
|
1733 hook->SubclassWindow(wnd);
|
|
|
1734 this->AddCtrlMsg(wnd);
|
|
|
1735 }
|
|
|
1736
|
|
|
1737 void CHooks::AddTreeView(HWND wnd) {
|
|
|
1738 auto hook = new ImplementOnFinalMessage<CTreeViewHook>(m_dark);
|
|
|
1739 hook->SubclassWindow(wnd);
|
|
|
1740 this->AddCtrlMsg(wnd);
|
|
|
1741 }
|
|
|
1742 void CHooks::AddListBox(HWND wnd) {
|
|
|
1743 this->AddGeneric( wnd );
|
|
|
1744 #if 0
|
|
|
1745 auto subst = CListControl_ReplaceListBox(wnd);
|
|
|
1746 if (subst) AddPPListControl(subst);
|
|
|
1747 #endif
|
|
|
1748 }
|
|
|
1749
|
|
|
1750 void CHooks::AddListView(HWND wnd) {
|
|
|
1751 auto subst = CListControl_ReplaceListView(wnd);
|
|
|
1752 if (subst) AddPPListControl(subst);
|
|
|
1753 }
|
|
|
1754
|
|
|
1755 void CHooks::AddPPListControl(HWND wnd) {
|
|
|
1756 this->AddCtrlMsg(wnd);
|
|
|
1757 // this->addOp([this, wnd] { CListControl::wndSetDarkMode(wnd, m_dark); });
|
|
|
1758 }
|
|
|
1759
|
|
|
1760 void CHooks::SetDark(bool v) {
|
|
|
1761 // Important: some handlers to ugly things if told to apply when no state change occurred - UpdateTitleBar() stuff in particular
|
|
|
1762 if (m_dark != v) {
|
|
|
1763 m_dark = v;
|
|
|
1764 for (auto& f : m_apply) f();
|
|
|
1765 }
|
|
|
1766 }
|
|
|
1767 void CHooks::flushMoveToBack() {
|
|
|
1768 for (auto w : m_lstMoveToBack) {
|
|
|
1769 ::SetWindowPos(w, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
|
|
|
1770 }
|
|
|
1771 m_lstMoveToBack.clear();
|
|
|
1772 }
|
|
|
1773 void CHooks::AddControls(HWND wndParent) {
|
|
|
1774 for (HWND walk = GetWindow(wndParent, GW_CHILD); walk != NULL; ) {
|
|
|
1775 HWND next = GetWindow(walk, GW_HWNDNEXT);
|
|
|
1776 AddCtrlAuto(walk);
|
|
|
1777 walk = next;
|
|
|
1778 }
|
|
|
1779 this->flushMoveToBack();
|
|
|
1780 // EnumChildWindows(wndParent, [this](HWND ctrl) {this->AddCtrlAuto(ctrl);});
|
|
|
1781 }
|
|
|
1782
|
|
|
1783 void CHooks::AddCtrlMsg(HWND w) {
|
|
|
1784 this->addOp([this, w] {
|
|
|
1785 ::SendMessage(w, msgSetDarkMode(), this->m_dark ? 1 : 0, 0);
|
|
|
1786 });
|
|
|
1787 }
|
|
|
1788
|
|
|
1789 void CHooks::AddCtrlAuto(HWND wnd) {
|
|
|
1790
|
|
|
1791 if (::SendMessage(wnd, msgSetDarkMode(), -1, -1)) {
|
|
|
1792 AddCtrlMsg(wnd); return;
|
|
|
1793 }
|
|
|
1794
|
|
|
1795 wchar_t buffer[128] = {};
|
|
|
1796
|
|
|
1797 ::GetClassName(wnd, buffer, (int)(std::size(buffer) - 1));
|
|
|
1798
|
|
|
1799 const wchar_t* cls = buffer;
|
|
|
1800 if (_wcsnicmp(cls, L"ATL:", 4) == 0) cls += 4;
|
|
|
1801
|
|
|
1802
|
|
|
1803 if (_wcsicmp(cls, CButton::GetWndClassName()) == 0) {
|
|
|
1804 AddButton(wnd);
|
|
|
1805 } else if (_wcsicmp(cls, CComboBox::GetWndClassName()) == 0) {
|
|
|
1806 AddComboBox(wnd);
|
|
|
1807 } else if (_wcsicmp(cls, CComboBoxEx::GetWndClassName()) == 0 ) {
|
|
|
1808 AddComboBoxEx(wnd);
|
|
|
1809 } else if (_wcsicmp(cls, CTabCtrl::GetWndClassName()) == 0) {
|
|
|
1810 AddTabCtrl(wnd);
|
|
|
1811 } else if (_wcsicmp(cls, CStatusBarCtrl::GetWndClassName()) == 0) {
|
|
|
1812 AddStatusBar(wnd);
|
|
|
1813 } else if (_wcsicmp(cls, CEdit::GetWndClassName()) == 0) {
|
|
|
1814 AddEditBox(wnd);
|
|
|
1815 } else if (_wcsicmp(cls, WC_SCROLLBAR) == 0) {
|
|
|
1816 AddScrollBar(wnd);
|
|
|
1817 } else if (_wcsicmp(cls, CToolBarCtrl::GetWndClassName()) == 0) {
|
|
|
1818 AddToolBar(wnd);
|
|
|
1819 } else if (_wcsicmp(cls, CTrackBarCtrl::GetWndClassName()) == 0) {
|
|
|
1820 AddGeneric(wnd);
|
|
|
1821 } else if (_wcsicmp(cls, CTreeViewCtrl::GetWndClassName()) == 0) {
|
|
|
1822 AddTreeView(wnd);
|
|
|
1823 } else if (_wcsicmp(cls, CStatic::GetWndClassName()) == 0) {
|
|
|
1824 AddStatic(wnd);
|
|
|
1825 } else if (_wcsicmp(cls, CUpDownCtrl::GetWndClassName()) == 0) {
|
|
|
1826 AddUpDown(wnd);
|
|
|
1827 } else if (_wcsicmp(cls, CListViewCtrl::GetWndClassName()) == 0) {
|
|
|
1828 AddListView(wnd);
|
|
|
1829 } else if (_wcsicmp(cls, CListBox::GetWndClassName()) == 0) {
|
|
|
1830 AddListBox(wnd);
|
|
|
1831 } else if (_wcsicmp(cls, CReBarCtrl::GetWndClassName()) == 0) {
|
|
|
1832 AddReBar(wnd);
|
|
|
1833 } else {
|
|
|
1834 #if PFC_DEBUG
|
|
|
1835 pfc::outputDebugLine(pfc::format("DarkMode: unknown class - ", buffer));
|
|
|
1836 #endif
|
|
|
1837 }
|
|
|
1838 }
|
|
|
1839
|
|
|
1840 void CHooks::clear() {
|
|
|
1841 m_apply.clear();
|
|
|
1842 for (auto v : m_cleanup) v();
|
|
|
1843 m_cleanup.clear();
|
|
|
1844 }
|
|
|
1845
|
|
|
1846 void CHooks::AddApp() {
|
|
|
1847 addOp([this] {
|
|
|
1848 SetAppDarkMode(this->m_dark);
|
|
|
1849 });
|
|
|
1850 }
|
|
|
1851
|
|
|
1852 void NCPaintDarkFrame(HWND wnd_, HRGN rgn_) {
|
|
|
1853 // rgn is in SCREEN COORDINATES, possibly (HRGN)1 to indicate no clipping / whole nonclient area redraw
|
|
|
1854 // we're working with SCREEN COORDINATES until actual DC painting
|
|
|
1855 CWindow wnd = wnd_;
|
|
|
1856
|
|
|
1857 CRect rcWindow, rcClient;
|
|
|
1858 WIN32_OP_D( wnd.GetWindowRect(rcWindow) );
|
|
|
1859 WIN32_OP_D( wnd.GetClientRect(rcClient) );
|
|
|
1860 WIN32_OP_D( wnd.ClientToScreen( rcClient ) ); // transform all to same coordinate system
|
|
|
1861
|
|
|
1862 CRgn rgnClip;
|
|
|
1863 WIN32_OP_D( rgnClip.CreateRectRgnIndirect(rcWindow) != NULL );
|
|
|
1864 if (rgn_ != NULL && rgn_ != (HRGN)1) {
|
|
|
1865 // we have a valid HRGN from caller?
|
|
|
1866 if (rgnClip.CombineRgn(rgn_, RGN_AND) == NULLREGION) return; // nothing to draw, exit early
|
|
|
1867 }
|
|
|
1868
|
|
|
1869 {
|
|
|
1870 // Have scroll bars? Have DefWindowProc() them then exclude from our rgnClip.
|
|
|
1871 SCROLLBARINFO si = { sizeof(si) };
|
|
|
1872 if (::GetScrollBarInfo(wnd, OBJID_VSCROLL, &si) && (si.rgstate[0] & STATE_SYSTEM_INVISIBLE) == 0 && si.rcScrollBar.left < si.rcScrollBar.right) {
|
|
|
1873 CRect rc = si.rcScrollBar;
|
|
|
1874 // rcClient.right = rc.right;
|
|
|
1875 CRgn rgn; WIN32_OP_D( rgn.CreateRectRgnIndirect(rc) );
|
|
|
1876 int status = SIMPLEREGION;
|
|
|
1877 if (rgnClip) {
|
|
|
1878 status = rgn.CombineRgn(rgn, rgnClip, RGN_AND);
|
|
|
1879 }
|
|
|
1880 if (status != NULLREGION) {
|
|
|
1881 DefWindowProc(wnd, WM_NCPAINT, (WPARAM)rgn.m_hRgn, 0);
|
|
|
1882 rgnClip.CombineRgn(rgn, RGN_DIFF); // exclude from further drawing
|
|
|
1883 }
|
|
|
1884 }
|
|
|
1885 if (::GetScrollBarInfo(wnd, OBJID_HSCROLL, &si) && (si.rgstate[0] & STATE_SYSTEM_INVISIBLE) == 0 && si.rcScrollBar.top < si.rcScrollBar.bottom) {
|
|
|
1886 CRect rc = si.rcScrollBar;
|
|
|
1887 // rcClient.bottom = rc.bottom;
|
|
|
1888 CRgn rgn; WIN32_OP_D(rgn.CreateRectRgnIndirect(rc));
|
|
|
1889 int status = SIMPLEREGION;
|
|
|
1890 if (rgnClip) {
|
|
|
1891 status = rgn.CombineRgn(rgn, rgnClip, RGN_AND);
|
|
|
1892 }
|
|
|
1893 if (status != NULLREGION) {
|
|
|
1894 DefWindowProc(wnd, WM_NCPAINT, (WPARAM)rgn.m_hRgn, 0);
|
|
|
1895 rgnClip.CombineRgn(rgn, RGN_DIFF); // exclude from further drawing
|
|
|
1896 }
|
|
|
1897 }
|
|
|
1898 }
|
|
|
1899
|
|
|
1900 const auto colorLight = DarkMode::GetSysColor(COLOR_BTNHIGHLIGHT);
|
|
|
1901 const auto colorDark = DarkMode::GetSysColor(COLOR_BTNSHADOW);
|
|
|
1902
|
|
|
1903 CWindowDC dc( wnd );
|
|
|
1904 if (dc.IsNull()) {
|
|
|
1905 PFC_ASSERT(!"???");
|
|
|
1906 return;
|
|
|
1907 }
|
|
|
1908
|
|
|
1909
|
|
|
1910 // Window DC has (0,0) in upper-left corner of our window (not screen, not client)
|
|
|
1911 // Turn rcWindow to (0,0), (winWidth, winHeight)
|
|
|
1912 CPoint origin = rcWindow.TopLeft();
|
|
|
1913 rcWindow.OffsetRect(-origin);
|
|
|
1914 rcClient.OffsetRect(-origin);
|
|
|
1915
|
|
|
1916 if (!rgnClip.IsNull()) {
|
|
|
1917 // rgnClip is still in screen coordinates, fix this here
|
|
|
1918 rgnClip.OffsetRgn(-origin);
|
|
|
1919 dc.SelectClipRgn(rgnClip);
|
|
|
1920 }
|
|
|
1921
|
|
|
1922 // bottom
|
|
|
1923 dc.FillSolidRect(CRect(rcClient.left, rcClient.bottom, rcWindow.right, rcWindow.bottom), colorLight);
|
|
|
1924 // right
|
|
|
1925 dc.FillSolidRect(CRect(rcClient.right, rcWindow.top, rcWindow.right, rcClient.bottom), colorLight);
|
|
|
1926 // top
|
|
|
1927 dc.FillSolidRect(CRect(rcWindow.left, rcWindow.top, rcWindow.right, rcClient.top), colorDark);
|
|
|
1928 // left
|
|
|
1929 dc.FillSolidRect(CRect(rcWindow.left, rcClient.top, rcClient.left, rcWindow.bottom), colorDark);
|
|
|
1930 }
|
|
|
1931 }
|
