archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/shell/themes/uxtheme/borderfill.cpp

651 lines
21 KiB
Raw Permalink Blame History

//---------------------------------------------------------------------------
// BorderFill.cpp - implements the drawing API for bgtype = BorderFill
//---------------------------------------------------------------------------
#include "stdafx.h"
#include "Render.h"
#include "Utils.h"
#include "gradient.h"
#include "tmutils.h"
#include "rgn.h"
#include "BorderFill.h"
#include "CacheList.h"
#include "gradient.h"
#include "drawhelp.h"
//---------------------------------------------------------------------------
HRESULT CBorderFill::PackProperties(CRenderObj *pRender, BOOL fNoDraw, int iPartId, int iStateId)
{
memset(this, 0, sizeof(CBorderFill)); // allowed because we have no vtable
_eBgType = BT_BORDERFILL;
//---- save off partid, stateid for debugging ----
_iSourcePartId = iPartId;
_iSourceStateId = iStateId;
if (fNoDraw)
{
//---- this is used to fake a bgtype=none object ----
_fNoDraw = TRUE;
}
else
{
//---- get border type ----
if (FAILED(pRender->GetEnumValue(iPartId, iStateId, TMT_BORDERTYPE, (int *)&_eBorderType)))
_eBorderType = BT_RECT; // TODO: Make Zero the default when no bordertype is specified.
//---- get border color ----
if (FAILED(pRender->GetColor(iPartId, iStateId, TMT_BORDERCOLOR, &_crBorder)))
_crBorder = RGB(0, 0, 0);
//---- get border size ----
if (FAILED(pRender->GetInt(iPartId, iStateId, TMT_BORDERSIZE, &_iBorderSize)))
_iBorderSize = 1; // TODO: Make Zero the default when no bordersize is specified.
if (_eBorderType == BT_ROUNDRECT)
{
//---- get round rect width ----
if (FAILED(pRender->GetInt(iPartId, iStateId, TMT_ROUNDCORNERWIDTH, &_iRoundCornerWidth)))
_iRoundCornerWidth = 80;
//---- get round rect height ----
if (FAILED(pRender->GetInt(iPartId, iStateId, TMT_ROUNDCORNERHEIGHT, &_iRoundCornerHeight)))
_iRoundCornerHeight = 80;
}
//---- get fill type ----
if (FAILED(pRender->GetEnumValue(iPartId, iStateId, TMT_FILLTYPE, (int *)&_eFillType)))
_eFillType = FT_SOLID;
if (_eFillType == FT_SOLID)
{
//---- get fill color ----
if (FAILED(pRender->GetColor(iPartId, iStateId, TMT_FILLCOLOR, &_crFill)))
_crFill = RGB(255, 255, 255);
}
else if (_eFillType == FT_TILEIMAGE)
{
_iDibOffset = pRender->GetValueIndex(iPartId, iStateId, TMT_DIBDATA);
if (_iDibOffset == -1) // not found
_iDibOffset = 0;
}
else // one of the graident filltypes
{
_iGradientPartCount = 0;
GRADIENTPART gpParts[5]; // max is 5 for now
for (int i=0; i < ARRAYSIZE(gpParts); i++)
{
COLORREF crPart;
if (FAILED(pRender->GetColor(iPartId, iStateId, TMT_GRADIENTCOLOR1+i, &crPart)))
break;
int iPartRatio;
if (FAILED(pRender->GetInt(iPartId, iStateId, TMT_GRADIENTRATIO1+i, &iPartRatio)))
iPartRatio = 0;
_crGradientColors[_iGradientPartCount] = crPart;
_iGradientRatios[_iGradientPartCount] = iPartRatio;
_iGradientPartCount++;
}
}
//---- ContentMargins ----
if (FAILED(pRender->GetMargins(NULL, iPartId, iStateId, TMT_CONTENTMARGINS, NULL,
&_ContentMargins)))
{
_ContentMargins.cxLeftWidth = _iBorderSize;
_ContentMargins.cxRightWidth = _iBorderSize;
_ContentMargins.cyTopHeight = _iBorderSize;
_ContentMargins.cyBottomHeight = _iBorderSize;
}
}
return S_OK;
}
//---------------------------------------------------------------------------
BOOL CBorderFill::KeyProperty(int iPropId)
{
BOOL fKey = FALSE;
switch (iPropId)
{
case TMT_BGTYPE:
case TMT_BORDERSIZE:
case TMT_ROUNDCORNERWIDTH:
case TMT_ROUNDCORNERHEIGHT:
case TMT_GRADIENTRATIO1:
case TMT_GRADIENTRATIO2:
case TMT_GRADIENTRATIO3:
case TMT_GRADIENTRATIO4:
case TMT_GRADIENTRATIO5:
//case TMT_IMAGEFILE: // borrowed from imagefile
case TMT_CONTENTMARGINS:
case TMT_BORDERCOLOR:
case TMT_FILLCOLOR:
case TMT_GRADIENTCOLOR1:
case TMT_GRADIENTCOLOR2:
case TMT_GRADIENTCOLOR3:
case TMT_GRADIENTCOLOR4:
case TMT_GRADIENTCOLOR5:
case TMT_BORDERTYPE:
case TMT_FILLTYPE:
fKey = TRUE;
break;
}
return fKey;
}
//---------------------------------------------------------------------------
void CBorderFill::DumpProperties(CSimpleFile *pFile, BYTE *pbThemeData, BOOL fFullInfo)
{
if (fFullInfo)
pFile->OutLine(L"Dump of CBorderFill at offset=0x%x", (BYTE *)this - pbThemeData);
else
pFile->OutLine(L"Dump of CBorderFill");
pFile->OutLine(L" _eBgType=%d, _fNoDraw=%d", _eBgType, _fNoDraw);
pFile->OutLine(L" _eBorderType=%d, _iBorderSize=%d, _crBorder=0x%08x",
_eBorderType, _iBorderSize, _crBorder);
pFile->OutLine(L" _iRoundCornerWidth=%d, _iRoundCornerHeight=%d",
_iRoundCornerWidth, _iRoundCornerHeight);
if (fFullInfo)
{
pFile->OutLine(L" _eFillType=%d, _iDibOffset=%d, _crFill=0x%08x",
_eFillType, _iDibOffset, _crFill);
}
else
{
pFile->OutLine(L" _eFillType=%d, _crFill=0x%08x",
_eFillType, _crFill);
}
pFile->OutLine(L" _ContentMargins=%d, %d, %d, %d",
_ContentMargins.cxLeftWidth, _ContentMargins.cxRightWidth,
_ContentMargins.cyTopHeight, _ContentMargins.cyBottomHeight);
pFile->OutLine(L" _iGradientPartCount=%d", _iGradientPartCount);
for (int i=0; i < _iGradientPartCount; i++)
{
pFile->OutLine(L" _crGradientColors[%d]=0x%08x, _iGradientRatios[%d]=%d",
i, _iGradientRatios[i], i, _iGradientRatios[i]);
}
}
//---------------------------------------------------------------------------
HRESULT CBorderFill::DrawComplexBackground(CRenderObj *pRender, HDC hdcOrig,
const RECT *pRect, BOOL fGettingRegion, BOOL fBorder, BOOL fContent,
OPTIONAL const RECT *pClipRect)
{
CSaveClipRegion scrOrig;
HRESULT hr = S_OK;
bool fGradient = false;
int iWidth;
int iHeight;
//---- pen & brush should proceed hdc so auto-delete happens in correct order ----
CAutoGDI<HPEN> hPen;
CAutoGDI<HBRUSH> hBrush;
CAutoDC hdc(hdcOrig);
CMemoryDC memoryDC;
//---- draw border first (along with simple fills) ----
BOOL fHavePath = FALSE;
int width = WIDTH(*pRect);
int height = HEIGHT(*pRect);
if (pClipRect) // use GDI clipping for complex cases
{
//---- get previous clipping region (for restoring at end) ----
hr = scrOrig.Save(hdc);
if (FAILED(hr))
goto exit;
//---- add "pClipRect" to the GDI clipping region ----
int iRetVal = IntersectClipRect(hdc, pClipRect->left, pClipRect->top,
pClipRect->right, pClipRect->bottom);
if (iRetVal == ERROR)
{
hr = MakeErrorLast();
goto exit;
}
}
if ((fBorder) && (_iBorderSize))
{
hPen = CreatePen(PS_SOLID | PS_INSIDEFRAME, _iBorderSize, _crBorder);
if (! hPen)
{
hr = MakeErrorLast();
goto exit;
}
}
if (fContent)
{
if (_eFillType == FT_SOLID)
{
hBrush = CreateSolidBrush(_crFill);
if (! hBrush)
{
hr = MakeErrorLast();
goto exit;
}
}
else if (_eFillType == FT_TILEIMAGE)
{
ASSERT(FALSE); // this fill type not supported
}
else
fGradient = true;
}
if (fGettingRegion)
fGradient = false;
if (! hBrush) // no brush wanted
hBrush = (HBRUSH)GetStockObject(NULL_BRUSH);
if (! hPen) // no pen wanted
hPen = (HPEN)GetStockObject(NULL_PEN);
hdc.SelectPen(hPen);
hdc.SelectBrush(hBrush);
if (_eBorderType == BT_RECT)
{
if (_iBorderSize > 0)
{
//---- no need to create a path for region in this case ----
Rectangle(hdc, pRect->left, pRect->top, pRect->right, pRect->bottom);
}
else
{
FillRect(hdc, pRect, hBrush);
}
}
else if (_eBorderType == BT_ROUNDRECT)
{
int iEllipHeight = (_iRoundCornerHeight*height)/100;
int iEllipWidth = (_iRoundCornerWidth*width)/100;
RoundRect(hdc, pRect->left, pRect->top, pRect->right, pRect->bottom,
iEllipHeight, iEllipWidth);
if (fGradient) // create a path of the border
{
BeginPath(hdc);
RoundRect(hdc, pRect->left, pRect->top, pRect->right, pRect->bottom,
iEllipHeight, iEllipWidth);
EndPath(hdc);
fHavePath = TRUE;
}
}
else // if (_eBorderType == BT_ELLIPSE)
{
Ellipse(hdc, pRect->left, pRect->top, pRect->right, pRect->bottom);
if (fGradient) // create a path of the border
{
BeginPath(hdc);
Ellipse(hdc, pRect->left, pRect->top, pRect->right, pRect->bottom);
EndPath(hdc);
fHavePath = TRUE;
}
}
if (! fGradient) // we're done
goto exit;
//---- draw gradient fill within the border drawn above ----
//---- shrink rect to subtract border ----
RECT rect;
SetRect(&rect, pRect->left, pRect->top, pRect->right, pRect->bottom);
rect.left += _iBorderSize;
rect.top += _iBorderSize;
rect.right -= _iBorderSize;
rect.bottom -= _iBorderSize;
iWidth = WIDTH(rect);
iHeight = HEIGHT(rect);
hr = memoryDC.OpenDC(hdc, iWidth, iHeight);
if (FAILED(hr))
goto exit;
//---- paint our bounding rect into dcBitmap with our gradient ----
RECT rect2;
SetRect(&rect2, 0, 0, iWidth, iHeight);
GRADIENTPART gpParts[5]; // max is 5 for now
//---- get gradient colors & ratios ----
for (int i=0; i < _iGradientPartCount; i++)
{
COLORREF crPart = _crGradientColors[i];
gpParts[i].Color.bRed = RED(crPart);
gpParts[i].Color.bGreen = GREEN(crPart);
gpParts[i].Color.bBlue = BLUE(crPart);
gpParts[i].Color.bAlpha = 255;
gpParts[i].Ratio = (BYTE)_iGradientRatios[i];
};
if (_eFillType == FT_RADIALGRADIENT)
{
PaintGradientRadialRect(memoryDC, rect2, _iGradientPartCount, gpParts);
}
else if (_eFillType == FT_VERTGRADIENT)
{
PaintVertGradient(memoryDC, rect2, _iGradientPartCount, gpParts);
}
else // if (_eFillType == FT_HORZGRADIENT)
{
PaintHorzGradient(memoryDC, rect2, _iGradientPartCount, gpParts);
}
if (fHavePath)
{
CSaveClipRegion scrCurrent;
hr = scrCurrent.Save(hdc); // save current clip region
if (FAILED(hr))
goto exit;
//---- select our shape as the clipping region in normal hdc ----
SelectClipPath(hdc, RGN_AND);
//---- blt our gradient into the shape-clipped rect into the normal hdc ----
BitBlt(hdc, rect.left, rect.top, iWidth, iHeight, memoryDC, 0, 0, SRCCOPY);
scrCurrent.Restore(hdc); // restore current clip region
}
else
{
//---- blt our gradient into the shape-clipped rect into the normal hdc ----
BitBlt(hdc, rect.left, rect.top, iWidth, iHeight, memoryDC, 0, 0, SRCCOPY);
}
exit:
scrOrig.Restore(hdc); // restore clipping region
return hr;
}
//---------------------------------------------------------------------------
HRESULT CBorderFill::DrawBackground(CRenderObj *pRender, HDC hdcOrig,
const RECT *pRect, OPTIONAL const DTBGOPTS *pOptions)
{
HRESULT hr = S_OK;
//---- options ----
DWORD dwOptionFlags = 0;
BOOL fBorder = TRUE;
BOOL fContent = TRUE;
BOOL fGettingRegion = FALSE;
const RECT *pClipRect = NULL;
if (pOptions)
{
dwOptionFlags = pOptions->dwFlags;
if (dwOptionFlags & DTBG_CLIPRECT)
pClipRect = &pOptions->rcClip;
if (dwOptionFlags & DTBG_OMITBORDER)
fBorder = FALSE;
if (dwOptionFlags & DTBG_OMITCONTENT)
fContent = FALSE;
if (dwOptionFlags & DTBG_COMPUTINGREGION)
fGettingRegion = TRUE;
}
//---- optimize for perf-sensitive paths thru here ----
if (_fNoDraw)
{
//---- nothing to do ----
}
else if ((_eFillType == FT_SOLID) && (_eBorderType == BT_RECT)) // solid rectangle
{
if (! _iBorderSize) // no border case
{
if (fContent)
{
//---- clip, if needed ----
RECT rcContent = *pRect;
if (pClipRect)
IntersectRect(&rcContent, &rcContent, pClipRect);
//---- fastest solid rect ----
COLORREF crOld = SetBkColor(hdcOrig, _crFill);
ExtTextOut(hdcOrig, 0, 0, ETO_OPAQUE, &rcContent, NULL, 0, NULL);
//---- restore old color ----
SetBkColor(hdcOrig, crOld);
}
}
else // border case
{
COLORREF crOld = GetBkColor(hdcOrig);
//---- draw clipped borders ----
if (fBorder)
{
RECT rcLine;
SetBkColor(hdcOrig, _crBorder);
//---- draw LEFT line ----
SetRect(&rcLine, pRect->left, pRect->top, pRect->left+_iBorderSize,
pRect->bottom);
if (pClipRect)
IntersectRect(&rcLine, &rcLine, pClipRect);
ExtTextOut(hdcOrig, 0, 0, ETO_OPAQUE, &rcLine, NULL, 0, NULL);
//---- draw RIGHT line ----
SetRect(&rcLine, pRect->right-_iBorderSize, pRect->top, pRect->right,
pRect->bottom);
if (pClipRect)
IntersectRect(&rcLine, &rcLine, pClipRect);
ExtTextOut(hdcOrig, 0, 0, ETO_OPAQUE, &rcLine, NULL, 0, NULL);
//---- draw TOP line ----
SetRect(&rcLine, pRect->left, pRect->top, pRect->right,
pRect->top+_iBorderSize);
if (pClipRect)
IntersectRect(&rcLine, &rcLine, pClipRect);
ExtTextOut(hdcOrig, 0, 0, ETO_OPAQUE, &rcLine, NULL, 0, NULL);
//---- draw BOTTOM line ----
SetRect(&rcLine, pRect->left, pRect->bottom-_iBorderSize, pRect->right,
pRect->bottom);
if (pClipRect)
IntersectRect(&rcLine, &rcLine, pClipRect);
ExtTextOut(hdcOrig, 0, 0, ETO_OPAQUE, &rcLine, NULL, 0, NULL);
}
//---- remove borders from rect to draw content ----
if (fContent)
{
RECT rcContent = *pRect;
rcContent.left += _iBorderSize;
rcContent.right -= _iBorderSize;
rcContent.top += _iBorderSize;
rcContent.bottom -= _iBorderSize;
if (pClipRect)
IntersectRect(&rcContent, &rcContent, pClipRect);
//---- fastest solid rect ----
SetBkColor(hdcOrig, _crFill);
ExtTextOut(hdcOrig, 0, 0, ETO_OPAQUE, &rcContent, NULL, 0, NULL);
}
//---- restore old color ----
SetBkColor(hdcOrig, crOld);
}
}
else // all other cases
{
hr = DrawComplexBackground(pRender, hdcOrig, pRect, fGettingRegion,
fBorder, fContent, pClipRect);
}
return hr;
}
//---------------------------------------------------------------------------
HRESULT CBorderFill::GetBackgroundRegion(CRenderObj *pRender, OPTIONAL HDC hdc,
const RECT *pRect, HRGN *pRegion)
{
HRESULT hr;
//---- see if it even has a transparent part ----
if (! IsBackgroundPartiallyTransparent())
{
//---- return the bounding rect as the region ----
HRGN hrgn = CreateRectRgn(pRect->left, pRect->top,
pRect->right, pRect->bottom);
if (! hrgn)
return MakeErrorLast();
*pRegion = hrgn;
return S_OK;
}
//---- create a memory dc/bitmap to draw info ----
CMemoryDC hdcMemory;
//---- use maximum drawing values as size of DC ----
hr = hdcMemory.OpenDC(NULL, RECTWIDTH(pRect), RECTHEIGHT(pRect));
if (FAILED(hr))
return hr;
BOOL fOK = BeginPath(hdcMemory);
if (! fOK)
return MakeErrorLast();
DTBGOPTS Opts = {sizeof(Opts), DTBG_COMPUTINGREGION};
hr = DrawBackground(pRender, hdcMemory, pRect, &Opts);
if (FAILED(hr))
return hr;
fOK = EndPath(hdcMemory);
if (! fOK)
return MakeErrorLast();
HRGN hrgn = PathToRegion(hdcMemory);
if (! hrgn)
return MakeErrorLast();
*pRegion = hrgn;
return S_OK;
}
//---------------------------------------------------------------------------
BOOL CBorderFill::IsBackgroundPartiallyTransparent()
{
return ((_eBorderType != BT_RECT) || _fNoDraw);
}
//---------------------------------------------------------------------------
HRESULT CBorderFill::HitTestBackground(CRenderObj *pRender, OPTIONAL HDC hdc,
DWORD dwHTFlags, const RECT *pRect, HRGN hrgn, POINT ptTest, OUT WORD *pwHitCode)
{
MARGINS margins;
GetContentMargins(pRender, hdc, &margins);
*pwHitCode = HitTestRect( dwHTFlags, pRect, margins, ptTest );
return S_OK;
}
//---------------------------------------------------------------------------
void CBorderFill::GetContentMargins(CRenderObj *pRender, OPTIONAL HDC hdc, MARGINS *pMargins)
{
*pMargins = _ContentMargins;
//---- adjust for DPI scaling ----
#if 0
int iDcDpi;
if (DpiDiff(hdc, &iDcDpi)))
{
pMargins->cxLeftWidth = DpiScale(pMargins->cxLeftWidth, iDcDpi);
pMargins->cxRightWidth = DpiScale(pMargins->cxRightWidth, iDcDpi);
pMargins->cyTopHeight = DpiScale(pMargins->cyTopHeight, iDcDpi);
pMargins->cyBottomHeight = DpiScale(pMargins->cyBottomHeight, iDcDpi);
}
#endif
}
//---------------------------------------------------------------------------
HRESULT CBorderFill::GetBackgroundContentRect(CRenderObj *pRender, OPTIONAL HDC hdc,
const RECT *pBoundingRect, RECT *pContentRect)
{
MARGINS margins;
GetContentMargins(pRender, hdc, &margins);
pContentRect->left = pBoundingRect->left + margins.cxLeftWidth;
pContentRect->top = pBoundingRect->top + margins.cyTopHeight;
pContentRect->right = pBoundingRect->right - margins.cxRightWidth;
pContentRect->bottom = pBoundingRect->bottom - margins.cyBottomHeight;
return S_OK;
}
//---------------------------------------------------------------------------
HRESULT CBorderFill::GetBackgroundExtent(CRenderObj *pRender, OPTIONAL HDC hdc,
const RECT *pContentRect, RECT *pExtentRect)
{
MARGINS margins;
GetContentMargins(pRender, hdc, &margins);
pExtentRect->left = pContentRect->left - margins.cxLeftWidth;
pExtentRect->top = pContentRect->top-+ margins.cyTopHeight;
pExtentRect->right = pContentRect->right + margins.cxRightWidth;
pExtentRect->bottom = pContentRect->bottom + margins.cyBottomHeight;
return S_OK;
}
//---------------------------------------------------------------------------
HRESULT CBorderFill::GetPartSize(HDC hdc, THEMESIZE eSize, SIZE *psz)
{
HRESULT hr = S_OK;
if (eSize == TS_MIN)
{
psz->cx = max(1, _iBorderSize*2);
psz->cy = max(1, _iBorderSize*2);
}
else if (eSize == TS_TRUE)
{
psz->cx = _iBorderSize*2 + 1;
psz->cy = _iBorderSize*2 + 1;
}
else
{
hr = MakeError32(E_INVALIDARG);
}
return hr;
}
//---------------------------------------------------------------------------