source: trunk/src/comctl32/status.c@ 7133

Last change on this file since 7133 was 7133, checked in by phaller, 24 years ago

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