?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shell32/tests: Some tests for IShellWindows.
[wine.git] / dlls / comctl32 / progress.c
blob1b8fcf7211fc04f4923c851e5439b96bf7d5e813
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 * TODO:
31 *
32 * Styles:
33 * -- PBS_SMOOTHREVERSE
34 *
35 */
36
37 #include <stdarg.h>
38 #include <string.h>
39 #include "windef.h"
40 #include "winbase.h"
41 #include "wingdi.h"
42 #include "winuser.h"
43 #include "winnls.h"
44 #include "commctrl.h"
45 #include "comctl32.h"
46 #include "uxtheme.h"
47 #include "vssym32.h"
48 #include "wine/debug.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(progress);
51
52 typedef struct
53 {
54 HWND Self; /* The window handle for this control */
55 INT CurVal; /* Current progress value */
56 INT MinVal; /* Minimum progress value */
57 INT MaxVal; /* Maximum progress value */
58 INT Step; /* Step to use on PMB_STEPIT */
59 INT MarqueePos; /* Marquee animation position */
60 BOOL Marquee; /* Whether the marquee animation is enabled */
61 COLORREF ColorBar; /* Bar color */
62 COLORREF ColorBk; /* Background color */
63 HFONT Font; /* Handle to font (not unused) */
64 } PROGRESS_INFO;
65
66 /* Control configuration constants */
67
68 #define LED_GAP 2
69 #define MARQUEE_LEDS 5
70 #define ID_MARQUEE_TIMER 1
71 #define DEFAULT_MARQUEE_PERIOD 30
72
73 /* Helper to obtain size of a progress bar chunk ("led"). */
74 static inline int get_led_size ( const PROGRESS_INFO *infoPtr, LONG style,
75 const RECT* rect )
76 {
77 HTHEME theme = GetWindowTheme (infoPtr->Self);
78 if (theme)
79 {
80 int chunkSize;
81 if (SUCCEEDED( GetThemeInt( theme, 0, 0, TMT_PROGRESSCHUNKSIZE, &chunkSize )))
82 return chunkSize;
83 }
84
85 if (style & PBS_VERTICAL)
86 return MulDiv (rect->right - rect->left, 2, 3);
87 else
88 return MulDiv (rect->bottom - rect->top, 2, 3);
89 }
90
91 /* Helper to obtain gap between progress bar chunks */
92 static inline int get_led_gap ( const PROGRESS_INFO *infoPtr )
93 {
94 HTHEME theme = GetWindowTheme (infoPtr->Self);
95 if (theme)
96 {
97 int spaceSize;
98 if (SUCCEEDED( GetThemeInt( theme, 0, 0, TMT_PROGRESSSPACESIZE, &spaceSize )))
99 return spaceSize;
100 }
101
102 return LED_GAP;
103 }
104
105 /* Get client rect. Takes into account that theming needs no adjustment. */
106 static inline void get_client_rect (HWND hwnd, RECT* rect)
107 {
108 HTHEME theme = GetWindowTheme (hwnd);
109 GetClientRect (hwnd, rect);
110 if (!theme)
111 InflateRect(rect, -1, -1);
112 else
113 {
114 DWORD dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
115 int part = (dwStyle & PBS_VERTICAL) ? PP_BARVERT : PP_BAR;
116 GetThemeBackgroundContentRect (theme, 0, part, 0, rect, rect);
117 }
118 }
119
120 /* Compute the extend of the bar */
121 static inline int get_bar_size( LONG style, const RECT* rect )
122 {
123 if (style & PBS_VERTICAL)
124 return rect->bottom - rect->top;
125 else
126 return rect->right - rect->left;
127 }
128
129 /* Compute the pixel position of a progress value */
130 static inline int get_bar_position( const PROGRESS_INFO *infoPtr, LONG style,
131 const RECT* rect, INT value )
132 {
133 return MulDiv (value - infoPtr->MinVal, get_bar_size (style, rect),
134 infoPtr->MaxVal - infoPtr->MinVal);
135 }
136
137 /***********************************************************************
138 * PROGRESS_Invalidate
139 *
140 * Don't be too clever about invalidating the progress bar.
141 * InstallShield depends on this simple behaviour.
142 */
143 static void PROGRESS_Invalidate( const PROGRESS_INFO *infoPtr, INT old, INT new )
144 {
145 InvalidateRect( infoPtr->Self, NULL, old > new );
146 }
147
148 /* Information for a progress bar drawing helper */
149 typedef struct tagProgressDrawInfo
150 {
151 HDC hdc;
152 RECT rect;
153 HBRUSH hbrBar;
154 HBRUSH hbrBk;
155 int ledW, ledGap;
156 HTHEME theme;
157 RECT bgRect;
158 } ProgressDrawInfo;
159
160 typedef void (*ProgressDrawProc)(const ProgressDrawInfo* di, int start, int end);
161
162 /* draw solid horizontal bar from 'start' to 'end' */
163 static void draw_solid_bar_H (const ProgressDrawInfo* di, int start, int end)
164 {
165 RECT r;
166 r.left = di->rect.left + start;
167 r.top = di->rect.top;
168 r.right = di->rect.left + end;
169 r.bottom = di->rect.bottom;
170 FillRect (di->hdc, &r, di->hbrBar);
171 }
172
173 /* draw solid horizontal background from 'start' to 'end' */
174 static void draw_solid_bkg_H (const ProgressDrawInfo* di, int start, int end)
175 {
176 RECT r;
177 r.left = di->rect.left + start;
178 r.top = di->rect.top;
179 r.right = di->rect.left + end;
180 r.bottom = di->rect.bottom;
181 FillRect (di->hdc, &r, di->hbrBk);
182 }
183
184 /* draw solid vertical bar from 'start' to 'end' */
185 static void draw_solid_bar_V (const ProgressDrawInfo* di, int start, int end)
186 {
187 RECT r;
188 r.left = di->rect.left;
189 r.top = di->rect.bottom - end;
190 r.right = di->rect.right;
191 r.bottom = di->rect.bottom - start;
192 FillRect (di->hdc, &r, di->hbrBar);
193 }
194
195 /* draw solid vertical background from 'start' to 'end' */
196 static void draw_solid_bkg_V (const ProgressDrawInfo* di, int start, int end)
197 {
198 RECT r;
199 r.left = di->rect.left;
200 r.top = di->rect.bottom - end;
201 r.right = di->rect.right;
202 r.bottom = di->rect.bottom - start;
203 FillRect (di->hdc, &r, di->hbrBk);
204 }
205
206 /* draw chunky horizontal bar from 'start' to 'end' */
207 static void draw_chunk_bar_H (const ProgressDrawInfo* di, int start, int end)
208 {
209 RECT r;
210 int right = di->rect.left + end;
211 r.left = di->rect.left + start;
212 r.top = di->rect.top;
213 r.bottom = di->rect.bottom;
214 while (r.left < right)
215 {
216 r.right = min (r.left + di->ledW, right);
217 FillRect (di->hdc, &r, di->hbrBar);
218 r.left = r.right;
219 r.right = min (r.left + di->ledGap, right);
220 FillRect (di->hdc, &r, di->hbrBk);
221 r.left = r.right;
222 }
223 }
224
225 /* draw chunky vertical bar from 'start' to 'end' */
226 static void draw_chunk_bar_V (const ProgressDrawInfo* di, int start, int end)
227 {
228 RECT r;
229 int top = di->rect.bottom - end;
230 r.left = di->rect.left;
231 r.right = di->rect.right;
232 r.bottom = di->rect.bottom - start;
233 while (r.bottom > top)
234 {
235 r.top = max (r.bottom - di->ledW, top);
236 FillRect (di->hdc, &r, di->hbrBar);
237 r.bottom = r.top;
238 r.top = max (r.bottom - di->ledGap, top);
239 FillRect (di->hdc, &r, di->hbrBk);
240 r.bottom = r.top;
241 }
242 }
243
244 /* drawing functions for "classic" style */
245 static const ProgressDrawProc drawProcClassic[8] = {
246 /* Smooth */
247 /* Horizontal */
248 draw_solid_bar_H, draw_solid_bkg_H,
249 /* Vertical */
250 draw_solid_bar_V, draw_solid_bkg_V,
251 /* Chunky */
252 /* Horizontal */
253 draw_chunk_bar_H, draw_solid_bkg_H,
254 /* Vertical */
255 draw_chunk_bar_V, draw_solid_bkg_V,
256 };
257
258 /* draw themed horizontal bar from 'start' to 'end' */
259 static void draw_theme_bar_H (const ProgressDrawInfo* di, int start, int end)
260 {
261 RECT r;
262 r.left = di->rect.left + start;
263 r.top = di->rect.top;
264 r.bottom = di->rect.bottom;
265 r.right = di->rect.left + end;
266 DrawThemeBackground (di->theme, di->hdc, PP_CHUNK, 0, &r, NULL);
267 }
268
269 /* draw themed vertical bar from 'start' to 'end' */
270 static void draw_theme_bar_V (const ProgressDrawInfo* di, int start, int end)
271 {
272 RECT r;
273 r.left = di->rect.left;
274 r.right = di->rect.right;
275 r.bottom = di->rect.bottom - start;
276 r.top = di->rect.bottom - end;
277 DrawThemeBackground (di->theme, di->hdc, PP_CHUNKVERT, 0, &r, NULL);
278 }
279
280 /* draw themed horizontal background from 'start' to 'end' */
281 static void draw_theme_bkg_H (const ProgressDrawInfo* di, int start, int end)
282 {
283 RECT bgrect, r;
284
285 r.left = di->rect.left + start;
286 r.top = di->rect.top;
287 r.right = di->rect.left + end;
288 r.bottom = di->rect.bottom;
289
290 bgrect = di->bgRect;
291 OffsetRect(&bgrect, -bgrect.left, -bgrect.top);
292
293 DrawThemeBackground (di->theme, di->hdc, PP_BAR, 0, &bgrect, &r);
294 }
295
296 /* draw themed vertical background from 'start' to 'end' */
297 static void draw_theme_bkg_V (const ProgressDrawInfo* di, int start, int end)
298 {
299 RECT bgrect, r;
300
301 r.left = di->rect.left;
302 r.top = di->rect.bottom - end;
303 r.right = di->rect.right;
304 r.bottom = di->rect.bottom - start;
305
306 bgrect = di->bgRect;
307 OffsetRect(&bgrect, -bgrect.left, -bgrect.top);
308
309 DrawThemeBackground (di->theme, di->hdc, PP_BARVERT, 0, &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 MapWindowPoints( infoPtr->Self, 0, (POINT*)&pdi.bgRect, 2 );
390 }
391
392 if (!barSmooth)
393 pdi.ledW = get_led_size( infoPtr, dwStyle, &pdi.rect);
394 pdi.ledGap = get_led_gap( infoPtr );
395
396 if (dwStyle & PBS_MARQUEE)
397 {
398 const int ledW = !barSmooth ? (pdi.ledW + pdi.ledGap) : 1;
399 const int leds = (barSize + ledW - 1) / ledW;
400 const int ledMEnd = infoPtr->MarqueePos + MARQUEE_LEDS;
401
402 if (ledMEnd > leds)
403 {
404 /* case 1: the marquee bar extends over the end and wraps around to
405 * the start */
406 const int gapStart = max((ledMEnd - leds) * ledW, 0);
407 const int gapEnd = min(infoPtr->MarqueePos * ledW, barSize);
408
409 drawProcs[0]( &pdi, 0, gapStart);
410 drawProcs[1]( &pdi, gapStart, gapEnd);
411 drawProcs[0]( &pdi, gapEnd, barSize);
412 }
413 else
414 {
415 /* case 2: the marquee bar is between start and end */
416 const int barStart = infoPtr->MarqueePos * ledW;
417 const int barEnd = min (ledMEnd * ledW, barSize);
418
419 drawProcs[1]( &pdi, 0, barStart);
420 drawProcs[0]( &pdi, barStart, barEnd);
421 drawProcs[1]( &pdi, barEnd, barSize);
422 }
423 }
424 else
425 {
426 int barEnd = get_bar_position( infoPtr, dwStyle, &pdi.rect,
427 infoPtr->CurVal);
428 if (!barSmooth)
429 {
430 const int ledW = pdi.ledW + pdi.ledGap;
431 barEnd = min (((barEnd + ledW - 1) / ledW) * ledW, barSize);
432 }
433 drawProcs[0]( &pdi, 0, barEnd);
434 drawProcs[1]( &pdi, barEnd, barSize);
435 }
436
437 /* delete bar brush */
438 if (infoPtr->ColorBar != CLR_DEFAULT) DeleteObject (pdi.hbrBar);
439 if (infoPtr->ColorBk != CLR_DEFAULT) DeleteObject (pdi.hbrBk);
440
441 return 0;
442 }
443
444 /***********************************************************************
445 * PROGRESS_Paint
446 * Draw the progress bar. The background need not be erased.
447 * If dc!=0, it draws on it
448 */
449 static LRESULT PROGRESS_Paint (PROGRESS_INFO *infoPtr, HDC hdc)
450 {
451 PAINTSTRUCT ps;
452 if (hdc) return PROGRESS_Draw (infoPtr, hdc);
453 hdc = BeginPaint (infoPtr->Self, &ps);
454 PROGRESS_Draw (infoPtr, hdc);
455 EndPaint (infoPtr->Self, &ps);
456 return 0;
457 }
458
459
460 /***********************************************************************
461 * Advance marquee progress by one step.
462 */
463 static void PROGRESS_UpdateMarquee (PROGRESS_INFO *infoPtr)
464 {
465 LONG style = GetWindowLongW (infoPtr->Self, GWL_STYLE);
466 RECT rect;
467 int ledWidth, leds;
468 HTHEME theme = GetWindowTheme (infoPtr->Self);
469 BOOL smooth = (style & PBS_SMOOTH) && !theme;
470
471 get_client_rect (infoPtr->Self, &rect);
472
473 if (smooth)
474 ledWidth = 1;
475 else
476 ledWidth = get_led_size( infoPtr, style, &rect ) + get_led_gap( infoPtr );
477
478 leds = (get_bar_size( style, &rect ) + ledWidth - 1) /
479 ledWidth;
480
481 /* increment the marquee progress */
482 if (++infoPtr->MarqueePos >= leds)
483 infoPtr->MarqueePos = 0;
484
485 InvalidateRect(infoPtr->Self, &rect, TRUE);
486 UpdateWindow(infoPtr->Self);
487 }
488
489
490 /***********************************************************************
491 * PROGRESS_CoercePos
492 * Makes sure the current position (CurVal) is within bounds.
493 */
494 static void PROGRESS_CoercePos(PROGRESS_INFO *infoPtr)
495 {
496 if(infoPtr->CurVal < infoPtr->MinVal)
497 infoPtr->CurVal = infoPtr->MinVal;
498 if(infoPtr->CurVal > infoPtr->MaxVal)
499 infoPtr->CurVal = infoPtr->MaxVal;
500 }
501
502
503 /***********************************************************************
504 * PROGRESS_SetFont
505 * Set new Font for progress bar
506 */
507 static HFONT PROGRESS_SetFont (PROGRESS_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
508 {
509 HFONT hOldFont = infoPtr->Font;
510 infoPtr->Font = hFont;
511 /* Since infoPtr->Font is not used, there is no need for repaint */
512 return hOldFont;
513 }
514
515 static DWORD PROGRESS_SetRange (PROGRESS_INFO *infoPtr, int low, int high)
516 {
517 DWORD res = MAKELONG(LOWORD(infoPtr->MinVal), LOWORD(infoPtr->MaxVal));
518
519 /* if nothing changes, simply return */
520 if(infoPtr->MinVal == low && infoPtr->MaxVal == high) return res;
521
522 infoPtr->MinVal = low;
523 infoPtr->MaxVal = high;
524 PROGRESS_CoercePos(infoPtr);
525 InvalidateRect(infoPtr->Self, NULL, TRUE);
526 return res;
527 }
528
529 static UINT PROGRESS_SetPos (PROGRESS_INFO *infoPtr, INT pos)
530 {
531 DWORD style = GetWindowLongW(infoPtr->Self, GWL_STYLE);
532
533 if (style & PBS_MARQUEE)
534 {
535 PROGRESS_UpdateMarquee(infoPtr);
536 return 1;
537 }
538 else
539 {
540 UINT oldVal;
541 oldVal = infoPtr->CurVal;
542 if (oldVal != pos) {
543 infoPtr->CurVal = pos;
544 PROGRESS_CoercePos(infoPtr);
545 TRACE("PBM_SETPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
546 PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
547 UpdateWindow( infoPtr->Self );
548 }
549 return oldVal;
550 }
551 }
552
553 /***********************************************************************
554 * ProgressWindowProc
555 */
556 static LRESULT WINAPI ProgressWindowProc(HWND hwnd, UINT message,
557 WPARAM wParam, LPARAM lParam)
558 {
559 PROGRESS_INFO *infoPtr;
560 static const WCHAR themeClass[] = {'P','r','o','g','r','e','s','s',0};
561 HTHEME theme;
562
563 TRACE("hwnd=%p msg=%04x wparam=%lx lParam=%lx\n", hwnd, message, wParam, lParam);
564
565 infoPtr = (PROGRESS_INFO *)GetWindowLongPtrW(hwnd, 0);
566
567 if (!infoPtr && message != WM_CREATE)
568 return DefWindowProcW( hwnd, message, wParam, lParam );
569
570 switch(message) {
571 case WM_CREATE:
572 {
573 DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
574
575 theme = OpenThemeData (hwnd, themeClass);
576
577 dwExStyle &= ~(WS_EX_CLIENTEDGE | WS_EX_WINDOWEDGE);
578 if (!theme) dwExStyle |= WS_EX_STATICEDGE;
579 SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle);
580 /* Force recalculation of a non-client area */
581 SetWindowPos(hwnd, 0, 0, 0, 0, 0,
582 SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
583
584 /* allocate memory for info struct */
585 infoPtr = Alloc (sizeof(PROGRESS_INFO));
586 if (!infoPtr) return -1;
587 SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
588
589 /* initialize the info struct */
590 infoPtr->Self = hwnd;
591 infoPtr->MinVal = 0;
592 infoPtr->MaxVal = 100;
593 infoPtr->CurVal = 0;
594 infoPtr->Step = 10;
595 infoPtr->MarqueePos = 0;
596 infoPtr->Marquee = FALSE;
597 infoPtr->ColorBar = CLR_DEFAULT;
598 infoPtr->ColorBk = CLR_DEFAULT;
599 infoPtr->Font = 0;
600
601 TRACE("Progress Ctrl creation, hwnd=%p\n", hwnd);
602 return 0;
603 }
604
605 case WM_DESTROY:
606 TRACE("Progress Ctrl destruction, hwnd=%p\n", hwnd);
607 Free (infoPtr);
608 SetWindowLongPtrW(hwnd, 0, 0);
609 theme = GetWindowTheme (hwnd);
610 CloseThemeData (theme);
611 return 0;
612
613 case WM_ERASEBKGND:
614 return 1;
615
616 case WM_GETFONT:
617 return (LRESULT)infoPtr->Font;
618
619 case WM_SETFONT:
620 return (LRESULT)PROGRESS_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
621
622 case WM_PRINTCLIENT:
623 case WM_PAINT:
624 return PROGRESS_Paint (infoPtr, (HDC)wParam);
625
626 case WM_TIMER:
627 if (wParam == ID_MARQUEE_TIMER)
628 PROGRESS_UpdateMarquee (infoPtr);
629 return 0;
630
631 case WM_THEMECHANGED:
632 {
633 DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
634
635 theme = GetWindowTheme (hwnd);
636 CloseThemeData (theme);
637 theme = OpenThemeData (hwnd, themeClass);
638
639 /* WS_EX_STATICEDGE disappears when the control is themed */
640 if (theme)
641 dwExStyle &= ~WS_EX_STATICEDGE;
642 else
643 dwExStyle |= WS_EX_STATICEDGE;
644 SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle);
645
646 InvalidateRect (hwnd, NULL, FALSE);
647 return 0;
648 }
649
650 case PBM_DELTAPOS:
651 {
652 INT oldVal;
653 oldVal = infoPtr->CurVal;
654 if(wParam != 0) {
655 infoPtr->CurVal += (INT)wParam;
656 PROGRESS_CoercePos (infoPtr);
657 TRACE("PBM_DELTAPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
658 PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
659 UpdateWindow( infoPtr->Self );
660 }
661 return oldVal;
662 }
663
664 case PBM_SETPOS:
665 return PROGRESS_SetPos(infoPtr, wParam);
666
667 case PBM_SETRANGE:
668 return PROGRESS_SetRange (infoPtr, (int)LOWORD(lParam), (int)HIWORD(lParam));
669
670 case PBM_SETSTEP:
671 {
672 INT oldStep;
673 oldStep = infoPtr->Step;
674 infoPtr->Step = (INT)wParam;
675 return oldStep;
676 }
677
678 case PBM_GETSTEP:
679 return infoPtr->Step;
680
681 case PBM_STEPIT:
682 {
683 INT oldVal;
684 oldVal = infoPtr->CurVal;
685 infoPtr->CurVal += infoPtr->Step;
686 if(infoPtr->CurVal > infoPtr->MaxVal)
687 infoPtr->CurVal = infoPtr->MinVal;
688 if(oldVal != infoPtr->CurVal)
689 {
690 TRACE("PBM_STEPIT: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
691 PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
692 UpdateWindow( infoPtr->Self );
693 }
694 return oldVal;
695 }
696
697 case PBM_SETRANGE32:
698 return PROGRESS_SetRange (infoPtr, (int)wParam, (int)lParam);
699
700 case PBM_GETRANGE:
701 if (lParam) {
702 ((PPBRANGE)lParam)->iLow = infoPtr->MinVal;
703 ((PPBRANGE)lParam)->iHigh = infoPtr->MaxVal;
704 }
705 return wParam ? infoPtr->MinVal : infoPtr->MaxVal;
706
707 case PBM_GETPOS:
708 return infoPtr->CurVal;
709
710 case PBM_SETBARCOLOR:
711 {
712 COLORREF clr = infoPtr->ColorBar;
713
714 infoPtr->ColorBar = (COLORREF)lParam;
715 InvalidateRect(hwnd, NULL, TRUE);
716 return clr;
717 }
718
719 case PBM_GETBARCOLOR:
720 return infoPtr->ColorBar;
721
722 case PBM_SETBKCOLOR:
723 {
724 COLORREF clr = infoPtr->ColorBk;
725
726 infoPtr->ColorBk = (COLORREF)lParam;
727 InvalidateRect(hwnd, NULL, TRUE);
728 return clr;
729 }
730
731 case PBM_GETBKCOLOR:
732 return infoPtr->ColorBk;
733
734 case PBM_SETSTATE:
735 if(wParam != PBST_NORMAL)
736 FIXME("state %04lx not yet handled\n", wParam);
737 return PBST_NORMAL;
738
739 case PBM_GETSTATE:
740 return PBST_NORMAL;
741
742 case PBM_SETMARQUEE:
743 if(wParam != 0)
744 {
745 UINT period = lParam ? (UINT)lParam : DEFAULT_MARQUEE_PERIOD;
746 infoPtr->Marquee = TRUE;
747 SetTimer(infoPtr->Self, ID_MARQUEE_TIMER, period, NULL);
748 }
749 else
750 {
751 infoPtr->Marquee = FALSE;
752 KillTimer(infoPtr->Self, ID_MARQUEE_TIMER);
753 }
754 return infoPtr->Marquee;
755
756 default:
757 if ((message >= WM_USER) && (message < WM_APP) && !COMCTL32_IsReflectedMessage(message))
758 ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam );
759 return DefWindowProcW( hwnd, message, wParam, lParam );
760 }
761 }
762
763
764 /***********************************************************************
765 * PROGRESS_Register [Internal]
766 *
767 * Registers the progress bar window class.
768 */
769 void PROGRESS_Register (void)
770 {
771 WNDCLASSW wndClass;
772
773 ZeroMemory (&wndClass, sizeof(wndClass));
774 wndClass.style = CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
775 wndClass.lpfnWndProc = ProgressWindowProc;
776 wndClass.cbClsExtra = 0;
777 wndClass.cbWndExtra = sizeof (PROGRESS_INFO *);
778 wndClass.hCursor = LoadCursorW (0, (LPWSTR)IDC_ARROW);
779 wndClass.lpszClassName = PROGRESS_CLASSW;
780
781 RegisterClassW (&wndClass);
782 }
783
784
785 /***********************************************************************
786 * PROGRESS_Unregister [Internal]
787 *
788 * Unregisters the progress bar window class.
789 */
790 void PROGRESS_Unregister (void)
791 {
792 UnregisterClassW (PROGRESS_CLASSW, NULL);
793 }
Windows API implementation