4 * Copyright 1997, 2002 Dimitrie O. Paun
5 * Copyright 1998, 1999 Eric Kohl
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 * This code was audited for completeness against the documented features
24 * of Comctl32.dll version 6.0 on Sep. 9, 2002, by Dimitrie O. Paun.
26 * Unless otherwise noted, we believe this code to be complete, as per
27 * the specification mentioned above.
28 * If you discover missing features, or bugs, please note them below.
38 * -- PBS_SMOOTHREVERSE
53 #include "wine/debug.h"
55 WINE_DEFAULT_DEBUG_CHANNEL(progress
);
59 HWND Self
; /* The window handle for this control */
60 INT CurVal
; /* Current progress value */
61 INT MinVal
; /* Minimum progress value */
62 INT MaxVal
; /* Maximum progress value */
63 INT Step
; /* Step to use on PMB_STEPIT */
64 INT MarqueePos
; /* Marquee animation position */
65 BOOL Marquee
; /* Whether the marquee animation is enabled */
66 COLORREF ColorBar
; /* Bar color */
67 COLORREF ColorBk
; /* Background color */
68 HFONT Font
; /* Handle to font (not unused) */
71 /* Control configuration constants */
74 #define MARQUEE_LEDS 5
75 #define ID_MARQUEE_TIMER 1
77 /* Helper to obtain size of a progress bar chunk ("led"). */
78 static inline int get_led_size ( const PROGRESS_INFO
*infoPtr
, LONG style
,
81 HTHEME theme
= GetWindowTheme (infoPtr
->Self
);
85 if (SUCCEEDED( GetThemeInt( theme
, 0, 0, TMT_PROGRESSCHUNKSIZE
, &chunkSize
)))
89 if (style
& PBS_VERTICAL
)
90 return MulDiv (rect
->right
- rect
->left
, 2, 3);
92 return MulDiv (rect
->bottom
- rect
->top
, 2, 3);
95 /* Helper to obtain gap between progress bar chunks */
96 static inline int get_led_gap ( const PROGRESS_INFO
*infoPtr
)
98 HTHEME theme
= GetWindowTheme (infoPtr
->Self
);
102 if (SUCCEEDED( GetThemeInt( theme
, 0, 0, TMT_PROGRESSSPACESIZE
, &spaceSize
)))
109 /* Get client rect. Takes into account that theming needs no adjustment. */
110 static inline void get_client_rect (HWND hwnd
, RECT
* rect
)
112 HTHEME theme
= GetWindowTheme (hwnd
);
113 GetClientRect (hwnd
, rect
);
115 InflateRect(rect
, -1, -1);
118 DWORD dwStyle
= GetWindowLongW (hwnd
, GWL_STYLE
);
119 int part
= (dwStyle
& PBS_VERTICAL
) ? PP_BARVERT
: PP_BAR
;
120 GetThemeBackgroundContentRect (theme
, 0, part
, 0, rect
, rect
);
124 /* Compute the extend of the bar */
125 static inline int get_bar_size( LONG style
, const RECT
* rect
)
127 if (style
& PBS_VERTICAL
)
128 return rect
->bottom
- rect
->top
;
130 return rect
->right
- rect
->left
;
133 /* Compute the pixel position of a progress value */
134 static inline int get_bar_position( const PROGRESS_INFO
*infoPtr
, LONG style
,
135 const RECT
* rect
, INT value
)
137 return MulDiv (value
- infoPtr
->MinVal
, get_bar_size (style
, rect
),
138 infoPtr
->MaxVal
- infoPtr
->MinVal
);
141 /***********************************************************************
142 * PROGRESS_Invalidate
144 * Don't be too clever about invalidating the progress bar.
145 * InstallShield depends on this simple behaviour.
147 static void PROGRESS_Invalidate( const PROGRESS_INFO
*infoPtr
, INT old
, INT
new )
149 InvalidateRect( infoPtr
->Self
, NULL
, old
> new );
152 /* Information for a progress bar drawing helper */
153 typedef struct tagProgressDrawInfo
164 typedef void (*ProgressDrawProc
)(const ProgressDrawInfo
* di
, int start
, int end
);
166 /* draw solid horizontal bar from 'start' to 'end' */
167 static void draw_solid_bar_H (const ProgressDrawInfo
* di
, int start
, int end
)
170 r
.left
= di
->rect
.left
+ start
;
171 r
.top
= di
->rect
.top
;
172 r
.right
= di
->rect
.left
+ end
;
173 r
.bottom
= di
->rect
.bottom
;
174 FillRect (di
->hdc
, &r
, di
->hbrBar
);
177 /* draw solid horizontal background from 'start' to 'end' */
178 static void draw_solid_bkg_H (const ProgressDrawInfo
* di
, int start
, int end
)
181 r
.left
= di
->rect
.left
+ start
;
182 r
.top
= di
->rect
.top
;
183 r
.right
= di
->rect
.left
+ end
;
184 r
.bottom
= di
->rect
.bottom
;
185 FillRect (di
->hdc
, &r
, di
->hbrBk
);
188 /* draw solid vertical bar from 'start' to 'end' */
189 static void draw_solid_bar_V (const ProgressDrawInfo
* di
, int start
, int end
)
192 r
.left
= di
->rect
.left
;
193 r
.top
= di
->rect
.bottom
- end
;
194 r
.right
= di
->rect
.right
;
195 r
.bottom
= di
->rect
.bottom
- start
;
196 FillRect (di
->hdc
, &r
, di
->hbrBar
);
199 /* draw solid vertical background from 'start' to 'end' */
200 static void draw_solid_bkg_V (const ProgressDrawInfo
* di
, int start
, int end
)
203 r
.left
= di
->rect
.left
;
204 r
.top
= di
->rect
.bottom
- end
;
205 r
.right
= di
->rect
.right
;
206 r
.bottom
= di
->rect
.bottom
- start
;
207 FillRect (di
->hdc
, &r
, di
->hbrBk
);
210 /* draw chunky horizontal bar from 'start' to 'end' */
211 static void draw_chunk_bar_H (const ProgressDrawInfo
* di
, int start
, int end
)
214 int right
= di
->rect
.left
+ end
;
215 r
.left
= di
->rect
.left
+ start
;
216 r
.top
= di
->rect
.top
;
217 r
.bottom
= di
->rect
.bottom
;
218 while (r
.left
< right
)
220 r
.right
= min (r
.left
+ di
->ledW
, right
);
221 FillRect (di
->hdc
, &r
, di
->hbrBar
);
223 r
.right
= min (r
.left
+ di
->ledGap
, right
);
224 FillRect (di
->hdc
, &r
, di
->hbrBk
);
229 /* draw chunky vertical bar from 'start' to 'end' */
230 static void draw_chunk_bar_V (const ProgressDrawInfo
* di
, int start
, int end
)
233 int top
= di
->rect
.bottom
- end
;
234 r
.left
= di
->rect
.left
;
235 r
.right
= di
->rect
.right
;
236 r
.bottom
= di
->rect
.bottom
- start
;
237 while (r
.bottom
> top
)
239 r
.top
= max (r
.bottom
- di
->ledW
, top
);
240 FillRect (di
->hdc
, &r
, di
->hbrBar
);
242 r
.top
= max (r
.bottom
- di
->ledGap
, top
);
243 FillRect (di
->hdc
, &r
, di
->hbrBk
);
248 /* drawing functions for "classic" style */
249 static const ProgressDrawProc drawProcClassic
[8] = {
252 draw_solid_bar_H
, draw_solid_bkg_H
,
254 draw_solid_bar_V
, draw_solid_bkg_V
,
257 draw_chunk_bar_H
, draw_solid_bkg_H
,
259 draw_chunk_bar_V
, draw_solid_bkg_V
,
262 /* draw themed horizontal bar from 'start' to 'end' */
263 static void draw_theme_bar_H (const ProgressDrawInfo
* di
, int start
, int end
)
266 r
.left
= di
->rect
.left
+ start
;
267 r
.top
= di
->rect
.top
;
268 r
.bottom
= di
->rect
.bottom
;
269 r
.right
= di
->rect
.left
+ end
;
270 DrawThemeBackground (di
->theme
, di
->hdc
, PP_CHUNK
, 0, &r
, NULL
);
273 /* draw themed vertical bar from 'start' to 'end' */
274 static void draw_theme_bar_V (const ProgressDrawInfo
* di
, int start
, int end
)
277 r
.left
= di
->rect
.left
;
278 r
.right
= di
->rect
.right
;
279 r
.bottom
= di
->rect
.bottom
- start
;
280 r
.top
= di
->rect
.bottom
- end
;
281 DrawThemeBackground (di
->theme
, di
->hdc
, PP_CHUNKVERT
, 0, &r
, NULL
);
284 /* draw themed horizontal background from 'start' to 'end' */
285 static void draw_theme_bkg_H (const ProgressDrawInfo
* di
, int start
, int end
)
288 r
.left
= di
->rect
.left
+ start
;
289 r
.top
= di
->rect
.top
;
290 r
.right
= di
->rect
.left
+ end
;
291 r
.bottom
= di
->rect
.bottom
;
292 DrawThemeBackground (di
->theme
, di
->hdc
, PP_BAR
, 0, &di
->bgRect
, &r
);
295 /* draw themed vertical background from 'start' to 'end' */
296 static void draw_theme_bkg_V (const ProgressDrawInfo
* di
, int start
, int end
)
299 r
.left
= di
->rect
.left
;
300 r
.top
= di
->rect
.bottom
- end
;
301 r
.right
= di
->rect
.right
;
302 r
.bottom
= di
->rect
.bottom
- start
;
303 DrawThemeBackground (di
->theme
, di
->hdc
, PP_BARVERT
, 0, &di
->bgRect
, &r
);
306 /* drawing functions for themed style */
307 static const ProgressDrawProc drawProcThemed
[8] = {
310 draw_theme_bar_H
, draw_theme_bkg_H
,
312 draw_theme_bar_V
, draw_theme_bkg_V
,
315 draw_theme_bar_H
, draw_theme_bkg_H
,
317 draw_theme_bar_V
, draw_theme_bkg_V
,
320 /***********************************************************************
322 * Draws the progress bar.
324 static LRESULT
PROGRESS_Draw (PROGRESS_INFO
*infoPtr
, HDC hdc
)
329 const ProgressDrawProc
* drawProcs
;
330 ProgressDrawInfo pdi
;
332 TRACE("(infoPtr=%p, hdc=%p)\n", infoPtr
, hdc
);
335 pdi
.theme
= GetWindowTheme (infoPtr
->Self
);
337 /* get the required bar brush */
338 if (infoPtr
->ColorBar
== CLR_DEFAULT
)
339 pdi
.hbrBar
= GetSysColorBrush(COLOR_HIGHLIGHT
);
341 pdi
.hbrBar
= CreateSolidBrush (infoPtr
->ColorBar
);
343 if (infoPtr
->ColorBk
== CLR_DEFAULT
)
344 pdi
.hbrBk
= GetSysColorBrush(COLOR_3DFACE
);
346 pdi
.hbrBk
= CreateSolidBrush(infoPtr
->ColorBk
);
348 /* get the window style */
349 dwStyle
= GetWindowLongW (infoPtr
->Self
, GWL_STYLE
);
351 /* get client rectangle */
352 GetClientRect (infoPtr
->Self
, &pdi
.rect
);
354 FrameRect( hdc
, &pdi
.rect
, pdi
.hbrBk
);
355 InflateRect(&pdi
.rect
, -1, -1);
360 int part
= (dwStyle
& PBS_VERTICAL
) ? PP_BARVERT
: PP_BAR
;
362 GetThemeBackgroundContentRect (pdi
.theme
, hdc
, part
, 0, &pdi
.rect
,
365 /* Exclude content rect - content background will be drawn later */
366 ExcludeClipRect (hdc
, cntRect
.left
, cntRect
.top
,
367 cntRect
.right
, cntRect
.bottom
);
368 if (IsThemeBackgroundPartiallyTransparent (pdi
.theme
, part
, 0))
369 DrawThemeParentBackground (infoPtr
->Self
, hdc
, NULL
);
370 DrawThemeBackground (pdi
.theme
, hdc
, part
, 0, &pdi
.rect
, NULL
);
371 SelectClipRgn (hdc
, NULL
);
372 CopyRect (&pdi
.rect
, &cntRect
);
375 /* compute some drawing parameters */
376 barSmooth
= (dwStyle
& PBS_SMOOTH
) && !pdi
.theme
;
377 drawProcs
= &((pdi
.theme
? drawProcThemed
: drawProcClassic
)[(barSmooth
? 0 : 4)
378 + ((dwStyle
& PBS_VERTICAL
) ? 2 : 0)]);
379 barSize
= get_bar_size( dwStyle
, &pdi
.rect
);
382 GetWindowRect( infoPtr
->Self
, &pdi
.bgRect
);
383 MapWindowPoints( infoPtr
->Self
, 0, (POINT
*)&pdi
.bgRect
, 2 );
387 pdi
.ledW
= get_led_size( infoPtr
, dwStyle
, &pdi
.rect
);
388 pdi
.ledGap
= get_led_gap( infoPtr
);
390 if (dwStyle
& PBS_MARQUEE
)
392 const int ledW
= !barSmooth
? (pdi
.ledW
+ pdi
.ledGap
) : 1;
393 const int leds
= (barSize
+ ledW
- 1) / ledW
;
394 const int ledMEnd
= infoPtr
->MarqueePos
+ MARQUEE_LEDS
;
398 /* case 1: the marquee bar extends over the end and wraps around to
400 const int gapStart
= max((ledMEnd
- leds
) * ledW
, 0);
401 const int gapEnd
= min(infoPtr
->MarqueePos
* ledW
, barSize
);
403 drawProcs
[0]( &pdi
, 0, gapStart
);
404 drawProcs
[1]( &pdi
, gapStart
, gapEnd
);
405 drawProcs
[0]( &pdi
, gapEnd
, barSize
);
409 /* case 2: the marquee bar is between start and end */
410 const int barStart
= infoPtr
->MarqueePos
* ledW
;
411 const int barEnd
= min (ledMEnd
* ledW
, barSize
);
413 drawProcs
[1]( &pdi
, 0, barStart
);
414 drawProcs
[0]( &pdi
, barStart
, barEnd
);
415 drawProcs
[1]( &pdi
, barEnd
, barSize
);
420 int barEnd
= get_bar_position( infoPtr
, dwStyle
, &pdi
.rect
,
424 const int ledW
= pdi
.ledW
+ pdi
.ledGap
;
425 barEnd
= min (((barEnd
+ ledW
- 1) / ledW
) * ledW
, barSize
);
427 drawProcs
[0]( &pdi
, 0, barEnd
);
428 drawProcs
[1]( &pdi
, barEnd
, barSize
);
431 /* delete bar brush */
432 if (infoPtr
->ColorBar
!= CLR_DEFAULT
) DeleteObject (pdi
.hbrBar
);
433 if (infoPtr
->ColorBk
!= CLR_DEFAULT
) DeleteObject (pdi
.hbrBk
);
438 /***********************************************************************
440 * Draw the progress bar. The background need not be erased.
441 * If dc!=0, it draws on it
443 static LRESULT
PROGRESS_Paint (PROGRESS_INFO
*infoPtr
, HDC hdc
)
446 if (hdc
) return PROGRESS_Draw (infoPtr
, hdc
);
447 hdc
= BeginPaint (infoPtr
->Self
, &ps
);
448 PROGRESS_Draw (infoPtr
, hdc
);
449 EndPaint (infoPtr
->Self
, &ps
);
454 /***********************************************************************
456 * Handle the marquee timer messages
458 static LRESULT
PROGRESS_Timer (PROGRESS_INFO
*infoPtr
, INT idTimer
)
460 if(idTimer
== ID_MARQUEE_TIMER
)
462 LONG style
= GetWindowLongW (infoPtr
->Self
, GWL_STYLE
);
465 HTHEME theme
= GetWindowTheme (infoPtr
->Self
);
466 BOOL barSmooth
= (style
& PBS_SMOOTH
) && !theme
;
468 get_client_rect (infoPtr
->Self
, &rect
);
471 ledWidth
= get_led_size( infoPtr
, style
, &rect
) +
472 get_led_gap( infoPtr
);
476 leds
= (get_bar_size( style
, &rect
) + ledWidth
- 1) /
479 /* increment the marquee progress */
480 if(++infoPtr
->MarqueePos
>= leds
)
482 infoPtr
->MarqueePos
= 0;
485 InvalidateRect(infoPtr
->Self
, &rect
, FALSE
);
486 UpdateWindow(infoPtr
->Self
);
492 /***********************************************************************
494 * Makes sure the current position (CurVal) is within bounds.
496 static void PROGRESS_CoercePos(PROGRESS_INFO
*infoPtr
)
498 if(infoPtr
->CurVal
< infoPtr
->MinVal
)
499 infoPtr
->CurVal
= infoPtr
->MinVal
;
500 if(infoPtr
->CurVal
> infoPtr
->MaxVal
)
501 infoPtr
->CurVal
= infoPtr
->MaxVal
;
505 /***********************************************************************
507 * Set new Font for progress bar
509 static HFONT
PROGRESS_SetFont (PROGRESS_INFO
*infoPtr
, HFONT hFont
, BOOL bRedraw
)
511 HFONT hOldFont
= infoPtr
->Font
;
512 infoPtr
->Font
= hFont
;
513 /* Since infoPtr->Font is not used, there is no need for repaint */
517 static DWORD
PROGRESS_SetRange (PROGRESS_INFO
*infoPtr
, int low
, int high
)
519 DWORD res
= MAKELONG(LOWORD(infoPtr
->MinVal
), LOWORD(infoPtr
->MaxVal
));
521 /* if nothing changes, simply return */
522 if(infoPtr
->MinVal
== low
&& infoPtr
->MaxVal
== high
) return res
;
524 infoPtr
->MinVal
= low
;
525 infoPtr
->MaxVal
= high
;
526 PROGRESS_CoercePos(infoPtr
);
527 InvalidateRect(infoPtr
->Self
, NULL
, TRUE
);
531 /***********************************************************************
534 static LRESULT WINAPI
ProgressWindowProc(HWND hwnd
, UINT message
,
535 WPARAM wParam
, LPARAM lParam
)
537 PROGRESS_INFO
*infoPtr
;
538 static const WCHAR themeClass
[] = {'P','r','o','g','r','e','s','s',0};
541 TRACE("hwnd=%p msg=%04x wparam=%lx lParam=%lx\n", hwnd
, message
, wParam
, lParam
);
543 infoPtr
= (PROGRESS_INFO
*)GetWindowLongPtrW(hwnd
, 0);
545 if (!infoPtr
&& message
!= WM_CREATE
)
546 return DefWindowProcW( hwnd
, message
, wParam
, lParam
);
551 DWORD dwExStyle
= GetWindowLongW (hwnd
, GWL_EXSTYLE
);
553 theme
= OpenThemeData (hwnd
, themeClass
);
555 dwExStyle
&= ~(WS_EX_CLIENTEDGE
| WS_EX_WINDOWEDGE
);
556 if (!theme
) dwExStyle
|= WS_EX_STATICEDGE
;
557 SetWindowLongW (hwnd
, GWL_EXSTYLE
, dwExStyle
);
558 /* Force recalculation of a non-client area */
559 SetWindowPos(hwnd
, 0, 0, 0, 0, 0,
560 SWP_FRAMECHANGED
| SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOZORDER
| SWP_NOACTIVATE
);
562 /* allocate memory for info struct */
563 infoPtr
= Alloc (sizeof(PROGRESS_INFO
));
564 if (!infoPtr
) return -1;
565 SetWindowLongPtrW (hwnd
, 0, (DWORD_PTR
)infoPtr
);
567 /* initialize the info struct */
568 infoPtr
->Self
= hwnd
;
570 infoPtr
->MaxVal
= 100;
573 infoPtr
->MarqueePos
= 0;
574 infoPtr
->Marquee
= FALSE
;
575 infoPtr
->ColorBar
= CLR_DEFAULT
;
576 infoPtr
->ColorBk
= CLR_DEFAULT
;
579 TRACE("Progress Ctrl creation, hwnd=%p\n", hwnd
);
584 TRACE("Progress Ctrl destruction, hwnd=%p\n", hwnd
);
586 SetWindowLongPtrW(hwnd
, 0, 0);
587 theme
= GetWindowTheme (hwnd
);
588 CloseThemeData (theme
);
595 return (LRESULT
)infoPtr
->Font
;
598 return (LRESULT
)PROGRESS_SetFont(infoPtr
, (HFONT
)wParam
, (BOOL
)lParam
);
602 return PROGRESS_Paint (infoPtr
, (HDC
)wParam
);
605 return PROGRESS_Timer (infoPtr
, (INT
)wParam
);
607 case WM_THEMECHANGED
:
609 DWORD dwExStyle
= GetWindowLongW (hwnd
, GWL_EXSTYLE
);
611 theme
= GetWindowTheme (hwnd
);
612 CloseThemeData (theme
);
613 theme
= OpenThemeData (hwnd
, themeClass
);
615 /* WS_EX_STATICEDGE disappears when the control is themed */
617 dwExStyle
&= ~WS_EX_STATICEDGE
;
619 dwExStyle
|= WS_EX_STATICEDGE
;
620 SetWindowLongW (hwnd
, GWL_EXSTYLE
, dwExStyle
);
622 InvalidateRect (hwnd
, NULL
, FALSE
);
629 oldVal
= infoPtr
->CurVal
;
631 infoPtr
->CurVal
+= (INT
)wParam
;
632 PROGRESS_CoercePos (infoPtr
);
633 TRACE("PBM_DELTAPOS: current pos changed from %d to %d\n", oldVal
, infoPtr
->CurVal
);
634 PROGRESS_Invalidate( infoPtr
, oldVal
, infoPtr
->CurVal
);
635 UpdateWindow( infoPtr
->Self
);
643 oldVal
= infoPtr
->CurVal
;
644 if(oldVal
!= wParam
) {
645 infoPtr
->CurVal
= (INT
)wParam
;
646 PROGRESS_CoercePos(infoPtr
);
647 TRACE("PBM_SETPOS: current pos changed from %d to %d\n", oldVal
, infoPtr
->CurVal
);
648 PROGRESS_Invalidate( infoPtr
, oldVal
, infoPtr
->CurVal
);
649 UpdateWindow( infoPtr
->Self
);
655 return PROGRESS_SetRange (infoPtr
, (int)LOWORD(lParam
), (int)HIWORD(lParam
));
660 oldStep
= infoPtr
->Step
;
661 infoPtr
->Step
= (INT
)wParam
;
668 oldVal
= infoPtr
->CurVal
;
669 infoPtr
->CurVal
+= infoPtr
->Step
;
670 if(infoPtr
->CurVal
> infoPtr
->MaxVal
)
671 infoPtr
->CurVal
= infoPtr
->MinVal
;
672 if(oldVal
!= infoPtr
->CurVal
)
674 TRACE("PBM_STEPIT: current pos changed from %d to %d\n", oldVal
, infoPtr
->CurVal
);
675 PROGRESS_Invalidate( infoPtr
, oldVal
, infoPtr
->CurVal
);
676 UpdateWindow( infoPtr
->Self
);
682 return PROGRESS_SetRange (infoPtr
, (int)wParam
, (int)lParam
);
686 ((PPBRANGE
)lParam
)->iLow
= infoPtr
->MinVal
;
687 ((PPBRANGE
)lParam
)->iHigh
= infoPtr
->MaxVal
;
689 return wParam
? infoPtr
->MinVal
: infoPtr
->MaxVal
;
692 return infoPtr
->CurVal
;
694 case PBM_SETBARCOLOR
:
695 infoPtr
->ColorBar
= (COLORREF
)lParam
;
696 InvalidateRect(hwnd
, NULL
, TRUE
);
699 case PBM_GETBARCOLOR
:
700 return infoPtr
->ColorBar
;
703 infoPtr
->ColorBk
= (COLORREF
)lParam
;
704 InvalidateRect(hwnd
, NULL
, TRUE
);
708 return infoPtr
->ColorBk
;
713 infoPtr
->Marquee
= TRUE
;
714 SetTimer(infoPtr
->Self
, ID_MARQUEE_TIMER
, (UINT
)lParam
, NULL
);
718 infoPtr
->Marquee
= FALSE
;
719 KillTimer(infoPtr
->Self
, ID_MARQUEE_TIMER
);
721 return infoPtr
->Marquee
;
724 if ((message
>= WM_USER
) && (message
< WM_APP
) && !COMCTL32_IsReflectedMessage(message
))
725 ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message
, wParam
, lParam
);
726 return DefWindowProcW( hwnd
, message
, wParam
, lParam
);
731 /***********************************************************************
732 * PROGRESS_Register [Internal]
734 * Registers the progress bar window class.
736 void PROGRESS_Register (void)
740 ZeroMemory (&wndClass
, sizeof(wndClass
));
741 wndClass
.style
= CS_GLOBALCLASS
| CS_VREDRAW
| CS_HREDRAW
;
742 wndClass
.lpfnWndProc
= (WNDPROC
)ProgressWindowProc
;
743 wndClass
.cbClsExtra
= 0;
744 wndClass
.cbWndExtra
= sizeof (PROGRESS_INFO
*);
745 wndClass
.hCursor
= LoadCursorW (0, (LPWSTR
)IDC_ARROW
);
746 wndClass
.lpszClassName
= PROGRESS_CLASSW
;
748 RegisterClassW (&wndClass
);
752 /***********************************************************************
753 * PROGRESS_Unregister [Internal]
755 * Unregisters the progress bar window class.
757 void PROGRESS_Unregister (void)
759 UnregisterClassW (PROGRESS_CLASSW
, NULL
);