1 /* 2 * ReactOS Explorer 3 * 4 * Copyright 2006 - 2007 Thomas Weidenmueller <w3seek@reactos.org> 5 * Copyright 2018 Ged Murphy <gedmurphy@reactos.org> 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22 #include "precomp.h" 23 24 /* 25 * TrayClockWnd 26 */ 27 28 const struct 29 { 30 BOOL IsTime; 31 DWORD dwFormatFlags; 32 LPCWSTR lpFormat; 33 } ClockWndFormats[] = { 34 { TRUE, 0, NULL }, 35 { FALSE, 0, L"dddd" }, 36 { FALSE, DATE_SHORTDATE, NULL } 37 }; 38 const UINT ClockWndFormatsCount = _ARRAYSIZE(ClockWndFormats); 39 40 #define CLOCKWND_FORMAT_COUNT ClockWndFormatsCount 41 42 static const WCHAR szTrayClockWndClass[] = L"TrayClockWClass"; 43 44 class CTrayClockWnd : 45 public CComCoClass<CTrayClockWnd>, 46 public CComObjectRootEx<CComMultiThreadModelNoCS>, 47 public CWindowImpl < CTrayClockWnd, CWindow, CControlWinTraits >, 48 public IOleWindow 49 { 50 HFONT hFont; 51 COLORREF textColor; 52 RECT rcText; 53 SYSTEMTIME LocalTime; 54 CTooltips m_tooltip; 55 56 union 57 { 58 DWORD dwFlags; 59 struct 60 { 61 DWORD IsTimerEnabled : 1; 62 DWORD IsInitTimerEnabled : 1; 63 DWORD LinesMeasured : 1; 64 DWORD IsHorizontal : 1; 65 }; 66 }; 67 DWORD LineSpacing; 68 SIZE CurrentSize; 69 WORD VisibleLines; 70 SIZE LineSizes[CLOCKWND_FORMAT_COUNT]; 71 WCHAR szLines[CLOCKWND_FORMAT_COUNT][48]; 72 73 public: 74 CTrayClockWnd(); 75 virtual ~CTrayClockWnd(); 76 77 private: 78 LRESULT OnThemeChanged(); 79 LRESULT OnThemeChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 80 81 BOOL MeasureLines(); 82 WORD GetMinimumSize(IN BOOL Horizontal, IN OUT PSIZE pSize); 83 VOID UpdateWnd(); 84 VOID Update(); 85 UINT CalculateDueTime(); 86 BOOL ResetTime(); 87 VOID CalibrateTimer(); 88 LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 89 LRESULT OnPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 90 VOID SetFont(IN HFONT hNewFont, IN BOOL bRedraw); 91 LRESULT DrawBackground(HDC hdc); 92 LRESULT OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 93 LRESULT OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 94 LRESULT OnGetMinimumSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 95 LRESULT OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 96 LRESULT OnSetFont(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 97 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 98 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 99 LRESULT OnTaskbarSettingsChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 100 LRESULT OnLButtonDblClick(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled); 101 102 public: 103 104 HRESULT WINAPI GetWindow(HWND* phwnd) 105 { 106 if (!phwnd) 107 return E_INVALIDARG; 108 *phwnd = m_hWnd; 109 return S_OK; 110 } 111 112 HRESULT WINAPI ContextSensitiveHelp(BOOL fEnterMode) 113 { 114 return E_NOTIMPL; 115 } 116 117 DECLARE_NOT_AGGREGATABLE(CTrayClockWnd) 118 119 DECLARE_PROTECT_FINAL_CONSTRUCT() 120 BEGIN_COM_MAP(CTrayClockWnd) 121 COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow) 122 END_COM_MAP() 123 124 DECLARE_WND_CLASS_EX(szTrayClockWndClass, CS_DBLCLKS, COLOR_3DFACE) 125 126 BEGIN_MSG_MAP(CTrayClockWnd) 127 MESSAGE_HANDLER(WM_CREATE, OnCreate) 128 MESSAGE_HANDLER(WM_DESTROY, OnDestroy) 129 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground) 130 MESSAGE_HANDLER(WM_SIZE, OnSize) 131 MESSAGE_HANDLER(WM_PAINT, OnPaint) 132 MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint) 133 MESSAGE_HANDLER(WM_THEMECHANGED, OnThemeChanged) 134 MESSAGE_HANDLER(WM_TIMER, OnTimer) 135 MESSAGE_HANDLER(WM_NCHITTEST, OnNcHitTest) 136 MESSAGE_HANDLER(WM_SETFONT, OnSetFont) 137 MESSAGE_HANDLER(TNWM_GETMINIMUMSIZE, OnGetMinimumSize) 138 MESSAGE_HANDLER(TWM_SETTINGSCHANGED, OnTaskbarSettingsChanged) 139 MESSAGE_HANDLER(WM_LBUTTONDBLCLK, OnLButtonDblClick) 140 END_MSG_MAP() 141 142 HRESULT Initialize(IN HWND hWndParent); 143 }; 144 145 #define ID_TRAYCLOCK_TIMER 0 146 #define ID_TRAYCLOCK_TIMER_INIT 1 147 148 #define TRAY_CLOCK_WND_SPACING_X 5 149 #define TRAY_CLOCK_WND_SPACING_Y 0 150 151 CTrayClockWnd::CTrayClockWnd() : 152 hFont(NULL), 153 dwFlags(0), 154 LineSpacing(0), 155 VisibleLines(0) 156 { 157 ZeroMemory(&textColor, sizeof(textColor)); 158 ZeroMemory(&rcText, sizeof(rcText)); 159 ZeroMemory(&LocalTime, sizeof(LocalTime)); 160 ZeroMemory(&CurrentSize, sizeof(CurrentSize)); 161 ZeroMemory(LineSizes, sizeof(LineSizes)); 162 ZeroMemory(szLines, sizeof(szLines)); 163 } 164 CTrayClockWnd::~CTrayClockWnd() { } 165 166 LRESULT CTrayClockWnd::OnThemeChanged() 167 { 168 LOGFONTW clockFont; 169 HTHEME clockTheme; 170 HFONT hFont; 171 172 clockTheme = OpenThemeData(m_hWnd, L"Clock"); 173 174 if (clockTheme) 175 { 176 GetThemeFont(clockTheme, 177 NULL, 178 CLP_TIME, 179 0, 180 TMT_FONT, 181 &clockFont); 182 183 hFont = CreateFontIndirectW(&clockFont); 184 185 GetThemeColor(clockTheme, 186 CLP_TIME, 187 0, 188 TMT_TEXTCOLOR, 189 &textColor); 190 191 if (this->hFont != NULL) 192 DeleteObject(this->hFont); 193 194 SetFont(hFont, FALSE); 195 } 196 else 197 { 198 /* We don't need to set a font here, our parent will use 199 * WM_SETFONT to set the right one when themes are not enabled. */ 200 textColor = RGB(0, 0, 0); 201 } 202 203 CloseThemeData(clockTheme); 204 205 return TRUE; 206 } 207 208 LRESULT CTrayClockWnd::OnThemeChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 209 { 210 return OnThemeChanged(); 211 } 212 213 BOOL CTrayClockWnd::MeasureLines() 214 { 215 HDC hDC; 216 HFONT hPrevFont; 217 UINT c, i; 218 BOOL bRet = TRUE; 219 220 hDC = GetDC(); 221 if (hDC != NULL) 222 { 223 if (hFont) 224 hPrevFont = (HFONT) SelectObject(hDC, hFont); 225 226 for (i = 0; i < CLOCKWND_FORMAT_COUNT && bRet; i++) 227 { 228 if (szLines[i][0] != L'\0' && 229 !GetTextExtentPointW(hDC, szLines[i], wcslen(szLines[i]), 230 &LineSizes[i])) 231 { 232 bRet = FALSE; 233 break; 234 } 235 } 236 237 if (hFont) 238 SelectObject(hDC, hPrevFont); 239 240 ReleaseDC(hDC); 241 242 if (bRet) 243 { 244 LineSpacing = 0; 245 246 /* calculate the line spacing */ 247 for (i = 0, c = 0; i < CLOCKWND_FORMAT_COUNT; i++) 248 { 249 if (LineSizes[i].cx > 0) 250 { 251 LineSpacing += LineSizes[i].cy; 252 c++; 253 } 254 } 255 256 if (c > 0) 257 { 258 /* We want a spacing of 1/2 line */ 259 LineSpacing = (LineSpacing / c) / 2; 260 } 261 262 return TRUE; 263 } 264 } 265 266 return FALSE; 267 } 268 269 WORD CTrayClockWnd::GetMinimumSize(IN BOOL Horizontal, IN OUT PSIZE pSize) 270 { 271 WORD iLinesVisible = 0; 272 UINT i; 273 SIZE szMax = { 0, 0 }; 274 275 if (!LinesMeasured) 276 LinesMeasured = MeasureLines(); 277 278 if (!LinesMeasured) 279 return 0; 280 281 for (i = 0; i < CLOCKWND_FORMAT_COUNT; i++) 282 { 283 if (LineSizes[i].cx != 0) 284 { 285 if (iLinesVisible > 0) 286 { 287 if (Horizontal) 288 { 289 if (szMax.cy + LineSizes[i].cy + (LONG) LineSpacing > 290 pSize->cy - (2 * TRAY_CLOCK_WND_SPACING_Y)) 291 { 292 break; 293 } 294 } 295 else 296 { 297 if (LineSizes[i].cx > pSize->cx - (2 * TRAY_CLOCK_WND_SPACING_X)) 298 break; 299 } 300 301 /* Add line spacing */ 302 szMax.cy += LineSpacing; 303 } 304 305 iLinesVisible++; 306 307 /* Increase maximum rectangle */ 308 szMax.cy += LineSizes[i].cy; 309 if (LineSizes[i].cx > szMax.cx) 310 szMax.cx = LineSizes[i].cx; 311 } 312 } 313 314 szMax.cx += 2 * TRAY_CLOCK_WND_SPACING_X; 315 szMax.cy += 2 * TRAY_CLOCK_WND_SPACING_Y; 316 317 *pSize = szMax; 318 319 return iLinesVisible; 320 } 321 322 VOID CTrayClockWnd::UpdateWnd() 323 { 324 SIZE szPrevCurrent; 325 UINT BufSize, i; 326 INT iRet; 327 RECT rcClient; 328 329 ZeroMemory(LineSizes, sizeof(LineSizes)); 330 331 szPrevCurrent = CurrentSize; 332 333 for (i = 0; i < CLOCKWND_FORMAT_COUNT; i++) 334 { 335 szLines[i][0] = L'\0'; 336 BufSize = _countof(szLines[0]); 337 338 if (ClockWndFormats[i].IsTime) 339 { 340 iRet = GetTimeFormat(LOCALE_USER_DEFAULT, 341 g_TaskbarSettings.bShowSeconds ? ClockWndFormats[i].dwFormatFlags : TIME_NOSECONDS, 342 &LocalTime, 343 ClockWndFormats[i].lpFormat, 344 szLines[i], 345 BufSize); 346 } 347 else 348 { 349 iRet = GetDateFormat(LOCALE_USER_DEFAULT, 350 ClockWndFormats[i].dwFormatFlags, 351 &LocalTime, 352 ClockWndFormats[i].lpFormat, 353 szLines[i], 354 BufSize); 355 } 356 357 if (iRet != 0 && i == 0) 358 { 359 /* Set the window text to the time only */ 360 SetWindowText(szLines[i]); 361 } 362 } 363 364 LinesMeasured = MeasureLines(); 365 366 if (LinesMeasured && 367 GetClientRect(&rcClient)) 368 { 369 SIZE szWnd; 370 371 szWnd.cx = rcClient.right; 372 szWnd.cy = rcClient.bottom; 373 374 VisibleLines = GetMinimumSize(IsHorizontal, &szWnd); 375 CurrentSize = szWnd; 376 } 377 378 if (IsWindowVisible()) 379 { 380 InvalidateRect(NULL, TRUE); 381 382 if (szPrevCurrent.cx != CurrentSize.cx || 383 szPrevCurrent.cy != CurrentSize.cy) 384 { 385 /* Ask the parent to resize */ 386 NMHDR nmh = {GetParent(), 0, NTNWM_REALIGN}; 387 GetParent().SendMessage(WM_NOTIFY, 0, (LPARAM) &nmh); 388 } 389 } 390 391 int iDateLength = GetDateFormat(LOCALE_USER_DEFAULT, 392 DATE_LONGDATE, 393 &LocalTime, 394 NULL, 395 NULL, 396 0); 397 if (iDateLength <= 0) 398 { 399 return; 400 } 401 402 WCHAR* szDate = new WCHAR[iDateLength]; 403 if (GetDateFormat(LOCALE_USER_DEFAULT, 404 DATE_LONGDATE, 405 &LocalTime, 406 NULL, 407 szDate, 408 iDateLength) > 0) 409 { 410 m_tooltip.UpdateTipText(m_hWnd, 411 reinterpret_cast<UINT_PTR>(m_hWnd), 412 szDate); 413 } 414 delete[] szDate; 415 } 416 417 VOID CTrayClockWnd::Update() 418 { 419 GetLocalTime(&LocalTime); 420 UpdateWnd(); 421 } 422 423 UINT CTrayClockWnd::CalculateDueTime() 424 { 425 UINT uiDueTime; 426 427 /* Calculate the due time */ 428 GetLocalTime(&LocalTime); 429 uiDueTime = 1000 - (UINT) LocalTime.wMilliseconds; 430 if (g_TaskbarSettings.bShowSeconds) 431 uiDueTime += (UINT) LocalTime.wSecond * 100; 432 else 433 uiDueTime += (59 - (UINT) LocalTime.wSecond) * 1000; 434 435 if (uiDueTime < USER_TIMER_MINIMUM || uiDueTime > USER_TIMER_MAXIMUM) 436 uiDueTime = 1000; 437 else 438 { 439 /* Add an artificial delay of 0.05 seconds to make sure the timer 440 doesn't fire too early*/ 441 uiDueTime += 50; 442 } 443 444 return uiDueTime; 445 } 446 447 BOOL CTrayClockWnd::ResetTime() 448 { 449 UINT uiDueTime; 450 BOOL Ret; 451 452 /* Disable all timers */ 453 if (IsTimerEnabled) 454 { 455 KillTimer(ID_TRAYCLOCK_TIMER); 456 IsTimerEnabled = FALSE; 457 } 458 459 if (IsInitTimerEnabled) 460 { 461 KillTimer(ID_TRAYCLOCK_TIMER_INIT); 462 } 463 464 uiDueTime = CalculateDueTime(); 465 466 /* Set the new timer */ 467 Ret = SetTimer(ID_TRAYCLOCK_TIMER_INIT, uiDueTime, NULL) != 0; 468 IsInitTimerEnabled = Ret; 469 470 /* Update the time */ 471 Update(); 472 473 return Ret; 474 } 475 476 VOID CTrayClockWnd::CalibrateTimer() 477 { 478 UINT uiDueTime; 479 BOOL Ret; 480 UINT uiWait1, uiWait2; 481 482 /* Kill the initialization timer */ 483 KillTimer(ID_TRAYCLOCK_TIMER_INIT); 484 IsInitTimerEnabled = FALSE; 485 486 uiDueTime = CalculateDueTime(); 487 488 if (g_TaskbarSettings.bShowSeconds) 489 { 490 uiWait1 = 1000 - 200; 491 uiWait2 = 1000; 492 } 493 else 494 { 495 uiWait1 = 60 * 1000 - 200; 496 uiWait2 = 60 * 1000; 497 } 498 499 if (uiDueTime > uiWait1) 500 { 501 /* The update of the clock will be up to 200 ms late, but that's 502 acceptable. We're going to setup a timer that fires depending 503 uiWait2. */ 504 Ret = SetTimer(ID_TRAYCLOCK_TIMER, uiWait2, NULL) != 0; 505 IsTimerEnabled = Ret; 506 507 /* Update the time */ 508 Update(); 509 } 510 else 511 { 512 /* Recalibrate the timer and recalculate again when the current 513 minute/second ends. */ 514 ResetTime(); 515 } 516 } 517 518 LRESULT CTrayClockWnd::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 519 { 520 /* Disable all timers */ 521 if (IsTimerEnabled) 522 { 523 KillTimer(ID_TRAYCLOCK_TIMER); 524 } 525 526 if (IsInitTimerEnabled) 527 { 528 KillTimer(ID_TRAYCLOCK_TIMER_INIT); 529 } 530 531 return TRUE; 532 } 533 534 LRESULT CTrayClockWnd::OnPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 535 { 536 RECT rcClient; 537 HFONT hPrevFont; 538 INT iPrevBkMode; 539 UINT i, line; 540 541 PAINTSTRUCT ps; 542 HDC hDC = (HDC) wParam; 543 544 if (wParam == 0) 545 { 546 hDC = BeginPaint(&ps); 547 } 548 549 if (hDC == NULL) 550 return FALSE; 551 552 if (LinesMeasured && 553 GetClientRect(&rcClient)) 554 { 555 iPrevBkMode = SetBkMode(hDC, TRANSPARENT); 556 557 SetTextColor(hDC, textColor); 558 559 hPrevFont = (HFONT) SelectObject(hDC, hFont); 560 561 rcClient.top = (rcClient.bottom - CurrentSize.cy) / 2; 562 rcClient.bottom = rcClient.top + CurrentSize.cy; 563 564 for (i = 0, line = 0; 565 i < CLOCKWND_FORMAT_COUNT && line < VisibleLines; 566 i++) 567 { 568 if (LineSizes[i].cx != 0) 569 { 570 TextOut(hDC, 571 (rcClient.right - LineSizes[i].cx) / 2, 572 rcClient.top + TRAY_CLOCK_WND_SPACING_Y, 573 szLines[i], 574 wcslen(szLines[i])); 575 576 rcClient.top += LineSizes[i].cy + LineSpacing; 577 line++; 578 } 579 } 580 581 SelectObject(hDC, hPrevFont); 582 583 SetBkMode(hDC, iPrevBkMode); 584 } 585 586 if (wParam == 0) 587 { 588 EndPaint(&ps); 589 } 590 591 return TRUE; 592 } 593 594 VOID CTrayClockWnd::SetFont(IN HFONT hNewFont, IN BOOL bRedraw) 595 { 596 hFont = hNewFont; 597 LinesMeasured = MeasureLines(); 598 if (bRedraw) 599 { 600 InvalidateRect(NULL, TRUE); 601 } 602 } 603 604 LRESULT CTrayClockWnd::DrawBackground(HDC hdc) 605 { 606 RECT rect; 607 608 GetClientRect(&rect); 609 DrawThemeParentBackground(m_hWnd, hdc, &rect); 610 611 return TRUE; 612 } 613 614 LRESULT CTrayClockWnd::OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 615 { 616 HDC hdc = (HDC) wParam; 617 618 if (!IsAppThemed()) 619 { 620 bHandled = FALSE; 621 return 0; 622 } 623 624 return DrawBackground(hdc); 625 } 626 627 LRESULT CTrayClockWnd::OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 628 { 629 switch (wParam) 630 { 631 case ID_TRAYCLOCK_TIMER: 632 Update(); 633 break; 634 635 case ID_TRAYCLOCK_TIMER_INIT: 636 CalibrateTimer(); 637 break; 638 } 639 return TRUE; 640 } 641 642 LRESULT CTrayClockWnd::OnGetMinimumSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 643 { 644 IsHorizontal = (BOOL) wParam; 645 646 return (LRESULT) GetMinimumSize((BOOL) wParam, (PSIZE) lParam) != 0; 647 } 648 649 LRESULT CTrayClockWnd::OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 650 { 651 // HTCLIENT is returned to receive WM_MOUSEMOVE messages for the tooltip 652 return HTCLIENT; 653 } 654 655 LRESULT CTrayClockWnd::OnSetFont(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 656 { 657 SetFont((HFONT) wParam, (BOOL) LOWORD(lParam)); 658 return TRUE; 659 } 660 661 LRESULT CTrayClockWnd::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 662 { 663 m_tooltip.Create(m_hWnd, WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP); 664 665 TOOLINFOW ti = { 0 }; 666 ti.cbSize = TTTOOLINFOW_V1_SIZE; 667 ti.uFlags = TTF_IDISHWND | TTF_SUBCLASS; 668 ti.hwnd = m_hWnd; 669 ti.uId = reinterpret_cast<UINT_PTR>(m_hWnd); 670 ti.lpszText = NULL; 671 ti.lParam = NULL; 672 673 m_tooltip.AddTool(&ti); 674 675 ResetTime(); 676 return TRUE; 677 } 678 679 LRESULT CTrayClockWnd::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 680 { 681 SIZE szClient; 682 683 szClient.cx = LOWORD(lParam); 684 szClient.cy = HIWORD(lParam); 685 686 VisibleLines = GetMinimumSize(IsHorizontal, &szClient); 687 CurrentSize = szClient; 688 689 InvalidateRect(NULL, TRUE); 690 return TRUE; 691 } 692 693 LRESULT CTrayClockWnd::OnTaskbarSettingsChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 694 { 695 BOOL bRealign = FALSE; 696 697 TaskbarSettings* newSettings = (TaskbarSettings*)lParam; 698 if (newSettings->bShowSeconds != g_TaskbarSettings.bShowSeconds) 699 { 700 g_TaskbarSettings.bShowSeconds = newSettings->bShowSeconds; 701 bRealign = TRUE; 702 } 703 704 if (newSettings->sr.HideClock != g_TaskbarSettings.sr.HideClock) 705 { 706 g_TaskbarSettings.sr.HideClock = newSettings->sr.HideClock; 707 ShowWindow(g_TaskbarSettings.sr.HideClock ? SW_HIDE : SW_SHOW); 708 bRealign = TRUE; 709 } 710 711 if (bRealign) 712 { 713 /* Ask the parent to resize */ 714 NMHDR nmh = {GetParent(), 0, NTNWM_REALIGN}; 715 GetParent().SendMessage(WM_NOTIFY, 0, (LPARAM) &nmh); 716 Update(); 717 } 718 return 0; 719 } 720 721 LRESULT CTrayClockWnd::OnLButtonDblClick(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 722 { 723 if (IsWindowVisible()) 724 { 725 //FIXME: use SHRunControlPanel 726 ShellExecuteW(m_hWnd, NULL, L"timedate.cpl", NULL, NULL, SW_NORMAL); 727 } 728 return TRUE; 729 } 730 731 HRESULT CTrayClockWnd::Initialize(IN HWND hWndParent) 732 { 733 IsHorizontal = TRUE; 734 735 /* Create the window. The tray window is going to move it to the correct 736 position and resize it as needed. */ 737 DWORD dwStyle = WS_CHILD | WS_CLIPSIBLINGS; 738 if (!g_TaskbarSettings.sr.HideClock) 739 dwStyle |= WS_VISIBLE; 740 741 Create(hWndParent, 0, NULL, dwStyle); 742 if (!m_hWnd) 743 return E_FAIL; 744 745 SetWindowTheme(m_hWnd, L"TrayNotify", NULL); 746 747 return S_OK; 748 749 }; 750 751 HRESULT CTrayClockWnd_CreateInstance(HWND hwndParent, REFIID riid, void **ppv) 752 { 753 return ShellObjectCreatorInit<CTrayClockWnd>(hwndParent, riid, ppv); 754 } 755