mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
631 lines
22 KiB
631 lines
22 KiB
//---------------------------------------------------------------------------
|
|
// DrawHelp.cpp - flat drawing helper routines
|
|
//---------------------------------------------------------------------------
|
|
#include "stdafx.h"
|
|
#include "DrawHelp.h"
|
|
#include "rgn.h"
|
|
|
|
#define cxRESIZE (ClassicGetSystemMetrics(SM_CXEDGE)+ClassicGetSystemMetrics( SM_CXSIZEFRAME ))
|
|
#define cyRESIZE (ClassicGetSystemMetrics(SM_CYEDGE)+ClassicGetSystemMetrics( SM_CYSIZEFRAME ))
|
|
#define cxRESIZEPAD ClassicGetSystemMetrics(SM_CXVSCROLL)
|
|
#define cyRESIZEPAD ClassicGetSystemMetrics(SM_CYHSCROLL)
|
|
|
|
//---------------------------------------------------------------------------
|
|
typedef WORD (* HITTESTRECTPROC)(LPCRECT, int, int, const POINT&, WORD);
|
|
WORD _HitTestRectCorner( HITTESTRECTPROC, HITTESTRECTPROC, LPCRECT,
|
|
int, int, int, int, const POINT&,
|
|
WORD, WORD, WORD, WORD );
|
|
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestRectLeft(
|
|
LPCRECT prc, int cxMargin, int cyMargin, const POINT& pt, WORD wMiss )
|
|
{
|
|
return ((WORD)((pt.x <= (prc->left + cxMargin)) ? HTLEFT : wMiss));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestRectTop(
|
|
LPCRECT prc, int cxMargin, int cyMargin, const POINT& pt, WORD wMiss )
|
|
{
|
|
return ((WORD)((pt.y <= (prc->top + cyMargin)) ? HTTOP : wMiss));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestRectRight(
|
|
LPCRECT prc, int cxMargin, int cyMargin, const POINT& pt, WORD wMiss )
|
|
{
|
|
return ((WORD)((pt.x >= (prc->right - cxMargin)) ? HTRIGHT : wMiss));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestRectBottom(
|
|
LPCRECT prc, int cxMargin, int cyMargin, const POINT& pt, WORD wMiss )
|
|
{
|
|
return ((WORD)((pt.y >= (prc->bottom - cyMargin)) ? HTBOTTOM : wMiss));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestRectTopLeft(
|
|
LPCRECT prc, int cxMargin, int cyMargin, const POINT& pt, WORD wMiss )
|
|
{
|
|
return _HitTestRectCorner(
|
|
_HitTestRectLeft, _HitTestRectTop, prc,
|
|
cxMargin, cyMargin, cxRESIZEPAD, cyRESIZEPAD,
|
|
pt, HTTOPLEFT, HTLEFT, HTTOP, wMiss );
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestRectTopRight(
|
|
LPCRECT prc, int cxMargin, int cyMargin, const POINT& pt, WORD wMiss )
|
|
{
|
|
return _HitTestRectCorner(
|
|
_HitTestRectRight, _HitTestRectTop, prc,
|
|
cxMargin, cyMargin, cxRESIZEPAD, cyRESIZEPAD,
|
|
pt, HTTOPRIGHT, HTRIGHT, HTTOP, wMiss );
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestRectBottomLeft(
|
|
LPCRECT prc, int cxMargin, int cyMargin, const POINT& pt, WORD wMiss )
|
|
{
|
|
return _HitTestRectCorner(
|
|
_HitTestRectLeft, _HitTestRectBottom, prc,
|
|
cxMargin, cyMargin, cxRESIZEPAD, cyRESIZEPAD,
|
|
pt, HTBOTTOMLEFT, HTLEFT, HTBOTTOM, wMiss );
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestRectBottomRight(
|
|
LPCRECT prc, int cxMargin, int cyMargin, const POINT& pt, WORD wMiss )
|
|
{
|
|
return _HitTestRectCorner(
|
|
_HitTestRectRight, _HitTestRectBottom, prc,
|
|
cxMargin, cyMargin, cxRESIZEPAD, cyRESIZEPAD,
|
|
pt, HTBOTTOMRIGHT, HTRIGHT, HTBOTTOM, wMiss );
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestRectCorner(
|
|
HITTESTRECTPROC pfnX, HITTESTRECTPROC pfnY,
|
|
LPCRECT prc, // target rect
|
|
int cxMargin, int cyMargin, // width, height of resizing borders
|
|
int cxMargin2, int cyMargin2, // width, height of scrollbars
|
|
const POINT& pt, // test point
|
|
WORD wHitC, WORD wHitX, WORD wHitY, // winning hittest codes
|
|
WORD wMiss ) // losing hittest code
|
|
{
|
|
WORD wRetX = pfnX( prc, cxMargin, cyMargin, pt, wMiss );
|
|
WORD wRetY = pfnY( prc, cxMargin, cyMargin, pt, wMiss );
|
|
|
|
if( wMiss != wRetX && wMiss != wRetY )
|
|
return wHitC;
|
|
|
|
if( wMiss != wRetX )
|
|
{
|
|
wMiss = wHitX;
|
|
if( wMiss != pfnY( prc, cxMargin2, cyMargin2, pt, wMiss ) )
|
|
return wHitC;
|
|
}
|
|
else if( wMiss != wRetY )
|
|
{
|
|
wMiss = wHitY;
|
|
if( wMiss != pfnX( prc, cxMargin2, cyMargin2, pt, wMiss ) )
|
|
return wHitC;
|
|
}
|
|
|
|
return wMiss;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
WORD HitTest9Grid( LPCRECT prc, const MARGINS& margins, const POINT& pt )
|
|
{
|
|
ASSERT(PtInRect(prc,pt));
|
|
|
|
WORD wHit = HTCLIENT;
|
|
|
|
// test left side
|
|
if( HTLEFT == _HitTestRectLeft( prc, margins.cxLeftWidth, 0, pt, wHit ) )
|
|
{
|
|
if( HTTOP == _HitTestRectTop( prc, 0, margins.cyTopHeight, pt, wHit ) )
|
|
return HTTOPLEFT;
|
|
if( HTBOTTOM == _HitTestRectBottom( prc, 0, margins.cyBottomHeight, pt, wHit ) )
|
|
return HTBOTTOMLEFT;
|
|
wHit = HTLEFT;
|
|
}
|
|
else // test right side
|
|
if( HTRIGHT == _HitTestRectRight( prc, margins.cxRightWidth, 0, pt, wHit ) )
|
|
{
|
|
if( HTTOP == _HitTestRectTop( prc, 0, margins.cyTopHeight, pt, wHit ) )
|
|
return HTTOPRIGHT;
|
|
if( HTBOTTOM == _HitTestRectBottom( prc, 0, margins.cyBottomHeight, pt, wHit ) )
|
|
return HTBOTTOMRIGHT;
|
|
wHit = HTRIGHT;
|
|
}
|
|
else // test top
|
|
if( HTTOP == _HitTestRectTop( prc, 0, margins.cyTopHeight, pt, wHit ) )
|
|
{
|
|
return HTTOP;
|
|
}
|
|
else // test bottom
|
|
if( HTBOTTOM == _HitTestRectBottom( prc, 0, margins.cyBottomHeight, pt, wHit ) )
|
|
{
|
|
return HTBOTTOM;
|
|
}
|
|
|
|
return wHit;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestResizingRect( DWORD dwHTFlags, LPCRECT prc, const POINT& pt,
|
|
WORD w9GridHit, WORD wMiss )
|
|
{
|
|
WORD wHit = wMiss;
|
|
BOOL fTestLeft = TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER_LEFT);
|
|
BOOL fTestTop = TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER_TOP);
|
|
BOOL fTestRight = TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER_RIGHT);
|
|
BOOL fTestBottom = TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER_BOTTOM);
|
|
BOOL fTestCaption = TESTFLAG( dwHTFlags, HTTB_CAPTION );
|
|
|
|
switch( w9GridHit )
|
|
{
|
|
case HTLEFT:
|
|
if( fTestLeft )
|
|
{
|
|
// first test for a hit in the corner resizing areas, respecting caller's option flags.
|
|
if( (fTestTop && (wHit = _HitTestRectTopLeft( prc, cxRESIZE, cyRESIZE, pt, wMiss )) != HTLEFT) ||
|
|
(fTestBottom && (wHit = _HitTestRectBottomLeft( prc, cxRESIZE, cyRESIZE, pt, wMiss )) != HTLEFT) )
|
|
break;
|
|
// failed corners, just test the resizing margin within the specified 9-grid hit seg.
|
|
wHit = _HitTestRectLeft( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
}
|
|
break;
|
|
case HTTOP:
|
|
if( fTestCaption )
|
|
wHit = wMiss = HTCAPTION;
|
|
|
|
if( fTestTop )
|
|
{
|
|
// first test for a hit in the corner resizing areas, respecting caller's option flags.
|
|
if( (fTestLeft && (wHit = _HitTestRectTopLeft( prc, cxRESIZE, cyRESIZE, pt, wMiss )) != HTTOP) ||
|
|
(fTestRight && (wHit = _HitTestRectTopRight( prc, cxRESIZE, cyRESIZE, pt, wMiss )) != HTTOP) )
|
|
break;
|
|
// failed corners, just test the resizing margin within the specified 9-grid hit seg.
|
|
wHit = _HitTestRectTop( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
}
|
|
break;
|
|
|
|
case HTRIGHT:
|
|
if( fTestRight )
|
|
{
|
|
// first test for a hit in the corner resizing areas, respecting caller's option flags.
|
|
if( (fTestTop && (wHit = _HitTestRectTopRight( prc, cxRESIZE, cyRESIZE, pt, wMiss )) != HTRIGHT) ||
|
|
(fTestBottom && (wHit = _HitTestRectBottomRight( prc, cxRESIZE, cyRESIZE, pt, wMiss )) != HTRIGHT) )
|
|
break;
|
|
// failed corners, just test the resizing margin within the specified 9-grid hit seg.
|
|
wHit = _HitTestRectRight( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
break;
|
|
}
|
|
|
|
case HTBOTTOM:
|
|
if( fTestBottom )
|
|
{
|
|
// first test for a hit in the corner resizing areas, respecting caller's option flags.
|
|
if( (fTestLeft && (wHit = _HitTestRectBottomLeft( prc, cxRESIZE, cyRESIZE, pt, wMiss )) != HTBOTTOM) ||
|
|
(fTestRight && (wHit = _HitTestRectBottomRight( prc, cxRESIZE, cyRESIZE, pt, wMiss )) != HTBOTTOM) )
|
|
break;
|
|
// failed corners, just test the resizing margin within the specified 9-grid hit seg.
|
|
wHit = _HitTestRectBottom( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
}
|
|
break;
|
|
|
|
case HTTOPLEFT:
|
|
if( fTestCaption )
|
|
wHit = wMiss = HTCAPTION;
|
|
// first test for a resizing hit in the corner, and failing that, test the
|
|
// resizing margin on either side.
|
|
if( fTestTop && fTestLeft )
|
|
wHit = _HitTestRectTopLeft( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
else if( fTestLeft )
|
|
wHit = _HitTestRectLeft( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
else if( fTestTop )
|
|
wHit = _HitTestRectTop( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
break;
|
|
|
|
case HTTOPRIGHT:
|
|
if( fTestCaption )
|
|
wHit = wMiss = HTCAPTION;
|
|
// first test for a resizing hit in the corner, and failing that, test the
|
|
// resizing margin on either side.
|
|
if( fTestTop && fTestRight )
|
|
wHit = _HitTestRectTopRight( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
else if( fTestRight )
|
|
wHit = _HitTestRectRight( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
else if( fTestTop )
|
|
wHit = _HitTestRectTop( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
break;
|
|
|
|
case HTBOTTOMLEFT:
|
|
// first test for a resizing hit in the corner, and failing that, test the
|
|
// resizing margin on either side.
|
|
if( fTestBottom && fTestLeft )
|
|
wHit = _HitTestRectBottomLeft( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
else if( fTestLeft )
|
|
wHit = _HitTestRectLeft( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
else if( fTestBottom )
|
|
wHit = _HitTestRectBottom( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
break;
|
|
|
|
case HTBOTTOMRIGHT:
|
|
// first test for a resizing hit in the corner, and failing that, test the
|
|
// resizing margin on either side.
|
|
if( fTestBottom && fTestRight )
|
|
wHit = _HitTestRectBottomRight( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
else if( fTestRight )
|
|
wHit = _HitTestRectRight( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
else if( fTestBottom )
|
|
wHit = _HitTestRectBottom( prc, cxRESIZE, cyRESIZE, pt, wMiss );
|
|
break;
|
|
}
|
|
return wHit;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
WORD HitTestRect(DWORD dwHTFlags, LPCRECT prc, const MARGINS& margins, const POINT& pt )
|
|
{
|
|
WORD wHit = HTNOWHERE;
|
|
|
|
if( PtInRect( prc, pt ) )
|
|
{
|
|
wHit = HitTest9Grid( prc, margins, pt );
|
|
|
|
if( HTCLIENT != wHit )
|
|
{
|
|
if( TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER) )
|
|
{
|
|
WORD wMiss = HTBORDER;
|
|
wHit = _HitTestResizingRect( dwHTFlags, prc, pt, wHit, wMiss );
|
|
}
|
|
else if( TESTFLAG(dwHTFlags, HTTB_CAPTION|HTTB_FIXEDBORDER) )
|
|
{
|
|
switch( wHit )
|
|
{
|
|
case HTTOP:
|
|
case HTTOPLEFT:
|
|
case HTTOPRIGHT:
|
|
wHit = (WORD)(TESTFLAG(dwHTFlags, HTTB_CAPTION) ? HTCAPTION : HTBORDER);
|
|
break;
|
|
default:
|
|
wHit = HTBORDER;
|
|
}
|
|
}
|
|
|
|
} // !HTCLIENT
|
|
} // PtInRect
|
|
|
|
return wHit;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
WORD _HitTestResizingTemplate( DWORD dwHTFlags, HRGN hrgn, const POINT& pt,
|
|
WORD w9GridHit, WORD wMiss )
|
|
{
|
|
WORD wHit = wMiss;
|
|
BOOL fTestLeft = TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER_LEFT);
|
|
BOOL fTestTop = TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER_TOP);
|
|
BOOL fTestRight = TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER_RIGHT);
|
|
BOOL fTestBottom = TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER_BOTTOM);
|
|
BOOL fTestCaption = TESTFLAG( dwHTFlags, HTTB_CAPTION );
|
|
BOOL fInsideRgn;
|
|
|
|
switch( w9GridHit )
|
|
{
|
|
case HTLEFT:
|
|
if( !fTestLeft )
|
|
{
|
|
return wMiss;
|
|
}
|
|
break;
|
|
case HTTOP:
|
|
if( fTestCaption )
|
|
wMiss = HTCAPTION;
|
|
|
|
if( !fTestTop )
|
|
{
|
|
return wMiss;
|
|
}
|
|
break;
|
|
case HTRIGHT:
|
|
if( !fTestRight )
|
|
{
|
|
return wMiss;
|
|
}
|
|
break;
|
|
case HTBOTTOM:
|
|
if( !fTestBottom )
|
|
{
|
|
return wMiss;
|
|
}
|
|
break;
|
|
case HTTOPLEFT:
|
|
if( fTestCaption )
|
|
wMiss = HTCAPTION;
|
|
|
|
if( !fTestTop || !fTestLeft )
|
|
{
|
|
return wMiss;
|
|
}
|
|
break;
|
|
|
|
case HTTOPRIGHT:
|
|
if( fTestCaption )
|
|
wMiss = HTCAPTION;
|
|
|
|
if( !fTestTop || !fTestRight )
|
|
{
|
|
return wMiss;
|
|
}
|
|
break;
|
|
|
|
case HTBOTTOMLEFT:
|
|
if( !fTestBottom || !fTestLeft )
|
|
{
|
|
return wMiss;
|
|
}
|
|
break;
|
|
|
|
case HTBOTTOMRIGHT:
|
|
if( !fTestBottom || !fTestRight )
|
|
{
|
|
return wMiss;
|
|
}
|
|
break;
|
|
}
|
|
|
|
fInsideRgn = PtInRegion(hrgn, pt.x, pt.y);
|
|
|
|
if( fInsideRgn )
|
|
{
|
|
wHit = w9GridHit;
|
|
}
|
|
return wHit;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
WORD HitTestTemplate(DWORD dwHTFlags, LPCRECT prc, HRGN hrgn, const MARGINS& margins, const POINT& pt )
|
|
{
|
|
WORD wHit = HTNOWHERE;
|
|
|
|
if( PtInRect( prc, pt ) )
|
|
{
|
|
wHit = HitTest9Grid( prc, margins, pt );
|
|
|
|
if( HTCLIENT != wHit )
|
|
{
|
|
if( TESTFLAG(dwHTFlags, HTTB_RESIZINGBORDER) )
|
|
{
|
|
WORD wMiss = HTBORDER;
|
|
wHit = _HitTestResizingTemplate( dwHTFlags, hrgn, pt, wHit, wMiss );
|
|
}
|
|
else if( TESTFLAG(dwHTFlags, HTTB_CAPTION|HTTB_FIXEDBORDER) )
|
|
{
|
|
switch( wHit )
|
|
{
|
|
case HTTOP:
|
|
case HTTOPLEFT:
|
|
case HTTOPRIGHT:
|
|
wHit = (WORD)(TESTFLAG(dwHTFlags, HTTB_CAPTION) ? HTCAPTION : HTBORDER);
|
|
break;
|
|
default:
|
|
wHit = HTBORDER;
|
|
}
|
|
}
|
|
|
|
} // !HTCLIENT
|
|
}
|
|
return wHit;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// FillRectClr
|
|
//
|
|
// History: 2000-12-06 lmouton borrowed from comctl32\v6\cutils.c
|
|
//---------------------------------------------------------------------------
|
|
void FillRectClr(HDC hdc, LPRECT prc, COLORREF clr)
|
|
{
|
|
COLORREF clrSave = SetBkColor(hdc, clr);
|
|
ExtTextOut(hdc,0,0,ETO_OPAQUE,prc,NULL,0,NULL);
|
|
SetBkColor(hdc, clrSave);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
// _DrawEdge
|
|
//
|
|
// Classic values are:
|
|
// clrLight = 192 192 192
|
|
// clrHighlight = 255 255 255
|
|
// clrShadow = 128 128 128
|
|
// clrDkShadow = 0 0 0
|
|
// clrFill = 192 192 192
|
|
//
|
|
// History: 2000-12-06 lmouton borrowed from comctl32\v6\cutils.c, modified colors
|
|
//---------------------------------------------------------------------------
|
|
HRESULT _DrawEdge(HDC hdc, const RECT *pDestRect, UINT uEdge, UINT uFlags,
|
|
COLORREF clrLight, COLORREF clrHighlight, COLORREF clrShadow, COLORREF clrDkShadow, COLORREF clrFill,
|
|
OUT RECT *pContentRect)
|
|
{
|
|
if (hdc == NULL || pDestRect == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
RECT rc, rcD;
|
|
UINT bdrType;
|
|
COLORREF clrTL = 0;
|
|
COLORREF clrBR = 0;
|
|
|
|
// This is were we would adjust for high DPI if the new "BF_DPISCALE" flag is specified in uFlags.
|
|
int cxBorder = GetSystemMetrics(SM_CXBORDER);
|
|
int cyBorder = GetSystemMetrics(SM_CYBORDER);
|
|
|
|
//
|
|
// Enforce monochromicity and flatness
|
|
//
|
|
|
|
// if (oemInfo.BitCount == 1)
|
|
// uFlags |= BF_MONO;
|
|
if (uFlags & BF_MONO)
|
|
uFlags |= BF_FLAT;
|
|
|
|
CopyRect(&rc, pDestRect);
|
|
|
|
//
|
|
// Draw the border segment(s), and calculate the remaining space as we
|
|
// go.
|
|
//
|
|
bdrType = (uEdge & BDR_OUTER);
|
|
if (bdrType)
|
|
{
|
|
DrawBorder:
|
|
//
|
|
// Get colors. Note the symmetry between raised outer, sunken inner and
|
|
// sunken outer, raised inner.
|
|
//
|
|
|
|
if (uFlags & BF_FLAT)
|
|
{
|
|
if (uFlags & BF_MONO)
|
|
clrBR = (bdrType & BDR_OUTER) ? clrDkShadow : clrHighlight;
|
|
else
|
|
clrBR = (bdrType & BDR_OUTER) ? clrShadow: clrFill;
|
|
|
|
clrTL = clrBR;
|
|
}
|
|
else
|
|
{
|
|
// 5 == HILIGHT
|
|
// 4 == LIGHT
|
|
// 3 == FACE
|
|
// 2 == SHADOW
|
|
// 1 == DKSHADOW
|
|
|
|
switch (bdrType)
|
|
{
|
|
// +2 above surface
|
|
case BDR_RAISEDOUTER: // 5 : 4
|
|
clrTL = ((uFlags & BF_SOFT) ? clrHighlight : clrLight);
|
|
clrBR = clrDkShadow; // 1
|
|
break;
|
|
|
|
// +1 above surface
|
|
case BDR_RAISEDINNER: // 4 : 5
|
|
clrTL = ((uFlags & BF_SOFT) ? clrLight : clrHighlight);
|
|
clrBR = clrShadow; // 2
|
|
break;
|
|
|
|
// -1 below surface
|
|
case BDR_SUNKENOUTER: // 1 : 2
|
|
clrTL = ((uFlags & BF_SOFT) ? clrDkShadow : clrShadow);
|
|
clrBR = clrHighlight; // 5
|
|
break;
|
|
|
|
// -2 below surface
|
|
case BDR_SUNKENINNER: // 2 : 1
|
|
clrTL = ((uFlags & BF_SOFT) ? clrShadow : clrDkShadow);
|
|
clrBR = clrLight; // 4
|
|
break;
|
|
|
|
default:
|
|
hr = E_INVALIDARG;
|
|
}
|
|
}
|
|
|
|
if FAILED(hr)
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Draw the sides of the border. NOTE THAT THE ALGORITHM FAVORS THE
|
|
// BOTTOM AND RIGHT SIDES, since the light source is assumed to be top
|
|
// left. If we ever decide to let the user set the light source to a
|
|
// particular corner, then change this algorithm.
|
|
//
|
|
|
|
// Bottom Right edges
|
|
if (uFlags & (BF_RIGHT | BF_BOTTOM))
|
|
{
|
|
// Right
|
|
if (uFlags & BF_RIGHT)
|
|
{
|
|
rc.right -= cxBorder;
|
|
// PatBlt(hdc, rc.right, rc.top, g_cxBorder, rc.bottom - rc.top, PATCOPY);
|
|
rcD.left = rc.right;
|
|
rcD.right = rc.right + cxBorder;
|
|
rcD.top = rc.top;
|
|
rcD.bottom = rc.bottom;
|
|
|
|
FillRectClr(hdc, &rcD, clrBR);
|
|
}
|
|
|
|
// Bottom
|
|
if (uFlags & BF_BOTTOM)
|
|
{
|
|
rc.bottom -= cyBorder;
|
|
// PatBlt(hdc, rc.left, rc.bottom, rc.right - rc.left, g_cyBorder, PATCOPY);
|
|
rcD.left = rc.left;
|
|
rcD.right = rc.right;
|
|
rcD.top = rc.bottom;
|
|
rcD.bottom = rc.bottom + cyBorder;
|
|
|
|
FillRectClr(hdc, &rcD, clrBR);
|
|
}
|
|
}
|
|
|
|
// Top Left edges
|
|
if (uFlags & (BF_TOP | BF_LEFT))
|
|
{
|
|
// Left
|
|
if (uFlags & BF_LEFT)
|
|
{
|
|
// PatBlt(hdc, rc.left, rc.top, g_cxBorder, rc.bottom - rc.top, PATCOPY);
|
|
rc.left += cxBorder;
|
|
|
|
rcD.left = rc.left - cxBorder;
|
|
rcD.right = rc.left;
|
|
rcD.top = rc.top;
|
|
rcD.bottom = rc.bottom;
|
|
|
|
FillRectClr(hdc, &rcD, clrTL);
|
|
}
|
|
|
|
// Top
|
|
if (uFlags & BF_TOP)
|
|
{
|
|
// PatBlt(hdc, rc.left, rc.top, rc.right - rc.left, g_cyBorder, PATCOPY);
|
|
rc.top += cyBorder;
|
|
|
|
rcD.left = rc.left;
|
|
rcD.right = rc.right;
|
|
rcD.top = rc.top - cyBorder;
|
|
rcD.bottom = rc.top;
|
|
|
|
FillRectClr(hdc, &rcD, clrTL);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bdrType = (uEdge & BDR_INNER);
|
|
if (bdrType)
|
|
{
|
|
//
|
|
// Strip this so the next time through, bdrType will be 0.
|
|
// Otherwise, we'll loop forever.
|
|
//
|
|
uEdge &= ~BDR_INNER;
|
|
goto DrawBorder;
|
|
}
|
|
|
|
//
|
|
// Fill the middle & clean up if asked
|
|
//
|
|
if (uFlags & BF_MIDDLE)
|
|
FillRectClr(hdc, &rc, (uFlags & BF_MONO) ? clrHighlight : clrFill);
|
|
|
|
if ((uFlags & BF_ADJUST) && (pContentRect != NULL))
|
|
CopyRect(pContentRect, &rc);
|
|
|
|
return hr;
|
|
}
|