git.oblomov.eu Git - wine/blob - 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 = 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) && !COMCTL32_IsReflectedMessage(message))
 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 }