1 /* 2 * Interface code to StatusWindow widget/control 3 * 4 * Copyright 1996 Bruce Milner 5 * Copyright 1998, 1999 Eric Kohl 6 * Copyright 2002 Dimitrie O. Paun 7 * 8 * This library is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2.1 of the License, or (at your option) any later version. 12 * 13 * This library is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with this library; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 21 * 22 * TODO: 23 * -- CCS_BOTTOM (default) 24 * -- CCS_LEFT 25 * -- CCS_NODIVIDER 26 * -- CCS_NOMOVEX 27 * -- CCS_NOMOVEY 28 * -- CCS_NOPARENTALIGN 29 * -- CCS_RIGHT 30 * -- CCS_TOP 31 * -- CCS_VERT (defaults to RIGHT) 32 */ 33 34 #include <stdarg.h> 35 #include <string.h> 36 37 #include "windef.h" 38 #include "winbase.h" 39 #include "wine/unicode.h" 40 #include "wingdi.h" 41 #include "winuser.h" 42 #include "winnls.h" 43 #include "commctrl.h" 44 #include "comctl32.h" 45 #include "uxtheme.h" 46 #include "vssym32.h" 47 #include "wine/debug.h" 48 49 WINE_DEFAULT_DEBUG_CHANNEL(statusbar); 50 51 typedef struct 52 { 53 INT x; 54 INT style; 55 RECT bound; 56 LPWSTR text; 57 HICON hIcon; 58 } STATUSWINDOWPART; 59 60 typedef struct 61 { 62 HWND Self; 63 HWND Notify; 64 WORD numParts; 65 UINT height; 66 UINT minHeight; /* at least MIN_PANE_HEIGHT, can be increased by SB_SETMINHEIGHT */ 67 BOOL simple; 68 HWND hwndToolTip; 69 HFONT hFont; 70 HFONT hDefaultFont; 71 COLORREF clrBk; /* background color */ 72 BOOL bUnicode; /* notify format. TRUE if notifies in Unicode */ 73 STATUSWINDOWPART part0; /* simple window */ 74 STATUSWINDOWPART* parts; 75 INT horizontalBorder; 76 INT verticalBorder; 77 INT horizontalGap; 78 } STATUS_INFO; 79 80 /* 81 * Run tests using Waite Group Windows95 API Bible Vol. 1&2 82 * The second cdrom contains executables drawstat.exe, gettext.exe, 83 * simple.exe, getparts.exe, setparts.exe, statwnd.exe 84 */ 85 86 #define HORZ_BORDER 0 87 #define VERT_BORDER 2 88 #define HORZ_GAP 2 89 90 static const WCHAR themeClass[] = { 'S','t','a','t','u','s',0 }; 91 92 /* prototype */ 93 static void 94 STATUSBAR_SetPartBounds (STATUS_INFO *infoPtr); 95 static LRESULT 96 STATUSBAR_NotifyFormat (STATUS_INFO *infoPtr, HWND from, INT cmd); 97 98 static inline LPCSTR debugstr_t(LPCWSTR text, BOOL isW) 99 { 100 return isW ? debugstr_w(text) : debugstr_a((LPCSTR)text); 101 } 102 103 static UINT 104 STATUSBAR_ComputeHeight(STATUS_INFO *infoPtr) 105 { 106 HTHEME theme; 107 UINT height; 108 TEXTMETRICW tm; 109 int margin; 110 111 COMCTL32_GetFontMetrics(infoPtr->hFont ? infoPtr->hFont : infoPtr->hDefaultFont, &tm); 112 margin = (tm.tmInternalLeading ? tm.tmInternalLeading : 2); 113 height = max(tm.tmHeight + margin + 2*GetSystemMetrics(SM_CYBORDER), infoPtr->minHeight) + infoPtr->verticalBorder; 114 115 if ((theme = GetWindowTheme(infoPtr->Self))) 116 { 117 /* Determine bar height from theme such that the content area is 118 * textHeight pixels large */ 119 HDC hdc = GetDC(infoPtr->Self); 120 RECT r; 121 122 SetRect(&r, 0, 0, 0, max(infoPtr->minHeight, tm.tmHeight)); 123 if (SUCCEEDED(GetThemeBackgroundExtent(theme, hdc, SP_PANE, 0, &r, &r))) 124 { 125 height = r.bottom - r.top; 126 } 127 ReleaseDC(infoPtr->Self, hdc); 128 } 129 130 TRACE(" textHeight=%d+%d, final height=%d\n", tm.tmHeight, tm.tmInternalLeading, height); 131 return height; 132 } 133 134 static void 135 STATUSBAR_DrawSizeGrip (HTHEME theme, HDC hdc, LPRECT lpRect) 136 { 137 RECT rc = *lpRect; 138 139 TRACE("draw size grip %s\n", wine_dbgstr_rect(lpRect)); 140 141 if (theme) 142 { 143 SIZE gripperSize; 144 if (SUCCEEDED (GetThemePartSize (theme, hdc, SP_GRIPPER, 0, lpRect, 145 TS_DRAW, &gripperSize))) 146 { 147 rc.left = rc.right - gripperSize.cx; 148 rc.top = rc.bottom - gripperSize.cy; 149 if (SUCCEEDED (DrawThemeBackground(theme, hdc, SP_GRIPPER, 0, &rc, NULL))) 150 return; 151 } 152 } 153 154 rc.left = max( rc.left, rc.right - GetSystemMetrics(SM_CXVSCROLL) - 1 ); 155 rc.top = max( rc.top, rc.bottom - GetSystemMetrics(SM_CYHSCROLL) - 1 ); 156 DrawFrameControl( hdc, &rc, DFC_SCROLL, DFCS_SCROLLSIZEGRIP ); 157 } 158 159 160 static void 161 STATUSBAR_DrawPart (const STATUS_INFO *infoPtr, HDC hdc, const STATUSWINDOWPART *part, int itemID) 162 { 163 RECT r = part->bound; 164 UINT border = BDR_SUNKENOUTER; 165 HTHEME theme = GetWindowTheme (infoPtr->Self); 166 int themePart = SP_PANE; 167 int x = 0; 168 169 TRACE("part bound %s\n", wine_dbgstr_rect(&r)); 170 if (part->style & SBT_POPOUT) 171 border = BDR_RAISEDOUTER; 172 else if (part->style & SBT_NOBORDERS) 173 border = 0; 174 175 if (theme) 176 { 177 if ((GetWindowLongW (infoPtr->Self, GWL_STYLE) & SBARS_SIZEGRIP) 178 && (infoPtr->simple || (itemID == (infoPtr->numParts-1)))) 179 themePart = SP_GRIPPERPANE; 180 DrawThemeBackground(theme, hdc, themePart, 0, &r, NULL); 181 } 182 else 183 DrawEdge(hdc, &r, border, BF_RECT|BF_ADJUST); 184 185 if (part->hIcon) { 186 INT cy = r.bottom - r.top; 187 DrawIconEx (hdc, r.left + 2, r.top, part->hIcon, cy, cy, 0, 0, DI_NORMAL); 188 x = 2 + cy; 189 } 190 191 if (part->style & SBT_OWNERDRAW) { 192 DRAWITEMSTRUCT dis; 193 194 dis.CtlID = GetWindowLongPtrW (infoPtr->Self, GWLP_ID); 195 dis.itemID = itemID; 196 dis.hwndItem = infoPtr->Self; 197 dis.hDC = hdc; 198 dis.rcItem = r; 199 dis.itemData = (ULONG_PTR)part->text; 200 SendMessageW (infoPtr->Notify, WM_DRAWITEM, dis.CtlID, (LPARAM)&dis); 201 } else { 202 r.left += x; 203 #ifdef __REACTOS__ 204 if (!theme) 205 { 206 r.left -= 2; 207 DrawStatusTextW (hdc, &r, part->text, SBT_NOBORDERS); 208 } 209 else 210 { 211 r.left += 2; 212 r.right -= 2; 213 DrawThemeText(theme, hdc, SP_PANE, 0, part->text, -1, DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX, 0, &r); 214 } 215 #else 216 DrawStatusTextW (hdc, &r, part->text, SBT_NOBORDERS); 217 #endif 218 } 219 } 220 221 222 static void 223 STATUSBAR_RefreshPart (const STATUS_INFO *infoPtr, HDC hdc, const STATUSWINDOWPART *part, int itemID) 224 { 225 HBRUSH hbrBk; 226 HTHEME theme; 227 228 TRACE("item %d\n", itemID); 229 230 if (part->bound.right < part->bound.left) return; 231 232 if (!RectVisible(hdc, &part->bound)) 233 return; 234 235 if ((theme = GetWindowTheme (infoPtr->Self))) 236 { 237 RECT cr; 238 GetClientRect (infoPtr->Self, &cr); 239 DrawThemeBackground(theme, hdc, 0, 0, &cr, &part->bound); 240 } 241 else 242 { 243 if (infoPtr->clrBk != CLR_DEFAULT) 244 hbrBk = CreateSolidBrush (infoPtr->clrBk); 245 else 246 hbrBk = GetSysColorBrush (COLOR_3DFACE); 247 FillRect(hdc, &part->bound, hbrBk); 248 if (infoPtr->clrBk != CLR_DEFAULT) 249 DeleteObject (hbrBk); 250 } 251 252 STATUSBAR_DrawPart (infoPtr, hdc, part, itemID); 253 } 254 255 256 static LRESULT 257 STATUSBAR_Refresh (STATUS_INFO *infoPtr, HDC hdc) 258 { 259 RECT rect; 260 HBRUSH hbrBk; 261 HFONT hOldFont; 262 HTHEME theme; 263 264 TRACE("\n"); 265 if (!IsWindowVisible(infoPtr->Self)) 266 return 0; 267 268 STATUSBAR_SetPartBounds(infoPtr); 269 270 GetClientRect (infoPtr->Self, &rect); 271 272 if ((theme = GetWindowTheme (infoPtr->Self))) 273 { 274 DrawThemeBackground(theme, hdc, 0, 0, &rect, NULL); 275 } 276 else 277 { 278 if (infoPtr->clrBk != CLR_DEFAULT) 279 hbrBk = CreateSolidBrush (infoPtr->clrBk); 280 else 281 hbrBk = GetSysColorBrush (COLOR_3DFACE); 282 FillRect(hdc, &rect, hbrBk); 283 if (infoPtr->clrBk != CLR_DEFAULT) 284 DeleteObject (hbrBk); 285 } 286 287 hOldFont = SelectObject (hdc, infoPtr->hFont ? infoPtr->hFont : infoPtr->hDefaultFont); 288 289 if (infoPtr->simple) { 290 STATUSBAR_RefreshPart (infoPtr, hdc, &infoPtr->part0, 0); 291 } else { 292 unsigned int i; 293 294 for (i = 0; i < infoPtr->numParts; i++) { 295 STATUSBAR_RefreshPart (infoPtr, hdc, &infoPtr->parts[i], i); 296 } 297 } 298 299 SelectObject (hdc, hOldFont); 300 301 if ((GetWindowLongW (infoPtr->Self, GWL_STYLE) & SBARS_SIZEGRIP) 302 && !(GetWindowLongW (infoPtr->Notify, GWL_STYLE) & WS_MAXIMIZE)) 303 STATUSBAR_DrawSizeGrip (theme, hdc, &rect); 304 305 return 0; 306 } 307 308 309 static int 310 STATUSBAR_InternalHitTest(const STATUS_INFO *infoPtr, const POINT *pt) 311 { 312 unsigned int i; 313 314 if (infoPtr->simple) 315 return 255; 316 317 for (i = 0; i < infoPtr->numParts; i++) 318 if (pt->x >= infoPtr->parts[i].bound.left && pt->x <= infoPtr->parts[i].bound.right) 319 return i; 320 return -2; 321 } 322 323 324 static void 325 STATUSBAR_SetPartBounds (STATUS_INFO *infoPtr) 326 { 327 STATUSWINDOWPART *part; 328 RECT rect, *r; 329 UINT i; 330 331 /* get our window size */ 332 GetClientRect (infoPtr->Self, &rect); 333 TRACE("client wnd size is %s\n", wine_dbgstr_rect(&rect)); 334 335 rect.left += infoPtr->horizontalBorder; 336 rect.top += infoPtr->verticalBorder; 337 338 /* set bounds for simple rectangle */ 339 infoPtr->part0.bound = rect; 340 341 /* set bounds for non-simple rectangles */ 342 for (i = 0; i < infoPtr->numParts; i++) { 343 part = &infoPtr->parts[i]; 344 r = &infoPtr->parts[i].bound; 345 r->top = rect.top; 346 r->bottom = rect.bottom; 347 if (i == 0) 348 r->left = 0; 349 else 350 r->left = infoPtr->parts[i-1].bound.right + infoPtr->horizontalGap; 351 if (part->x == -1) 352 r->right = rect.right; 353 else 354 r->right = part->x; 355 356 if (infoPtr->hwndToolTip) { 357 TTTOOLINFOW ti; 358 359 ti.cbSize = sizeof(TTTOOLINFOW); 360 ti.hwnd = infoPtr->Self; 361 ti.uId = i; 362 ti.rect = *r; 363 SendMessageW (infoPtr->hwndToolTip, TTM_NEWTOOLRECTW, 364 0, (LPARAM)&ti); 365 } 366 } 367 } 368 369 370 static LRESULT 371 STATUSBAR_Relay2Tip (const STATUS_INFO *infoPtr, UINT uMsg, 372 WPARAM wParam, LPARAM lParam) 373 { 374 MSG msg; 375 376 msg.hwnd = infoPtr->Self; 377 msg.message = uMsg; 378 msg.wParam = wParam; 379 msg.lParam = lParam; 380 msg.time = GetMessageTime (); 381 msg.pt.x = (short)LOWORD(GetMessagePos ()); 382 msg.pt.y = (short)HIWORD(GetMessagePos ()); 383 384 return SendMessageW (infoPtr->hwndToolTip, TTM_RELAYEVENT, 0, (LPARAM)&msg); 385 } 386 387 388 static BOOL 389 STATUSBAR_GetBorders (const STATUS_INFO *infoPtr, INT out[]) 390 { 391 TRACE("\n"); 392 out[0] = infoPtr->horizontalBorder; 393 out[1] = infoPtr->verticalBorder; 394 out[2] = infoPtr->horizontalGap; 395 396 return TRUE; 397 } 398 399 400 static BOOL 401 STATUSBAR_SetBorders (STATUS_INFO *infoPtr, const INT in[]) 402 { 403 TRACE("\n"); 404 infoPtr->horizontalBorder = in[0]; 405 infoPtr->verticalBorder = in[1]; 406 infoPtr->horizontalGap = in[2]; 407 InvalidateRect(infoPtr->Self, NULL, FALSE); 408 409 return TRUE; 410 } 411 412 413 static HICON 414 STATUSBAR_GetIcon (const STATUS_INFO *infoPtr, INT nPart) 415 { 416 TRACE("%d\n", nPart); 417 /* MSDN says: "simple parts are indexed with -1" */ 418 if ((nPart < -1) || (nPart >= infoPtr->numParts)) 419 return 0; 420 421 if (nPart == -1) 422 return (infoPtr->part0.hIcon); 423 else 424 return (infoPtr->parts[nPart].hIcon); 425 } 426 427 428 static INT 429 STATUSBAR_GetParts (const STATUS_INFO *infoPtr, INT num_parts, INT parts[]) 430 { 431 INT i; 432 433 TRACE("(%d)\n", num_parts); 434 if (parts) { 435 #ifdef __REACTOS__ 436 if (num_parts > infoPtr->numParts) 437 num_parts = infoPtr->numParts; 438 #endif 439 for (i = 0; i < num_parts; i++) { 440 parts[i] = infoPtr->parts[i].x; 441 } 442 } 443 return infoPtr->numParts; 444 } 445 446 447 static BOOL 448 STATUSBAR_GetRect (const STATUS_INFO *infoPtr, INT nPart, LPRECT rect) 449 { 450 TRACE("part %d\n", nPart); 451 if(nPart >= infoPtr->numParts || nPart < 0) 452 return FALSE; 453 if (infoPtr->simple) 454 *rect = infoPtr->part0.bound; 455 else 456 *rect = infoPtr->parts[nPart].bound; 457 return TRUE; 458 } 459 460 461 static LRESULT 462 STATUSBAR_GetTextA (STATUS_INFO *infoPtr, INT nPart, LPSTR buf) 463 { 464 STATUSWINDOWPART *part; 465 LRESULT result; 466 467 TRACE("part %d\n", nPart); 468 469 /* MSDN says: "simple parts use index of 0", so this check is ok. */ 470 if (nPart < 0 || nPart >= infoPtr->numParts) return 0; 471 472 if (infoPtr->simple) 473 part = &infoPtr->part0; 474 else 475 part = &infoPtr->parts[nPart]; 476 477 if (part->style & SBT_OWNERDRAW) 478 result = (LRESULT)part->text; 479 else { 480 DWORD len = part->text ? WideCharToMultiByte( CP_ACP, 0, part->text, -1, 481 NULL, 0, NULL, NULL ) - 1 : 0; 482 result = MAKELONG( len, part->style ); 483 if (part->text && buf) 484 WideCharToMultiByte( CP_ACP, 0, part->text, -1, buf, len+1, NULL, NULL ); 485 } 486 return result; 487 } 488 489 490 static LRESULT 491 STATUSBAR_GetTextW (STATUS_INFO *infoPtr, INT nPart, LPWSTR buf) 492 { 493 STATUSWINDOWPART *part; 494 LRESULT result; 495 496 TRACE("part %d\n", nPart); 497 if (nPart < 0 || nPart >= infoPtr->numParts) return 0; 498 499 if (infoPtr->simple) 500 part = &infoPtr->part0; 501 else 502 part = &infoPtr->parts[nPart]; 503 504 if (part->style & SBT_OWNERDRAW) 505 result = (LRESULT)part->text; 506 else { 507 result = part->text ? strlenW (part->text) : 0; 508 result |= (part->style << 16); 509 if (part->text && buf) 510 strcpyW (buf, part->text); 511 } 512 return result; 513 } 514 515 516 static LRESULT 517 STATUSBAR_GetTextLength (STATUS_INFO *infoPtr, INT nPart) 518 { 519 STATUSWINDOWPART *part; 520 DWORD result; 521 522 TRACE("part %d\n", nPart); 523 524 /* MSDN says: "simple parts use index of 0", so this check is ok. */ 525 if (nPart < 0 || nPart >= infoPtr->numParts) return 0; 526 527 if (infoPtr->simple) 528 part = &infoPtr->part0; 529 else 530 part = &infoPtr->parts[nPart]; 531 532 if ((~part->style & SBT_OWNERDRAW) && part->text) 533 result = strlenW(part->text); 534 else 535 result = 0; 536 537 result |= (part->style << 16); 538 return result; 539 } 540 541 static LRESULT 542 STATUSBAR_GetTipTextA (const STATUS_INFO *infoPtr, INT id, LPSTR tip, INT size) 543 { 544 TRACE("\n"); 545 if (tip) { 546 CHAR buf[INFOTIPSIZE]; 547 buf[0]='\0'; 548 549 if (infoPtr->hwndToolTip) { 550 TTTOOLINFOA ti; 551 ti.cbSize = sizeof(TTTOOLINFOA); 552 ti.hwnd = infoPtr->Self; 553 ti.uId = id; 554 ti.lpszText = buf; 555 SendMessageA (infoPtr->hwndToolTip, TTM_GETTEXTA, 0, (LPARAM)&ti); 556 } 557 lstrcpynA (tip, buf, size); 558 } 559 return 0; 560 } 561 562 563 static LRESULT 564 STATUSBAR_GetTipTextW (const STATUS_INFO *infoPtr, INT id, LPWSTR tip, INT size) 565 { 566 TRACE("\n"); 567 if (tip) { 568 WCHAR buf[INFOTIPSIZE]; 569 buf[0]=0; 570 571 if (infoPtr->hwndToolTip) { 572 TTTOOLINFOW ti; 573 ti.cbSize = sizeof(TTTOOLINFOW); 574 ti.hwnd = infoPtr->Self; 575 ti.uId = id; 576 ti.lpszText = buf; 577 SendMessageW(infoPtr->hwndToolTip, TTM_GETTEXTW, 0, (LPARAM)&ti); 578 } 579 lstrcpynW(tip, buf, size); 580 } 581 582 return 0; 583 } 584 585 586 static COLORREF 587 STATUSBAR_SetBkColor (STATUS_INFO *infoPtr, COLORREF color) 588 { 589 COLORREF oldBkColor; 590 591 oldBkColor = infoPtr->clrBk; 592 infoPtr->clrBk = color; 593 InvalidateRect(infoPtr->Self, NULL, FALSE); 594 595 TRACE("CREF: %08x -> %08x\n", oldBkColor, infoPtr->clrBk); 596 return oldBkColor; 597 } 598 599 600 static BOOL 601 STATUSBAR_SetIcon (STATUS_INFO *infoPtr, INT nPart, HICON hIcon) 602 { 603 if ((nPart < -1) || (nPart >= infoPtr->numParts)) 604 return FALSE; 605 606 TRACE("setting part %d\n", nPart); 607 608 /* FIXME: MSDN says "if nPart is -1, the status bar is assumed simple" */ 609 if (nPart == -1) { 610 if (infoPtr->part0.hIcon == hIcon) /* same as - no redraw */ 611 return TRUE; 612 infoPtr->part0.hIcon = hIcon; 613 if (infoPtr->simple) 614 InvalidateRect(infoPtr->Self, &infoPtr->part0.bound, FALSE); 615 } else { 616 if (infoPtr->parts[nPart].hIcon == hIcon) /* same as - no redraw */ 617 return TRUE; 618 619 infoPtr->parts[nPart].hIcon = hIcon; 620 if (!(infoPtr->simple)) 621 InvalidateRect(infoPtr->Self, &infoPtr->parts[nPart].bound, FALSE); 622 } 623 return TRUE; 624 } 625 626 627 static BOOL 628 STATUSBAR_SetMinHeight (STATUS_INFO *infoPtr, INT height) 629 { 630 DWORD ysize = GetSystemMetrics(SM_CYSIZE); 631 if (ysize & 1) ysize--; 632 infoPtr->minHeight = max(height, ysize); 633 infoPtr->height = STATUSBAR_ComputeHeight(infoPtr); 634 /* like native, don't resize the control */ 635 return TRUE; 636 } 637 638 639 static BOOL 640 STATUSBAR_SetParts (STATUS_INFO *infoPtr, INT count, LPINT parts) 641 { 642 STATUSWINDOWPART *tmp; 643 INT i, oldNumParts; 644 645 TRACE("(%d,%p)\n", count, parts); 646 647 if(!count) return FALSE; 648 649 oldNumParts = infoPtr->numParts; 650 infoPtr->numParts = count; 651 if (oldNumParts > infoPtr->numParts) { 652 for (i = infoPtr->numParts ; i < oldNumParts; i++) { 653 if (!(infoPtr->parts[i].style & SBT_OWNERDRAW)) 654 Free (infoPtr->parts[i].text); 655 } 656 } else if (oldNumParts < infoPtr->numParts) { 657 tmp = Alloc (sizeof(STATUSWINDOWPART) * infoPtr->numParts); 658 if (!tmp) return FALSE; 659 for (i = 0; i < oldNumParts; i++) { 660 tmp[i] = infoPtr->parts[i]; 661 } 662 Free (infoPtr->parts); 663 infoPtr->parts = tmp; 664 } 665 if (oldNumParts == infoPtr->numParts) { 666 for (i=0; i < oldNumParts; i++) 667 if (infoPtr->parts[i].x != parts[i]) 668 break; 669 if (i==oldNumParts) /* Unchanged? no need to redraw! */ 670 return TRUE; 671 } 672 673 for (i = 0; i < infoPtr->numParts; i++) 674 infoPtr->parts[i].x = parts[i]; 675 676 if (infoPtr->hwndToolTip) { 677 INT nTipCount; 678 TTTOOLINFOW ti; 679 WCHAR wEmpty = 0; 680 681 ZeroMemory (&ti, sizeof(TTTOOLINFOW)); 682 ti.cbSize = sizeof(TTTOOLINFOW); 683 ti.hwnd = infoPtr->Self; 684 ti.lpszText = &wEmpty; 685 686 nTipCount = SendMessageW (infoPtr->hwndToolTip, TTM_GETTOOLCOUNT, 0, 0); 687 if (nTipCount < infoPtr->numParts) { 688 /* add tools */ 689 for (i = nTipCount; i < infoPtr->numParts; i++) { 690 TRACE("add tool %d\n", i); 691 ti.uId = i; 692 SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW, 693 0, (LPARAM)&ti); 694 } 695 } 696 else if (nTipCount > infoPtr->numParts) { 697 /* delete tools */ 698 for (i = nTipCount - 1; i >= infoPtr->numParts; i--) { 699 TRACE("delete tool %d\n", i); 700 ti.uId = i; 701 SendMessageW (infoPtr->hwndToolTip, TTM_DELTOOLW, 702 0, (LPARAM)&ti); 703 } 704 } 705 } 706 STATUSBAR_SetPartBounds (infoPtr); 707 InvalidateRect(infoPtr->Self, NULL, FALSE); 708 return TRUE; 709 } 710 711 712 static BOOL 713 STATUSBAR_SetTextT (STATUS_INFO *infoPtr, INT nPart, WORD style, 714 LPWSTR text, BOOL isW) 715 { 716 STATUSWINDOWPART *part=NULL; 717 BOOL changed = FALSE; 718 INT oldStyle; 719 720 if (style & SBT_OWNERDRAW) { 721 TRACE("part %d, text %p\n",nPart,text); 722 } 723 else TRACE("part %d, text %s\n", nPart, debugstr_t(text, isW)); 724 725 /* MSDN says: "If the parameter is set to SB_SIMPLEID (255), the status 726 * window is assumed to be a simple window */ 727 728 if (nPart == 0x00ff) { 729 part = &infoPtr->part0; 730 } else { 731 if (infoPtr->parts && nPart >= 0 && nPart < infoPtr->numParts) { 732 part = &infoPtr->parts[nPart]; 733 } 734 } 735 if (!part) return FALSE; 736 737 if (part->style != style) 738 changed = TRUE; 739 740 oldStyle = part->style; 741 part->style = style; 742 if (style & SBT_OWNERDRAW) { 743 if (!(oldStyle & SBT_OWNERDRAW)) 744 Free (part->text); 745 part->text = text; 746 } else { 747 LPWSTR ntext; 748 WCHAR *idx; 749 750 if (text && !isW) { 751 LPCSTR atxt = (LPCSTR)text; 752 DWORD len = MultiByteToWideChar( CP_ACP, 0, atxt, -1, NULL, 0 ); 753 ntext = Alloc( (len + 1)*sizeof(WCHAR) ); 754 if (!ntext) return FALSE; 755 MultiByteToWideChar( CP_ACP, 0, atxt, -1, ntext, len ); 756 } else if (text) { 757 ntext = Alloc( (strlenW(text) + 1)*sizeof(WCHAR) ); 758 if (!ntext) return FALSE; 759 strcpyW (ntext, text); 760 } else ntext = 0; 761 762 /* replace nonprintable characters with spaces */ 763 if (ntext) { 764 idx = ntext; 765 while (*idx) { 766 if(!isprintW(*idx)) 767 *idx = ' '; 768 idx++; 769 } 770 } 771 772 /* check if text is unchanged -> no need to redraw */ 773 if (text) { 774 if (!changed && part->text && !lstrcmpW(ntext, part->text)) { 775 Free(ntext); 776 return TRUE; 777 } 778 } else { 779 if (!changed && !part->text) 780 return TRUE; 781 } 782 783 if (!(oldStyle & SBT_OWNERDRAW)) 784 Free (part->text); 785 part->text = ntext; 786 } 787 InvalidateRect(infoPtr->Self, &part->bound, FALSE); 788 UpdateWindow(infoPtr->Self); 789 790 return TRUE; 791 } 792 793 794 static LRESULT 795 STATUSBAR_SetTipTextA (const STATUS_INFO *infoPtr, INT id, LPSTR text) 796 { 797 TRACE("part %d: \"%s\"\n", id, text); 798 if (infoPtr->hwndToolTip) { 799 TTTOOLINFOA ti; 800 ti.cbSize = sizeof(TTTOOLINFOA); 801 ti.hwnd = infoPtr->Self; 802 ti.uId = id; 803 ti.hinst = 0; 804 ti.lpszText = text; 805 SendMessageA (infoPtr->hwndToolTip, TTM_UPDATETIPTEXTA, 0, (LPARAM)&ti); 806 } 807 808 return 0; 809 } 810 811 812 static LRESULT 813 STATUSBAR_SetTipTextW (const STATUS_INFO *infoPtr, INT id, LPWSTR text) 814 { 815 TRACE("part %d: \"%s\"\n", id, debugstr_w(text)); 816 if (infoPtr->hwndToolTip) { 817 TTTOOLINFOW ti; 818 ti.cbSize = sizeof(TTTOOLINFOW); 819 ti.hwnd = infoPtr->Self; 820 ti.uId = id; 821 ti.hinst = 0; 822 ti.lpszText = text; 823 SendMessageW (infoPtr->hwndToolTip, TTM_UPDATETIPTEXTW, 0, (LPARAM)&ti); 824 } 825 826 return 0; 827 } 828 829 830 static inline LRESULT 831 STATUSBAR_SetUnicodeFormat (STATUS_INFO *infoPtr, BOOL bUnicode) 832 { 833 BOOL bOld = infoPtr->bUnicode; 834 835 TRACE("(0x%x)\n", bUnicode); 836 infoPtr->bUnicode = bUnicode; 837 838 return bOld; 839 } 840 841 842 static BOOL 843 STATUSBAR_Simple (STATUS_INFO *infoPtr, BOOL simple) 844 { 845 NMHDR nmhdr; 846 847 TRACE("(simple=%d)\n", simple); 848 if (infoPtr->simple == simple) /* no need to change */ 849 return TRUE; 850 851 infoPtr->simple = simple; 852 853 /* send notification */ 854 nmhdr.hwndFrom = infoPtr->Self; 855 nmhdr.idFrom = GetWindowLongPtrW (infoPtr->Self, GWLP_ID); 856 nmhdr.code = SBN_SIMPLEMODECHANGE; 857 SendMessageW (infoPtr->Notify, WM_NOTIFY, 0, (LPARAM)&nmhdr); 858 InvalidateRect(infoPtr->Self, NULL, FALSE); 859 return TRUE; 860 } 861 862 863 static LRESULT 864 STATUSBAR_WMDestroy (STATUS_INFO *infoPtr) 865 { 866 unsigned int i; 867 868 TRACE("\n"); 869 for (i = 0; i < infoPtr->numParts; i++) { 870 if (!(infoPtr->parts[i].style & SBT_OWNERDRAW)) 871 Free (infoPtr->parts[i].text); 872 } 873 if (!(infoPtr->part0.style & SBT_OWNERDRAW)) 874 Free (infoPtr->part0.text); 875 Free (infoPtr->parts); 876 877 /* delete default font */ 878 if (infoPtr->hDefaultFont) 879 DeleteObject (infoPtr->hDefaultFont); 880 881 /* delete tool tip control */ 882 if (infoPtr->hwndToolTip) 883 DestroyWindow (infoPtr->hwndToolTip); 884 885 CloseThemeData (GetWindowTheme (infoPtr->Self)); 886 887 SetWindowLongPtrW(infoPtr->Self, 0, 0); 888 Free (infoPtr); 889 return 0; 890 } 891 892 893 static LRESULT 894 STATUSBAR_WMCreate (HWND hwnd, const CREATESTRUCTA *lpCreate) 895 { 896 STATUS_INFO *infoPtr; 897 NONCLIENTMETRICSW nclm; 898 DWORD dwStyle; 899 RECT rect; 900 int len; 901 902 TRACE("\n"); 903 infoPtr = Alloc (sizeof(STATUS_INFO)); 904 if (!infoPtr) goto create_fail; 905 SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr); 906 907 infoPtr->Self = hwnd; 908 infoPtr->Notify = lpCreate->hwndParent; 909 infoPtr->numParts = 1; 910 infoPtr->parts = 0; 911 infoPtr->simple = FALSE; 912 infoPtr->clrBk = CLR_DEFAULT; 913 infoPtr->hFont = 0; 914 infoPtr->horizontalBorder = HORZ_BORDER; 915 infoPtr->verticalBorder = VERT_BORDER; 916 infoPtr->horizontalGap = HORZ_GAP; 917 infoPtr->minHeight = GetSystemMetrics(SM_CYSIZE); 918 if (infoPtr->minHeight & 1) infoPtr->minHeight--; 919 920 STATUSBAR_NotifyFormat(infoPtr, infoPtr->Notify, NF_REQUERY); 921 922 ZeroMemory (&nclm, sizeof(nclm)); 923 nclm.cbSize = sizeof(nclm); 924 SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, nclm.cbSize, &nclm, 0); 925 infoPtr->hDefaultFont = CreateFontIndirectW (&nclm.lfStatusFont); 926 927 GetClientRect (hwnd, &rect); 928 929 /* initialize simple case */ 930 infoPtr->part0.bound = rect; 931 infoPtr->part0.text = 0; 932 infoPtr->part0.x = 0; 933 infoPtr->part0.style = 0; 934 infoPtr->part0.hIcon = 0; 935 936 /* initialize first part */ 937 infoPtr->parts = Alloc (sizeof(STATUSWINDOWPART)); 938 if (!infoPtr->parts) goto create_fail; 939 infoPtr->parts[0].bound = rect; 940 infoPtr->parts[0].text = 0; 941 infoPtr->parts[0].x = -1; 942 infoPtr->parts[0].style = 0; 943 infoPtr->parts[0].hIcon = 0; 944 945 OpenThemeData (hwnd, themeClass); 946 947 if (lpCreate->lpszName && (len = strlenW ((LPCWSTR)lpCreate->lpszName))) 948 { 949 infoPtr->parts[0].text = Alloc ((len + 1)*sizeof(WCHAR)); 950 if (!infoPtr->parts[0].text) goto create_fail; 951 strcpyW (infoPtr->parts[0].text, (LPCWSTR)lpCreate->lpszName); 952 } 953 954 dwStyle = GetWindowLongW (hwnd, GWL_STYLE); 955 /* native seems to clear WS_BORDER, too */ 956 dwStyle &= ~WS_BORDER; 957 SetWindowLongW (hwnd, GWL_STYLE, dwStyle); 958 959 infoPtr->height = STATUSBAR_ComputeHeight(infoPtr); 960 961 if (dwStyle & SBT_TOOLTIPS) { 962 infoPtr->hwndToolTip = 963 CreateWindowExW (0, TOOLTIPS_CLASSW, NULL, WS_POPUP | TTS_ALWAYSTIP, 964 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 965 CW_USEDEFAULT, hwnd, 0, 966 (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL); 967 968 if (infoPtr->hwndToolTip) { 969 NMTOOLTIPSCREATED nmttc; 970 971 nmttc.hdr.hwndFrom = hwnd; 972 nmttc.hdr.idFrom = GetWindowLongPtrW (hwnd, GWLP_ID); 973 nmttc.hdr.code = NM_TOOLTIPSCREATED; 974 nmttc.hwndToolTips = infoPtr->hwndToolTip; 975 976 SendMessageW (lpCreate->hwndParent, WM_NOTIFY, nmttc.hdr.idFrom, (LPARAM)&nmttc); 977 } 978 } 979 980 return 0; 981 982 create_fail: 983 TRACE(" failed!\n"); 984 if (infoPtr) STATUSBAR_WMDestroy(infoPtr); 985 return -1; 986 } 987 988 989 /* in contrast to SB_GETTEXT*, WM_GETTEXT handles the text 990 * of the first part only (usual behaviour) */ 991 static INT 992 STATUSBAR_WMGetText (const STATUS_INFO *infoPtr, INT size, LPWSTR buf) 993 { 994 INT len; 995 996 TRACE("\n"); 997 if (!(infoPtr->parts[0].text)) 998 return 0; 999 1000 len = strlenW (infoPtr->parts[0].text); 1001 1002 if (!size) 1003 return len; 1004 else if (size > len) { 1005 strcpyW (buf, infoPtr->parts[0].text); 1006 return len; 1007 } 1008 else { 1009 memcpy (buf, infoPtr->parts[0].text, (size - 1) * sizeof(WCHAR)); 1010 buf[size - 1] = 0; 1011 return size - 1; 1012 } 1013 } 1014 1015 1016 static BOOL 1017 STATUSBAR_WMNCHitTest (const STATUS_INFO *infoPtr, INT x, INT y) 1018 { 1019 if ((GetWindowLongW (infoPtr->Self, GWL_STYLE) & SBARS_SIZEGRIP) 1020 && !(GetWindowLongW (infoPtr->Notify, GWL_STYLE) & WS_MAXIMIZE)) { 1021 RECT rect; 1022 POINT pt; 1023 1024 GetClientRect (infoPtr->Self, &rect); 1025 1026 pt.x = x; 1027 pt.y = y; 1028 ScreenToClient (infoPtr->Self, &pt); 1029 1030 if (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)) 1031 { 1032 if (GetWindowLongW( infoPtr->Self, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL) return HTBOTTOMLEFT; 1033 else return HTBOTTOMRIGHT; 1034 } 1035 } 1036 1037 return HTERROR; 1038 } 1039 1040 1041 static LRESULT 1042 STATUSBAR_WMPaint (STATUS_INFO *infoPtr, HDC hdc) 1043 { 1044 PAINTSTRUCT ps; 1045 1046 TRACE("\n"); 1047 if (hdc) return STATUSBAR_Refresh (infoPtr, hdc); 1048 hdc = BeginPaint (infoPtr->Self, &ps); 1049 STATUSBAR_Refresh (infoPtr, hdc); 1050 EndPaint (infoPtr->Self, &ps); 1051 1052 return 0; 1053 } 1054 1055 1056 static LRESULT 1057 STATUSBAR_WMSetFont (STATUS_INFO *infoPtr, HFONT font, BOOL redraw) 1058 { 1059 infoPtr->hFont = font; 1060 TRACE("%p\n", infoPtr->hFont); 1061 1062 infoPtr->height = STATUSBAR_ComputeHeight(infoPtr); 1063 SendMessageW(infoPtr->Self, WM_SIZE, 0, 0); /* update size */ 1064 if (redraw) 1065 InvalidateRect(infoPtr->Self, NULL, FALSE); 1066 1067 return 0; 1068 } 1069 1070 1071 static BOOL 1072 STATUSBAR_WMSetText (const STATUS_INFO *infoPtr, LPCSTR text) 1073 { 1074 STATUSWINDOWPART *part; 1075 int len; 1076 1077 TRACE("\n"); 1078 if (infoPtr->numParts == 0) 1079 return FALSE; 1080 1081 part = &infoPtr->parts[0]; 1082 /* duplicate string */ 1083 Free (part->text); 1084 part->text = 0; 1085 1086 if (text && (len = strlenW((LPCWSTR)text))) { 1087 part->text = Alloc ((len+1)*sizeof(WCHAR)); 1088 if (!part->text) return FALSE; 1089 strcpyW (part->text, (LPCWSTR)text); 1090 } 1091 1092 InvalidateRect(infoPtr->Self, &part->bound, FALSE); 1093 1094 return TRUE; 1095 } 1096 1097 1098 static BOOL 1099 STATUSBAR_WMSize (STATUS_INFO *infoPtr, WORD flags) 1100 { 1101 INT width, x, y; 1102 RECT parent_rect; 1103 1104 /* Need to resize width to match parent */ 1105 TRACE("flags %04x\n", flags); 1106 1107 if (flags != SIZE_RESTORED && flags != SIZE_MAXIMIZED) { 1108 WARN("flags MUST be SIZE_RESTORED or SIZE_MAXIMIZED\n"); 1109 return FALSE; 1110 } 1111 1112 if (GetWindowLongW(infoPtr->Self, GWL_STYLE) & CCS_NORESIZE) return FALSE; 1113 1114 /* width and height don't apply */ 1115 if (!GetClientRect (infoPtr->Notify, &parent_rect)) 1116 return FALSE; 1117 1118 width = parent_rect.right - parent_rect.left; 1119 x = parent_rect.left; 1120 y = parent_rect.bottom - infoPtr->height; 1121 MoveWindow (infoPtr->Self, x, y, width, infoPtr->height, TRUE); 1122 STATUSBAR_SetPartBounds (infoPtr); 1123 return TRUE; 1124 } 1125 1126 1127 /* update theme after a WM_THEMECHANGED message */ 1128 static LRESULT theme_changed (const STATUS_INFO* infoPtr) 1129 { 1130 HTHEME theme = GetWindowTheme (infoPtr->Self); 1131 CloseThemeData (theme); 1132 OpenThemeData (infoPtr->Self, themeClass); 1133 return 0; 1134 } 1135 1136 1137 static LRESULT 1138 STATUSBAR_NotifyFormat (STATUS_INFO *infoPtr, HWND from, INT cmd) 1139 { 1140 if (cmd == NF_REQUERY) { 1141 INT i = SendMessageW(from, WM_NOTIFYFORMAT, (WPARAM)infoPtr->Self, NF_QUERY); 1142 infoPtr->bUnicode = (i == NFR_UNICODE); 1143 } 1144 return infoPtr->bUnicode ? NFR_UNICODE : NFR_ANSI; 1145 } 1146 1147 1148 static LRESULT 1149 STATUSBAR_SendMouseNotify(const STATUS_INFO *infoPtr, UINT code, UINT msg, WPARAM wParam, LPARAM lParam) 1150 { 1151 NMMOUSE nm; 1152 1153 TRACE("code %04x, lParam=%lx\n", code, lParam); 1154 nm.hdr.hwndFrom = infoPtr->Self; 1155 nm.hdr.idFrom = GetWindowLongPtrW(infoPtr->Self, GWLP_ID); 1156 nm.hdr.code = code; 1157 nm.pt.x = (short)LOWORD(lParam); 1158 nm.pt.y = (short)HIWORD(lParam); 1159 nm.dwItemSpec = STATUSBAR_InternalHitTest(infoPtr, &nm.pt); 1160 nm.dwItemData = 0; 1161 nm.dwHitInfo = 0x30000; /* seems constant */ 1162 1163 /* Do default processing if WM_NOTIFY returns zero */ 1164 if(!SendMessageW(infoPtr->Notify, WM_NOTIFY, nm.hdr.idFrom, (LPARAM)&nm)) 1165 { 1166 return DefWindowProcW(infoPtr->Self, msg, wParam, lParam); 1167 } 1168 return 0; 1169 } 1170 1171 1172 1173 static LRESULT WINAPI 1174 StatusWindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) 1175 { 1176 STATUS_INFO *infoPtr = (STATUS_INFO *)GetWindowLongPtrW (hwnd, 0); 1177 INT nPart = ((INT) wParam) & 0x00ff; 1178 LRESULT res; 1179 1180 TRACE("hwnd=%p msg=%x wparam=%lx lparam=%lx\n", hwnd, msg, wParam, lParam); 1181 if (!infoPtr && msg != WM_CREATE) 1182 return DefWindowProcW (hwnd, msg, wParam, lParam); 1183 1184 switch (msg) { 1185 case SB_GETBORDERS: 1186 return STATUSBAR_GetBorders (infoPtr, (INT *)lParam); 1187 1188 case SB_GETICON: 1189 return (LRESULT)STATUSBAR_GetIcon (infoPtr, nPart); 1190 1191 case SB_GETPARTS: 1192 return STATUSBAR_GetParts (infoPtr, (INT)wParam, (INT *)lParam); 1193 1194 case SB_GETRECT: 1195 return STATUSBAR_GetRect (infoPtr, nPart, (LPRECT)lParam); 1196 1197 case SB_GETTEXTA: 1198 return STATUSBAR_GetTextA (infoPtr, nPart, (LPSTR)lParam); 1199 1200 case SB_GETTEXTW: 1201 return STATUSBAR_GetTextW (infoPtr, nPart, (LPWSTR)lParam); 1202 1203 case SB_GETTEXTLENGTHA: 1204 case SB_GETTEXTLENGTHW: 1205 return STATUSBAR_GetTextLength (infoPtr, nPart); 1206 1207 case SB_GETTIPTEXTA: 1208 return STATUSBAR_GetTipTextA (infoPtr, LOWORD(wParam), (LPSTR)lParam, HIWORD(wParam)); 1209 1210 case SB_GETTIPTEXTW: 1211 return STATUSBAR_GetTipTextW (infoPtr, LOWORD(wParam), (LPWSTR)lParam, HIWORD(wParam)); 1212 1213 case SB_GETUNICODEFORMAT: 1214 return infoPtr->bUnicode; 1215 1216 case SB_ISSIMPLE: 1217 return infoPtr->simple; 1218 1219 case SB_SETBORDERS: 1220 return STATUSBAR_SetBorders (infoPtr, (INT *)lParam); 1221 1222 case SB_SETBKCOLOR: 1223 return STATUSBAR_SetBkColor (infoPtr, (COLORREF)lParam); 1224 1225 case SB_SETICON: 1226 return STATUSBAR_SetIcon (infoPtr, nPart, (HICON)lParam); 1227 1228 case SB_SETMINHEIGHT: 1229 return STATUSBAR_SetMinHeight (infoPtr, (INT)wParam); 1230 1231 case SB_SETPARTS: 1232 return STATUSBAR_SetParts (infoPtr, (INT)wParam, (LPINT)lParam); 1233 1234 case SB_SETTEXTA: 1235 return STATUSBAR_SetTextT (infoPtr, nPart, wParam & 0xff00, (LPWSTR)lParam, FALSE); 1236 1237 case SB_SETTEXTW: 1238 return STATUSBAR_SetTextT (infoPtr, nPart, wParam & 0xff00, (LPWSTR)lParam, TRUE); 1239 1240 case SB_SETTIPTEXTA: 1241 return STATUSBAR_SetTipTextA (infoPtr, (INT)wParam, (LPSTR)lParam); 1242 1243 case SB_SETTIPTEXTW: 1244 return STATUSBAR_SetTipTextW (infoPtr, (INT)wParam, (LPWSTR)lParam); 1245 1246 case SB_SETUNICODEFORMAT: 1247 return STATUSBAR_SetUnicodeFormat (infoPtr, (BOOL)wParam); 1248 1249 case SB_SIMPLE: 1250 return STATUSBAR_Simple (infoPtr, (BOOL)wParam); 1251 1252 case WM_CREATE: 1253 return STATUSBAR_WMCreate (hwnd, (LPCREATESTRUCTA)lParam); 1254 1255 case WM_DESTROY: 1256 return STATUSBAR_WMDestroy (infoPtr); 1257 1258 case WM_GETFONT: 1259 return (LRESULT)(infoPtr->hFont? infoPtr->hFont : infoPtr->hDefaultFont); 1260 1261 case WM_GETTEXT: 1262 return STATUSBAR_WMGetText (infoPtr, (INT)wParam, (LPWSTR)lParam); 1263 1264 case WM_GETTEXTLENGTH: 1265 return LOWORD(STATUSBAR_GetTextLength (infoPtr, 0)); 1266 1267 case WM_LBUTTONDBLCLK: 1268 return STATUSBAR_SendMouseNotify(infoPtr, NM_DBLCLK, msg, wParam, lParam); 1269 1270 case WM_LBUTTONUP: 1271 return STATUSBAR_SendMouseNotify(infoPtr, NM_CLICK, msg, wParam, lParam); 1272 1273 case WM_MOUSEMOVE: 1274 return STATUSBAR_Relay2Tip (infoPtr, msg, wParam, lParam); 1275 1276 case WM_NCHITTEST: 1277 res = STATUSBAR_WMNCHitTest(infoPtr, (short)LOWORD(lParam), 1278 (short)HIWORD(lParam)); 1279 if (res != HTERROR) return res; 1280 return DefWindowProcW (hwnd, msg, wParam, lParam); 1281 1282 case WM_NCLBUTTONUP: 1283 case WM_NCLBUTTONDOWN: 1284 PostMessageW (infoPtr->Notify, msg, wParam, lParam); 1285 return 0; 1286 1287 case WM_NOTIFYFORMAT: 1288 return STATUSBAR_NotifyFormat(infoPtr, (HWND)wParam, (INT)lParam); 1289 1290 case WM_PRINTCLIENT: 1291 case WM_PAINT: 1292 return STATUSBAR_WMPaint (infoPtr, (HDC)wParam); 1293 1294 case WM_RBUTTONDBLCLK: 1295 return STATUSBAR_SendMouseNotify(infoPtr, NM_RDBLCLK, msg, wParam, lParam); 1296 1297 case WM_RBUTTONUP: 1298 return STATUSBAR_SendMouseNotify(infoPtr, NM_RCLICK, msg, wParam, lParam); 1299 1300 case WM_SETFONT: 1301 return STATUSBAR_WMSetFont (infoPtr, (HFONT)wParam, LOWORD(lParam)); 1302 1303 case WM_SETTEXT: 1304 return STATUSBAR_WMSetText (infoPtr, (LPCSTR)lParam); 1305 1306 case WM_SIZE: 1307 if (STATUSBAR_WMSize (infoPtr, (WORD)wParam)) return 0; 1308 return DefWindowProcW (hwnd, msg, wParam, lParam); 1309 1310 case WM_SYSCOLORCHANGE: 1311 COMCTL32_RefreshSysColors(); 1312 return 0; 1313 1314 case WM_THEMECHANGED: 1315 return theme_changed (infoPtr); 1316 1317 default: 1318 if ((msg >= WM_USER) && (msg < WM_APP) && !COMCTL32_IsReflectedMessage(msg)) 1319 ERR("unknown msg %04x wp=%04lx lp=%08lx\n", 1320 msg, wParam, lParam); 1321 return DefWindowProcW (hwnd, msg, wParam, lParam); 1322 } 1323 } 1324 1325 1326 /*********************************************************************** 1327 * STATUS_Register [Internal] 1328 * 1329 * Registers the status window class. 1330 */ 1331 1332 void 1333 STATUS_Register (void) 1334 { 1335 WNDCLASSW wndClass; 1336 1337 ZeroMemory (&wndClass, sizeof(WNDCLASSW)); 1338 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS | CS_VREDRAW; 1339 wndClass.lpfnWndProc = StatusWindowProc; 1340 wndClass.cbClsExtra = 0; 1341 wndClass.cbWndExtra = sizeof(STATUS_INFO *); 1342 wndClass.hCursor = LoadCursorW (0, (LPWSTR)IDC_ARROW); 1343 wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1); 1344 wndClass.lpszClassName = STATUSCLASSNAMEW; 1345 1346 RegisterClassW (&wndClass); 1347 } 1348 1349 1350 /*********************************************************************** 1351 * STATUS_Unregister [Internal] 1352 * 1353 * Unregisters the status window class. 1354 */ 1355 1356 void 1357 STATUS_Unregister (void) 1358 { 1359 UnregisterClassW (STATUSCLASSNAMEW, NULL); 1360 } 1361