draw.c File Reference

#include <user32.h>

Include dependency graph for draw.c:

Go to the source code of this file.

Macros
#define	RBInnerSoft   RBInnerNormal /* These are the same */
#define	RBOuterSoft   RBOuterNormal

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (user32)
HBRUSH WINAPI	GetSysColorBrush (int nIndex)
static BOOL	IntDrawDiagEdge (HDC hdc, LPRECT rc, UINT uType, UINT uFlags)
static BOOL	IntDrawRectEdge (HDC hdc, LPRECT rc, UINT uType, UINT uFlags, UINT width)
static int	UITOOLS_MakeSquareRect (LPRECT src, LPRECT dst)
static void	UITOOLS_DrawCheckedRect (HDC dc, LPRECT rect)
static BOOL	UITOOLS95_DFC_ButtonPush (HDC dc, LPRECT r, UINT uFlags)
static BOOL	UITOOLS95_DFC_ButtonCheckRadio (HDC dc, LPRECT r, UINT uFlags, BOOL Radio)
static BOOL	UITOOLS95_DrawFrameButton (HDC hdc, LPRECT rc, UINT uState)
static BOOL	UITOOLS95_DrawFrameCaption (HDC dc, LPRECT r, UINT uFlags)
static BOOL	UITOOLS95_DrawFrameScroll (HDC dc, LPRECT r, UINT uFlags)
static BOOL	UITOOLS95_DrawFrameMenu (HDC dc, LPRECT r, UINT uFlags)
BOOL WINAPI	IntGrayString (HDC hDC, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight, BOOL unicode)
static BOOL	PAINTING_DrawStateJam (HDC hdc, UINT opcode, DRAWSTATEPROC func, LPARAM lp, WPARAM wp, LPRECT rc, UINT dtflags, BOOL unicode)
static BOOL	IntDrawState (HDC hdc, HBRUSH hbr, DRAWSTATEPROC func, LPARAM lp, WPARAM wp, INT x, INT y, INT cx, INT cy, UINT flags, BOOL unicode)
BOOL WINAPI	RealDrawFrameControl (HDC hDC, LPRECT rc, UINT uType, UINT uState)
BOOL WINAPI	DrawFrameControl (HDC hDC, LPRECT rc, UINT uType, UINT uState)
BOOL WINAPI	DrawEdge (HDC hDC, LPRECT rc, UINT edge, UINT flags)
BOOL WINAPI	GrayStringA (HDC hDC, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight)
BOOL WINAPI	GrayStringW (HDC hDC, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight)
BOOL WINAPI	InvertRect (HDC hDC, CONST RECT *lprc)
INT WINAPI	FrameRect (HDC hDC, CONST RECT *lprc, HBRUSH hbr)
BOOL WINAPI	FlashWindow (HWND hWnd, BOOL bInvert)
INT WINAPI	FillRect (HDC hDC, CONST RECT *lprc, HBRUSH hbr)
BOOL WINAPI	DrawFocusRect (HDC hdc, CONST RECT *rect)
BOOL WINAPI	DrawStateA (HDC hDC, HBRUSH hBrush, DRAWSTATEPROC lpOutputFunc, LPARAM lData, WPARAM wData, int x, int y, int cx, int cy, UINT fuFlags)
BOOL WINAPI	DrawStateW (HDC hDC, HBRUSH hBrush, DRAWSTATEPROC lpOutputFunc, LPARAM lData, WPARAM wData, int x, int y, int cx, int cy, UINT fuFlags)

Variables
static const signed char	LTInnerNormal []
static const signed char	LTOuterNormal []
static const signed char	RBInnerNormal []
static const signed char	RBOuterNormal []
static const signed char	LTInnerSoft []
static const signed char	LTOuterSoft []
static const signed char	LTRBOuterMono []
static const signed char	LTRBInnerMono []
static const signed char	LTRBOuterFlat []
static const signed char	LTRBInnerFlat []

Macro Definition Documentation

RBInnerSoft

#define RBInnerSoft   RBInnerNormal /* These are the same */

Definition at line 83 of file draw.c.

RBOuterSoft

#define RBOuterSoft   RBOuterNormal

Definition at line 84 of file draw.c.

Function Documentation

DrawEdge()

BOOL WINAPI DrawEdge	(	HDC	hDC,
		LPRECT	rc,
		UINT	edge,
		UINT	flags
	)

Definition at line 1474 of file draw.c.

{
    if (flags & BF_DIAGONAL)
        return IntDrawDiagEdge(hDC, rc, edge, flags);
    else
        return IntDrawRectEdge(hDC, rc, edge, flags, 1);
}

DrawFocusRect()

BOOL WINAPI DrawFocusRect	(	HDC	hdc,
		CONST RECT *	rect
	)

Definition at line 1585 of file draw.c.

{
    HGDIOBJ OldObj;
    UINT cx, cy;

    NtUserSystemParametersInfo(SPI_GETFOCUSBORDERWIDTH, 0, &cx, 0);
    NtUserSystemParametersInfo(SPI_GETFOCUSBORDERHEIGHT, 0, &cy, 0);

    OldObj = SelectObject(hdc, gpsi->hbrGray);

    /* top */
    PatBlt(hdc, rect->left, rect->top, rect->right - rect->left, cy, PATINVERT);
    /* bottom */
    PatBlt(hdc, rect->left, rect->bottom - cy, rect->right - rect->left, cy, PATINVERT);
    /* left */
    PatBlt(hdc, rect->left, rect->top + cy, cx, rect->bottom - rect->top - (2 * cy), PATINVERT);
    /* right */
    PatBlt(hdc, rect->right - cx, rect->top + cy, cx, rect->bottom - rect->top - (2 * cy), PATINVERT);

    SelectObject(hdc, OldObj);
    return TRUE;
}

DrawFrameControl()

BOOL WINAPI DrawFrameControl	(	HDC	hDC,
		LPRECT	rc,
		UINT	uType,
		UINT	uState
	)

Definition at line 1444 of file draw.c.

{
   BOOL Hook, Ret = FALSE;

   LoadUserApiHook();

   Hook = BeginIfHookedUserApiHook();

   /* Bypass SEH and go direct. */
   if (!Hook) return RealDrawFrameControl(hDC, rc, uType, uState);

   _SEH2_TRY
   {
      Ret = guah.DrawFrameControl(hDC, rc, uType, uState);
   }
   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
   {
       ERR("Got exception in hooked DrawFrameControl!\n");
   }
   _SEH2_END;

   EndUserApiHook();

   return Ret;
}

DrawStateA()

BOOL WINAPI DrawStateA	(	HDC	hDC,
		HBRUSH	hBrush,
		DRAWSTATEPROC	lpOutputFunc,
		LPARAM	lData,
		WPARAM	wData,
		int	x,
		int	y,
		int	cx,
		int	cy,
		UINT	fuFlags
	)

Definition at line 1612 of file draw.c.

{
    return IntDrawState(hDC, hBrush, lpOutputFunc, lData, wData, x, y, cx, cy, fuFlags, FALSE);
}

DrawStateW()

BOOL WINAPI DrawStateW	(	HDC	hDC,
		HBRUSH	hBrush,
		DRAWSTATEPROC	lpOutputFunc,
		LPARAM	lData,
		WPARAM	wData,
		int	x,
		int	y,
		int	cx,
		int	cy,
		UINT	fuFlags
	)

Definition at line 1622 of file draw.c.

{
    return IntDrawState(hDC, hBrush, lpOutputFunc, lData, wData, x, y, cx, cy, fuFlags, TRUE);
}

FillRect()

INT WINAPI FillRect	(	HDC	hDC,
		CONST RECT *	lprc,
		HBRUSH	hbr
	)

Definition at line 1554 of file draw.c.

{
    BOOL Ret;
    HBRUSH prevhbr = NULL;

    /* Select brush if specified */
    if (hbr)
    {
        /* Handle system colors */
        if (hbr <= (HBRUSH)(COLOR_MENUBAR + 1))
            hbr = GetSysColorBrush(PtrToUlong(hbr) - 1);

        prevhbr = SelectObject(hDC, hbr);
        if (prevhbr == NULL)
            return (INT)FALSE;
    }

    Ret = PatBlt(hDC, lprc->left, lprc->top, lprc->right - lprc->left,
                 lprc->bottom - lprc->top, PATCOPY);

    /* Select old brush */
    if (prevhbr)
        SelectObject(hDC, prevhbr);

    return (INT)Ret;
}

FlashWindow()

BOOL WINAPI FlashWindow	(	HWND	hWnd,
		BOOL	bInvert
	)

Definition at line 1537 of file draw.c.

{
    FLASHWINFO FlashWndInfo;

    FlashWndInfo.cbSize = sizeof(FLASHWINFO);
    FlashWndInfo.hwnd = hWnd;
    FlashWndInfo.dwFlags = !bInvert ? 0 : (FLASHW_TRAY | FLASHW_CAPTION);
    FlashWndInfo.uCount = 1;
    FlashWndInfo.dwTimeout = 0;

    return NtUserFlashWindowEx(&FlashWndInfo);
}

FrameRect()

INT WINAPI FrameRect	(	HDC	hDC,
		CONST RECT *	lprc,
		HBRUSH	hbr
	)

Definition at line 1516 of file draw.c.

{
    HBRUSH oldbrush;
    RECT r = *lprc;

    if (IsRectEmpty(&r)) return 0;
    if (!(oldbrush = SelectObject(hDC, hbr))) return 0;

    PatBlt(hDC, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
    PatBlt(hDC, r.right - 1, r.top, 1, r.bottom - r.top, PATCOPY);
    PatBlt(hDC, r.left, r.top, r.right - r.left, 1, PATCOPY);
    PatBlt(hDC, r.left, r.bottom - 1, r.right - r.left, 1, PATCOPY);

    SelectObject(hDC, oldbrush);
    return TRUE;
}

GetSysColorBrush()

HBRUSH WINAPI GetSysColorBrush

(

int

nIndex

)

Definition at line 39 of file defwnd.c.

{
  if(nIndex >= 0 && nIndex < NUM_SYSCOLORS)
  {
    return gpsi->ahbrSystem[nIndex];
  }

  return NULL;
}

Referenced by DefWndControlColor(), FillRect(), IntDrawRectEdge(), IntDrawState(), UITOOLS95_DFC_ButtonPush(), and UITOOLS_DrawCheckedRect().

GrayStringA()

BOOL WINAPI GrayStringA	(	HDC	hDC,
		HBRUSH	hBrush,
		GRAYSTRINGPROC	lpOutputFunc,
		LPARAM	lpData,
		int	nCount,
		int	X,
		int	Y,
		int	nWidth,
		int	nHeight
	)

Definition at line 1486 of file draw.c.

{
    return IntGrayString(hDC, hBrush, lpOutputFunc, lpData, nCount, X, Y, nWidth, nHeight, FALSE);
}

GrayStringW()

BOOL WINAPI GrayStringW	(	HDC	hDC,
		HBRUSH	hBrush,
		GRAYSTRINGPROC	lpOutputFunc,
		LPARAM	lpData,
		int	nCount,
		int	X,
		int	Y,
		int	nWidth,
		int	nHeight
	)

Definition at line 1496 of file draw.c.

{
    return IntGrayString(hDC, hBrush, lpOutputFunc, lpData, nCount, X, Y, nWidth, nHeight, TRUE);
}

IntDrawDiagEdge()

static BOOL IntDrawDiagEdge ( HDC  hdc, LPRECT  rc, UINT  uType, UINT  uFlags  )

static

Definition at line 120 of file draw.c.

{
    POINT Points[4];
    signed char InnerI, OuterI;
    HPEN InnerPen, OuterPen;
    POINT SavePoint;
    HPEN SavePen;
    int spx, spy;
    int epx, epy;
    int Width = rc->right - rc->left;
    int Height= rc->bottom - rc->top;
    int SmallDiam = Width > Height ? Height : Width;
    BOOL retval = !(   ((uType & BDR_INNER) == BDR_INNER
                        || (uType & BDR_OUTER) == BDR_OUTER)
                       && !(uFlags & (BF_FLAT|BF_MONO)) );
    int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0)
            + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0);

    /* Init some vars */
    OuterPen = InnerPen = (HPEN)GetStockObject(NULL_PEN);
    SavePen = (HPEN)SelectObject(hdc, InnerPen);
    spx = spy = epx = epy = 0; /* Satisfy the compiler... */

    /* Determine the colors of the edges */
    if(uFlags & BF_MONO)
    {
        InnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)];
        OuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)];
    }
    else if(uFlags & BF_FLAT)
    {
        InnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)];
        OuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)];
    }
    else if(uFlags & BF_SOFT)
    {
        if(uFlags & BF_BOTTOM)
        {
            InnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
            OuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
        }
        else
        {
            InnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
            OuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
        }
    }
    else
    {
        if(uFlags & BF_BOTTOM)
        {
            InnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
            OuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
        }
        else
        {
            InnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
            OuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
        }
    }

    if(InnerI != -1) InnerPen = GetStockObject(DC_PEN);
    if(OuterI != -1) OuterPen = GetStockObject(DC_PEN);

    MoveToEx(hdc, 0, 0, &SavePoint);

    /* Don't ask me why, but this is what is visible... */
    /* This must be possible to do much simpler, but I fail to */
    /* see the logic in the MS implementation (sigh...). */
    /* So, this might look a bit brute force here (and it is), but */
    /* it gets the job done;) */

    switch(uFlags & BF_RECT)
    {
        case 0:
        case BF_LEFT:
        case BF_BOTTOM:
        case BF_BOTTOMLEFT:
            /* Left bottom endpoint */
            epx = rc->left-1;
            spx = epx + SmallDiam;
            epy = rc->bottom;
            spy = epy - SmallDiam;
            break;

        case BF_TOPLEFT:
        case BF_BOTTOMRIGHT:
            /* Left top endpoint */
            epx = rc->left-1;
            spx = epx + SmallDiam;
            epy = rc->top-1;
            spy = epy + SmallDiam;
            break;

        case BF_TOP:
        case BF_RIGHT:
        case BF_TOPRIGHT:
        case BF_RIGHT|BF_LEFT:
        case BF_RIGHT|BF_LEFT|BF_TOP:
        case BF_BOTTOM|BF_TOP:
        case BF_BOTTOM|BF_TOP|BF_LEFT:
        case BF_BOTTOMRIGHT|BF_LEFT:
        case BF_BOTTOMRIGHT|BF_TOP:
        case BF_RECT:
            /* Right top endpoint */
            spx = rc->left;
            epx = spx + SmallDiam;
            spy = rc->bottom-1;
            epy = spy - SmallDiam;
            break;
    }

    MoveToEx(hdc, spx, spy, NULL);
    SelectObject(hdc, OuterPen);
    SetDCPenColor(hdc, GetSysColor(OuterI));
    LineTo(hdc, epx, epy);

    SelectObject(hdc, InnerPen);
    SetDCPenColor(hdc, GetSysColor(InnerI));

    switch(uFlags & (BF_RECT|BF_DIAGONAL))
    {
        case BF_DIAGONAL_ENDBOTTOMLEFT:
        case (BF_DIAGONAL|BF_BOTTOM):
        case BF_DIAGONAL:
        case (BF_DIAGONAL|BF_LEFT):
            MoveToEx(hdc, spx-1, spy, NULL);
            LineTo(hdc, epx, epy-1);
            Points[0].x = spx-add;
            Points[0].y = spy;
            Points[1].x = rc->left;
            Points[1].y = rc->top;
            Points[2].x = epx+1;
            Points[2].y = epy-1-add;
            Points[3] = Points[2];
            break;

        case BF_DIAGONAL_ENDBOTTOMRIGHT:
            MoveToEx(hdc, spx-1, spy, NULL);
            LineTo(hdc, epx, epy+1);
            Points[0].x = spx-add;
            Points[0].y = spy;
            Points[1].x = rc->left;
            Points[1].y = rc->bottom-1;
            Points[2].x = epx+1;
            Points[2].y = epy+1+add;
            Points[3] = Points[2];
            break;

        case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP):
        case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP|BF_LEFT):
        case BF_DIAGONAL_ENDTOPRIGHT:
        case (BF_DIAGONAL|BF_RIGHT|BF_TOP|BF_LEFT):
            MoveToEx(hdc, spx+1, spy, NULL);
            LineTo(hdc, epx, epy+1);
            Points[0].x = epx-1;
            Points[0].y = epy+1+add;
            Points[1].x = rc->right-1;
            Points[1].y = rc->top+add;
            Points[2].x = rc->right-1;
            Points[2].y = rc->bottom-1;
            Points[3].x = spx+add;
            Points[3].y = spy;
            break;

        case BF_DIAGONAL_ENDTOPLEFT:
            MoveToEx(hdc, spx, spy-1, NULL);
            LineTo(hdc, epx+1, epy);
            Points[0].x = epx+1+add;
            Points[0].y = epy+1;
            Points[1].x = rc->right-1;
            Points[1].y = rc->top;
            Points[2].x = rc->right-1;
            Points[2].y = rc->bottom-1-add;
            Points[3].x = spx;
            Points[3].y = spy-add;
            break;

        case (BF_DIAGONAL|BF_TOP):
        case (BF_DIAGONAL|BF_BOTTOM|BF_TOP):
        case (BF_DIAGONAL|BF_BOTTOM|BF_TOP|BF_LEFT):
            MoveToEx(hdc, spx+1, spy-1, NULL);
            LineTo(hdc, epx, epy);
            Points[0].x = epx-1;
            Points[0].y = epy+1;
            Points[1].x = rc->right-1;
            Points[1].y = rc->top;
            Points[2].x = rc->right-1;
            Points[2].y = rc->bottom-1-add;
            Points[3].x = spx+add;
            Points[3].y = spy-add;
            break;

        case (BF_DIAGONAL|BF_RIGHT):
        case (BF_DIAGONAL|BF_RIGHT|BF_LEFT):
        case (BF_DIAGONAL|BF_RIGHT|BF_LEFT|BF_BOTTOM):
            MoveToEx(hdc, spx, spy, NULL);
            LineTo(hdc, epx-1, epy+1);
            Points[0].x = spx;
            Points[0].y = spy;
            Points[1].x = rc->left;
            Points[1].y = rc->top+add;
            Points[2].x = epx-1-add;
            Points[2].y = epy+1+add;
            Points[3] = Points[2];
            break;
    }

    /* Fill the interior if asked */
    if((uFlags & BF_MIDDLE) && retval)
    {
        HBRUSH hbsave;
        HPEN hpsave;
        hbsave = (HBRUSH)SelectObject(hdc, GetStockObject(DC_BRUSH));
        hpsave = (HPEN)SelectObject(hdc, GetStockObject(DC_PEN));
        SetDCBrushColor(hdc, GetSysColor(uFlags & BF_MONO ? COLOR_WINDOW : COLOR_BTNFACE));
        SetDCPenColor(hdc, GetSysColor(uFlags & BF_MONO ? COLOR_WINDOW : COLOR_BTNFACE));
        Polygon(hdc, Points, 4);
        SelectObject(hdc, hbsave);
        SelectObject(hdc, hpsave);
    }

    /* Adjust rectangle if asked */
    if(uFlags & BF_ADJUST)
    {
        if(uFlags & BF_LEFT)   rc->left   += add;
        if(uFlags & BF_RIGHT)  rc->right  -= add;
        if(uFlags & BF_TOP)    rc->top    += add;
        if(uFlags & BF_BOTTOM) rc->bottom -= add;
    }

    /* Cleanup */
    SelectObject(hdc, SavePen);
    MoveToEx(hdc, SavePoint.x, SavePoint.y, NULL);

    return retval;
}

IntDrawRectEdge()

static BOOL IntDrawRectEdge ( HDC  hdc, LPRECT  rc, UINT  uType, UINT  uFlags, UINT  width  )

static

Definition at line 429 of file draw.c.

{
    signed char LTInnerI, LTOuterI;
    signed char RBInnerI, RBOuterI;
    HBRUSH lti_brush, lto_brush, rbi_brush, rbo_brush;
    RECT InnerRect = *rc, fill_rect;
    int lbi_offset = 0, lti_offset = 0, rti_offset = 0, rbi_offset = 0;
    BOOL retval = !(   ((uType & BDR_INNER) == BDR_INNER
                       || (uType & BDR_OUTER) == BDR_OUTER)
                      && !(uFlags & (BF_FLAT|BF_MONO)) );

    lti_brush = lto_brush = rbi_brush = rbo_brush = GetStockObject(NULL_BRUSH);

    /* Determine the colors of the edges */
    if(uFlags & BF_MONO)
    {
        LTInnerI = RBInnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)];
        LTOuterI = RBOuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)];
    }
    else if(uFlags & BF_FLAT)
    {
        LTInnerI = RBInnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)];
        LTOuterI = RBOuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)];

        /* Bertho Stultiens states above that this function exactly matches win95
         * In win98 BF_FLAT rectangles have an inner border same color as the
        * middle (COLOR_BTNFACE). I believe it's the same for win95 but since
        * I don't know I go with Bertho and just sets it for win98 until proven
        * otherwise.
        *                                          Dennis Björklund, 10 June, 99
        */
    if( LTInnerI != -1 ) LTInnerI = RBInnerI = COLOR_BTNFACE;
    }
    else if(uFlags & BF_SOFT)
    {
        LTInnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
        LTOuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
        RBInnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
        RBOuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
    }
    else
    {
        LTInnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
        LTOuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
        RBInnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
        RBOuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
    }

    if((uFlags & BF_BOTTOMLEFT) == BF_BOTTOMLEFT)   lbi_offset = width;
    if((uFlags & BF_TOPRIGHT) == BF_TOPRIGHT)       rti_offset = width;
    if((uFlags & BF_BOTTOMRIGHT) == BF_BOTTOMRIGHT) rbi_offset = width;
    if((uFlags & BF_TOPLEFT) == BF_TOPLEFT)         lti_offset = width;

    if(LTInnerI != -1) lti_brush = GetSysColorBrush(LTInnerI);
    if(LTOuterI != -1) lto_brush = GetSysColorBrush(LTOuterI);
    if(RBInnerI != -1) rbi_brush = GetSysColorBrush(RBInnerI);
    if(RBOuterI != -1) rbo_brush = GetSysColorBrush(RBOuterI);

    /* Draw the outer edge */
    if(uFlags & BF_TOP)
    {
        fill_rect = InnerRect;
        fill_rect.bottom = fill_rect.top + width;
        FillRect( hdc, &fill_rect, lto_brush );
    }
    if(uFlags & BF_LEFT)
    {
        fill_rect = InnerRect;
        fill_rect.right = fill_rect.left + width;
        FillRect( hdc, &fill_rect, lto_brush );
    }
    if(uFlags & BF_BOTTOM)
    {
        fill_rect = InnerRect;
        fill_rect.top = fill_rect.bottom - width;
        FillRect( hdc, &fill_rect, rbo_brush );
    }
    if(uFlags & BF_RIGHT)
    {
        fill_rect = InnerRect;
        fill_rect.left = fill_rect.right - width;
        FillRect( hdc, &fill_rect, rbo_brush );
    }

    /* Draw the inner edge */
    if(uFlags & BF_TOP)
    {
        SetRect( &fill_rect, InnerRect.left + lti_offset, InnerRect.top + width,
                 InnerRect.right - rti_offset, InnerRect.top + 2 * width );
        FillRect( hdc, &fill_rect, lti_brush );
    }
    if(uFlags & BF_LEFT)
    {
        SetRect( &fill_rect, InnerRect.left + width, InnerRect.top + lti_offset,
                 InnerRect.left + 2 * width, InnerRect.bottom - lbi_offset );
        FillRect( hdc, &fill_rect, lti_brush );
    }
    if(uFlags & BF_BOTTOM)
    {
        SetRect( &fill_rect, InnerRect.left + lbi_offset, InnerRect.bottom - 2 * width,
                 InnerRect.right - rbi_offset, InnerRect.bottom - width );
        FillRect( hdc, &fill_rect, rbi_brush );
    }
    if(uFlags & BF_RIGHT)
    {
        SetRect( &fill_rect, InnerRect.right - 2 * width, InnerRect.top + rti_offset,
                 InnerRect.right - width, InnerRect.bottom - rbi_offset );
        FillRect( hdc, &fill_rect, rbi_brush );
    }

    if( ((uFlags & BF_MIDDLE) && retval) || (uFlags & BF_ADJUST) )
    {
        int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? width : 0)
                + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? width : 0);

        if(uFlags & BF_LEFT)   InnerRect.left   += add;
        if(uFlags & BF_RIGHT)  InnerRect.right  -= add;
        if(uFlags & BF_TOP)    InnerRect.top    += add;
        if(uFlags & BF_BOTTOM) InnerRect.bottom -= add;

        if((uFlags & BF_MIDDLE) && retval)
    {
            FillRect(hdc, &InnerRect, GetSysColorBrush(uFlags & BF_MONO ?
                               COLOR_WINDOW : COLOR_BTNFACE));
    }

    if(uFlags & BF_ADJUST)
        *rc = InnerRect;
    }

    return retval;
}

IntDrawState()

static BOOL IntDrawState ( HDC  hdc, HBRUSH  hbr, DRAWSTATEPROC  func, LPARAM  lp, WPARAM  wp, INT  x, INT  y, INT  cx, INT  cy, UINT  flags, BOOL  unicode  )

static

Definition at line 1233 of file draw.c.

{
    HBITMAP hbm, hbmsave;
    HFONT hfsave;
    HBRUSH hbsave, hbrtmp = 0;
    HDC memdc;
    RECT rc;
    UINT dtflags = DT_NOCLIP;
    COLORREF fg, bg;
    UINT opcode = flags & 0xf;
    INT len = wp;
    BOOL retval, tmp;
    LOGFONTW lf;
    HFONT hFontOriginal, hNaaFont = NULL;

    if((opcode == DST_TEXT || opcode == DST_PREFIXTEXT) && !len)    /* The string is '\0' terminated */
    {
        if(unicode)
            len = lstrlenW((LPWSTR)lp);
        else
            len = lstrlenA((LPSTR)lp);
    }

    hFontOriginal = GetCurrentObject(hdc, OBJ_FONT);
    if (flags & (DSS_MONO | DSS_DISABLED))
    {
        /* Create a non-antialiased font */
        GetObjectW(hFontOriginal, sizeof(lf), &lf);
        lf.lfQuality = NONANTIALIASED_QUALITY;
        hNaaFont = CreateFontIndirectW(&lf);
    }

    /* Find out what size the image has if not given by caller */
    if(!cx || !cy)
    {
        SIZE s;
        BITMAP bm;

        switch(opcode)
        {
            case DST_TEXT:
            case DST_PREFIXTEXT:
                if(unicode)
                    retval = GetTextExtentPoint32W(hdc, (LPWSTR)lp, len, &s);
                else
                    retval = GetTextExtentPoint32A(hdc, (LPSTR)lp, len, &s);
                if(!retval)
                    return FALSE;
                break;

            case DST_ICON:
                if(!get_icon_size((HICON)lp, &s))
                    return FALSE;
                break;

            case DST_BITMAP:
                if(!GetObjectW((HBITMAP)lp, sizeof(bm), &bm))
                    return FALSE;
                s.cx = bm.bmWidth;
                s.cy = bm.bmHeight;
                break;

            case DST_COMPLEX: /* cx and cy must be set in this mode */
                return FALSE;

            default:
                ERR("Invalid opcode: %u\n", opcode);
                return FALSE;
        }

        if(!cx) cx = s.cx;
        if(!cy) cy = s.cy;
    }

    SetRect(&rc, x, y, x + cx, y + cy);

    if(flags & DSS_RIGHT)    /* This one is not documented in the win32.hlp file */
        dtflags |= DT_RIGHT;
    if(opcode == DST_TEXT)
        dtflags |= DT_NOPREFIX;
    else if(opcode == DST_PREFIXTEXT)
    {
        if (flags & DSS_HIDEPREFIX)
            dtflags |= DT_HIDEPREFIX;
        if (flags & DSS_PREFIXONLY)
            dtflags |= DT_PREFIXONLY;
    }

    /* For DSS_NORMAL we just jam in the image and return */
    if((flags & 0x79f0) == DSS_NORMAL)
    {
        return PAINTING_DrawStateJam(hdc, opcode, func, lp, len, &rc, dtflags, unicode);
    }

    /* For all other states we need to convert the image to B/W in a local bitmap */
    /* before it is displayed */
    fg = SetTextColor(hdc, RGB(0, 0, 0));
    bg = SetBkColor(hdc, RGB(255, 255, 255));
    hbm = NULL; hbmsave = NULL;
    memdc = NULL; hbsave = NULL;
    retval = FALSE; /* assume failure */

    /* From here on we must use "goto cleanup" when something goes wrong */
    hbm     = CreateBitmap(cx, cy, 1, 1, NULL);
    if(!hbm) goto cleanup;
    memdc   = CreateCompatibleDC(hdc);
    if(!memdc) goto cleanup;
    hbmsave = (HBITMAP)SelectObject(memdc, hbm);
    if(!hbmsave) goto cleanup;
    SetRect(&rc, 0, 0, cx, cy);
    if(!FillRect(memdc, &rc, (HBRUSH)GetStockObject(WHITE_BRUSH))) goto cleanup;
    SetBkColor(memdc, RGB(255, 255, 255));
    SetTextColor(memdc, RGB(0, 0, 0));
    if (hNaaFont)
        hfsave  = (HFONT)SelectObject(memdc, hNaaFont);
    else
        hfsave  = (HFONT)SelectObject(memdc, hFontOriginal);
    SetLayout( memdc, GetLayout( hdc ));

    /* DST_COMPLEX may draw text as well,
     * so we must be sure that correct font is selected
     */
    if(!hfsave && (opcode <= DST_PREFIXTEXT)) goto cleanup;
    tmp = PAINTING_DrawStateJam(memdc, opcode, func, lp, len, &rc, dtflags, unicode);
    if(hfsave) SelectObject(memdc, hfsave);
    if (hNaaFont) DeleteObject(hNaaFont);
    if(!tmp) goto cleanup;

    /* This state cause the image to be dithered */
    if(flags & DSS_UNION)
    {
        hbsave = (HBRUSH)SelectObject(memdc, gpsi->hbrGray);
        if(!hbsave) goto cleanup;
        tmp = PatBlt(memdc, 0, 0, cx, cy, 0x00FA0089);
        SelectObject(memdc, hbsave);
        if(!tmp) goto cleanup;
    }

    if (flags & DSS_DISABLED)
        hbrtmp = GetSysColorBrush(COLOR_3DHILIGHT);
    else if (flags & DSS_DEFAULT)
        hbrtmp = GetSysColorBrush(COLOR_3DSHADOW);

    /* Draw light or dark shadow */
    if (flags & (DSS_DISABLED|DSS_DEFAULT))
    {
        if(!hbrtmp) goto cleanup;
        hbsave = (HBRUSH)SelectObject(hdc, hbrtmp);
        if(!hbsave) goto cleanup;
        if(!BitBlt(hdc, x+1, y+1, cx, cy, memdc, 0, 0, 0x00B8074A)) goto cleanup;
        SelectObject(hdc, hbsave);
    }

    if (flags & DSS_DISABLED)
    {
        hbr = hbrtmp = GetSysColorBrush(COLOR_3DSHADOW);
        if(!hbrtmp) goto cleanup;
    }
    else if (!hbr)
    {
        hbr = (HBRUSH)GetStockObject(BLACK_BRUSH);
    }

    hbsave = (HBRUSH)SelectObject(hdc, hbr);

    if(!BitBlt(hdc, x, y, cx, cy, memdc, 0, 0, 0x00B8074A)) goto cleanup;

    retval = TRUE; /* We succeeded */

cleanup:
    SetTextColor(hdc, fg);
    SetBkColor(hdc, bg);

    if(hbsave) SelectObject(hdc, hbsave);
    if(hbmsave) SelectObject(memdc, hbmsave);
    if(hbm) DeleteObject(hbm);
    if(memdc) DeleteDC(memdc);

    return retval;
}

Referenced by DrawStateA(), and DrawStateW().

IntGrayString()

BOOL WINAPI IntGrayString	(	HDC	hDC,
		HBRUSH	hBrush,
		GRAYSTRINGPROC	lpOutputFunc,
		LPARAM	lpData,
		int	nCount,
		int	X,
		int	Y,
		int	nWidth,
		int	nHeight,
		BOOL	unicode
	)

Definition at line 1046 of file draw.c.

{
    // AG: Mostly implemented, but probably won't work properly or return
    // correct error codes. I doubt it grays strings either... Untested!

    BOOL    success = FALSE;
    HBRUSH  hbsave;
    HDC     MemDC = NULL;
    HBITMAP MemBMP = NULL, OldBMP = NULL;
    HBRUSH  OldBrush = NULL;
    HFONT   OldFont = NULL;
    RECT    r;
    COLORREF ForeColor, BackColor;

    ForeColor = SetTextColor(hDC, RGB(0, 0, 0));
    BackColor = SetBkColor(hDC, RGB(255, 255, 255));

    if (! hBrush)
    {
        // The documentation is a little vague on what exactly should happen
        // here. Something about using the same brush for window text???
        hBrush = (HBRUSH) GetCurrentObject(hDC, OBJ_BRUSH);
    }

    if ((nCount == -1) && (! lpOutputFunc))
        return FALSE;

    if (! nCount)
    {
        // TODO: calculate the length (easy enough)

        if (unicode)
            nCount = lstrlenW((WCHAR*)lpData);
        else
            nCount = lstrlenA((CHAR*)lpData);
    }

    if (! nWidth || ! nHeight)
    {
        SIZE s;
        // TODO: calculate the rect

        if (unicode)
            success = GetTextExtentPoint32W(hDC, (WCHAR*) lpData, nCount, &s);
        else
            success = GetTextExtentPoint32A(hDC, (CHAR*) lpData, nCount, &s);

        if (! success) goto cleanup;

        if (! nWidth)   nWidth = s.cx;
        if (! nHeight)  nHeight = s.cy;
    }

    SetRect(&r, X, Y, X + nWidth, Y + nHeight);

    MemDC = CreateCompatibleDC(hDC);
    if (! MemDC) goto cleanup;
    MemBMP = CreateBitmap(nWidth, nHeight, 1, 1, NULL);
    if (! MemBMP) goto cleanup;
    OldBMP = SelectObject(MemDC, MemBMP);
    if (! OldBMP) goto cleanup;
    OldFont = SelectObject(MemDC, GetCurrentObject(hDC, OBJ_FONT));
    if (! OldFont) goto cleanup;
    OldBrush = SelectObject(MemDC, hBrush);
    if (! OldBrush) goto cleanup;

    if (! BitBlt(MemDC, 0, 0, nWidth, nHeight, hDC, X, Y, SRCCOPY)) goto cleanup;

    SetTextColor(MemDC, RGB(255, 255, 255));
    SetBkColor(MemDC, RGB(0, 0, 0));

    if (lpOutputFunc)
    {
        success = lpOutputFunc(MemDC, lpData, nCount); // Set brush etc first?

        if ((nCount == -1) && (! success))
        {
            // Don't gray (documented behaviour)
            success = (BOOL) BitBlt(hDC, X, Y, nWidth, nHeight, MemDC, 0, 0, SRCCOPY);
            goto cleanup;
        }
    }
    else
    {
        if (unicode)
            success = TextOutW(MemDC, 0, 0, (WCHAR*) lpData, nCount);
        else
            success = TextOutA(MemDC, 0, 0, (CHAR*) lpData, nCount);

        if (! success) goto cleanup;

        hbsave = (HBRUSH)SelectObject(MemDC, gpsi->hbrGray);
        PatBlt(MemDC, 0, 0, nWidth, nHeight, 0x000A0329);
        SelectObject(MemDC, hbsave);
    }

    if (! BitBlt(hDC, X, Y, nWidth, nHeight, MemDC, 0, 0, SRCCOPY)) goto cleanup;

cleanup:
    SetTextColor(hDC, ForeColor);
    SetBkColor(hDC, BackColor);

    if (MemDC)
    {
        if (OldFont) SelectObject(MemDC, OldFont);
        if (OldBrush) SelectObject(MemDC, OldBrush);
        if (OldBMP) SelectObject(MemDC, OldBMP);
        if (MemBMP) DeleteObject(MemBMP);
        DeleteDC(MemDC);
    }

    return success;
}

Referenced by GrayStringA(), and GrayStringW().

InvertRect()

BOOL WINAPI InvertRect	(	HDC	hDC,
		CONST RECT *	lprc
	)

Definition at line 1506 of file draw.c.

{
    return PatBlt(hDC, lprc->left, lprc->top, lprc->right - lprc->left,
                  lprc->bottom - lprc->top, DSTINVERT);
}

PAINTING_DrawStateJam()

static BOOL PAINTING_DrawStateJam ( HDC  hdc, UINT  opcode, DRAWSTATEPROC  func, LPARAM  lp, WPARAM  wp, LPRECT  rc, UINT  dtflags, BOOL  unicode  )

static

Definition at line 1175 of file draw.c.

{
    HDC memdc;
    HBITMAP hbmsave;
    BOOL retval;
    INT cx = rc->right - rc->left;
    INT cy = rc->bottom - rc->top;

    switch(opcode)
    {
        case DST_TEXT:
        case DST_PREFIXTEXT:
            if(unicode)
                return DrawTextW(hdc, (LPWSTR)lp, (INT)wp, rc, dtflags);
            else
                return DrawTextA(hdc, (LPSTR)lp, (INT)wp, rc, dtflags);

        case DST_ICON:
            return DrawIconEx(hdc, rc->left, rc->top, (HICON)lp, cx, cy, 0, NULL, DI_NORMAL);

        case DST_BITMAP:
            memdc = CreateCompatibleDC(hdc);
            if(!memdc)
                return FALSE;
            hbmsave = (HBITMAP)SelectObject(memdc, (HBITMAP)lp);
            if(!hbmsave)
            {
                DeleteDC(memdc);
                return FALSE;
            }
            retval = BitBlt(hdc, rc->left, rc->top, cx, cy, memdc, 0, 0, SRCCOPY);
            SelectObject(memdc, hbmsave);
            DeleteDC(memdc);
            return retval;

        case DST_COMPLEX:
            if(func)
            {
                BOOL bRet;
                /* DRAWSTATEPROC assumes that it draws at the center of coordinates  */

                OffsetViewportOrgEx(hdc, rc->left, rc->top, NULL);
                bRet = func(hdc, lp, wp, cx, cy);
                /* Restore origin */
                OffsetViewportOrgEx(hdc, -rc->left, -rc->top, NULL);
                return bRet;
            }
            else
            {
                return FALSE;
            }
    }
    return FALSE;
}

Referenced by IntDrawState().

RealDrawFrameControl()

BOOL WINAPI RealDrawFrameControl	(	HDC	hDC,
		LPRECT	rc,
		UINT	uType,
		UINT	uState
	)

Definition at line 1419 of file draw.c.

{
    if (GetMapMode(hDC) != MM_TEXT)
        return FALSE;

    switch(uType)
    {
        case DFC_BUTTON:
            return UITOOLS95_DrawFrameButton(hDC, rc, uState);
        case DFC_CAPTION:
            return UITOOLS95_DrawFrameCaption(hDC, rc, uState);
        case DFC_MENU:
            return UITOOLS95_DrawFrameMenu(hDC, rc, uState);
#if 0
        case DFC_POPUPMENU:
            UNIMPLEMENTED;
            break;
#endif
        case DFC_SCROLL:
            return UITOOLS95_DrawFrameScroll(hDC, rc, uState);
    }
    return FALSE;
}

Referenced by DrawFrameControl(), and ResetUserApiHook().

UITOOLS95_DFC_ButtonCheckRadio()

static BOOL UITOOLS95_DFC_ButtonCheckRadio ( HDC  dc, LPRECT  r, UINT  uFlags, BOOL  Radio  )

static

Definition at line 657 of file draw.c.

{
    LOGFONTW lf;
    HFONT hFont, hOldFont;
    int i;
    TCHAR OutRight, OutLeft, InRight, InLeft, Center;
    INT X, Y, Width, Height, Shorter;
    INT BkMode = GetBkMode(dc);
    COLORREF TextColor = GetTextColor(dc);

    Width = r->right - r->left;
    Height = r->bottom - r->top;
    Shorter = (Width < Height) ? Width : Height;
    X = r->left + (Width - Shorter) / 2;
    Y = r->top + (Height - Shorter) / 2;

    if (Radio)
    {
        OutRight = 'j'; // Outer right
        OutLeft  = 'k'; // Outer left
        InRight  = 'l'; // inner left
        InLeft   = 'm'; // inner right
        Center   = 'n'; // center
    }
    else
    {
        OutRight = 'c'; // Outer right
        OutLeft  = 'd'; // Outer left
        InRight  = 'e'; // inner left
        InLeft   = 'f'; // inner right
        Center   = 'g'; // center
    }

    ZeroMemory(&lf, sizeof(LOGFONTW));
    lf.lfHeight = Shorter;
    lf.lfCharSet = DEFAULT_CHARSET;
    lstrcpy(lf.lfFaceName, TEXT("Marlett"));
    if (Radio && ((uFlags & 0xFF) == DFCS_BUTTONRADIOMASK))
    {
        lf.lfQuality = NONANTIALIASED_QUALITY;
    }
    hFont = CreateFontIndirect(&lf);
    hOldFont = SelectObject(dc, hFont);

    if (Radio && ((uFlags & 0xFF) == DFCS_BUTTONRADIOMASK))
    {
#if 1
        // FIXME: improve font rendering
        RECT Rect;
        HGDIOBJ hbrOld, hpenOld;
        FillRect(dc, r, (HBRUSH)GetStockObject(WHITE_BRUSH));
        SetRect(&Rect, X, Y, X + Shorter, Y + Shorter);
        InflateRect(&Rect, -(Shorter * 8) / 54, -(Shorter * 8) / 54);
        hbrOld = SelectObject(dc, GetStockObject(BLACK_BRUSH));
        hpenOld = SelectObject(dc, GetStockObject(NULL_PEN));
        Ellipse(dc, Rect.left, Rect.top, Rect.right, Rect.bottom);
        SelectObject(dc, hbrOld);
        SelectObject(dc, hpenOld);
#else
        SetBkMode(dc, OPAQUE);
        SetBkColor(dc, RGB(255, 255, 255));
        SetTextColor(dc, RGB(0, 0, 0));
        TextOut(dc, X, Y, &Center, 1);
        SetBkMode(dc, TRANSPARENT);
        TextOut(dc, X, Y, &OutRight, 1);
        TextOut(dc, X, Y, &OutLeft, 1);
        TextOut(dc, X, Y, &InRight, 1);
        TextOut(dc, X, Y, &InLeft, 1);
#endif
    }
    else
    {
        SetBkMode(dc, TRANSPARENT);

        /* Center section, white for active, grey for inactive */
        if ((uFlags & (DFCS_INACTIVE | DFCS_PUSHED)))
            i = COLOR_BTNFACE;
        else
            i = COLOR_WINDOW;
        SetTextColor(dc, GetSysColor(i));
        TextOut(dc, X, Y, &Center, 1);

        if (uFlags & (DFCS_FLAT | DFCS_MONO))
        {
            SetTextColor(dc, GetSysColor(COLOR_WINDOWFRAME));
            TextOut(dc, X, Y, &OutRight, 1);
            TextOut(dc, X, Y, &OutLeft, 1);
            TextOut(dc, X, Y, &InRight, 1);
            TextOut(dc, X, Y, &InLeft, 1);
        }
        else
        {
            SetTextColor(dc, GetSysColor(COLOR_BTNSHADOW));
            TextOut(dc, X, Y, &OutRight, 1);
            SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
            TextOut(dc, X, Y, &OutLeft, 1);
            SetTextColor(dc, GetSysColor(COLOR_3DDKSHADOW));
            TextOut(dc, X, Y, &InRight, 1);
            SetTextColor(dc, GetSysColor(COLOR_3DLIGHT));
            TextOut(dc, X, Y, &InLeft, 1);
        }

        if (uFlags & DFCS_CHECKED)
        {
            TCHAR Check = (Radio) ? 'i' : 'b';

            SetTextColor(dc, GetSysColor(COLOR_WINDOWTEXT));
            TextOut(dc, X, Y, &Check, 1);
        }
    }

    SelectObject(dc, hOldFont);
    DeleteObject(hFont);

    SetTextColor(dc, TextColor);
    SetBkMode(dc, BkMode);

    return TRUE;
}

UITOOLS95_DFC_ButtonPush()

static BOOL UITOOLS95_DFC_ButtonPush ( HDC  dc, LPRECT  r, UINT  uFlags  )

static

Definition at line 618 of file draw.c.

{
    UINT edge;
    RECT myr = *r;

    if(uFlags & (DFCS_PUSHED | DFCS_CHECKED | DFCS_FLAT))
        edge = EDGE_SUNKEN;
    else
        edge = EDGE_RAISED;

    if(uFlags & DFCS_CHECKED)
    {
        if(uFlags & DFCS_MONO)
            IntDrawRectEdge(dc, &myr, edge, BF_MONO|BF_RECT|BF_ADJUST, 1);
        else
            IntDrawRectEdge(dc, &myr, edge, (uFlags&DFCS_FLAT)|BF_RECT|BF_SOFT|BF_ADJUST, 1);

        UITOOLS_DrawCheckedRect( dc, &myr );
    }
    else
    {
        if(uFlags & DFCS_MONO)
        {
            IntDrawRectEdge(dc, &myr, edge, BF_MONO|BF_RECT|BF_ADJUST, 1);
            FillRect(dc, &myr, GetSysColorBrush(COLOR_BTNFACE));
        }
        else
        {
            IntDrawRectEdge(dc, r, edge, (uFlags&DFCS_FLAT) | BF_MIDDLE | BF_RECT | BF_SOFT, 1);
        }
    }

    /* Adjust rectangle if asked */
    if(uFlags & DFCS_ADJUSTRECT)
        InflateRect(r, -2, -2);

    return TRUE;
}

UITOOLS95_DrawFrameButton()

static BOOL UITOOLS95_DrawFrameButton ( HDC  hdc, LPRECT  rc, UINT  uState  )

static

Definition at line 778 of file draw.c.

{
    switch(uState & 0x1f)
    {
        case DFCS_BUTTONPUSH:
            return UITOOLS95_DFC_ButtonPush(hdc, rc, uState);

        case DFCS_BUTTONCHECK:
        case DFCS_BUTTON3STATE:
            return UITOOLS95_DFC_ButtonCheckRadio(hdc, rc, uState, FALSE);

        case DFCS_BUTTONRADIOIMAGE:
        case DFCS_BUTTONRADIOMASK:
        case DFCS_BUTTONRADIO:
            return UITOOLS95_DFC_ButtonCheckRadio(hdc, rc, uState, TRUE);


        default:
            ERR("Invalid button state=0x%04x\n", uState);

    }

    return FALSE;
}

UITOOLS95_DrawFrameCaption()

static BOOL UITOOLS95_DrawFrameCaption ( HDC  dc, LPRECT  r, UINT  uFlags  )

static

Definition at line 803 of file draw.c.

{
    LOGFONTW lf;
    HFONT hFont, hOldFont;
    COLORREF clrsave;
    RECT myr;
    INT bkmode;
    TCHAR Symbol;
    switch(uFlags & 0xf)
    {
        case DFCS_CAPTIONCLOSE:
        Symbol = 'r';
        break;
        case DFCS_CAPTIONHELP:
        Symbol = 's';
        break;
        case DFCS_CAPTIONMIN:
        Symbol = '0';
        break;
        case DFCS_CAPTIONMAX:
        Symbol = '1';
        break;
        case DFCS_CAPTIONRESTORE:
        Symbol = '2';
        break;
        default:
             ERR("Invalid caption; flags=0x%04x\n", uFlags);
             return FALSE;
    }
    IntDrawRectEdge(dc,r,(uFlags&DFCS_PUSHED) ? EDGE_SUNKEN : EDGE_RAISED, BF_RECT | BF_MIDDLE | BF_SOFT, 1);
    ZeroMemory(&lf, sizeof(LOGFONTW));
    UITOOLS_MakeSquareRect(r, &myr);
    myr.left += 1;
    myr.top += 1;
    myr.right -= 1;
    myr.bottom -= 1;
    if(uFlags & DFCS_PUSHED)
       OffsetRect(&myr,1,1);
    lf.lfHeight = myr.bottom - myr.top;
    lf.lfWidth = 0;
    lf.lfWeight = FW_NORMAL;
    lf.lfCharSet = DEFAULT_CHARSET;
    lstrcpy(lf.lfFaceName, TEXT("Marlett"));
    hFont = CreateFontIndirect(&lf);
    /* save font and text color */
    hOldFont = SelectObject(dc, hFont);
    clrsave = GetTextColor(dc);
    bkmode = GetBkMode(dc);
    /* set color and drawing mode */
    SetBkMode(dc, TRANSPARENT);
    if(uFlags & DFCS_INACTIVE)
    {
        /* draw shadow */
        SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
        TextOut(dc, myr.left + 1, myr.top + 1, &Symbol, 1);
    }
    SetTextColor(dc, GetSysColor((uFlags & DFCS_INACTIVE) ? COLOR_BTNSHADOW : COLOR_BTNTEXT));
    /* draw selected symbol */
    TextOut(dc, myr.left, myr.top, &Symbol, 1);
    /* restore previous settings */
    SetTextColor(dc, clrsave);
    SelectObject(dc, hOldFont);
    SetBkMode(dc, bkmode);
    DeleteObject(hFont);
    return TRUE;
}

UITOOLS95_DrawFrameMenu()

static BOOL UITOOLS95_DrawFrameMenu ( HDC  dc, LPRECT  r, UINT  uFlags  )

static

Definition at line 973 of file draw.c.

{
    // TODO: DFCS_TRANSPARENT upon DFCS_MENUARROWUP or DFCS_MENUARROWDOWN
    LOGFONTW lf;
    HFONT hFont, hOldFont;
    TCHAR Symbol;
    RECT myr;
    INT cxy;
    cxy = UITOOLS_MakeSquareRect(r, &myr);
    switch(uFlags & 0x1f)
    {
        case DFCS_MENUARROWUP:
            Symbol = '5';
            break;

        case DFCS_MENUARROWDOWN:
            Symbol = '6';
            break;

        case DFCS_MENUARROW:
            Symbol = '8';
            break;

        case DFCS_MENUARROWRIGHT:
        Symbol = 'w'; // FIXME: needs to confirm
        break;

        case DFCS_MENUBULLET:
            Symbol = 'h';
            break;

        case DFCS_MENUCHECK:
            Symbol = 'a';
            break;

        default:
            ERR("Invalid menu; flags=0x%04x\n", uFlags);
            return FALSE;
    }
    /* acquire ressources only if valid menu */
    ZeroMemory(&lf, sizeof(LOGFONTW));
    lf.lfHeight = cxy;
    lf.lfWidth = 0;
    lf.lfWeight = FW_NORMAL;
    lf.lfCharSet = DEFAULT_CHARSET;
    lstrcpy(lf.lfFaceName, TEXT("Marlett"));
    hFont = CreateFontIndirect(&lf);
    /* save font */
    hOldFont = SelectObject(dc, hFont);

    if ((uFlags & 0x1f) == DFCS_MENUARROWUP ||  
        (uFlags & 0x1f) == DFCS_MENUARROWDOWN ) 
    {
#if 0
       if (uFlags & DFCS_INACTIVE)
       {
           /* draw shadow */
           SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
           TextOut(dc, myr.left + 1, myr.top + 1, &Symbol, 1);
       }
#endif
       SetTextColor(dc, GetSysColor((uFlags & DFCS_INACTIVE) ? COLOR_BTNSHADOW : COLOR_BTNTEXT));
    }
    /* draw selected symbol */
    TextOut(dc, myr.left, myr.top, &Symbol, 1);
    /* restore previous settings */
    SelectObject(dc, hOldFont);
    DeleteObject(hFont);
    return TRUE;
}

UITOOLS95_DrawFrameScroll()

static BOOL UITOOLS95_DrawFrameScroll ( HDC  dc, LPRECT  r, UINT  uFlags  )

static

Definition at line 870 of file draw.c.

{
    LOGFONTW lf;
    HFONT hFont, hOldFont;
    COLORREF clrsave;
    RECT myr;
    INT bkmode;
    TCHAR Symbol;
    switch(uFlags & 0x1f)
    {
        case DFCS_SCROLLCOMBOBOX:
        case DFCS_SCROLLDOWN:
        Symbol = '6';
        break;

    case DFCS_SCROLLUP:
        Symbol = '5';
        break;

    case DFCS_SCROLLLEFT:
        Symbol = '3';
        break;

    case DFCS_SCROLLRIGHT:
        Symbol = '4';
        break;

    case DFCS_SCROLLSIZEGRIP:
    case DFCS_SCROLLSIZEGRIPRIGHT:
        ZeroMemory(&lf, sizeof(LOGFONTW));
        UITOOLS_MakeSquareRect(r, &myr);
        lf.lfHeight = myr.bottom - myr.top;
        lf.lfWidth = 0;
        lf.lfWeight = FW_NORMAL;
        lf.lfCharSet = DEFAULT_CHARSET;
        lstrcpy(lf.lfFaceName, TEXT("Marlett"));
        hFont = CreateFontIndirect(&lf);
        /* save font and text color */
        hOldFont = SelectObject(dc, hFont);
        clrsave = GetTextColor(dc);
        bkmode = GetBkMode(dc);
        /* set color and drawing mode */
        SetBkMode(dc, TRANSPARENT);
        if (!(uFlags & (DFCS_MONO | DFCS_FLAT)))
        {
            SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
            /* draw selected symbol */
            Symbol = ((uFlags & 0xff) == DFCS_SCROLLSIZEGRIP) ? 'o' : 'x';
            TextOut(dc, myr.left, myr.top, &Symbol, 1);
            SetTextColor(dc, GetSysColor(COLOR_BTNSHADOW));
        } else
            SetTextColor(dc, GetSysColor(COLOR_WINDOWFRAME));
        /* draw selected symbol */
        Symbol = ((uFlags & 0xff) == DFCS_SCROLLSIZEGRIP) ? 'p' : 'y';
        TextOut(dc, myr.left, myr.top, &Symbol, 1);
        /* restore previous settings */
        SetTextColor(dc, clrsave);
        SelectObject(dc, hOldFont);
        SetBkMode(dc, bkmode);
        DeleteObject(hFont);
            return TRUE;
    default:
        ERR("Invalid scroll; flags=0x%04x\n", uFlags);
            return FALSE;
    }
    IntDrawRectEdge(dc, r, (uFlags & DFCS_PUSHED) ? EDGE_SUNKEN : EDGE_RAISED, (uFlags&DFCS_FLAT) | BF_MIDDLE | BF_RECT, 1);
    ZeroMemory(&lf, sizeof(LOGFONTW));
    UITOOLS_MakeSquareRect(r, &myr);
    myr.left += 1;
    myr.top += 1;
    myr.right -= 1;
    myr.bottom -= 1;
    if(uFlags & DFCS_PUSHED)
       OffsetRect(&myr,1,1);
    lf.lfHeight = myr.bottom - myr.top;
    lf.lfWidth = 0;
    lf.lfWeight = FW_NORMAL;
    lf.lfCharSet = DEFAULT_CHARSET;
    lstrcpy(lf.lfFaceName, TEXT("Marlett"));
    hFont = CreateFontIndirect(&lf);
    /* save font and text color */
    hOldFont = SelectObject(dc, hFont);
    clrsave = GetTextColor(dc);
    bkmode = GetBkMode(dc);
    /* set color and drawing mode */
    SetBkMode(dc, TRANSPARENT);
    if(uFlags & DFCS_INACTIVE)
    {
        /* draw shadow */
        SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
        TextOut(dc, myr.left + 1, myr.top + 1, &Symbol, 1);
    }
    SetTextColor(dc, GetSysColor((uFlags & DFCS_INACTIVE) ? COLOR_BTNSHADOW : COLOR_BTNTEXT));
    /* draw selected symbol */
    TextOut(dc, myr.left, myr.top, &Symbol, 1);
    /* restore previous settings */
    SetTextColor(dc, clrsave);
    SelectObject(dc, hOldFont);
    SetBkMode(dc, bkmode);
    DeleteObject(hFont);
    return TRUE;
}

UITOOLS_DrawCheckedRect()

static void UITOOLS_DrawCheckedRect ( HDC  dc, LPRECT  rect  )

static

Definition at line 588 of file draw.c.

{
    if(GetSysColor(COLOR_BTNHIGHLIGHT) == RGB(255, 255, 255))
    {
        HBRUSH hbsave;
        COLORREF bg;

        FillRect(dc, rect, GetSysColorBrush(COLOR_BTNFACE));
        bg = SetBkColor(dc, RGB(255, 255, 255));
        hbsave = (HBRUSH)SelectObject(dc, gpsi->hbrGray);
        PatBlt(dc, rect->left, rect->top, rect->right-rect->left, rect->bottom-rect->top, 0x00FA0089);
        SelectObject(dc, hbsave);
        SetBkColor(dc, bg);
    }
    else
    {
        FillRect(dc, rect, GetSysColorBrush(COLOR_BTNHIGHLIGHT));
    }
}

UITOOLS_MakeSquareRect()

static int UITOOLS_MakeSquareRect ( LPRECT  src, LPRECT  dst  )

static

Definition at line 564 of file draw.c.

{
    int Width  = src->right - src->left;
    int Height = src->bottom - src->top;
    int SmallDiam = Width > Height ? Height : Width;

    *dst = *src;

    /* Make it a square box */
    if(Width < Height)      /* SmallDiam == Width */
    {
        dst->top += (Height-Width)/2;
        dst->bottom = dst->top + SmallDiam;
    }
    else if(Width > Height) /* SmallDiam == Height */
    {
        dst->left += (Width-Height)/2;
        dst->right = dst->left + SmallDiam;
    }

    return SmallDiam;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

user32

)

Variable Documentation

LTInnerNormal

const signed char LTInnerNormal[]

static

Initial value:

= {
            -1,           -1,                 -1,                 -1,
            -1,           COLOR_BTNHIGHLIGHT, COLOR_BTNHIGHLIGHT, -1,
            -1,           COLOR_3DDKSHADOW,   COLOR_3DDKSHADOW,   -1,
            -1,           -1,                 -1,                 -1
}

Definition at line 41 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().

LTInnerSoft

const signed char LTInnerSoft[]

static

Initial value:

= {
            -1,                  -1,                -1,              -1,
            -1,                  COLOR_3DLIGHT,     COLOR_3DLIGHT,   -1,
            -1,                  COLOR_BTNSHADOW,   COLOR_BTNSHADOW, -1,
            -1,                  -1,                -1,              -1
}

Definition at line 69 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().

LTOuterNormal

const signed char LTOuterNormal[]

static

Initial value:

= {
            -1,                 COLOR_3DLIGHT,     COLOR_BTNSHADOW, -1,
            COLOR_BTNHIGHLIGHT, COLOR_3DLIGHT,     COLOR_BTNSHADOW, -1,
            COLOR_3DDKSHADOW,   COLOR_3DLIGHT,     COLOR_BTNSHADOW, -1,
            -1,                 COLOR_3DLIGHT,     COLOR_BTNSHADOW, -1
}

Definition at line 48 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().

LTOuterSoft

const signed char LTOuterSoft[]

static

Initial value:

= {
            -1,              COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1,
            COLOR_3DLIGHT,   COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1,
            COLOR_BTNSHADOW, COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1,
            -1,              COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1
}

Definition at line 76 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().

LTRBInnerFlat

const signed char LTRBInnerFlat[]

static

Initial value:

= {
            -1, -1,              -1,              -1,
            -1, COLOR_BTNFACE,     COLOR_BTNFACE,     COLOR_BTNFACE,
            -1, COLOR_BTNFACE,     COLOR_BTNFACE,     COLOR_BTNFACE,
            -1, COLOR_BTNFACE,     COLOR_BTNFACE,     COLOR_BTNFACE,
}

Definition at line 107 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().

LTRBInnerMono

const signed char LTRBInnerMono[]

static

Initial value:

= {
            -1, -1,           -1,           -1,
            -1, COLOR_WINDOW, COLOR_WINDOW, COLOR_WINDOW,
            -1, COLOR_WINDOW, COLOR_WINDOW, COLOR_WINDOW,
            -1, COLOR_WINDOW, COLOR_WINDOW, COLOR_WINDOW,
}

Definition at line 93 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().

LTRBOuterFlat

const signed char LTRBOuterFlat[]

static

Initial value:

= {
            -1,                COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
            COLOR_BTNFACE,     COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
            COLOR_BTNFACE,     COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
            COLOR_BTNFACE,     COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
}

Definition at line 100 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().

LTRBOuterMono

const signed char LTRBOuterMono[]

static

Initial value:

= {
            -1,           COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
            COLOR_WINDOW, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
            COLOR_WINDOW, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
            COLOR_WINDOW, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
}

Definition at line 86 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().

RBInnerNormal

const signed char RBInnerNormal[]

static

Initial value:

= {
            -1,           -1,                -1,              -1,
            -1,           COLOR_BTNSHADOW,   COLOR_BTNSHADOW, -1,
            -1,           COLOR_3DLIGHT,     COLOR_3DLIGHT,   -1,
            -1,           -1,                -1,              -1
}

Definition at line 55 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().

RBOuterNormal

const signed char RBOuterNormal[]

static

Initial value:

= {
            -1,              COLOR_3DDKSHADOW,  COLOR_BTNHIGHLIGHT, -1,
            COLOR_BTNSHADOW, COLOR_3DDKSHADOW,  COLOR_BTNHIGHLIGHT, -1,
            COLOR_3DLIGHT,   COLOR_3DDKSHADOW,  COLOR_BTNHIGHLIGHT, -1,
            -1,              COLOR_3DDKSHADOW,  COLOR_BTNHIGHLIGHT, -1
}

Definition at line 62 of file draw.c.

Referenced by IntDrawDiagEdge(), and IntDrawRectEdge().