progress.c File Reference

#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "commctrl.h"
#include "comctl32.h"
#include "uxtheme.h"
#include "vssym32.h"
#include "wine/debug.h"
#include "wine/heap.h"

Include dependency graph for progress.c:

Go to the source code of this file.

Classes
struct	PROGRESS_INFO
struct	tagProgressDrawInfo

Macros
#define	LED_GAP   2
#define	MARQUEE_LEDS   5
#define	ID_MARQUEE_TIMER   1
#define	DEFAULT_MARQUEE_PERIOD   30

Typedefs
typedef struct tagProgressDrawInfo	ProgressDrawInfo
typedef void(*	ProgressDrawProc) (const ProgressDrawInfo *di, int start, int end)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (progress)
static int	get_led_size (const PROGRESS_INFO *infoPtr, LONG style, const RECT *rect)
static int	get_led_gap (const PROGRESS_INFO *infoPtr)
static void	get_client_rect (HWND hwnd, RECT *rect)
static int	get_bar_size (LONG style, const RECT *rect)
static int	get_bar_position (const PROGRESS_INFO *infoPtr, LONG style, const RECT *rect, INT value)
static void	PROGRESS_Invalidate (const PROGRESS_INFO *infoPtr, INT old, INT new)
static void	draw_solid_bar_H (const ProgressDrawInfo *di, int start, int end)
static void	draw_solid_bkg_H (const ProgressDrawInfo *di, int start, int end)
static void	draw_solid_bar_V (const ProgressDrawInfo *di, int start, int end)
static void	draw_solid_bkg_V (const ProgressDrawInfo *di, int start, int end)
static void	draw_chunk_bar_H (const ProgressDrawInfo *di, int start, int end)
static void	draw_chunk_bar_V (const ProgressDrawInfo *di, int start, int end)
static void	draw_theme_bar_H (const ProgressDrawInfo *di, int start, int end)
static void	draw_theme_bar_V (const ProgressDrawInfo *di, int start, int end)
static void	draw_theme_bkg_H (const ProgressDrawInfo *di, int start, int end)
static void	draw_theme_bkg_V (const ProgressDrawInfo *di, int start, int end)
static LRESULT	PROGRESS_Draw (PROGRESS_INFO *infoPtr, HDC hdc)
static LRESULT	PROGRESS_Paint (PROGRESS_INFO *infoPtr, HDC hdc)
static void	PROGRESS_UpdateMarquee (PROGRESS_INFO *infoPtr)
static void	PROGRESS_CoercePos (PROGRESS_INFO *infoPtr)
static HFONT	PROGRESS_SetFont (PROGRESS_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
static DWORD	PROGRESS_SetRange (PROGRESS_INFO *infoPtr, int low, int high)
static UINT	PROGRESS_SetPos (PROGRESS_INFO *infoPtr, INT pos)
static LRESULT WINAPI	ProgressWindowProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
void	PROGRESS_Register (void)
void	PROGRESS_Unregister (void)

Variables
static const ProgressDrawProc	drawProcClassic [8]
static const ProgressDrawProc	drawProcThemed [8]

Macro Definition Documentation

DEFAULT_MARQUEE_PERIOD

#define DEFAULT_MARQUEE_PERIOD   30

Definition at line 63 of file progress.c.

ID_MARQUEE_TIMER

#define ID_MARQUEE_TIMER   1

Definition at line 62 of file progress.c.

LED_GAP

#define LED_GAP   2

Definition at line 60 of file progress.c.

MARQUEE_LEDS

#define MARQUEE_LEDS   5

Definition at line 61 of file progress.c.

Typedef Documentation

ProgressDrawInfo

typedef struct tagProgressDrawInfo ProgressDrawInfo

ProgressDrawProc

typedef void(* ProgressDrawProc) (const ProgressDrawInfo *di, int start, int end)

Definition at line 152 of file progress.c.

Function Documentation

draw_chunk_bar_H()

static void draw_chunk_bar_H ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 187 of file progress.c.

{
    RECT r;
    int right = di->rect.left + end;
    r.left = di->rect.left + start;
    r.top = di->rect.top;
    r.bottom = di->rect.bottom;
    while (r.left < right)
    {
        r.right = min (r.left + di->ledW, right);
        FillRect (di->hdc, &r, di->hbrBar);
        r.left = r.right;
        r.right = min (r.left + di->ledGap, right);
        FillRect (di->hdc, &r, di->hbrBk);
        r.left = r.right;
    }
}

draw_chunk_bar_V()

static void draw_chunk_bar_V ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 206 of file progress.c.

{
    RECT r;
    int top = di->rect.bottom - end;
    r.left = di->rect.left;
    r.right = di->rect.right;
    r.bottom = di->rect.bottom - start;
    while (r.bottom > top)
    {
        r.top = max (r.bottom - di->ledW, top);
        FillRect (di->hdc, &r, di->hbrBar);
        r.bottom = r.top;
        r.top = max (r.bottom - di->ledGap, top);
        FillRect (di->hdc, &r, di->hbrBk);
        r.bottom = r.top;
    }
}

draw_solid_bar_H()

static void draw_solid_bar_H ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 155 of file progress.c.

{
    RECT r;
    SetRect(&r, di->rect.left + start, di->rect.top, di->rect.left + end, di->rect.bottom);
    FillRect (di->hdc, &r, di->hbrBar);
}

draw_solid_bar_V()

static void draw_solid_bar_V ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 171 of file progress.c.

{
    RECT r;
    SetRect(&r, di->rect.left, di->rect.bottom - end, di->rect.right, di->rect.bottom - start);
    FillRect (di->hdc, &r, di->hbrBar);
}

draw_solid_bkg_H()

static void draw_solid_bkg_H ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 163 of file progress.c.

{
    RECT r;
    SetRect(&r, di->rect.left + start, di->rect.top, di->rect.left + end, di->rect.bottom);
    FillRect (di->hdc, &r, di->hbrBk);
}

draw_solid_bkg_V()

static void draw_solid_bkg_V ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 179 of file progress.c.

{
    RECT r;
    SetRect(&r, di->rect.left, di->rect.bottom - end, di->rect.right, di->rect.bottom - start);
    FillRect (di->hdc, &r, di->hbrBk);
}

draw_theme_bar_H()

static void draw_theme_bar_H ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 239 of file progress.c.

{
    RECT r;
    r.left = di->rect.left + start;
    r.top = di->rect.top;
    r.bottom = di->rect.bottom;
    r.right = di->rect.left + end;
    DrawThemeBackground (di->theme, di->hdc, PP_CHUNK, 0, &r, NULL);
}

draw_theme_bar_V()

static void draw_theme_bar_V ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 250 of file progress.c.

{
    RECT r;
    r.left = di->rect.left;
    r.right = di->rect.right;
    r.bottom = di->rect.bottom - start;
    r.top = di->rect.bottom - end;
    DrawThemeBackground (di->theme, di->hdc, PP_CHUNKVERT, 0, &r, NULL);
}

draw_theme_bkg_H()

static void draw_theme_bkg_H ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 261 of file progress.c.

{
    RECT bgrect, r;
 
    SetRect(&r, di->rect.left + start, di->rect.top, di->rect.left + end, di->rect.bottom);
    bgrect = di->bgRect;
    OffsetRect(&bgrect, -bgrect.left, -bgrect.top);
 
    DrawThemeBackground (di->theme, di->hdc, PP_BAR, 0, &bgrect, &r);
}

draw_theme_bkg_V()

static void draw_theme_bkg_V ( const ProgressDrawInfo *  di, int  start, int  end  )

static

Definition at line 273 of file progress.c.

{
    RECT bgrect, r;
 
    SetRect(&r, di->rect.left, di->rect.bottom - end, di->rect.right, di->rect.bottom - start);
    bgrect = di->bgRect;
    OffsetRect(&bgrect, -bgrect.left, -bgrect.top);
 
    DrawThemeBackground (di->theme, di->hdc, PP_BARVERT, 0, &bgrect, &r);
}

get_bar_position()

static int get_bar_position ( const PROGRESS_INFO *  infoPtr, LONG  style, const RECT *  rect, INT  value  )

inlinestatic

Definition at line 122 of file progress.c.

{
    return MulDiv (value - infoPtr->MinVal, get_bar_size (style, rect),
                      infoPtr->MaxVal - infoPtr->MinVal);
}

Referenced by PROGRESS_Draw().

get_bar_size()

static int get_bar_size ( LONG  style, const RECT *  rect  )

inlinestatic

Definition at line 113 of file progress.c.

{
    if (style & PBS_VERTICAL)
        return rect->bottom - rect->top;
    else
        return rect->right - rect->left;
}

Referenced by get_bar_position(), PROGRESS_Draw(), and PROGRESS_UpdateMarquee().

get_client_rect()

static void get_client_rect ( HWND  hwnd, RECT *  rect  )

inlinestatic

Definition at line 98 of file progress.c.

{
    HTHEME theme = GetWindowTheme (hwnd);
    GetClientRect (hwnd, rect);
    if (!theme)
        InflateRect(rect, -1, -1);
    else
    {
        DWORD dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
        int part = (dwStyle & PBS_VERTICAL) ? PP_BARVERT : PP_BAR;
        GetThemeBackgroundContentRect (theme, 0, part, 0, rect, rect);
    }
}

Referenced by PROGRESS_UpdateMarquee().

get_led_gap()

static int get_led_gap ( const PROGRESS_INFO *  infoPtr )

inlinestatic

Definition at line 84 of file progress.c.

{
    HTHEME theme = GetWindowTheme (infoPtr->Self);
    if (theme)
    {
        int spaceSize;
        if (SUCCEEDED( GetThemeInt( theme, 0, 0, TMT_PROGRESSSPACESIZE, &spaceSize )))
            return spaceSize;
    }
 
    return LED_GAP;
}

Referenced by PROGRESS_Draw(), and PROGRESS_UpdateMarquee().

get_led_size()

static int get_led_size ( const PROGRESS_INFO *  infoPtr, LONG  style, const RECT *  rect  )

inlinestatic

Definition at line 66 of file progress.c.

{
    HTHEME theme = GetWindowTheme (infoPtr->Self);
    if (theme)
    {
        int chunkSize;
        if (SUCCEEDED( GetThemeInt( theme, 0, 0, TMT_PROGRESSCHUNKSIZE, &chunkSize )))
            return chunkSize;
    }
 
    if (style & PBS_VERTICAL)
        return MulDiv (rect->right - rect->left, 2, 3);
    else
        return MulDiv (rect->bottom - rect->top, 2, 3);
}

Referenced by PROGRESS_Draw(), and PROGRESS_UpdateMarquee().

PROGRESS_CoercePos()

static void PROGRESS_CoercePos ( PROGRESS_INFO *  infoPtr )

static

Definition at line 466 of file progress.c.

{
    if(infoPtr->CurVal < infoPtr->MinVal)
        infoPtr->CurVal = infoPtr->MinVal;
    if(infoPtr->CurVal > infoPtr->MaxVal)
        infoPtr->CurVal = infoPtr->MaxVal;
}

Referenced by PROGRESS_SetPos(), PROGRESS_SetRange(), and ProgressWindowProc().

PROGRESS_Draw()

static LRESULT PROGRESS_Draw ( PROGRESS_INFO *  infoPtr, HDC  hdc  )

static

Definition at line 302 of file progress.c.

{
    int barSize;
    DWORD dwStyle;
    BOOL barSmooth;
    const ProgressDrawProc* drawProcs;
    ProgressDrawInfo pdi;
 
    TRACE("(infoPtr=%p, hdc=%p)\n", infoPtr, hdc);
 
    pdi.hdc = hdc;
    pdi.theme = GetWindowTheme (infoPtr->Self);
 
    /* get the required bar brush */
    if (infoPtr->ColorBar == CLR_DEFAULT)
        pdi.hbrBar = GetSysColorBrush(COLOR_HIGHLIGHT);
    else
        pdi.hbrBar = CreateSolidBrush (infoPtr->ColorBar);
 
    if (infoPtr->ColorBk == CLR_DEFAULT)
        pdi.hbrBk = GetSysColorBrush(COLOR_3DFACE);
    else
        pdi.hbrBk = CreateSolidBrush(infoPtr->ColorBk);
 
    /* get the window style */
    dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
 
    /* get client rectangle */
    GetClientRect (infoPtr->Self, &pdi.rect);
    if (!pdi.theme) {
        FrameRect( hdc, &pdi.rect, pdi.hbrBk );
        InflateRect(&pdi.rect, -1, -1);
    }
    else
    {
        RECT cntRect;
        int part = (dwStyle & PBS_VERTICAL) ? PP_BARVERT : PP_BAR;
        
        GetThemeBackgroundContentRect (pdi.theme, hdc, part, 0, &pdi.rect, 
            &cntRect);
        
        /* Exclude content rect - content background will be drawn later */
        ExcludeClipRect (hdc, cntRect.left, cntRect.top, 
            cntRect.right, cntRect.bottom);
        if (IsThemeBackgroundPartiallyTransparent (pdi.theme, part, 0))
            DrawThemeParentBackground (infoPtr->Self, hdc, NULL);
        DrawThemeBackground (pdi.theme, hdc, part, 0, &pdi.rect, NULL);
        SelectClipRgn (hdc, NULL);
        pdi.rect = cntRect;
    }
 
    /* compute some drawing parameters */
    barSmooth = (dwStyle & PBS_SMOOTH) && !pdi.theme;
    drawProcs = &((pdi.theme ? drawProcThemed : drawProcClassic)[(barSmooth ? 0 : 4)
        + ((dwStyle & PBS_VERTICAL) ? 2 : 0)]);
    barSize = get_bar_size( dwStyle, &pdi.rect );
    if (pdi.theme)
    {
        GetWindowRect( infoPtr->Self, &pdi.bgRect );
        MapWindowPoints( infoPtr->Self, 0, (POINT*)&pdi.bgRect, 2 );
    }
 
    if (!barSmooth)
        pdi.ledW = get_led_size( infoPtr, dwStyle, &pdi.rect);
    pdi.ledGap = get_led_gap( infoPtr );
 
    if (dwStyle & PBS_MARQUEE)
    {
        const int ledW = !barSmooth ? (pdi.ledW + pdi.ledGap) : 1;
        const int leds = (barSize + ledW - 1) / ledW;
        const int ledMEnd = infoPtr->MarqueePos + MARQUEE_LEDS;
 
        if (ledMEnd > leds)
        {
            /* case 1: the marquee bar extends over the end and wraps around to 
             * the start */
            const int gapStart = max((ledMEnd - leds) * ledW, 0);
            const int gapEnd = min(infoPtr->MarqueePos * ledW, barSize);
 
            drawProcs[0]( &pdi, 0, gapStart);
            drawProcs[1]( &pdi, gapStart, gapEnd);
            drawProcs[0]( &pdi, gapEnd, barSize);
        }
        else
        {
            /* case 2: the marquee bar is between start and end */
            const int barStart = infoPtr->MarqueePos * ledW;
            const int barEnd = min (ledMEnd * ledW, barSize);
 
            drawProcs[1]( &pdi, 0, barStart);
            drawProcs[0]( &pdi, barStart, barEnd);
            drawProcs[1]( &pdi, barEnd, barSize);
        }
    }
    else
    {
        int barEnd = get_bar_position( infoPtr, dwStyle, &pdi.rect,
            infoPtr->CurVal);
        if (!barSmooth)
        {
            const int ledW = pdi.ledW + pdi.ledGap;
            barEnd = min (((barEnd + ledW - 1) / ledW) * ledW, barSize);
        }
        drawProcs[0]( &pdi, 0, barEnd);
        drawProcs[1]( &pdi, barEnd, barSize);
    }
 
    /* delete bar brush */
    if (infoPtr->ColorBar != CLR_DEFAULT) DeleteObject (pdi.hbrBar);
    if (infoPtr->ColorBk != CLR_DEFAULT) DeleteObject (pdi.hbrBk);
 
    return 0;
}

Referenced by PROGRESS_Paint().

PROGRESS_Invalidate()

static void PROGRESS_Invalidate ( const PROGRESS_INFO *  infoPtr, INT  old, INT  new  )

static

Definition at line 135 of file progress.c.

{
    InvalidateRect( infoPtr->Self, NULL, old > new );
}

Referenced by PROGRESS_SetPos(), and ProgressWindowProc().

PROGRESS_Paint()

static LRESULT PROGRESS_Paint ( PROGRESS_INFO *  infoPtr, HDC  hdc  )

static

Definition at line 421 of file progress.c.

{
    PAINTSTRUCT ps;
    if (hdc) return PROGRESS_Draw (infoPtr, hdc);
    hdc = BeginPaint (infoPtr->Self, &ps);
    PROGRESS_Draw (infoPtr, hdc);
    EndPaint (infoPtr->Self, &ps);
    return 0;
}

Referenced by ProgressWindowProc().

PROGRESS_Register()

void PROGRESS_Register

(

void

)

Definition at line 748 of file progress.c.

{
    WNDCLASSW wndClass;
 
    ZeroMemory (&wndClass, sizeof(wndClass));
    wndClass.style         = CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
    wndClass.lpfnWndProc   = ProgressWindowProc;
    wndClass.cbClsExtra    = 0;
    wndClass.cbWndExtra    = sizeof (PROGRESS_INFO *);
    wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
    wndClass.lpszClassName = PROGRESS_CLASSW;
 
    RegisterClassW (&wndClass);
}

Referenced by DllMain().

PROGRESS_SetFont()

static HFONT PROGRESS_SetFont ( PROGRESS_INFO *  infoPtr, HFONT  hFont, BOOL  bRedraw  )

static

Definition at line 479 of file progress.c.

{
    HFONT hOldFont = infoPtr->Font;
    infoPtr->Font = hFont;
    /* Since infoPtr->Font is not used, there is no need for repaint */
    return hOldFont;
}

Referenced by ProgressWindowProc().

PROGRESS_SetPos()

static UINT PROGRESS_SetPos ( PROGRESS_INFO *  infoPtr, INT  pos  )

static

Definition at line 501 of file progress.c.

{
    DWORD style = GetWindowLongW(infoPtr->Self, GWL_STYLE);
 
    if (style & PBS_MARQUEE)
    {
        PROGRESS_UpdateMarquee(infoPtr);
        return 1;
    }
    else
    {
        UINT oldVal;
        oldVal = infoPtr->CurVal;
        if (oldVal != pos) {
        infoPtr->CurVal = pos;
        PROGRESS_CoercePos(infoPtr);
        TRACE("PBM_SETPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
            PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
            UpdateWindow( infoPtr->Self );
        }
        return oldVal;
    }
}

Referenced by ProgressWindowProc().

PROGRESS_SetRange()

static DWORD PROGRESS_SetRange ( PROGRESS_INFO *  infoPtr, int  low, int  high  )

static

Definition at line 487 of file progress.c.

{
    DWORD res = MAKELONG(LOWORD(infoPtr->MinVal), LOWORD(infoPtr->MaxVal));
 
    /* if nothing changes, simply return */
    if(infoPtr->MinVal == low && infoPtr->MaxVal == high) return res;
 
    infoPtr->MinVal = low;
    infoPtr->MaxVal = high;
    PROGRESS_CoercePos(infoPtr);
    InvalidateRect(infoPtr->Self, NULL, TRUE);
    return res;
}

Referenced by ProgressWindowProc().

PROGRESS_Unregister()

void PROGRESS_Unregister

(

void

)

Definition at line 769 of file progress.c.

{
    UnregisterClassW (PROGRESS_CLASSW, NULL);
}

Referenced by DllMain().

PROGRESS_UpdateMarquee()

static void PROGRESS_UpdateMarquee ( PROGRESS_INFO *  infoPtr )

static

Definition at line 435 of file progress.c.

{
    LONG style = GetWindowLongW (infoPtr->Self, GWL_STYLE);
    RECT rect;
    int ledWidth, leds;
    HTHEME theme = GetWindowTheme (infoPtr->Self);
    BOOL smooth = (style & PBS_SMOOTH) && !theme;
 
    get_client_rect (infoPtr->Self, &rect);
 
    if (smooth)
        ledWidth = 1;
    else
        ledWidth = get_led_size( infoPtr, style, &rect ) + get_led_gap( infoPtr );
 
    leds = (get_bar_size( style, &rect ) + ledWidth - 1) /
        ledWidth;
 
    /* increment the marquee progress */
    if (++infoPtr->MarqueePos >= leds)
        infoPtr->MarqueePos = 0;
 
    InvalidateRect(infoPtr->Self, &rect, TRUE);
    UpdateWindow(infoPtr->Self);
}

Referenced by PROGRESS_SetPos(), and ProgressWindowProc().

ProgressWindowProc()

static LRESULT WINAPI ProgressWindowProc ( HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 528 of file progress.c.

{
    PROGRESS_INFO *infoPtr;
    static const WCHAR themeClass[] = {'P','r','o','g','r','e','s','s',0};
    HTHEME theme;
 
    TRACE("hwnd=%p msg=%04x wparam=%lx lParam=%lx\n", hwnd, message, wParam, lParam);
 
    infoPtr = (PROGRESS_INFO *)GetWindowLongPtrW(hwnd, 0);
 
    if (!infoPtr && message != WM_CREATE)
        return DefWindowProcW( hwnd, message, wParam, lParam );
 
    switch(message) {
    case WM_CREATE:
    {
    DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
 
        theme = OpenThemeData (hwnd, themeClass);
 
    dwExStyle &= ~(WS_EX_CLIENTEDGE | WS_EX_WINDOWEDGE);
    if (!theme) dwExStyle |= WS_EX_STATICEDGE;
        SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle);
    /* Force recalculation of a non-client area */
    SetWindowPos(hwnd, 0, 0, 0, 0, 0,
        SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
 
        /* allocate memory for info struct */
        infoPtr = heap_alloc_zero (sizeof(*infoPtr));
        if (!infoPtr) return -1;
        SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
 
        /* initialize the info struct */
        infoPtr->Self = hwnd;
        infoPtr->MinVal = 0;
        infoPtr->MaxVal = 100;
        infoPtr->CurVal = 0;
        infoPtr->Step = 10;
        infoPtr->MarqueePos = 0;
        infoPtr->Marquee = FALSE;
        infoPtr->ColorBar = CLR_DEFAULT;
        infoPtr->ColorBk = CLR_DEFAULT;
        infoPtr->Font = 0;
 
        TRACE("Progress Ctrl creation, hwnd=%p\n", hwnd);
        return 0;
    }
 
    case WM_DESTROY:
        TRACE("Progress Ctrl destruction, hwnd=%p\n", hwnd);
        heap_free (infoPtr);
        SetWindowLongPtrW(hwnd, 0, 0);
        theme = GetWindowTheme (hwnd);
        CloseThemeData (theme);
        return 0;
 
    case WM_ERASEBKGND:
        return 1;
 
    case WM_GETFONT:
        return (LRESULT)infoPtr->Font;
 
    case WM_SETFONT:
        return (LRESULT)PROGRESS_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
 
    case WM_PRINTCLIENT:
    case WM_PAINT:
        return PROGRESS_Paint (infoPtr, (HDC)wParam);
 
    case WM_TIMER:
        if (wParam == ID_MARQUEE_TIMER)
            PROGRESS_UpdateMarquee (infoPtr);
        return 0;
 
    case WM_THEMECHANGED:
    {
        DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
        
        theme = GetWindowTheme (hwnd);
        CloseThemeData (theme);
        theme = OpenThemeData (hwnd, themeClass);
        
        /* WS_EX_STATICEDGE disappears when the control is themed */
        if (theme)
            dwExStyle &= ~WS_EX_STATICEDGE;
        else
            dwExStyle |= WS_EX_STATICEDGE;
        SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle);
        
        InvalidateRect (hwnd, NULL, FALSE);
        return 0;
    }
 
    case PBM_DELTAPOS:
    {
    INT oldVal;
        oldVal = infoPtr->CurVal;
        if(wParam != 0) {
        infoPtr->CurVal += (INT)wParam;
        PROGRESS_CoercePos (infoPtr);
        TRACE("PBM_DELTAPOS: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
            PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
            UpdateWindow( infoPtr->Self );
        }
        return oldVal;
    }
 
    case PBM_SETPOS:
        return PROGRESS_SetPos(infoPtr, wParam);
 
    case PBM_SETRANGE:
        return PROGRESS_SetRange (infoPtr, (int)LOWORD(lParam), (int)HIWORD(lParam));
 
    case PBM_SETSTEP:
    {
    INT oldStep;
        oldStep = infoPtr->Step;
        infoPtr->Step = (INT)wParam;
        return oldStep;
    }
 
    case PBM_GETSTEP:
        return infoPtr->Step;
 
    case PBM_STEPIT:
    {
        int oldVal = infoPtr->CurVal;
 
        if (infoPtr->MinVal != infoPtr->MaxVal)
        {
            infoPtr->CurVal += infoPtr->Step;
            if (infoPtr->CurVal > infoPtr->MaxVal)
                infoPtr->CurVal = (infoPtr->CurVal - infoPtr->MinVal) % (infoPtr->MaxVal - infoPtr->MinVal) + infoPtr->MinVal;
            if (infoPtr->CurVal < infoPtr->MinVal)
                infoPtr->CurVal = (infoPtr->CurVal - infoPtr->MinVal) % (infoPtr->MaxVal - infoPtr->MinVal) + infoPtr->MaxVal;
 
            if (oldVal != infoPtr->CurVal)
            {
                TRACE("PBM_STEPIT: current pos changed from %d to %d\n", oldVal, infoPtr->CurVal);
                PROGRESS_Invalidate( infoPtr, oldVal, infoPtr->CurVal );
                UpdateWindow( infoPtr->Self );
            }
        }
 
        return oldVal;
    }
 
    case PBM_SETRANGE32:
        return PROGRESS_SetRange (infoPtr, (int)wParam, (int)lParam);
 
    case PBM_GETRANGE:
        if (lParam) {
            ((PPBRANGE)lParam)->iLow = infoPtr->MinVal;
            ((PPBRANGE)lParam)->iHigh = infoPtr->MaxVal;
        }
        return wParam ? infoPtr->MinVal : infoPtr->MaxVal;
 
    case PBM_GETPOS:
        return infoPtr->CurVal;
 
    case PBM_SETBARCOLOR:
    {
        COLORREF clr = infoPtr->ColorBar;
 
        infoPtr->ColorBar = (COLORREF)lParam;
    InvalidateRect(hwnd, NULL, TRUE);
        return clr;
    }
 
    case PBM_GETBARCOLOR:
    return infoPtr->ColorBar;
 
    case PBM_SETBKCOLOR:
    {
        COLORREF clr = infoPtr->ColorBk;
 
        infoPtr->ColorBk = (COLORREF)lParam;
    InvalidateRect(hwnd, NULL, TRUE);
        return clr;
    }
 
    case PBM_GETBKCOLOR:
    return infoPtr->ColorBk;
 
    case PBM_SETSTATE:
        if(wParam != PBST_NORMAL)
            FIXME("state %04lx not yet handled\n", wParam);
        return PBST_NORMAL;
 
    case PBM_GETSTATE:
        return PBST_NORMAL;
 
    case PBM_SETMARQUEE:
    if(wParam != 0)
        {
            UINT period = lParam ? (UINT)lParam : DEFAULT_MARQUEE_PERIOD;
            infoPtr->Marquee = TRUE;
            SetTimer(infoPtr->Self, ID_MARQUEE_TIMER, period, NULL);
        }
        else
        {
            infoPtr->Marquee = FALSE;
            KillTimer(infoPtr->Self, ID_MARQUEE_TIMER);
        }
    return infoPtr->Marquee;
 
    default:
        if ((message >= WM_USER) && (message < WM_APP) && !COMCTL32_IsReflectedMessage(message))
        ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam );
        return DefWindowProcW( hwnd, message, wParam, lParam );
    }
}

Referenced by PROGRESS_Register().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

progress

)

Variable Documentation

drawProcClassic

const ProgressDrawProc drawProcClassic[8]

static

Initial value:

= {
  
    
    draw_solid_bar_H, draw_solid_bkg_H,
    
    draw_solid_bar_V, draw_solid_bkg_V,
  
    
    draw_chunk_bar_H, draw_solid_bkg_H,
    
    draw_chunk_bar_V, draw_solid_bkg_V,
}

Definition at line 225 of file progress.c.

Referenced by PROGRESS_Draw().

drawProcThemed

const ProgressDrawProc drawProcThemed[8]

static

Initial value:

= {
  
    
    draw_theme_bar_H, draw_theme_bkg_H,
    
    draw_theme_bar_V, draw_theme_bkg_V,
  
    
    draw_theme_bar_H, draw_theme_bkg_H,
    
    draw_theme_bar_V, draw_theme_bkg_V,
}

Definition at line 285 of file progress.c.

Referenced by PROGRESS_Draw().