ReactOS  0.4.14-dev-390-g34947ad
progress.c
Go to the documentation of this file.
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  * TODO:
22  *
23  * Styles:
24  * -- PBS_SMOOTHREVERSE
25  *
26  */
27 
28 #include <stdarg.h>
29 #include <string.h>
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "winnls.h"
35 #include "commctrl.h"
36 #include "comctl32.h"
37 #include "uxtheme.h"
38 #include "vssym32.h"
39 #include "wine/debug.h"
40 #include "wine/heap.h"
41 
43 
44 typedef struct
45 {
46  HWND Self; /* The window handle for this control */
47  INT CurVal; /* Current progress value */
48  INT MinVal; /* Minimum progress value */
49  INT MaxVal; /* Maximum progress value */
50  INT Step; /* Step to use on PMB_STEPIT */
51  INT MarqueePos; /* Marquee animation position */
52  BOOL Marquee; /* Whether the marquee animation is enabled */
53  COLORREF ColorBar; /* Bar color */
54  COLORREF ColorBk; /* Background color */
55  HFONT Font; /* Handle to font (not unused) */
57 
58 /* Control configuration constants */
59 
60 #define LED_GAP 2
61 #define MARQUEE_LEDS 5
62 #define ID_MARQUEE_TIMER 1
63 #define DEFAULT_MARQUEE_PERIOD 30
64 
65 /* Helper to obtain size of a progress bar chunk ("led"). */
66 static inline int get_led_size ( const PROGRESS_INFO *infoPtr, LONG style,
67  const RECT* rect )
68 {
69  HTHEME theme = GetWindowTheme (infoPtr->Self);
70  if (theme)
71  {
72  int chunkSize;
73  if (SUCCEEDED( GetThemeInt( theme, 0, 0, TMT_PROGRESSCHUNKSIZE, &chunkSize )))
74  return chunkSize;
75  }
76 
77  if (style & PBS_VERTICAL)
78  return MulDiv (rect->right - rect->left, 2, 3);
79  else
80  return MulDiv (rect->bottom - rect->top, 2, 3);
81 }
82 
83 /* Helper to obtain gap between progress bar chunks */
84 static inline int get_led_gap ( const PROGRESS_INFO *infoPtr )
85 {
86  HTHEME theme = GetWindowTheme (infoPtr->Self);
87  if (theme)
88  {
89  int spaceSize;
90  if (SUCCEEDED( GetThemeInt( theme, 0, 0, TMT_PROGRESSSPACESIZE, &spaceSize )))
91  return spaceSize;
92  }
93 
94  return LED_GAP;
95 }
96 
97 /* Get client rect. Takes into account that theming needs no adjustment. */
98 static inline void get_client_rect (HWND hwnd, RECT* rect)
99 {
100  HTHEME theme = GetWindowTheme (hwnd);
102  if (!theme)
103  InflateRect(rect, -1, -1);
104  else
105  {
106  DWORD dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
107  int part = (dwStyle & PBS_VERTICAL) ? PP_BARVERT : PP_BAR;
108  GetThemeBackgroundContentRect (theme, 0, part, 0, rect, rect);
109  }
110 }
111 
112 /* Compute the extend of the bar */
113 static inline int get_bar_size( LONG style, const RECT* rect )
114 {
115  if (style & PBS_VERTICAL)
116  return rect->bottom - rect->top;
117  else
118  return rect->right - rect->left;
119 }
120 
121 /* Compute the pixel position of a progress value */
122 static inline int get_bar_position( const PROGRESS_INFO *infoPtr, LONG style,
123  const RECT* rect, INT value )
124 {
125  return MulDiv (value - infoPtr->MinVal, get_bar_size (style, rect),
126  infoPtr->MaxVal - infoPtr->MinVal);
127 }
128 
129 /***********************************************************************
130  * PROGRESS_Invalidate
131  *
132  * Don't be too clever about invalidating the progress bar.
133  * InstallShield depends on this simple behaviour.
134  */
135 static void PROGRESS_Invalidate( const PROGRESS_INFO *infoPtr, INT old, INT new )
136 {
137  InvalidateRect( infoPtr->Self, NULL, old > new );
138 }
139 
140 /* Information for a progress bar drawing helper */
141 typedef struct tagProgressDrawInfo
142 {
145  HBRUSH hbrBar;
146  HBRUSH hbrBk;
147  int ledW, ledGap;
151 
152 typedef void (*ProgressDrawProc)(const ProgressDrawInfo* di, int start, int end);
153 
154 /* draw solid horizontal bar from 'start' to 'end' */
155 static void draw_solid_bar_H (const ProgressDrawInfo* di, int start, int end)
156 {
157  RECT r;
158  SetRect(&r, di->rect.left + start, di->rect.top, di->rect.left + end, di->rect.bottom);
159  FillRect (di->hdc, &r, di->hbrBar);
160 }
161 
162 /* draw solid horizontal background from 'start' to 'end' */
163 static void draw_solid_bkg_H (const ProgressDrawInfo* di, int start, int end)
164 {
165  RECT r;
166  SetRect(&r, di->rect.left + start, di->rect.top, di->rect.left + end, di->rect.bottom);
167  FillRect (di->hdc, &r, di->hbrBk);
168 }
169 
170 /* draw solid vertical bar from 'start' to 'end' */
171 static void draw_solid_bar_V (const ProgressDrawInfo* di, int start, int end)
172 {
173  RECT r;
174  SetRect(&r, di->rect.left, di->rect.bottom - end, di->rect.right, di->rect.bottom - start);
175  FillRect (di->hdc, &r, di->hbrBar);
176 }
177 
178 /* draw solid vertical background from 'start' to 'end' */
179 static void draw_solid_bkg_V (const ProgressDrawInfo* di, int start, int end)
180 {
181  RECT r;
182  SetRect(&r, di->rect.left, di->rect.bottom - end, di->rect.right, di->rect.bottom - start);
183  FillRect (di->hdc, &r, di->hbrBk);
184 }
185 
186 /* draw chunky horizontal bar from 'start' to 'end' */
187 static void draw_chunk_bar_H (const ProgressDrawInfo* di, int start, int end)
188 {
189  RECT r;
190  int right = di->rect.left + end;
191  r.left = di->rect.left + start;
192  r.top = di->rect.top;
193  r.bottom = di->rect.bottom;
194  while (r.left < right)
195  {
196  r.right = min (r.left + di->ledW, right);
197  FillRect (di->hdc, &r, di->hbrBar);
198  r.left = r.right;
199  r.right = min (r.left + di->ledGap, right);
200  FillRect (di->hdc, &r, di->hbrBk);
201  r.left = r.right;
202  }
203 }
204 
205 /* draw chunky vertical bar from 'start' to 'end' */
206 static void draw_chunk_bar_V (const ProgressDrawInfo* di, int start, int end)
207 {
208  RECT r;
209  int top = di->rect.bottom - end;
210  r.left = di->rect.left;
211  r.right = di->rect.right;
212  r.bottom = di->rect.bottom - start;
213  while (r.bottom > top)
214  {
215  r.top = max (r.bottom - di->ledW, top);
216  FillRect (di->hdc, &r, di->hbrBar);
217  r.bottom = r.top;
218  r.top = max (r.bottom - di->ledGap, top);
219  FillRect (di->hdc, &r, di->hbrBk);
220  r.bottom = r.top;
221  }
222 }
223 
224 /* drawing functions for "classic" style */
226  /* Smooth */
227  /* Horizontal */
229  /* Vertical */
231  /* Chunky */
232  /* Horizontal */
234  /* Vertical */
236 };
237 
238 /* draw themed horizontal bar from 'start' to 'end' */
239 static void draw_theme_bar_H (const ProgressDrawInfo* di, int start, int end)
240 {
241  RECT r;
242  r.left = di->rect.left + start;
243  r.top = di->rect.top;
244  r.bottom = di->rect.bottom;
245  r.right = di->rect.left + end;
246  DrawThemeBackground (di->theme, di->hdc, PP_CHUNK, 0, &r, NULL);
247 }
248 
249 /* draw themed vertical bar from 'start' to 'end' */
250 static void draw_theme_bar_V (const ProgressDrawInfo* di, int start, int end)
251 {
252  RECT r;
253  r.left = di->rect.left;
254  r.right = di->rect.right;
255  r.bottom = di->rect.bottom - start;
256  r.top = di->rect.bottom - end;
257  DrawThemeBackground (di->theme, di->hdc, PP_CHUNKVERT, 0, &r, NULL);
258 }
259 
260 /* draw themed horizontal background from 'start' to 'end' */
261 static void draw_theme_bkg_H (const ProgressDrawInfo* di, int start, int end)
262 {
263  RECT bgrect, r;
264 
265  SetRect(&r, di->rect.left + start, di->rect.top, di->rect.left + end, di->rect.bottom);
266  bgrect = di->bgRect;
267  OffsetRect(&bgrect, -bgrect.left, -bgrect.top);
268 
269  DrawThemeBackground (di->theme, di->hdc, PP_BAR, 0, &bgrect, &r);
270 }
271 
272 /* draw themed vertical background from 'start' to 'end' */
273 static void draw_theme_bkg_V (const ProgressDrawInfo* di, int start, int end)
274 {
275  RECT bgrect, r;
276 
277  SetRect(&r, di->rect.left, di->rect.bottom - end, di->rect.right, di->rect.bottom - start);
278  bgrect = di->bgRect;
279  OffsetRect(&bgrect, -bgrect.left, -bgrect.top);
280 
281  DrawThemeBackground (di->theme, di->hdc, PP_BARVERT, 0, &bgrect, &r);
282 }
283 
284 /* drawing functions for themed style */
285 static const ProgressDrawProc drawProcThemed[8] = {
286  /* Smooth */
287  /* Horizontal */
289  /* Vertical */
291  /* Chunky */
292  /* Horizontal */
294  /* Vertical */
296 };
297 
298 /***********************************************************************
299  * PROGRESS_Draw
300  * Draws the progress bar.
301  */
303 {
304  int barSize;
305  DWORD dwStyle;
306  BOOL barSmooth;
307  const ProgressDrawProc* drawProcs;
309 
310  TRACE("(infoPtr=%p, hdc=%p)\n", infoPtr, hdc);
311 
312  pdi.hdc = hdc;
313  pdi.theme = GetWindowTheme (infoPtr->Self);
314 
315  /* get the required bar brush */
316  if (infoPtr->ColorBar == CLR_DEFAULT)
318  else
319  pdi.hbrBar = CreateSolidBrush (infoPtr->ColorBar);
320 
321  if (infoPtr->ColorBk == CLR_DEFAULT)
323  else
324  pdi.hbrBk = CreateSolidBrush(infoPtr->ColorBk);
325 
326  /* get the window style */
327  dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
328 
329  /* get client rectangle */
330  GetClientRect (infoPtr->Self, &pdi.rect);
331  if (!pdi.theme) {
332  FrameRect( hdc, &pdi.rect, pdi.hbrBk );
333  InflateRect(&pdi.rect, -1, -1);
334  }
335  else
336  {
337  RECT cntRect;
338  int part = (dwStyle & PBS_VERTICAL) ? PP_BARVERT : PP_BAR;
339 
340  GetThemeBackgroundContentRect (pdi.theme, hdc, part, 0, &pdi.rect,
341  &cntRect);
342 
343  /* Exclude content rect - content background will be drawn later */
344  ExcludeClipRect (hdc, cntRect.left, cntRect.top,
345  cntRect.right, cntRect.bottom);
346  if (IsThemeBackgroundPartiallyTransparent (pdi.theme, part, 0))
347  DrawThemeParentBackground (infoPtr->Self, hdc, NULL);
348  DrawThemeBackground (pdi.theme, hdc, part, 0, &pdi.rect, NULL);
350  pdi.rect = cntRect;
351  }
352 
353  /* compute some drawing parameters */
354  barSmooth = (dwStyle & PBS_SMOOTH) && !pdi.theme;
355  drawProcs = &((pdi.theme ? drawProcThemed : drawProcClassic)[(barSmooth ? 0 : 4)
356  + ((dwStyle & PBS_VERTICAL) ? 2 : 0)]);
357  barSize = get_bar_size( dwStyle, &pdi.rect );
358  if (pdi.theme)
359  {
360  GetWindowRect( infoPtr->Self, &pdi.bgRect );
361  MapWindowPoints( infoPtr->Self, 0, (POINT*)&pdi.bgRect, 2 );
362  }
363 
364  if (!barSmooth)
365  pdi.ledW = get_led_size( infoPtr, dwStyle, &pdi.rect);
366  pdi.ledGap = get_led_gap( infoPtr );
367 
368  if (dwStyle & PBS_MARQUEE)
369  {
370  const int ledW = !barSmooth ? (pdi.ledW + pdi.ledGap) : 1;
371  const int leds = (barSize + ledW - 1) / ledW;
372  const int ledMEnd = infoPtr->MarqueePos + MARQUEE_LEDS;
373 
374  if (ledMEnd > leds)
375  {
376  /* case 1: the marquee bar extends over the end and wraps around to
377  * the start */
378  const int gapStart = max((ledMEnd - leds) * ledW, 0);
379  const int gapEnd = min(infoPtr->MarqueePos * ledW, barSize);
380 
381  drawProcs[0]( &pdi, 0, gapStart);
382  drawProcs[1]( &pdi, gapStart, gapEnd);
383  drawProcs[0]( &pdi, gapEnd, barSize);
384  }
385  else
386  {
387  /* case 2: the marquee bar is between start and end */
388  const int barStart = infoPtr->MarqueePos * ledW;
389  const int barEnd = min (ledMEnd * ledW, barSize);
390 
391  drawProcs[1]( &pdi, 0, barStart);
392  drawProcs[0]( &pdi, barStart, barEnd);
393  drawProcs[1]( &pdi, barEnd, barSize);
394  }
395  }
396  else
397  {
398  int barEnd = get_bar_position( infoPtr, dwStyle, &pdi.rect,
399  infoPtr->CurVal);
400  if (!barSmooth)
401  {
402  const int ledW = pdi.ledW + pdi.ledGap;
403  barEnd = min (((barEnd + ledW - 1) / ledW) * ledW, barSize);
404  }
405  drawProcs[0]( &pdi, 0, barEnd);
406  drawProcs[1]( &pdi, barEnd, barSize);
407  }
408 
409  /* delete bar brush */
410  if (infoPtr->ColorBar != CLR_DEFAULT) DeleteObject (pdi.hbrBar);
411  if (infoPtr->ColorBk != CLR_DEFAULT) DeleteObject (pdi.hbrBk);
412 
413  return 0;
414 }
415 
416 /***********************************************************************
417  * PROGRESS_Paint
418  * Draw the progress bar. The background need not be erased.
419  * If dc!=0, it draws on it
420  */
422 {
423  PAINTSTRUCT ps;
424  if (hdc) return PROGRESS_Draw (infoPtr, hdc);
425  hdc = BeginPaint (infoPtr->Self, &ps);
426  PROGRESS_Draw (infoPtr, hdc);
427  EndPaint (infoPtr->Self, &ps);
428  return 0;
429 }
430 
431 
432 /***********************************************************************
433  * Advance marquee progress by one step.
434  */
435 static void PROGRESS_UpdateMarquee (PROGRESS_INFO *infoPtr)
436 {
437  LONG style = GetWindowLongW (infoPtr->Self, GWL_STYLE);
438  RECT rect;
439  int ledWidth, leds;
440  HTHEME theme = GetWindowTheme (infoPtr->Self);
441  BOOL smooth = (style & PBS_SMOOTH) && !theme;
442 
443  get_client_rect (infoPtr->Self, &rect);
444 
445  if (smooth)
446  ledWidth = 1;
447  else
448  ledWidth = get_led_size( infoPtr, style, &rect ) + get_led_gap( infoPtr );
449 
450  leds = (get_bar_size( style, &rect ) + ledWidth - 1) /
451  ledWidth;
452 
453  /* increment the marquee progress */
454  if (++infoPtr->MarqueePos >= leds)
455  infoPtr->MarqueePos = 0;
456 
457  InvalidateRect(infoPtr->Self, &rect, TRUE);
458  UpdateWindow(infoPtr->Self);
459 }
460 
461 
462 /***********************************************************************
463  * PROGRESS_CoercePos
464  * Makes sure the current position (CurVal) is within bounds.
465  */
466 static void PROGRESS_CoercePos(PROGRESS_INFO *infoPtr)
467 {
468  if(infoPtr->CurVal < infoPtr->MinVal)
469  infoPtr->CurVal = infoPtr->MinVal;
470  if(infoPtr->CurVal > infoPtr->MaxVal)
471  infoPtr->CurVal = infoPtr->MaxVal;
472 }
473 
474 
475 /***********************************************************************
476  * PROGRESS_SetFont
477  * Set new Font for progress bar
478  */
479 static HFONT PROGRESS_SetFont (PROGRESS_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
480 {
481  HFONT hOldFont = infoPtr->Font;
482  infoPtr->Font = hFont;
483  /* Since infoPtr->Font is not used, there is no need for repaint */
484  return hOldFont;
485 }
486 
487 static DWORD PROGRESS_SetRange (PROGRESS_INFO *infoPtr, int low, int high)
488 {
489  DWORD res = MAKELONG(LOWORD(infoPtr->MinVal), LOWORD(infoPtr->MaxVal));
490 
491  /* if nothing changes, simply return */
492  if(infoPtr->MinVal == low && infoPtr->MaxVal == high) return res;
493 
494  infoPtr->MinVal = low;
495  infoPtr->MaxVal = high;
496  PROGRESS_CoercePos(infoPtr);
497  InvalidateRect(infoPtr->Self, NULL, TRUE);
498  return res;
499 }
500 
502 {
503  DWORD style = GetWindowLongW(infoPtr->Self, GWL_STYLE);
504 
505  if (style & PBS_MARQUEE)
506  {
507  PROGRESS_UpdateMarquee(infoPtr);
508  return 1;
509  }
510  else
511  {
512  UINT oldVal;
513  oldVal = infoPtr->CurVal;
514  if (oldVal != pos) {
515  infoPtr->CurVal = pos;
516  PROGRESS_CoercePos(infoPtr);
517  TRACE("PBM_SETPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
518  PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
519  UpdateWindow( infoPtr->Self );
520  }
521  return oldVal;
522  }
523 }
524 
525 /***********************************************************************
526  * ProgressWindowProc
527  */
530 {
531  PROGRESS_INFO *infoPtr;
532  static const WCHAR themeClass[] = {'P','r','o','g','r','e','s','s',0};
533  HTHEME theme;
534 
535  TRACE("hwnd=%p msg=%04x wparam=%lx lParam=%lx\n", hwnd, message, wParam, lParam);
536 
537  infoPtr = (PROGRESS_INFO *)GetWindowLongPtrW(hwnd, 0);
538 
539  if (!infoPtr && message != WM_CREATE)
540  return DefWindowProcW( hwnd, message, wParam, lParam );
541 
542  switch(message) {
543  case WM_CREATE:
544  {
545  DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
546 
547  theme = OpenThemeData (hwnd, themeClass);
548 
549  dwExStyle &= ~(WS_EX_CLIENTEDGE | WS_EX_WINDOWEDGE);
550  if (!theme) dwExStyle |= WS_EX_STATICEDGE;
551  SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle);
552  /* Force recalculation of a non-client area */
553  SetWindowPos(hwnd, 0, 0, 0, 0, 0,
555 
556  /* allocate memory for info struct */
557  infoPtr = heap_alloc_zero (sizeof(*infoPtr));
558  if (!infoPtr) return -1;
559  SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
560 
561  /* initialize the info struct */
562  infoPtr->Self = hwnd;
563  infoPtr->MinVal = 0;
564  infoPtr->MaxVal = 100;
565  infoPtr->CurVal = 0;
566  infoPtr->Step = 10;
567  infoPtr->MarqueePos = 0;
568  infoPtr->Marquee = FALSE;
569  infoPtr->ColorBar = CLR_DEFAULT;
570  infoPtr->ColorBk = CLR_DEFAULT;
571  infoPtr->Font = 0;
572 
573  TRACE("Progress Ctrl creation, hwnd=%p\n", hwnd);
574  return 0;
575  }
576 
577  case WM_DESTROY:
578  TRACE("Progress Ctrl destruction, hwnd=%p\n", hwnd);
579  heap_free (infoPtr);
580  SetWindowLongPtrW(hwnd, 0, 0);
581  theme = GetWindowTheme (hwnd);
582  CloseThemeData (theme);
583  return 0;
584 
585  case WM_ERASEBKGND:
586  return 1;
587 
588  case WM_GETFONT:
589  return (LRESULT)infoPtr->Font;
590 
591  case WM_SETFONT:
592  return (LRESULT)PROGRESS_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
593 
594  case WM_PRINTCLIENT:
595  case WM_PAINT:
596  return PROGRESS_Paint (infoPtr, (HDC)wParam);
597 
598  case WM_TIMER:
599  if (wParam == ID_MARQUEE_TIMER)
600  PROGRESS_UpdateMarquee (infoPtr);
601  return 0;
602 
603  case WM_THEMECHANGED:
604  {
605  DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
606 
607  theme = GetWindowTheme (hwnd);
608  CloseThemeData (theme);
609  theme = OpenThemeData (hwnd, themeClass);
610 
611  /* WS_EX_STATICEDGE disappears when the control is themed */
612  if (theme)
613  dwExStyle &= ~WS_EX_STATICEDGE;
614  else
615  dwExStyle |= WS_EX_STATICEDGE;
616  SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle);
617 
619  return 0;
620  }
621 
622  case PBM_DELTAPOS:
623  {
624  INT oldVal;
625  oldVal = infoPtr->CurVal;
626  if(wParam != 0) {
627  infoPtr->CurVal += (INT)wParam;
628  PROGRESS_CoercePos (infoPtr);
629  TRACE("PBM_DELTAPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
630  PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
631  UpdateWindow( infoPtr->Self );
632  }
633  return oldVal;
634  }
635 
636  case PBM_SETPOS:
637  return PROGRESS_SetPos(infoPtr, wParam);
638 
639  case PBM_SETRANGE:
640  return PROGRESS_SetRange (infoPtr, (int)LOWORD(lParam), (int)HIWORD(lParam));
641 
642  case PBM_SETSTEP:
643  {
644  INT oldStep;
645  oldStep = infoPtr->Step;
646  infoPtr->Step = (INT)wParam;
647  return oldStep;
648  }
649 
650  case PBM_GETSTEP:
651  return infoPtr->Step;
652 
653  case PBM_STEPIT:
654  {
655  int oldVal = infoPtr->CurVal;
656 
657  if (infoPtr->MinVal != infoPtr->MaxVal)
658  {
659  infoPtr->CurVal += infoPtr->Step;
660  if (infoPtr->CurVal > infoPtr->MaxVal)
661  infoPtr->CurVal = (infoPtr->CurVal - infoPtr->MinVal) % (infoPtr->MaxVal - infoPtr->MinVal) + infoPtr->MinVal;
662  if (infoPtr->CurVal < infoPtr->MinVal)
663  infoPtr->CurVal = (infoPtr->CurVal - infoPtr->MinVal) % (infoPtr->MaxVal - infoPtr->MinVal) + infoPtr->MaxVal;
664 
665  if (oldVal != infoPtr->CurVal)
666  {
667  TRACE("PBM_STEPIT: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
668  PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
669  UpdateWindow( infoPtr->Self );
670  }
671  }
672 
673  return oldVal;
674  }
675 
676  case PBM_SETRANGE32:
677  return PROGRESS_SetRange (infoPtr, (int)wParam, (int)lParam);
678 
679  case PBM_GETRANGE:
680  if (lParam) {
681  ((PPBRANGE)lParam)->iLow = infoPtr->MinVal;
682  ((PPBRANGE)lParam)->iHigh = infoPtr->MaxVal;
683  }
684  return wParam ? infoPtr->MinVal : infoPtr->MaxVal;
685 
686  case PBM_GETPOS:
687  return infoPtr->CurVal;
688 
689  case PBM_SETBARCOLOR:
690  {
691  COLORREF clr = infoPtr->ColorBar;
692 
693  infoPtr->ColorBar = (COLORREF)lParam;
695  return clr;
696  }
697 
698  case PBM_GETBARCOLOR:
699  return infoPtr->ColorBar;
700 
701  case PBM_SETBKCOLOR:
702  {
703  COLORREF clr = infoPtr->ColorBk;
704 
705  infoPtr->ColorBk = (COLORREF)lParam;
707  return clr;
708  }
709 
710  case PBM_GETBKCOLOR:
711  return infoPtr->ColorBk;
712 
713  case PBM_SETSTATE:
714  if(wParam != PBST_NORMAL)
715  FIXME("state %04lx not yet handled\n", wParam);
716  return PBST_NORMAL;
717 
718  case PBM_GETSTATE:
719  return PBST_NORMAL;
720 
721  case PBM_SETMARQUEE:
722  if(wParam != 0)
723  {
725  infoPtr->Marquee = TRUE;
726  SetTimer(infoPtr->Self, ID_MARQUEE_TIMER, period, NULL);
727  }
728  else
729  {
730  infoPtr->Marquee = FALSE;
731  KillTimer(infoPtr->Self, ID_MARQUEE_TIMER);
732  }
733  return infoPtr->Marquee;
734 
735  default:
737  ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam );
738  return DefWindowProcW( hwnd, message, wParam, lParam );
739  }
740 }
741 
742 
743 /***********************************************************************
744  * PROGRESS_Register [Internal]
745  *
746  * Registers the progress bar window class.
747  */
748 void PROGRESS_Register (void)
749 {
750  WNDCLASSW wndClass;
751 
752  ZeroMemory (&wndClass, sizeof(wndClass));
753  wndClass.style = CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
754  wndClass.lpfnWndProc = ProgressWindowProc;
755  wndClass.cbClsExtra = 0;
756  wndClass.cbWndExtra = sizeof (PROGRESS_INFO *);
757  wndClass.hCursor = LoadCursorW (0, (LPWSTR)IDC_ARROW);
758  wndClass.lpszClassName = PROGRESS_CLASSW;
759 
760  RegisterClassW (&wndClass);
761 }
762 
763 
764 /***********************************************************************
765  * PROGRESS_Unregister [Internal]
766  *
767  * Unregisters the progress bar window class.
768  */
770 {
772 }
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define WS_EX_WINDOWEDGE
Definition: winuser.h:407
#define LED_GAP
Definition: progress.c:60
#define TMT_PROGRESSSPACESIZE
Definition: vssym32.h:283
INT MarqueePos
Definition: progress.c:51
#define max(a, b)
Definition: svc.c:63
BOOL WINAPI InflateRect(_Inout_ LPRECT, _In_ int, _In_ int)
Definition: tftpd.h:59
#define PBM_SETRANGE32
Definition: commctrl.h:2184
#define TRUE
Definition: types.h:120
#define COLOR_HIGHLIGHT
Definition: winuser.h:916
#define PBS_SMOOTH
Definition: commctrl.h:2176
#define PBS_MARQUEE
Definition: commctrl.h:2194
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
static HFONT PROGRESS_SetFont(PROGRESS_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
Definition: progress.c:479
int WINAPI SelectClipRgn(_In_ HDC, _In_opt_ HRGN)
UINT style
Definition: winuser.h:3150
int WINAPI MapWindowPoints(_In_opt_ HWND hWndFrom, _In_opt_ HWND hWndTo, _Inout_updates_(cPoints) LPPOINT lpPoints, _In_ UINT cPoints)
BOOL WINAPI OffsetRect(_Inout_ LPRECT, _In_ int, _In_ int)
BOOL WINAPI UnregisterClassW(_In_ LPCWSTR, HINSTANCE)
static void draw_chunk_bar_V(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:206
#define PBM_SETMARQUEE
Definition: commctrl.h:2195
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
struct tagProgressDrawInfo ProgressDrawInfo
static void draw_theme_bkg_V(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:273
static const ProgressDrawProc drawProcThemed[8]
Definition: progress.c:285
#define INT
Definition: polytest.cpp:20
static HDC
Definition: imagelist.c:92
BOOL WINAPI UpdateWindow(_In_ HWND)
static void draw_solid_bar_H(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:155
HFONT Font
Definition: progress.c:55
LONG top
Definition: windef.h:292
WINE_DEFAULT_DEBUG_CHANNEL(progress)
static void draw_theme_bar_H(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:239
static HTHEME(WINAPI *pOpenThemeDataEx)(HWND
#define ZeroMemory
Definition: winbase.h:1642
#define CS_HREDRAW
Definition: winuser.h:648
BOOL WINAPI DeleteObject(_In_ HGDIOBJ)
#define GWL_EXSTYLE
Definition: winuser.h:845
int cbClsExtra
Definition: winuser.h:3152
COLORREF ColorBk
Definition: progress.c:54
#define PBM_SETPOS
Definition: commctrl.h:2180
void(* ProgressDrawProc)(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:152
UINT_PTR WPARAM
Definition: windef.h:207
GLuint GLuint end
Definition: gl.h:1545
#define PBM_GETRANGE
Definition: commctrl.h:2189
#define GetWindowLongPtrW
Definition: winuser.h:4730
LONG left
Definition: windef.h:291
#define SWP_NOZORDER
Definition: winuser.h:1232
BOOL WINAPI EndPaint(_In_ HWND, _In_ const PAINTSTRUCT *)
LONG right
Definition: windef.h:293
HRESULT WINAPI DrawThemeBackground(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const RECT *pClipRect)
Definition: draw.c:128
static const WCHAR themeClass[]
Definition: header.c:115
int32_t INT
Definition: typedefs.h:56
& rect
Definition: startmenu.cpp:1413
WPARAM wParam
Definition: combotst.c:138
HFONT hFont
Definition: main.c:53
#define WM_PRINTCLIENT
Definition: richedit.h:70
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
static void draw_solid_bkg_H(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:163
static void PROGRESS_Invalidate(const PROGRESS_INFO *infoPtr, INT old, INT new)
Definition: progress.c:135
#define PBM_SETRANGE
Definition: commctrl.h:2179
BOOL WINAPI IsThemeBackgroundPartiallyTransparent(HTHEME hTheme, int iPartId, int iStateId)
Definition: draw.c:1883
ATOM WINAPI RegisterClassW(_In_ CONST WNDCLASSW *)
static LRESULT PROGRESS_Paint(PROGRESS_INFO *infoPtr, HDC hdc)
Definition: progress.c:421
#define COLOR_3DFACE
Definition: winuser.h:919
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
LONG WINAPI SetWindowLongW(_In_ HWND, _In_ int, _In_ LONG)
HDC WINAPI BeginPaint(_In_ HWND, _Out_ LPPAINTSTRUCT)
WNDPROC lpfnWndProc
Definition: winuser.h:3151
#define FIXME(fmt,...)
Definition: debug.h:110
LONG WINAPI GetWindowLongW(_In_ HWND, _In_ int)
#define MAKELONG(a, b)
Definition: typedefs.h:248
smooth NULL
Definition: ftsmooth.c:416
#define WM_GETFONT
Definition: winuser.h:1633
#define PBM_STEPIT
Definition: commctrl.h:2183
LPCWSTR lpszClassName
Definition: winuser.h:3159
LONG_PTR LPARAM
Definition: windef.h:208
static int get_led_size(const PROGRESS_INFO *infoPtr, LONG style, const RECT *rect)
Definition: progress.c:66
COLORREF ColorBar
Definition: progress.c:53
static int get_bar_position(const PROGRESS_INFO *infoPtr, LONG style, const RECT *rect, INT value)
Definition: progress.c:122
#define PBM_SETSTEP
Definition: commctrl.h:2182
#define PROGRESS_CLASSW
Definition: commctrl.h:2172
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)
#define WM_DESTROY
Definition: winuser.h:1591
static void PROGRESS_CoercePos(PROGRESS_INFO *infoPtr)
Definition: progress.c:466
#define MARQUEE_LEDS
Definition: progress.c:61
static void draw_chunk_bar_H(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:187
HRESULT WINAPI DrawThemeParentBackground(HWND hwnd, HDC hdc, RECT *prc)
Definition: draw.c:72
#define CS_VREDRAW
Definition: winuser.h:653
static const ProgressDrawProc drawProcClassic[8]
Definition: progress.c:225
#define TRACE(s)
Definition: solgame.cpp:4
static LRESULT WINAPI ProgressWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
Definition: progress.c:528
static int get_led_gap(const PROGRESS_INFO *infoPtr)
Definition: progress.c:84
int cbWndExtra
Definition: winuser.h:3153
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define SWP_NOACTIVATE
Definition: winuser.h:1227
DWORD COLORREF
Definition: windef.h:285
#define ID_MARQUEE_TIMER
Definition: progress.c:62
#define WM_TIMER
Definition: winuser.h:1724
#define DEFAULT_MARQUEE_PERIOD
Definition: progress.c:63
#define CS_GLOBALCLASS
Definition: winuser.h:647
void PROGRESS_Register(void)
Definition: progress.c:748
#define WINAPI
Definition: msvc.h:8
static void draw_theme_bkg_H(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:261
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)
BOOL Marquee
Definition: progress.c:52
unsigned long DWORD
Definition: ntddk_ex.h:95
#define PBS_VERTICAL
Definition: commctrl.h:2177
HCURSOR WINAPI LoadCursorW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
Definition: cursoricon.c:2074
GLdouble GLdouble right
Definition: glext.h:10859
HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist)
Definition: system.c:835
#define WM_PAINT
Definition: winuser.h:1602
HTHEME WINAPI GetWindowTheme(HWND hwnd)
Definition: system.c:851
BOOL WINAPI KillTimer(_In_opt_ HWND, _In_ UINT_PTR)
HDC hdc
Definition: main.c:9
#define PBM_SETBARCOLOR
Definition: commctrl.h:2191
static int get_bar_size(LONG style, const RECT *rect)
Definition: progress.c:113
#define SWP_FRAMECHANGED
Definition: winuser.h:1225
#define WM_APP
Definition: eventvwr.h:70
uint32_t DWORD_PTR
Definition: typedefs.h:63
#define WM_USER
Definition: winuser.h:1877
#define SWP_NOSIZE
Definition: winuser.h:1230
HCURSOR hCursor
Definition: winuser.h:3156
#define ERR(fmt,...)
Definition: debug.h:109
#define GWL_STYLE
Definition: winuser.h:846
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
BOOL WINAPI SetRect(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int)
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
int WINAPI ExcludeClipRect(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
static void draw_theme_bar_V(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:250
#define PBM_DELTAPOS
Definition: commctrl.h:2181
GLuint start
Definition: gl.h:1545
static void draw_solid_bkg_V(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:179
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
HBRUSH WINAPI CreateSolidBrush(_In_ COLORREF)
static LRESULT PROGRESS_Draw(PROGRESS_INFO *infoPtr, HDC hdc)
Definition: progress.c:302
cd_progress_ptr progress
Definition: cdjpeg.h:150
#define WM_SETFONT
Definition: winuser.h:1632
#define CLR_DEFAULT
Definition: commctrl.h:316
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
#define IDC_ARROW
Definition: winuser.h:682
HRESULT WINAPI GetThemeBackgroundContentRect(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pBoundingRect, RECT *pContentRect)
Definition: draw.c:1479
#define PBM_SETBKCOLOR
Definition: commctrl.h:2192
#define WM_CREATE
Definition: winuser.h:1590
GLuint res
Definition: glext.h:9613
static DWORD PROGRESS_SetRange(PROGRESS_INFO *infoPtr, int low, int high)
Definition: progress.c:487
#define HIWORD(l)
Definition: typedefs.h:246
LONG bottom
Definition: windef.h:294
BOOL COMCTL32_IsReflectedMessage(UINT uMsg) DECLSPEC_HIDDEN
Definition: commctrl.c:1748
#define TMT_PROGRESSCHUNKSIZE
Definition: vssym32.h:282
#define SWP_NOMOVE
Definition: winuser.h:1229
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
#define SetWindowLongPtrW
Definition: winuser.h:5247
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
static void PROGRESS_UpdateMarquee(PROGRESS_INFO *infoPtr)
Definition: progress.c:435
#define WM_ERASEBKGND
Definition: winuser.h:1607
struct PBRANGE * PPBRANGE
WCHAR * LPWSTR
Definition: xmlstorage.h:184
static void draw_solid_bar_V(const ProgressDrawInfo *di, int start, int end)
Definition: progress.c:171
LONG_PTR LRESULT
Definition: windef.h:209
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
static UINT PROGRESS_SetPos(PROGRESS_INFO *infoPtr, INT pos)
Definition: progress.c:501
Arabic default style
Definition: afstyles.h:93
HBRUSH WINAPI GetSysColorBrush(_In_ int)
#define WS_EX_STATICEDGE
Definition: winuser.h:403
static void get_client_rect(HWND hwnd, RECT *rect)
Definition: progress.c:98
LPARAM lParam
Definition: combotst.c:139
#define LOWORD(l)
Definition: pedump.c:82
#define MulDiv(x, y, z)
Definition: gdifloat.h:86
#define PBM_GETPOS
Definition: commctrl.h:2190
HRESULT WINAPI CloseThemeData(HTHEME hTheme)
Definition: system.c:950
void PROGRESS_Unregister(void)
Definition: progress.c:769
HRESULT WINAPI GetThemeInt(HTHEME hTheme, int iPartId, int iStateId, int iPropId, int *piVal)
Definition: property.c:126
#define SUCCEEDED(hr)
Definition: intsafe.h:57
int WINAPI FrameRect(_In_ HDC, _In_ LPCRECT, _In_ HBRUSH)
_In_ LPWSTR _In_ ULONG _In_ ULONG _In_ ULONG _Out_ DEVINFO * pdi
Definition: winddi.h:3553
static BOOL heap_free(void *mem)
Definition: appwiz.h:75