dlls/comctl32/status.c

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