static.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "commctrl.h"
#include "wine/debug.h"
#include "comctl32.h"

Include dependency graph for static.c:

Go to the source code of this file.

Macros
#define	HFONT_GWL_OFFSET   0
#define	HICON_GWL_OFFSET   (sizeof(HFONT))
#define	STATIC_EXTRA_BYTES   (HICON_GWL_OFFSET + sizeof(HICON))

Typedefs
typedef void(*	pfPaint) (HWND hwnd, HDC hdc, DWORD style)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (static)
static void	STATIC_PaintOwnerDrawfn (HWND hwnd, HDC hdc, DWORD style)
static void	STATIC_PaintTextfn (HWND hwnd, HDC hdc, DWORD style)
static void	STATIC_PaintRectfn (HWND hwnd, HDC hdc, DWORD style)
static void	STATIC_PaintIconfn (HWND hwnd, HDC hdc, DWORD style)
static void	STATIC_PaintBitmapfn (HWND hwnd, HDC hdc, DWORD style)
static void	STATIC_PaintEnhMetafn (HWND hwnd, HDC hdc, DWORD style)
static void	STATIC_PaintEtchedfn (HWND hwnd, HDC hdc, DWORD style)
static BOOL	get_icon_size (HICON handle, SIZE *size)
static HICON	STATIC_SetIcon (HWND hwnd, HICON hicon, DWORD style)
static HBITMAP	STATIC_SetBitmap (HWND hwnd, HBITMAP hBitmap, DWORD style)
static HENHMETAFILE	STATIC_SetEnhMetaFile (HWND hwnd, HENHMETAFILE hEnhMetaFile, DWORD style)
static HANDLE	STATIC_GetImage (HWND hwnd, WPARAM wParam, DWORD style)
static HICON	STATIC_LoadIconW (HINSTANCE hInstance, LPCWSTR name, DWORD style)
static VOID	STATIC_TryPaintFcn (HWND hwnd, LONG full_style)
static HBRUSH	STATIC_SendWmCtlColorStatic (HWND hwnd, HDC hdc)
static BOOL	hasTextStyle (DWORD style)
static LRESULT CALLBACK	STATIC_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
void	STATIC_Register (void)

Variables
static const pfPaint	staticPaintFunc [SS_TYPEMASK+1]

Macro Definition Documentation

HFONT_GWL_OFFSET

#define HFONT_GWL_OFFSET   0

Definition at line 59 of file static.c.

HICON_GWL_OFFSET

#define HICON_GWL_OFFSET   (sizeof(HFONT))

Definition at line 60 of file static.c.

STATIC_EXTRA_BYTES

#define STATIC_EXTRA_BYTES   (HICON_GWL_OFFSET + sizeof(HICON))

Definition at line 61 of file static.c.

Typedef Documentation

pfPaint

typedef void(* pfPaint) (HWND hwnd, HDC hdc, DWORD style)

Definition at line 63 of file static.c.

Function Documentation

get_icon_size()

static BOOL get_icon_size ( HICON  handle, SIZE *  size  )

static

Definition at line 88 of file static.c.

{
    ICONINFO info;
    BITMAP bmp;
    int ret;
 
    if (!GetIconInfo(handle, &info))
        return FALSE;
 
#ifdef __REACTOS__
    ret = GetObjectW(info.hbmMask, sizeof(bmp), &bmp);
#else
    ret = GetObjectW(info.hbmColor, sizeof(bmp), &bmp);
#endif
    if (ret)
    {
        size->cx = bmp.bmWidth;
        size->cy = bmp.bmHeight;
#ifdef __REACTOS__
        /*
            If this structure defines a black and white icon, this bitmask is formatted
            so that the upper half is the icon AND bitmask and the lower half is
            the icon XOR bitmask.
        */
        if (!info.hbmColor)
            size->cy /= 2;
#endif
    }
 
    DeleteObject(info.hbmMask);
    DeleteObject(info.hbmColor);
 
    return !!ret;
}

Referenced by IntDrawState(), STATIC_PaintIconfn(), and STATIC_SetIcon().

hasTextStyle()

static BOOL hasTextStyle ( DWORD  style )

static

Definition at line 311 of file static.c.

{
    switch (style & SS_TYPEMASK)
    {
        case SS_SIMPLE:
        case SS_LEFT:
        case SS_LEFTNOWORDWRAP:
        case SS_CENTER:
        case SS_RIGHT:
        case SS_OWNERDRAW:
            return TRUE;
    }
 
    return FALSE;
}

Referenced by STATIC_WindowProc(), and StaticWndProc_common().

STATIC_GetImage()

static HANDLE STATIC_GetImage ( HWND  hwnd, WPARAM  wParam, DWORD  style  )

static

Definition at line 219 of file static.c.

{
    switch (style & SS_TYPEMASK)
    {
        case SS_ICON:
            if ((wParam != IMAGE_ICON) &&
                (wParam != IMAGE_CURSOR)) return NULL;
            break;
        case SS_BITMAP:
            if (wParam != IMAGE_BITMAP) return NULL;
            break;
        case SS_ENHMETAFILE:
            if (wParam != IMAGE_ENHMETAFILE) return NULL;
            break;
        default:
            return NULL;
    }
    return (HANDLE)GetWindowLongPtrW( hwnd, HICON_GWL_OFFSET );
}

Referenced by STATIC_WindowProc(), and StaticWndProc_common().

STATIC_LoadIconW()

static HICON STATIC_LoadIconW ( HINSTANCE  hInstance, LPCWSTR  name, DWORD  style  )

static

Definition at line 244 of file static.c.

{
    HICON hicon = 0;
 
    if (hInstance && ((ULONG_PTR)hInstance >> 16))
    {
        if ((style & SS_REALSIZEIMAGE) != 0)
            hicon = LoadImageW(hInstance, name, IMAGE_ICON, 0, 0, LR_SHARED);
        else
        {
            hicon = LoadIconW( hInstance, name );
            if (!hicon) hicon = LoadCursorW( hInstance, name );
        }
    }
    if (!hicon) hicon = LoadIconW( 0, name );
    /* Windows doesn't try to load a standard cursor,
       probably because most IDs for standard cursors conflict
       with the IDs for standard icons anyway */
    return hicon;
}

Referenced by STATIC_WindowProc(), and StaticWndProc_common().

STATIC_PaintBitmapfn()

static void STATIC_PaintBitmapfn ( HWND  hwnd, HDC  hdc, DWORD  style  )

static

Definition at line 711 of file static.c.

{
    HDC hMemDC;
    HBITMAP hBitmap, oldbitmap;
    HBRUSH hbrush;
 
    /* message is still sent, even if the returned brush is not used */
    hbrush = STATIC_SendWmCtlColorStatic(hwnd, hdc);
 
    if ((hBitmap = (HBITMAP)GetWindowLongPtrW( hwnd, HICON_GWL_OFFSET ))
         && (GetObjectType(hBitmap) == OBJ_BITMAP)
         && (hMemDC = CreateCompatibleDC( hdc )))
    {
        BITMAP bm;
        RECT rcClient;
        LOGBRUSH brush;
 
        GetObjectW(hBitmap, sizeof(bm), &bm);
        oldbitmap = SelectObject(hMemDC, hBitmap);
 
        /* Set the background color for monochrome bitmaps
           to the color of the background brush */
        if (GetObjectW( hbrush, sizeof(brush), &brush ))
        {
            if (brush.lbStyle == BS_SOLID)
                SetBkColor(hdc, brush.lbColor);
        }
        GetClientRect(hwnd, &rcClient);
        if (style & SS_CENTERIMAGE)
        {
            FillRect( hdc, &rcClient, hbrush );
            rcClient.left = (rcClient.right - rcClient.left)/2 - bm.bmWidth/2;
            rcClient.top = (rcClient.bottom - rcClient.top)/2 - bm.bmHeight/2;
            rcClient.right = rcClient.left + bm.bmWidth;
            rcClient.bottom = rcClient.top + bm.bmHeight;
        }
        StretchBlt(hdc, rcClient.left, rcClient.top, rcClient.right - rcClient.left,
                   rcClient.bottom - rcClient.top, hMemDC,
                   0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
        SelectObject(hMemDC, oldbitmap);
        DeleteDC(hMemDC);
    }
}

STATIC_PaintEnhMetafn()

static void STATIC_PaintEnhMetafn ( HWND  hwnd, HDC  hdc, DWORD  style  )

static

Definition at line 755 of file static.c.

{
    HENHMETAFILE hEnhMetaFile;
    RECT rc;
    HBRUSH hbrush;
 
    GetClientRect(hwnd, &rc);
    hbrush = STATIC_SendWmCtlColorStatic(hwnd, hdc);
    FillRect(hdc, &rc, hbrush);
    if ((hEnhMetaFile = (HENHMETAFILE)GetWindowLongPtrW( hwnd, HICON_GWL_OFFSET )))
    {
        /* The control's current font is not selected into the
           device context! */
        if (GetObjectType(hEnhMetaFile) == OBJ_ENHMETAFILE)
            PlayEnhMetaFile(hdc, hEnhMetaFile, &rc);
    }
}

STATIC_PaintEtchedfn()

static void STATIC_PaintEtchedfn ( HWND  hwnd, HDC  hdc, DWORD  style  )

static

Definition at line 773 of file static.c.

{
    RECT rc;
 
    /* FIXME: sometimes (not always) sends WM_CTLCOLORSTATIC */
    GetClientRect( hwnd, &rc );
    switch (style & SS_TYPEMASK)
    {
    case SS_ETCHEDHORZ:
        DrawEdge(hdc, &rc, EDGE_ETCHED, BF_TOP | BF_BOTTOM);
        break;
    case SS_ETCHEDVERT:
        DrawEdge(hdc, &rc, EDGE_ETCHED, BF_LEFT | BF_RIGHT);
        break;
    case SS_ETCHEDFRAME:
        DrawEdge(hdc, &rc, EDGE_ETCHED, BF_RECT);
        break;
    }
}

STATIC_PaintIconfn()

static void STATIC_PaintIconfn ( HWND  hwnd, HDC  hdc, DWORD  style  )

static

Definition at line 680 of file static.c.

{
    RECT rc, iconRect;
    HBRUSH hbrush;
    HICON hIcon;
    SIZE size;
 
    GetClientRect( hwnd, &rc );
    hbrush = STATIC_SendWmCtlColorStatic(hwnd, hdc);
    hIcon = (HICON)GetWindowLongPtrW( hwnd, HICON_GWL_OFFSET );
    if (!hIcon || !get_icon_size( hIcon, &size ))
    {
        FillRect(hdc, &rc, hbrush);
    }
    else
    {
        if (style & SS_CENTERIMAGE)
        {
            iconRect.left = (rc.right - rc.left) / 2 - size.cx / 2;
            iconRect.top = (rc.bottom - rc.top) / 2 - size.cy / 2;
            iconRect.right = iconRect.left + size.cx;
            iconRect.bottom = iconRect.top + size.cy;
        }
        else
            iconRect = rc;
        FillRect( hdc, &rc, hbrush );
        DrawIconEx( hdc, iconRect.left, iconRect.top, hIcon, iconRect.right - iconRect.left,
                    iconRect.bottom - iconRect.top, 0, NULL, DI_NORMAL );
    }
}

STATIC_PaintOwnerDrawfn()

static void STATIC_PaintOwnerDrawfn ( HWND  hwnd, HDC  hdc, DWORD  style  )

static

Definition at line 513 of file static.c.

{
    DRAWITEMSTRUCT dis;
    HFONT font, oldFont = NULL;
    UINT id = (UINT)GetWindowLongPtrW( hwnd, GWLP_ID );
 
    dis.CtlType    = ODT_STATIC;
    dis.CtlID      = id;
    dis.itemID     = 0;
    dis.itemAction = ODA_DRAWENTIRE;
    dis.itemState  = IsWindowEnabled(hwnd) ? 0 : ODS_DISABLED;
    dis.hwndItem   = hwnd;
    dis.hDC        = hdc;
    dis.itemData   = 0;
    GetClientRect( hwnd, &dis.rcItem );
 
    font = (HFONT)GetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET );
    if (font) oldFont = SelectObject( hdc, font );
    SendMessageW( GetParent(hwnd), WM_CTLCOLORSTATIC, (WPARAM)hdc, (LPARAM)hwnd );
    SendMessageW( GetParent(hwnd), WM_DRAWITEM, id, (LPARAM)&dis );
    if (font) SelectObject( hdc, oldFont );
}

STATIC_PaintRectfn()

static void STATIC_PaintRectfn ( HWND  hwnd, HDC  hdc, DWORD  style  )

static

Definition at line 639 of file static.c.

{
    RECT rc;
    HBRUSH hBrush;
 
    GetClientRect( hwnd, &rc);
 
    /* FIXME: send WM_CTLCOLORSTATIC */
    switch (style & SS_TYPEMASK)
    {
    case SS_BLACKRECT:
        hBrush = CreateSolidBrush(comctl32_color.clr3dDkShadow);
        FillRect( hdc, &rc, hBrush );
        break;
    case SS_GRAYRECT:
        hBrush = CreateSolidBrush(comctl32_color.clr3dShadow);
        FillRect( hdc, &rc, hBrush );
        break;
    case SS_WHITERECT:
        hBrush = CreateSolidBrush(comctl32_color.clr3dHilight);
        FillRect( hdc, &rc, hBrush );
        break;
    case SS_BLACKFRAME:
        hBrush = CreateSolidBrush(comctl32_color.clr3dDkShadow);
        FrameRect( hdc, &rc, hBrush );
        break;
    case SS_GRAYFRAME:
        hBrush = CreateSolidBrush(comctl32_color.clr3dShadow);
        FrameRect( hdc, &rc, hBrush );
        break;
    case SS_WHITEFRAME:
        hBrush = CreateSolidBrush(comctl32_color.clr3dHilight);
        FrameRect( hdc, &rc, hBrush );
        break;
    default:
        return;
    }
    DeleteObject( hBrush );
}

STATIC_PaintTextfn()

static void STATIC_PaintTextfn ( HWND  hwnd, HDC  hdc, DWORD  style  )

static

Definition at line 536 of file static.c.

{
    RECT rc;
    HBRUSH hBrush;
    HFONT hFont, hOldFont = NULL;
    UINT format;
    INT len, buf_size;
    WCHAR *text;
 
    GetClientRect( hwnd, &rc);
 
    switch (style & SS_TYPEMASK)
    {
    case SS_LEFT:
        format = DT_LEFT | DT_EXPANDTABS | DT_WORDBREAK;
        break;
 
    case SS_CENTER:
        format = DT_CENTER | DT_EXPANDTABS | DT_WORDBREAK;
        break;
 
    case SS_RIGHT:
        format = DT_RIGHT | DT_EXPANDTABS | DT_WORDBREAK;
        break;
 
    case SS_SIMPLE:
        format = DT_LEFT | DT_SINGLELINE;
        break;
 
    case SS_LEFTNOWORDWRAP:
        format = DT_LEFT | DT_EXPANDTABS;
        break;
 
    default:
        return;
    }
 
    if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_RIGHT)
        format = DT_RIGHT | (format & ~(DT_LEFT | DT_CENTER));
 
    if (style & SS_NOPREFIX)
        format |= DT_NOPREFIX;
 
    if ((style & SS_TYPEMASK) != SS_SIMPLE)
    {
        if (style & SS_CENTERIMAGE)
            format |= DT_SINGLELINE | DT_VCENTER;
        if (style & SS_EDITCONTROL)
            format |= DT_EDITCONTROL;
        if (style & SS_ENDELLIPSIS)
            format |= DT_SINGLELINE | DT_END_ELLIPSIS;
        if (style & SS_PATHELLIPSIS)
            format |= DT_SINGLELINE | DT_PATH_ELLIPSIS;
        if (style & SS_WORDELLIPSIS)
            format |= DT_SINGLELINE | DT_WORD_ELLIPSIS;
    }
 
    if ((hFont = (HFONT)GetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET )))
        hOldFont = SelectObject( hdc, hFont );
 
    /* SS_SIMPLE controls: WM_CTLCOLORSTATIC is sent, but the returned
                           brush is not used */
    hBrush = STATIC_SendWmCtlColorStatic(hwnd, hdc);
 
    if ((style & SS_TYPEMASK) != SS_SIMPLE)
    {
        FillRect( hdc, &rc, hBrush );
        if (!IsWindowEnabled(hwnd)) SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
    }
 
    buf_size = 256;
    if (!(text = HeapAlloc( GetProcessHeap(), 0, buf_size * sizeof(WCHAR) )))
        goto no_TextOut;
 
    while ((len = InternalGetWindowText( hwnd, text, buf_size )) == buf_size - 1)
    {
        buf_size *= 2;
        if (!(text = HeapReAlloc( GetProcessHeap(), 0, text, buf_size * sizeof(WCHAR) )))
            goto no_TextOut;
    }
 
    if (!len) goto no_TextOut;
 
    if (((style & SS_TYPEMASK) == SS_SIMPLE) && (style & SS_NOPREFIX))
    {
        /* Windows uses the faster ExtTextOut() to draw the text and
           to paint the whole client rectangle with the text background
           color. Reference: "Static Controls" by Kyle Marsh, 1992 */
        ExtTextOutW( hdc, rc.left, rc.top, ETO_CLIPPED | ETO_OPAQUE,
                     &rc, text, len, NULL );
    }
    else
    {
        DrawTextW( hdc, text, -1, &rc, format );
    }
 
no_TextOut:
    HeapFree( GetProcessHeap(), 0, text );
 
    if (hFont)
        SelectObject( hdc, hOldFont );
}

STATIC_Register()

void STATIC_Register

(

void

)

Definition at line 793 of file static.c.

{
    WNDCLASSW wndClass;
 
    memset(&wndClass, 0, sizeof(wndClass));
    wndClass.style = CS_DBLCLKS | CS_PARENTDC | CS_GLOBALCLASS;
    wndClass.lpfnWndProc = STATIC_WindowProc;
    wndClass.cbClsExtra = 0;
    wndClass.cbWndExtra = STATIC_EXTRA_BYTES;
    wndClass.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
    wndClass.hbrBackground = NULL;
    wndClass.lpszClassName = WC_STATICW;
    RegisterClassW(&wndClass);
}

Referenced by DllMain().

STATIC_SendWmCtlColorStatic()

static HBRUSH STATIC_SendWmCtlColorStatic ( HWND  hwnd, HDC  hdc  )

static

Definition at line 290 of file static.c.

{
    HBRUSH hBrush;
    HWND parent = GetParent(hwnd);
 
    if (!parent) parent = hwnd;
    hBrush = (HBRUSH) SendMessageW( parent, WM_CTLCOLORSTATIC, (WPARAM)hdc, (LPARAM)hwnd );
    if (!hBrush) /* did the app forget to call DefWindowProc ? */
    {
        /* FIXME: DefWindowProc should return different colors if a
                  manifest is present */
        hBrush = (HBRUSH)DefWindowProcW( parent, WM_CTLCOLORSTATIC, (WPARAM)hdc, (LPARAM)hwnd);
    }
    return hBrush;
}

Referenced by STATIC_PaintBitmapfn(), STATIC_PaintEnhMetafn(), STATIC_PaintIconfn(), STATIC_PaintOwnerDrawfn(), STATIC_PaintRectfn(), and STATIC_PaintTextfn().

STATIC_SetBitmap()

static HBITMAP STATIC_SetBitmap ( HWND  hwnd, HBITMAP  hBitmap, DWORD  style  )

static

Definition at line 164 of file static.c.

{
    HBITMAP hOldBitmap;
 
    if ((style & SS_TYPEMASK) != SS_BITMAP) return 0;
    if (hBitmap && GetObjectType(hBitmap) != OBJ_BITMAP)
    {
        WARN("hBitmap != 0, but it's not a bitmap\n");
        return 0;
    }
    hOldBitmap = (HBITMAP)SetWindowLongPtrW( hwnd, HICON_GWL_OFFSET, (LONG_PTR)hBitmap );
    if (hBitmap && !(style & SS_CENTERIMAGE) && !(style & SS_REALSIZECONTROL))
    {
        BITMAP bm;
        GetObjectW(hBitmap, sizeof(bm), &bm);
        /* Windows currently doesn't implement SS_RIGHTJUST */
        /*
        if ((style & SS_RIGHTJUST) != 0)
        {
            RECT wr;
            GetWindowRect(hwnd, &wr);
            SetWindowPos( hwnd, 0, wr.right - bm.bmWidth, wr.bottom - bm.bmHeight,
                          bm.bmWidth, bm.bmHeight, SWP_NOACTIVATE | SWP_NOZORDER );
        }
        else */
        {
            SetWindowPos( hwnd, 0, 0, 0, bm.bmWidth, bm.bmHeight,
                          SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER );
        }
    }
    return hOldBitmap;
}

Referenced by STATIC_WindowProc(), and StaticWndProc_common().

STATIC_SetEnhMetaFile()

static HENHMETAFILE STATIC_SetEnhMetaFile ( HWND  hwnd, HENHMETAFILE  hEnhMetaFile, DWORD  style  )

static

Definition at line 202 of file static.c.

{
    if ((style & SS_TYPEMASK) != SS_ENHMETAFILE) return 0;
    if (hEnhMetaFile && GetObjectType(hEnhMetaFile) != OBJ_ENHMETAFILE)
    {
        WARN("hEnhMetaFile != 0, but it's not an enhanced metafile\n");
        return 0;
    }
    return (HENHMETAFILE)SetWindowLongPtrW( hwnd, HICON_GWL_OFFSET, (LONG_PTR)hEnhMetaFile );
}

Referenced by STATIC_WindowProc(), and StaticWndProc_common().

STATIC_SetIcon()

static HICON STATIC_SetIcon ( HWND  hwnd, HICON  hicon, DWORD  style  )

static

Definition at line 128 of file static.c.

{
    HICON prevIcon;
    SIZE size;
 
    if ((style & SS_TYPEMASK) != SS_ICON) return 0;
    if (hicon && !get_icon_size( hicon, &size ))
    {
        WARN("hicon != 0, but invalid\n");
        return 0;
    }
    prevIcon = (HICON)SetWindowLongPtrW( hwnd, HICON_GWL_OFFSET, (LONG_PTR)hicon );
    if (hicon && !(style & SS_CENTERIMAGE) && !(style & SS_REALSIZECONTROL))
    {
        /* Windows currently doesn't implement SS_RIGHTJUST */
        /*
        if ((style & SS_RIGHTJUST) != 0)
        {
            RECT wr;
            GetWindowRect(hwnd, &wr);
            SetWindowPos( hwnd, 0, wr.right - info->nWidth, wr.bottom - info->nHeight,
                          info->nWidth, info->nHeight, SWP_NOACTIVATE | SWP_NOZORDER );
        }
        else */
        {
            SetWindowPos( hwnd, 0, 0, 0, size.cx, size.cy, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER );
        }
    }
    return prevIcon;
}

Referenced by STATIC_WindowProc(), and StaticWndProc_common().

STATIC_TryPaintFcn()

static VOID STATIC_TryPaintFcn ( HWND  hwnd, LONG  full_style  )

static

Definition at line 270 of file static.c.

{
    LONG style = full_style & SS_TYPEMASK;
    RECT rc;
 
    GetClientRect( hwnd, &rc );
    if (!IsRectEmpty(&rc) && IsWindowVisible(hwnd) && staticPaintFunc[style])
    {
        HDC hdc;
        HRGN hrgn;
 
        hdc = GetDC( hwnd );
        hrgn = set_control_clipping( hdc, &rc );
        (staticPaintFunc[style])( hwnd, hdc, full_style );
        SelectClipRgn( hdc, hrgn );
        if (hrgn) DeleteObject( hrgn );
        ReleaseDC( hwnd, hdc );
    }
}

Referenced by STATIC_WindowProc(), and StaticWndProc_common().

STATIC_WindowProc()

static LRESULT CALLBACK STATIC_WindowProc ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 327 of file static.c.

{
    LRESULT lResult = 0;
    LONG full_style = GetWindowLongW( hwnd, GWL_STYLE );
    LONG style = full_style & SS_TYPEMASK;
 
    if (!IsWindow( hwnd )) return 0;
 
    switch (uMsg)
    {
    case WM_CREATE:
        if (style < 0L || style > SS_TYPEMASK)
        {
            ERR("Unknown style 0x%02x\n", style );
            return -1;
        }
        break;
 
    case WM_NCDESTROY:
        if (style == SS_ICON)
        {
/*
 * FIXME
 *           DestroyIcon32( STATIC_SetIcon( wndPtr, 0 ) );
 *
 * We don't want to do this yet because DestroyIcon32 is broken. If the icon
 * had already been loaded by the application the last thing we want to do is
 * GlobalFree16 the handle.
 */
            break;
        }
        else
            return DefWindowProcW(hwnd, uMsg, wParam, lParam);
 
    case WM_ERASEBKGND:
        /* do all painting in WM_PAINT like Windows does */
        return 1;
 
    case WM_PRINTCLIENT:
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            RECT rect;
            HDC hdc = wParam ? (HDC)wParam : BeginPaint(hwnd, &ps);
            GetClientRect( hwnd, &rect );
            if (staticPaintFunc[style])
            {
                HRGN hrgn = set_control_clipping( hdc, &rect );
                (staticPaintFunc[style])( hwnd, hdc, full_style );
                SelectClipRgn( hdc, hrgn );
                if (hrgn) DeleteObject( hrgn );
            }
            if (!wParam) EndPaint(hwnd, &ps);
        }
        break;
 
    case WM_ENABLE:
        STATIC_TryPaintFcn( hwnd, full_style );
        if (full_style & SS_NOTIFY)
        {
            if (wParam)
                SendMessageW( GetParent(hwnd), WM_COMMAND,
                              MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_ENABLE ), (LPARAM)hwnd);
            else
                SendMessageW( GetParent(hwnd), WM_COMMAND,
                              MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_DISABLE ), (LPARAM)hwnd);
        }
        break;
 
    case WM_SYSCOLORCHANGE:
        COMCTL32_RefreshSysColors();
        STATIC_TryPaintFcn( hwnd, full_style );
        break;
 
    case WM_NCCREATE:
        {
            CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
 
            if (full_style & SS_SUNKEN)
                SetWindowLongW( hwnd, GWL_EXSTYLE,
                                GetWindowLongW( hwnd, GWL_EXSTYLE ) | WS_EX_STATICEDGE );
 
            switch (style)
            {
            case SS_ICON:
                {
                    HICON hIcon;
 
                    hIcon = STATIC_LoadIconW(cs->hInstance, cs->lpszName, full_style);
                    STATIC_SetIcon(hwnd, hIcon, full_style);
                }
                break;
            case SS_BITMAP:
                if ((ULONG_PTR)cs->hInstance >> 16)
                {
                    HBITMAP hBitmap;
                    hBitmap = LoadBitmapW(cs->hInstance, cs->lpszName);
                    STATIC_SetBitmap(hwnd, hBitmap, full_style);
                }
                break;
            }
            /* SS_ENHMETAFILE: Despite what MSDN says, Windows does not load
               the enhanced metafile that was specified as the window text. */
        }
        return DefWindowProcW(hwnd, uMsg, wParam, lParam);
 
    case WM_SETTEXT:
        if (hasTextStyle( full_style ))
        {
            lResult = DefWindowProcW( hwnd, uMsg, wParam, lParam );
            STATIC_TryPaintFcn( hwnd, full_style );
        }
        break;
 
    case WM_SETFONT:
        if (hasTextStyle( full_style ))
        {
            SetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET, wParam );
            if (LOWORD(lParam))
                RedrawWindow( hwnd, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN );
        }
        break;
 
    case WM_GETFONT:
        return GetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET );
 
    case WM_NCHITTEST:
        if (full_style & SS_NOTIFY)
           return HTCLIENT;
        else
           return HTTRANSPARENT;
 
    case WM_GETDLGCODE:
        return DLGC_STATIC;
 
    case WM_LBUTTONDOWN:
    case WM_NCLBUTTONDOWN:
        if (full_style & SS_NOTIFY)
            SendMessageW( GetParent(hwnd), WM_COMMAND,
                          MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_CLICKED ), (LPARAM)hwnd);
        return 0;
 
    case WM_LBUTTONDBLCLK:
    case WM_NCLBUTTONDBLCLK:
        if (full_style & SS_NOTIFY)
            SendMessageW( GetParent(hwnd), WM_COMMAND,
                          MAKEWPARAM( GetWindowLongPtrW(hwnd,GWLP_ID), STN_DBLCLK ), (LPARAM)hwnd);
        return 0;
 
    case STM_GETIMAGE:
        return (LRESULT)STATIC_GetImage( hwnd, wParam, full_style );
 
    case STM_GETICON:
        return (LRESULT)STATIC_GetImage( hwnd, IMAGE_ICON, full_style );
 
    case STM_SETIMAGE:
        switch (wParam)
        {
        case IMAGE_BITMAP:
            lResult = (LRESULT)STATIC_SetBitmap( hwnd, (HBITMAP)lParam, full_style );
            break;
        case IMAGE_ENHMETAFILE:
            lResult = (LRESULT)STATIC_SetEnhMetaFile( hwnd, (HENHMETAFILE)lParam, full_style );
            break;
        case IMAGE_ICON:
        case IMAGE_CURSOR:
            lResult = (LRESULT)STATIC_SetIcon( hwnd, (HICON)lParam, full_style );
            break;
        default:
            FIXME("STM_SETIMAGE: Unhandled type %lx\n", wParam);
            break;
        }
        STATIC_TryPaintFcn( hwnd, full_style );
        break;
 
    case STM_SETICON:
        lResult = (LRESULT)STATIC_SetIcon( hwnd, (HICON)wParam, full_style );
        STATIC_TryPaintFcn( hwnd, full_style );
        break;
 
    default:
        return DefWindowProcW(hwnd, uMsg, wParam, lParam);
    }
    return lResult;
}

Referenced by STATIC_Register().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

static

)

Variable Documentation

staticPaintFunc

const pfPaint staticPaintFunc[SS_TYPEMASK+1]

static

Initial value:

=
{
    STATIC_PaintTextfn,      
    STATIC_PaintTextfn,      
    STATIC_PaintTextfn,      
    STATIC_PaintIconfn,      
    STATIC_PaintRectfn,      
    STATIC_PaintRectfn,      
    STATIC_PaintRectfn,      
    STATIC_PaintRectfn,      
    STATIC_PaintRectfn,      
    STATIC_PaintRectfn,      
    NULL,                    
    STATIC_PaintTextfn,      
    STATIC_PaintTextfn,      
    STATIC_PaintOwnerDrawfn, 
    STATIC_PaintBitmapfn,    
    STATIC_PaintEnhMetafn,   
    STATIC_PaintEtchedfn,    
    STATIC_PaintEtchedfn,    
    STATIC_PaintEtchedfn,    
}

Definition at line 65 of file static.c.

Referenced by STATIC_TryPaintFcn(), STATIC_WindowProc(), and StaticWndProc_common().