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 }
762
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.