mountmgr.sys: Implemented the IOCTL_MOUNTMGR_QUERY_POINTS request.
[wine] / dlls / comctl32 / progress.c
1 /*
2  * Progress control
3  *
4  * Copyright 1997, 2002 Dimitrie O. Paun
5  * Copyright 1998, 1999 Eric Kohl
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  *
21  * NOTE
22  * 
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.
25  * 
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.
29  *
30  */
31
32 #include <stdarg.h>
33 #include <string.h>
34 #include "windef.h"
35 #include "winbase.h"
36 #include "wingdi.h"
37 #include "winuser.h"
38 #include "winnls.h"
39 #include "commctrl.h"
40 #include "comctl32.h"
41 #include "uxtheme.h"
42 #include "tmschema.h"
43 #include "wine/debug.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(progress);
46
47 typedef struct
48 {
49     HWND      Self;         /* The window handle for this control */
50     INT       CurVal;       /* Current progress value */
51     INT       MinVal;       /* Minimum progress value */
52     INT       MaxVal;       /* Maximum progress value */
53     INT       Step;         /* Step to use on PMB_STEPIT */
54     INT       MarqueePos;   /* Marquee animation position */
55     BOOL      Marquee;      /* Whether the marquee animation is enabled */
56     COLORREF  ColorBar;     /* Bar color */
57     COLORREF  ColorBk;      /* Background color */
58     HFONT     Font;         /* Handle to font (not unused) */
59 } PROGRESS_INFO;
60
61 /* Control configuration constants */
62
63 #define LED_GAP           2
64 #define MARQUEE_LEDS      5
65 #define ID_MARQUEE_TIMER  1
66
67 /* Helper to obtain size of a progress bar chunk ("led"). */
68 static inline int get_led_size ( const PROGRESS_INFO *infoPtr, LONG style,
69                                  const RECT* rect )
70 {
71     HTHEME theme = GetWindowTheme (infoPtr->Self);
72     if (theme)
73     {
74         int chunkSize;
75         if (SUCCEEDED( GetThemeInt( theme, 0, 0, TMT_PROGRESSCHUNKSIZE, &chunkSize )))
76             return chunkSize;
77     }
78
79     if (style & PBS_VERTICAL)
80         return MulDiv (rect->right - rect->left, 2, 3);
81     else
82         return MulDiv (rect->bottom - rect->top, 2, 3);
83 }
84
85 /* Helper to obtain gap between progress bar chunks */
86 static inline int get_led_gap ( const PROGRESS_INFO *infoPtr )
87 {
88     HTHEME theme = GetWindowTheme (infoPtr->Self);
89     if (theme)
90     {
91         int spaceSize;
92         if (SUCCEEDED( GetThemeInt( theme, 0, 0, TMT_PROGRESSSPACESIZE, &spaceSize )))
93             return spaceSize;
94     }
95
96     return LED_GAP;
97 }
98
99 /* Get client rect. Takes into account that theming needs no adjustment. */
100 static inline void get_client_rect (HWND hwnd, RECT* rect)
101 {
102     HTHEME theme = GetWindowTheme (hwnd);
103     GetClientRect (hwnd, rect);
104     if (!theme)
105         InflateRect(rect, -1, -1);
106     else
107     {
108         DWORD dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
109         int part = (dwStyle & PBS_VERTICAL) ? PP_BARVERT : PP_BAR;
110         GetThemeBackgroundContentRect (theme, 0, part, 0, rect, rect);
111     }
112 }
113
114 /* Compute the extend of the bar */
115 static inline int get_bar_size( LONG style, const RECT* rect )
116 {
117     if (style & PBS_VERTICAL)
118         return rect->bottom - rect->top;
119     else
120         return rect->right - rect->left;
121 }
122
123 /* Compute the pixel position of a progress value */
124 static inline int get_bar_position( const PROGRESS_INFO *infoPtr, LONG style,
125                                     const RECT* rect, INT value )
126 {
127     return MulDiv (value - infoPtr->MinVal, get_bar_size (style, rect),
128                       infoPtr->MaxVal - infoPtr->MinVal);
129 }
130
131 /***********************************************************************
132  * PROGRESS_Invalidate
133  *
134  * Don't be too clever about invalidating the progress bar.
135  * InstallShield depends on this simple behaviour.
136  */
137 static void PROGRESS_Invalidate( const PROGRESS_INFO *infoPtr, INT old, INT new )
138 {
139     InvalidateRect( infoPtr->Self, NULL, old > new );
140 }
141
142 /* Information for a progress bar drawing helper */
143 typedef struct tagProgressDrawInfo
144 {
145     HDC hdc;
146     RECT rect;
147     HBRUSH hbrBar;
148     HBRUSH hbrBk;
149     int ledW, ledGap;
150     HTHEME theme;
151     RECT bgRect;
152 } ProgressDrawInfo;
153
154 typedef void (*ProgressDrawProc)(const ProgressDrawInfo* di, int start, int end);
155
156 /* draw solid horizontal bar from 'start' to 'end' */
157 static void draw_solid_bar_H (const ProgressDrawInfo* di, int start, int end)
158 {
159     RECT r;
160     r.left = di->rect.left + start;
161     r.top = di->rect.top;
162     r.right = di->rect.left + end;
163     r.bottom = di->rect.bottom;
164     FillRect (di->hdc, &r, di->hbrBar);
165 }
166
167 /* draw solid horizontal background from 'start' to 'end' */
168 static void draw_solid_bkg_H (const ProgressDrawInfo* di, int start, int end)
169 {
170     RECT r;
171     r.left = di->rect.left + start;
172     r.top = di->rect.top;
173     r.right = di->rect.left + end;
174     r.bottom = di->rect.bottom;
175     FillRect (di->hdc, &r, di->hbrBk);
176 }
177
178 /* draw solid vertical bar from 'start' to 'end' */
179 static void draw_solid_bar_V (const ProgressDrawInfo* di, int start, int end)
180 {
181     RECT r;
182     r.left = di->rect.left;
183     r.top = di->rect.bottom - end;
184     r.right = di->rect.right;
185     r.bottom = di->rect.bottom - start;
186     FillRect (di->hdc, &r, di->hbrBar);
187 }
188
189 /* draw solid vertical background from 'start' to 'end' */
190 static void draw_solid_bkg_V (const ProgressDrawInfo* di, int start, int end)
191 {
192     RECT r;
193     r.left = di->rect.left;
194     r.top = di->rect.bottom - end;
195     r.right = di->rect.right;
196     r.bottom = di->rect.bottom - start;
197     FillRect (di->hdc, &r, di->hbrBk);
198 }
199
200 /* draw chunky horizontal bar from 'start' to 'end' */
201 static void draw_chunk_bar_H (const ProgressDrawInfo* di, int start, int end)
202 {
203     RECT r;
204     int right = di->rect.left + end;
205     r.left = di->rect.left + start;
206     r.top = di->rect.top;
207     r.bottom = di->rect.bottom;
208     while (r.left < right)
209     {
210         r.right = min (r.left + di->ledW, right);
211         FillRect (di->hdc, &r, di->hbrBar);
212         r.left = r.right;
213         r.right = min (r.left + di->ledGap, right);
214         FillRect (di->hdc, &r, di->hbrBk);
215         r.left = r.right;
216     }
217 }
218
219 /* draw chunky vertical bar from 'start' to 'end' */
220 static void draw_chunk_bar_V (const ProgressDrawInfo* di, int start, int end)
221 {
222     RECT r;
223     int top = di->rect.bottom - end;
224     r.left = di->rect.left;
225     r.right = di->rect.right;
226     r.bottom = di->rect.bottom - start;
227     while (r.bottom > top)
228     {
229         r.top = max (r.bottom - di->ledW, top);
230         FillRect (di->hdc, &r, di->hbrBar);
231         r.bottom = r.top;
232         r.top = max (r.bottom - di->ledGap, top);
233         FillRect (di->hdc, &r, di->hbrBk);
234         r.bottom = r.top;
235     }
236 }
237
238 /* drawing functions for "classic" style */
239 static const ProgressDrawProc drawProcClassic[8] = {
240   /* Smooth */
241     /* Horizontal */
242     draw_solid_bar_H, draw_solid_bkg_H,
243     /* Vertical */
244     draw_solid_bar_V, draw_solid_bkg_V,
245   /* Chunky */
246     /* Horizontal */
247     draw_chunk_bar_H, draw_solid_bkg_H,
248     /* Vertical */
249     draw_chunk_bar_V, draw_solid_bkg_V,
250 };
251
252 /* draw themed horizontal bar from 'start' to 'end' */
253 static void draw_theme_bar_H (const ProgressDrawInfo* di, int start, int end)
254 {
255     RECT r;
256     int right = di->rect.left + end;
257     r.left = di->rect.left + start;
258     r.top = di->rect.top;
259     r.bottom = di->rect.bottom;
260     while (r.left < right)
261     {
262         r.right = min (r.left + di->ledW, right);
263         DrawThemeBackground (di->theme, di->hdc, PP_CHUNK, 0, &r, NULL);
264         r.left = r.right;
265         r.right = min (r.left + di->ledGap, right);
266         DrawThemeBackground (di->theme, di->hdc, PP_BAR, 0, &di->bgRect, &r);
267         r.left = r.right;
268     }
269 }
270
271 /* draw themed horizontal bar from 'start' to 'end' */
272 static void draw_theme_bar_V (const ProgressDrawInfo* di, int start, int end)
273 {
274     RECT r;
275     int top = di->rect.bottom - end;
276     r.left = di->rect.left;
277     r.right = di->rect.right;
278     r.bottom = di->rect.bottom - start;
279     while (r.bottom > top)
280     {
281         r.top = max (r.bottom - di->ledW, top);
282         DrawThemeBackground (di->theme, di->hdc, PP_CHUNKVERT, 0, &r, NULL);
283         r.bottom = r.top;
284         r.top = max (r.bottom - di->ledGap, top);
285         DrawThemeBackground (di->theme, di->hdc, PP_BARVERT, 0, &di->bgRect, &r);
286         r.bottom = r.top;
287     }
288 }
289
290 /* draw themed horizontal background from 'start' to 'end' */
291 static void draw_theme_bkg_H (const ProgressDrawInfo* di, int start, int end)
292 {
293     RECT r;
294     r.left = di->rect.left + start;
295     r.top = di->rect.top;
296     r.right = di->rect.left + end;
297     r.bottom = di->rect.bottom;
298     DrawThemeBackground (di->theme, di->hdc, PP_BAR, 0, &di->bgRect, &r);
299 }
300
301 /* draw themed vertical background from 'start' to 'end' */
302 static void draw_theme_bkg_V (const ProgressDrawInfo* di, int start, int end)
303 {
304     RECT r;
305     r.left = di->rect.left;
306     r.top = di->rect.bottom - end;
307     r.right = di->rect.right;
308     r.bottom = di->rect.bottom - start;
309     DrawThemeBackground (di->theme, di->hdc, PP_BARVERT, 0, &di->bgRect, &r);
310 }
311
312 /* drawing functions for themed style */
313 static const ProgressDrawProc drawProcThemed[8] = {
314   /* Smooth */
315     /* Horizontal */
316     draw_theme_bar_H, draw_theme_bkg_H,
317     /* Vertical */
318     draw_theme_bar_V, draw_theme_bkg_V,
319   /* Chunky */
320     /* Horizontal */
321     draw_theme_bar_H, draw_theme_bkg_H,
322     /* Vertical */
323     draw_theme_bar_V, draw_theme_bkg_V,
324 };
325
326 /***********************************************************************
327  * PROGRESS_Draw
328  * Draws the progress bar.
329  */
330 static LRESULT PROGRESS_Draw (PROGRESS_INFO *infoPtr, HDC hdc)
331 {
332     int barSize;
333     DWORD dwStyle;
334     BOOL barSmooth;
335     const ProgressDrawProc* drawProcs;
336     ProgressDrawInfo pdi;
337
338     TRACE("(infoPtr=%p, hdc=%p)\n", infoPtr, hdc);
339
340     pdi.hdc = hdc;
341     pdi.theme = GetWindowTheme (infoPtr->Self);
342
343     /* get the required bar brush */
344     if (infoPtr->ColorBar == CLR_DEFAULT)
345         pdi.hbrBar = GetSysColorBrush(COLOR_HIGHLIGHT);
346     else
347         pdi.hbrBar = CreateSolidBrush (infoPtr->ColorBar);
348
349     if (infoPtr->ColorBk == CLR_DEFAULT)
350         pdi.hbrBk = GetSysColorBrush(COLOR_3DFACE);
351     else
352         pdi.hbrBk = CreateSolidBrush(infoPtr->ColorBk);
353
354     /* get the window style */
355     dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
356
357     /* get client rectangle */
358     GetClientRect (infoPtr->Self, &pdi.rect);
359     if (!pdi.theme) {
360         FrameRect( hdc, &pdi.rect, pdi.hbrBk );
361         InflateRect(&pdi.rect, -1, -1);
362     }
363     else
364     {
365         RECT cntRect;
366         int part = (dwStyle & PBS_VERTICAL) ? PP_BARVERT : PP_BAR;
367         
368         GetThemeBackgroundContentRect (pdi.theme, hdc, part, 0, &pdi.rect, 
369             &cntRect);
370         
371         /* Exclude content rect - content background will be drawn later */
372         ExcludeClipRect (hdc, cntRect.left, cntRect.top, 
373             cntRect.right, cntRect.bottom);
374         if (IsThemeBackgroundPartiallyTransparent (pdi.theme, part, 0))
375             DrawThemeParentBackground (infoPtr->Self, hdc, NULL);
376         DrawThemeBackground (pdi.theme, hdc, part, 0, &pdi.rect, NULL);
377         SelectClipRgn (hdc, NULL);
378         CopyRect (&pdi.rect, &cntRect);
379     }
380
381     /* compute some drawing parameters */
382     barSmooth = (dwStyle & PBS_SMOOTH) && !pdi.theme;
383     drawProcs = &((pdi.theme ? drawProcThemed : drawProcClassic)[(barSmooth ? 0 : 4)
384         + ((dwStyle & PBS_VERTICAL) ? 2 : 0)]);
385     barSize = get_bar_size( dwStyle, &pdi.rect );
386     if (pdi.theme)
387     {
388         GetWindowRect( infoPtr->Self, &pdi.bgRect );
389         ScreenToClient( infoPtr->Self, (POINT*)&pdi.bgRect );
390         ScreenToClient( infoPtr->Self, (POINT*)&pdi.bgRect.right );
391     }
392
393     if (!barSmooth)
394         pdi.ledW = get_led_size( infoPtr, dwStyle, &pdi.rect);
395     pdi.ledGap = get_led_gap( infoPtr );
396
397     if (dwStyle & PBS_MARQUEE)
398     {
399         const int ledW = !barSmooth ? (pdi.ledW + pdi.ledGap) : 1;
400         const int leds = (barSize + ledW - 1) / ledW;
401         const int ledMEnd = infoPtr->MarqueePos + MARQUEE_LEDS;
402
403         if (ledMEnd > leds)
404         {
405             /* case 1: the marquee bar extends over the end and wraps around to 
406              * the start */
407             const int gapStart = max((ledMEnd - leds) * ledW, 0);
408             const int gapEnd = min(infoPtr->MarqueePos * ledW, barSize);
409
410             drawProcs[0]( &pdi, 0, gapStart);
411             drawProcs[1]( &pdi, gapStart, gapEnd);
412             drawProcs[0]( &pdi, gapEnd, barSize);
413         }
414         else
415         {
416             /* case 2: the marquee bar is between start and end */
417             const int barStart = infoPtr->MarqueePos * ledW;
418             const int barEnd = min (ledMEnd * ledW, barSize);
419
420             drawProcs[1]( &pdi, 0, barStart);
421             drawProcs[0]( &pdi, barStart, barEnd);
422             drawProcs[1]( &pdi, barEnd, barSize);
423         }
424     }
425     else
426     {
427         int barEnd = get_bar_position( infoPtr, dwStyle, &pdi.rect,
428             infoPtr->CurVal);
429         if (!barSmooth)
430         {
431             const int ledW = pdi.ledW + pdi.ledGap;
432             barEnd = min (((barEnd + ledW - 1) / ledW) * ledW, barSize);
433         }
434         drawProcs[0]( &pdi, 0, barEnd);
435         drawProcs[1]( &pdi, barEnd, barSize);
436     }
437
438     /* delete bar brush */
439     if (infoPtr->ColorBar != CLR_DEFAULT) DeleteObject (pdi.hbrBar);
440     if (infoPtr->ColorBk != CLR_DEFAULT) DeleteObject (pdi.hbrBk);
441
442     return 0;
443 }
444
445 /***********************************************************************
446  * PROGRESS_Paint
447  * Draw the progress bar. The background need not be erased.
448  * If dc!=0, it draws on it
449  */
450 static LRESULT PROGRESS_Paint (PROGRESS_INFO *infoPtr, HDC hdc)
451 {
452     PAINTSTRUCT ps;
453     if (hdc) return PROGRESS_Draw (infoPtr, hdc);
454     hdc = BeginPaint (infoPtr->Self, &ps);
455     PROGRESS_Draw (infoPtr, hdc);
456     EndPaint (infoPtr->Self, &ps);
457     return 0;
458 }
459
460
461 /***********************************************************************
462  * PROGRESS_Timer
463  * Handle the marquee timer messages
464  */
465 static LRESULT PROGRESS_Timer (PROGRESS_INFO *infoPtr, INT idTimer)
466 {
467     if(idTimer == ID_MARQUEE_TIMER)
468     {
469         LONG style = GetWindowLongW (infoPtr->Self, GWL_STYLE);
470         RECT rect;
471         int ledWidth, leds;
472         HTHEME theme = GetWindowTheme (infoPtr->Self);
473         BOOL barSmooth = (style & PBS_SMOOTH) && !theme;
474
475         get_client_rect (infoPtr->Self, &rect);
476
477         if(!barSmooth)
478             ledWidth = get_led_size( infoPtr, style, &rect ) + 
479                 get_led_gap( infoPtr );
480         else
481             ledWidth = 1;
482
483         leds = (get_bar_size( style, &rect ) + ledWidth - 1) / 
484             ledWidth;
485
486         /* increment the marquee progress */
487         if(++infoPtr->MarqueePos >= leds)
488         {
489             infoPtr->MarqueePos = 0;
490         }
491
492         InvalidateRect(infoPtr->Self, &rect, FALSE);
493         UpdateWindow(infoPtr->Self);
494     }
495     return 0;
496 }
497
498
499 /***********************************************************************
500  *           PROGRESS_CoercePos
501  * Makes sure the current position (CurVal) is within bounds.
502  */
503 static void PROGRESS_CoercePos(PROGRESS_INFO *infoPtr)
504 {
505     if(infoPtr->CurVal < infoPtr->MinVal)
506         infoPtr->CurVal = infoPtr->MinVal;
507     if(infoPtr->CurVal > infoPtr->MaxVal)
508         infoPtr->CurVal = infoPtr->MaxVal;
509 }
510
511
512 /***********************************************************************
513  *           PROGRESS_SetFont
514  * Set new Font for progress bar
515  */
516 static HFONT PROGRESS_SetFont (PROGRESS_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
517 {
518     HFONT hOldFont = infoPtr->Font;
519     infoPtr->Font = hFont;
520     /* Since infoPtr->Font is not used, there is no need for repaint */
521     return hOldFont;
522 }
523
524 static DWORD PROGRESS_SetRange (PROGRESS_INFO *infoPtr, int low, int high)
525 {
526     DWORD res = MAKELONG(LOWORD(infoPtr->MinVal), LOWORD(infoPtr->MaxVal));
527
528     /* if nothing changes, simply return */
529     if(infoPtr->MinVal == low && infoPtr->MaxVal == high) return res;
530
531     infoPtr->MinVal = low;
532     infoPtr->MaxVal = high;
533     PROGRESS_CoercePos(infoPtr);
534     InvalidateRect(infoPtr->Self, NULL, TRUE);
535     return res;
536 }
537
538 /***********************************************************************
539  *           ProgressWindowProc
540  */
541 static LRESULT WINAPI ProgressWindowProc(HWND hwnd, UINT message,
542                                          WPARAM wParam, LPARAM lParam)
543 {
544     PROGRESS_INFO *infoPtr;
545     static const WCHAR themeClass[] = {'P','r','o','g','r','e','s','s',0};
546     HTHEME theme;
547
548     TRACE("hwnd=%p msg=%04x wparam=%lx lParam=%lx\n", hwnd, message, wParam, lParam);
549
550     infoPtr = (PROGRESS_INFO *)GetWindowLongPtrW(hwnd, 0);
551
552     if (!infoPtr && message != WM_CREATE)
553         return DefWindowProcW( hwnd, message, wParam, lParam );
554
555     switch(message) {
556     case WM_CREATE:
557     {
558         DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
559         
560         theme = OpenThemeData (hwnd, themeClass);
561
562         dwExStyle &= ~(WS_EX_CLIENTEDGE | WS_EX_WINDOWEDGE);
563         if (!theme) dwExStyle |= WS_EX_STATICEDGE;
564         SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle);
565         /* Force recalculation of a non-client area */
566         SetWindowPos(hwnd, 0, 0, 0, 0, 0,
567             SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
568
569         /* allocate memory for info struct */
570         infoPtr = (PROGRESS_INFO *)Alloc (sizeof(PROGRESS_INFO));
571         if (!infoPtr) return -1;
572         SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
573
574         /* initialize the info struct */
575         infoPtr->Self = hwnd;
576         infoPtr->MinVal = 0;
577         infoPtr->MaxVal = 100;
578         infoPtr->CurVal = 0;
579         infoPtr->Step = 10;
580         infoPtr->MarqueePos = 0;
581         infoPtr->Marquee = FALSE;
582         infoPtr->ColorBar = CLR_DEFAULT;
583         infoPtr->ColorBk = CLR_DEFAULT;
584         infoPtr->Font = 0;
585
586         TRACE("Progress Ctrl creation, hwnd=%p\n", hwnd);
587         return 0;
588     }
589
590     case WM_DESTROY:
591         TRACE("Progress Ctrl destruction, hwnd=%p\n", hwnd);
592         Free (infoPtr);
593         SetWindowLongPtrW(hwnd, 0, 0);
594         theme = GetWindowTheme (hwnd);
595         CloseThemeData (theme);
596         return 0;
597
598     case WM_ERASEBKGND:
599         return 1;
600
601     case WM_GETFONT:
602         return (LRESULT)infoPtr->Font;
603
604     case WM_SETFONT:
605         return (LRESULT)PROGRESS_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
606
607     case WM_PRINTCLIENT:
608     case WM_PAINT:
609         return PROGRESS_Paint (infoPtr, (HDC)wParam);
610
611     case WM_TIMER:
612         return PROGRESS_Timer (infoPtr, (INT)wParam);
613
614     case WM_THEMECHANGED:
615     {
616         DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
617         
618         theme = GetWindowTheme (hwnd);
619         CloseThemeData (theme);
620         theme = OpenThemeData (hwnd, themeClass);
621         
622         /* WS_EX_STATICEDGE disappears when the control is themed */
623         if (theme)
624             dwExStyle &= ~WS_EX_STATICEDGE;
625         else
626             dwExStyle |= WS_EX_STATICEDGE;
627         SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle);
628         
629         InvalidateRect (hwnd, NULL, FALSE);
630         return 0;
631     }
632
633     case PBM_DELTAPOS:
634     {
635         INT oldVal;
636         oldVal = infoPtr->CurVal;
637         if(wParam != 0) {
638             infoPtr->CurVal += (INT)wParam;
639             PROGRESS_CoercePos (infoPtr);
640             TRACE("PBM_DELTAPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
641             PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
642             UpdateWindow( infoPtr->Self );
643         }
644         return oldVal;
645     }
646
647     case PBM_SETPOS:
648     {
649         UINT oldVal;
650         oldVal = infoPtr->CurVal;
651         if(oldVal != wParam) {
652             infoPtr->CurVal = (INT)wParam;
653             PROGRESS_CoercePos(infoPtr);
654             TRACE("PBM_SETPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
655             PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
656             UpdateWindow( infoPtr->Self );
657         }
658         return oldVal;
659     }
660
661     case PBM_SETRANGE:
662         return PROGRESS_SetRange (infoPtr, (int)LOWORD(lParam), (int)HIWORD(lParam));
663
664     case PBM_SETSTEP:
665     {
666         INT oldStep;
667         oldStep = infoPtr->Step;
668         infoPtr->Step = (INT)wParam;
669         return oldStep;
670     }
671
672     case PBM_STEPIT:
673     {
674         INT oldVal;
675         oldVal = infoPtr->CurVal;
676         infoPtr->CurVal += infoPtr->Step;
677         if(infoPtr->CurVal > infoPtr->MaxVal)
678             infoPtr->CurVal = infoPtr->MinVal;
679         if(oldVal != infoPtr->CurVal)
680         {
681             TRACE("PBM_STEPIT: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
682             PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
683             UpdateWindow( infoPtr->Self );
684         }
685         return oldVal;
686     }
687
688     case PBM_SETRANGE32:
689         return PROGRESS_SetRange (infoPtr, (int)wParam, (int)lParam);
690
691     case PBM_GETRANGE:
692         if (lParam) {
693             ((PPBRANGE)lParam)->iLow = infoPtr->MinVal;
694             ((PPBRANGE)lParam)->iHigh = infoPtr->MaxVal;
695         }
696         return wParam ? infoPtr->MinVal : infoPtr->MaxVal;
697
698     case PBM_GETPOS:
699         return infoPtr->CurVal;
700
701     case PBM_SETBARCOLOR:
702         infoPtr->ColorBar = (COLORREF)lParam;
703         InvalidateRect(hwnd, NULL, TRUE);
704         return 0;
705
706     case PBM_SETBKCOLOR:
707         infoPtr->ColorBk = (COLORREF)lParam;
708         InvalidateRect(hwnd, NULL, TRUE);
709         return 0;
710
711     case PBM_SETMARQUEE:
712         if(wParam != 0)
713         {
714             infoPtr->Marquee = TRUE;
715             SetTimer(infoPtr->Self, ID_MARQUEE_TIMER, (UINT)lParam, NULL);
716         }
717         else
718         {
719             infoPtr->Marquee = FALSE;
720             KillTimer(infoPtr->Self, ID_MARQUEE_TIMER);
721         }
722         return infoPtr->Marquee;
723
724     default:
725         if ((message >= WM_USER) && (message < WM_APP))
726             ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam );
727         return DefWindowProcW( hwnd, message, wParam, lParam );
728     }
729 }
730
731
732 /***********************************************************************
733  * PROGRESS_Register [Internal]
734  *
735  * Registers the progress bar window class.
736  */
737 void PROGRESS_Register (void)
738 {
739     WNDCLASSW wndClass;
740
741     ZeroMemory (&wndClass, sizeof(wndClass));
742     wndClass.style         = CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
743     wndClass.lpfnWndProc   = (WNDPROC)ProgressWindowProc;
744     wndClass.cbClsExtra    = 0;
745     wndClass.cbWndExtra    = sizeof (PROGRESS_INFO *);
746     wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
747     wndClass.lpszClassName = PROGRESS_CLASSW;
748
749     RegisterClassW (&wndClass);
750 }
751
752
753 /***********************************************************************
754  * PROGRESS_Unregister [Internal]
755  *
756  * Unregisters the progress bar window class.
757  */
758 void PROGRESS_Unregister (void)
759 {
760     UnregisterClassW (PROGRESS_CLASSW, NULL);
761 }