/**********************************************************************
* The edit control subclass window proc.
*/
LRESULT CALLBACK THEMING_EditSubclassProc (HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam,
ULONG_PTR dwRefData)
{
const WCHAR* themeClass = WC_EDITW;
HTHEME theme;
LRESULT result;
switch (msg)
{
case WM_CREATE:
result = THEMING_CallOriginalClass (hwnd, msg, wParam, lParam);
OpenThemeData( hwnd, themeClass );
return result;
case WM_DESTROY:
theme = GetWindowTheme( hwnd );
CloseThemeData ( theme );
return THEMING_CallOriginalClass (hwnd, msg, wParam, lParam);
case WM_THEMECHANGED:
theme = GetWindowTheme( hwnd );
CloseThemeData ( theme );
OpenThemeData( hwnd, themeClass );
break;
case WM_SYSCOLORCHANGE:
theme = GetWindowTheme( hwnd );
if (!theme) return THEMING_CallOriginalClass (hwnd, msg, wParam, lParam);
/* Do nothing. When themed, a WM_THEMECHANGED will be received, too,
* which will do the repaint. */
break;
case WM_NCPAINT:
theme = GetWindowTheme( hwnd );
if (!theme) return THEMING_CallOriginalClass (hwnd, msg, wParam, lParam);
nc_paint (theme, hwnd, (HRGN)wParam);
break;
case WM_ENABLE:
case WM_KILLFOCUS:
case WM_SETFOCUS:
theme = GetWindowTheme( hwnd );
if (theme) RedrawWindow (hwnd, NULL, NULL,
RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW);
return THEMING_CallOriginalClass (hwnd, msg, wParam, lParam);
default:
/* Call old proc */
return THEMING_CallOriginalClass (hwnd, msg, wParam, lParam);
}
return 0;
}
void threaded_process_v2_t::refresh_title_font()
{
LOGFONT lf;
memset(&lf, 0, sizeof(LOGFONT));
m_titlecolour = GetSysColor(COLOR_WINDOWTEXT);
HTHEME thm_textstyle = IsThemeActive() && IsAppThemed() ? OpenThemeData(get_wnd(), L"TextStyle") : NULL;
if (thm_textstyle)
{
if (SUCCEEDED(GetThemeFont(thm_textstyle, NULL, TEXT_MAININSTRUCTION, 0, TMT_FONT, &lf)))
{
m_titlefont = CreateFontIndirect(&lf);
GetThemeColor(thm_textstyle, TEXT_MAININSTRUCTION, NULL, TMT_TEXTCOLOR, &m_titlecolour);
}
CloseThemeData(thm_textstyle);
}
if (!m_titlefont.is_valid())
{
uGetIconFont(&lf);
lf.lfWeight = FW_BOLD;
m_titlefont = CreateFontIndirect(&lf);
}
m_titlefont_height = uGetFontHeight(m_titlefont);
}
CRect CPropPageFrameDefault::CalcCaptionArea()
{
CRect rect;
GetClientRect(rect);
if (IsAppThemed())
{
HTHEME hTheme = OpenThemeData(m_hWnd, L"Tab");
if (hTheme)
{
CRect rectContent;
CDC *pDc = GetDC();
GetThemeBackgroundContentRect(hTheme, pDc->m_hDC, TABP_PANE, 0, rect, rectContent);
ReleaseDC(pDc);
CloseThemeData(hTheme);
if (GetShowCaption())
rectContent.bottom = rect.top+GetCaptionHeight();
else
rectContent.bottom = rectContent.top;
rect = rectContent;
}
}
else
{
if (GetShowCaption())
rect.bottom = rect.top+GetCaptionHeight();
else
rect.bottom = rect.top;
}
return rect;
}
void CToolBarTreeView::Draw()
{
const int& cx = m_mdc.cx;
const int& cy = m_mdc.cy;
if (IsAppThemed())
{
HTHEME hTheme = OpenThemeData(m_hWnd, L"TREEVIEW");
ASSERT(hTheme);
RECT rc = {0, 0, cx, cy};
DrawThemeBackground(hTheme, m_mdc, LBCP_BORDER_NOSCROLL, LBPSN_NORMAL, &rc, NULL);
CloseThemeData(hTheme);
// TODO: detect size of border (check for high DPI)
DrawRect(m_mdc, 1, 1, cx - 2, SCY(24), GetSysColor(COLOR_BTNFACE), 96);
DrawRect(m_mdc, 1, 1 + SCY(24) - 1, cx - 2, 1, GetSysColor(COLOR_BTNFACE), 192);
}
else
{
RECT rc = {0, 0, cx, cy};
FillSolidRect(m_mdc, &rc, GetSysColor(COLOR_WINDOW));
FillSolidRect(m_mdc, 1, 1, cx - 2, SCY(24), GetSysColor(COLOR_BTNFACE));
DrawEdge(m_mdc, &rc, EDGE_SUNKEN, BF_RECT);
}
}
int CPopupFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
m_hThemeDLL = ::LoadLibrary(_T("uxtheme.dll"));
if (m_hThemeDLL != NULL)
{
m_pfnDrawThemeBackground = (PFN_DrawThemeBackground)::GetProcAddress(m_hThemeDLL, "DrawThemeBackground");
ASSERT(m_pfnDrawThemeBackground != NULL);
if(m_pfnDrawThemeBackground != NULL)
{
OpenThemeData();
}
else
{
::FreeLibrary(m_hThemeDLL);
m_hThemeDLL = NULL;
}
}
GetSystemSettings();
DWORD dwStyle = GetStyle();
m_cxFrameWidth = (dwStyle & WS_THICKFRAME) ? GetSystemMetrics(SM_CXSIZEFRAME) : GetSystemMetrics(SM_CXFIXEDFRAME);
m_cyFrameHeight = (dwStyle & WS_THICKFRAME) ? GetSystemMetrics(SM_CYSIZEFRAME) : GetSystemMetrics(SM_CYFIXEDFRAME);
return 0;
}
/********************************************
WriteText
Purpose
Provides a more straightforward way to draw text by wrapping all the calls required into the dll,
as well as using our theme data mappings to find the core info required. Was called DrawText,
but the preprocessor insisted on changing it to DrawTextA, which then obviously would not compile
Params
hwnd - the HWND of the control we draw to, or NULL
hdc - the device context for the dll to draw to
type - the cell type to draw
state - the state of the cell ( selected, current, etc )
text - the text to draw
textLength - the number of characters to draw
textFlags - the text style to use when drawing the text area
pRect - the rect to draw text into
Return
A bool to indicate success or failure, which is used to control drawing in the old style throughout the library
*********************************************/
bool UGXPThemes::WriteText(HWND hwnd, HDC hdc, UGXPCellType type,
UGXPThemeState state, LPCTSTR text, int textLength, DWORD textFlags, const RECT *pRect)
{
bool success = false;
if (useThemes)
{
UGThemeData * td = LookupThemeData(type, state);
if (!td)
{
return false;
}
HANDLE hTheme = OpenThemeData(hwnd, td->GetThemeName());
if(hTheme)
{
USES_CONVERSION;
success = SUCCEEDED(DrawThemeText(hTheme, hdc, td->GetPartID(), td->GetStateID(), T2W((LPTSTR)text), textLength, textFlags, 0, pRect));
// CloseThemeData(hTheme);
success = true;
}
}
return success;
}
/********************************************
WriteText
Purpose
Provides a more straightforward way to draw text by wrapping all the calls required into the dll,
as well as using our theme data mappings to find the core info required. Was called DrawText,
but the preprocessor insisted on changing it to DrawTextA, which then obviously would not compile
Params
hwnd - the HWND of the control we draw to, or NULL
hdc - the device context for the dll to draw to
theme - the name of the theme to use
partId - the theme part to draw
stateId - the state of the part to draw
text - the text to draw, which is converted from a char * to a wide string in this method.
textLength - the number of characters to draw
textFlags - the text style to use when drawing the text area
pRect - the rect to draw text into
Return
A bool to indicate success or failure, which is used to control drawing in the old style throughout the library
*********************************************/
bool UGXPThemes::WriteText(HWND hwnd, HDC hdc, LPCTSTR theme, int partID,
int stateID, LPCTSTR text, int textLength, DWORD textFlags, const RECT *pRect, bool useCache)
{
bool success = false;
if (useThemes)
{
USES_CONVERSION;
HANDLE themeHandle = OpenThemeData(hwnd, T2W((LPTSTR)theme), useCache);
if (themeHandle)
{
HRESULT hr = DrawThemeText(themeHandle, hdc, partID, stateID, T2W((LPTSTR)text), textLength, textFlags, 0, pRect);
success = SUCCEEDED(hr);
if (!useCache)
{
CloseThemeData(themeHandle);
}
}
}
return success;
}
static HRESULT drawCheckboxPart(HRESULT hr, struct drawState *s)
{
uiTableValue *value;
int checked, enabled;
HTHEME theme;
if (hr != S_OK)
return hr;
if (s->p->checkboxModelColumn == -1)
return S_OK;
value = uiprivTableModelCellValue(s->model, s->iItem, s->p->checkboxModelColumn);
checked = uiTableValueInt(value);
uiFreeTableValue(value);
enabled = uiprivTableModelCellEditable(s->model, s->iItem, s->p->checkboxEditableModelColumn);
theme = OpenThemeData(s->t->hwnd, L"button");
if (theme != NULL) {
hr = drawThemedCheckbox(s, theme, checked, enabled);
if (hr != S_OK)
return hr;
hr = CloseThemeData(theme);
if (hr != S_OK) {
logHRESULT(L"CloseThemeData()", hr);
return hr;
}
} else {
hr = drawUnthemedCheckbox(s, checked, enabled);
if (hr != S_OK)
return hr;
}
return S_OK;
}
VOID NcAreaInitializeTheme(
_Inout_ PEDIT_CONTEXT Context
)
{
Context->CXWidth = PhMultiplyDivide(20, PhGlobalDpi, 96);
Context->BrushNormal = GetSysColorBrush(COLOR_WINDOW);
Context->BrushHot = CreateSolidBrush(RGB(205, 232, 255));
Context->BrushPushed = CreateSolidBrush(RGB(153, 209, 255));
if (IsThemeActive())
{
HTHEME themeDataHandle;
if (themeDataHandle = OpenThemeData(Context->WindowHandle, VSCLASS_EDIT))
{
//IsThemePartDefined_I(themeDataHandle, EP_EDITBORDER_NOSCROLL, EPSHV_NORMAL);
GetThemeInt(
themeDataHandle,
EP_EDITBORDER_NOSCROLL,
EPSHV_NORMAL,
TMT_BORDERSIZE,
&Context->CXBorder
);
CloseThemeData(themeDataHandle);
}
}
else
{
Context->CXBorder = GetSystemMetrics(SM_CXBORDER) * 2;
}
}
/********************************************
GetTextExtent
Purpose
This wraps the call to GetThemeTextExtent, which returns
the area that will be taken up by drawing themed text.
Params
hwnd - the window to draw to, often NULL
hdc - the HDC to draw to
type - the cell type to draw
state - the state of the cell ( selected, current, etc )
pszText - the text to measure
iCharCount - the number of characters to draw
dwTextFlags - the text style to use when measuring the text area
pBoundingRect - the rect to draw text into
pExtentRect - used to return the rect which will be used by the text.
Return
A HRESULT to indicate success or failure.
*********************************************/
bool UGXPThemes::GetTextExtent(HWND hwnd, HDC hdc, UGXPCellType type, UGXPThemeState state,
LPCTSTR pszText, int iCharCount, DWORD dwTextFlags, const RECT *pBoundingRect,
RECT *pExtentRect)
{
bool success = false;
if (useThemes)
{
UGThemeData * td = LookupThemeData(type, state);
if (!td)
{
return false;
}
HANDLE themeHandle = OpenThemeData(hwnd, td->GetThemeName());
if (!themeHandle)
return false;
USES_CONVERSION;
success = SUCCEEDED(GetThemeTextExtent(themeHandle, hdc, td->GetPartID(), td->GetStateID(), A2W((LPCSTR)pszText), iCharCount,
dwTextFlags, pBoundingRect, pExtentRect));
}
return success;
}
/* update theme after a WM_THEMECHANGED message */
static LRESULT theme_changed (const STATUS_INFO* infoPtr)
{
HTHEME theme = GetWindowTheme (infoPtr->Self);
CloseThemeData (theme);
OpenThemeData (infoPtr->Self, themeClass);
return 0;
}
LRESULT CPanel::OnCreate(UINT, WPARAM,LPARAM,BOOL& bHandled)
{
OpenThemeData (L"TAB");
//OpenThemeData (L"BUTTON");
bHandled=FALSE;
return 0;
}
// TODO run again when the DPI or the theme changes
// TODO properly clean things up here
// TODO properly destroy the old lists here too
HRESULT uiprivUpdateImageListSize(uiTable *t)
{
HDC dc;
int cxList, cyList;
HTHEME theme;
SIZE sizeCheck;
HRESULT hr;
dc = GetDC(t->hwnd);
if (dc == NULL) {
logLastError(L"GetDC()");
return E_FAIL;
}
cxList = GetSystemMetrics(SM_CXSMICON);
cyList = GetSystemMetrics(SM_CYSMICON);
sizeCheck.cx = cxList;
sizeCheck.cy = cyList;
theme = OpenThemeData(t->hwnd, L"button");
if (theme != NULL) {
hr = GetThemePartSize(theme, dc,
BP_CHECKBOX, CBS_UNCHECKEDNORMAL,
NULL, TS_DRAW, &sizeCheck);
if (hr != S_OK) {
logHRESULT(L"GetThemePartSize()", hr);
return hr; // TODO fall back?
}
// make sure these checkmarks fit
// unthemed checkmarks will by the code above be smaller than cxList/cyList here
if (cxList < sizeCheck.cx)
cxList = sizeCheck.cx;
if (cyList < sizeCheck.cy)
cyList = sizeCheck.cy;
hr = CloseThemeData(theme);
if (hr != S_OK) {
logHRESULT(L"CloseThemeData()", hr);
return hr;
}
}
// TODO handle errors
t->imagelist = ImageList_Create(cxList, cyList,
ILC_COLOR32,
1, 1);
if (t->imagelist == NULL) {
logLastError(L"ImageList_Create()");
return E_FAIL;
}
// TODO will this return NULL here because it's an initial state?
SendMessageW(t->hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM) (t->imagelist));
if (ReleaseDC(t->hwnd, dc) == 0) {
logLastError(L"ReleaseDC()");
return E_FAIL;
}
return S_OK;
}
LRESULT CPopupFrame::OnThemeChanged(WPARAM, LPARAM)
{
if (m_hThemeDLL != NULL)
{
CloseThemeData();
OpenThemeData();
}
return 0;
}
int LTIndefProgressBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CWnd::OnCreate(lpCreateStruct) == -1)
return -1;
SetTimer(PROGRESS_TIMER, 30, NULL);
h_ThemeBar = OpenThemeData(m_hWnd, L"PROGRESS");
// TODO: Add your specialized creation code here
return 0;
}
int LTDrawToolBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CWnd::OnCreate(lpCreateStruct) == -1)
return -1;
h_Theme = OpenThemeData(m_hWnd, L"BUTTON");
// TODO: Add your specialized creation code here
return 0;
}
/********************************************
DrawBackground
Purpose
Provides a more straightforward way to draw a background by wrapping all the calls required into the dll,
as well as using our theme data mappings to find the core info required.
Params
hwnd - the HWND of the control we draw to, or NUL
hdc - the device context for the dll to draw to
type - the cell type we want to draw
state - the state of the cell we want to draw
pRect - represents the area we want to draw to
pClipRect - is exposed, but is almost always NULL
Return
A bool to indicate success or failure, which is used to control drawing in the old style throughout the library
*********************************************/
bool UGXPThemes::DrawBackground(HWND hwnd, HDC hdc, UGXPCellType type,
UGXPThemeState state, const RECT *pRect, const RECT *pClipRect)
{
bool success = false;
if (useThemes)
{
UGThemeData * td = LookupThemeData(type, state);
if (!td)
{
return false;
}
HANDLE hTheme = OpenThemeData(hwnd, td->GetThemeName());
if(hTheme)
{
// If the background is transparent, we draw using the Data cell type first,
// which fills the background. DrawThemeParentBackground just plain does not work
// for us, perhaps because the parent is an owner drawn control ?
// Of course, if the Data cell type has transparency, all we can do is return E_FAILED
if (IsThemeBackgroundPartiallyTransparent(hTheme, td->GetPartID(), td->GetStateID()))
{
if (type == XPCellTypeData) return FALSE;
UGThemeData * tdCell = LookupThemeData(XPCellTypeData, (state == ThemeStatePressed || state == ThemeStateTriState) ? ThemeStateNormal : state);
HANDLE hThemeCell = OpenThemeData(hwnd, tdCell->GetThemeName());
DrawThemeBackground(hThemeCell, hdc, tdCell->GetPartID(), tdCell->GetStateID(), pRect, pClipRect);
}
success = SUCCEEDED(DrawThemeBackground(hTheme, hdc, td->GetPartID(), td->GetStateID(), pRect, pClipRect));
// CloseThemeData(hTheme);
}
}
return success;
}
/********************************************
DrawBackground
Purpose
Provides a more straightforward way to draw a background by wrapping all the calls required into the dll,
as well as using our theme data mappings to find the core info required.
This version still takes a theme name instead of using our lookup
table, it's used in cases where we hard code the theme part ( such a progress bars )
Params
hwnd - the HWND of the control we draw to, or NUL
hdc - the device context for the dll to draw to
theme - the name of the theme to use
iPartId - the theme part to draw
iStateId - the state of the part to draw
pRect - represents the area we want to draw to
pClipRect - is exposed, but is almost always NULL
Return
A bool to indicate success or failure, which is used to control drawing in the old style throughout the library
*********************************************/
bool UGXPThemes::DrawBackground(HWND hwnd, HDC hdc, LPCWSTR theme, int partID,
int stateID, const RECT *pRect, const RECT *pClipRect, bool useCache)
{
bool success = false;
if (useThemes)
{
HANDLE themeHandle = OpenThemeData(hwnd, theme, useCache);
if (themeHandle)
{
// If the background is transparent, we draw using the Data cell type first,
// which fills the background. DrawThemeParentBackground just plain does not work
// for us, perhaps because the parent is an owner drawn control ?
// Of course, if the Data cell type has transparency, this will fail.
if (IsThemeBackgroundPartiallyTransparent(themeHandle, partID, stateID))
{
//RECT temp = *pRect;
UGThemeData * tdCell = LookupThemeData(XPCellTypeData, ThemeStateNormal);
HANDLE hThemeCell = OpenThemeData(hwnd, tdCell->GetThemeName());
DrawThemeBackground(hThemeCell, hdc, partID, stateID, pRect, pClipRect);
}
HRESULT hr = DrawThemeBackground(themeHandle, hdc, partID, stateID, pRect, pClipRect);
success = SUCCEEDED(hr);
if (!useCache)
{
CloseThemeData(themeHandle);
}
}
}
return success;
}
BOOL AeroControlBase::GetEditBorderColor(HWND hWnd, COLORREF *pClr)
{
ASSERT(pClr);
HTHEME hTheme = OpenThemeData(hWnd, L"Edit");
if(hTheme)
{
VERIFY(S_OK==GetThemeColor(hTheme, EP_BACKGROUNDWITHBORDER, EBWBS_NORMAL, TMT_BORDERCOLOR, pClr));
VERIFY(S_OK==CloseThemeData(hTheme));
return TRUE;
}
return FALSE;
}
//绘制发光文字
void DrawGlowingText(HDC hDC, int IDC)
{
HWND hWnd = GetDlgItem(g_hMainWnd, IDC);
char szText[128] = {0};
GetWindowText(hWnd, szText, 128);
RECT rcArea;
GetWindowRect(hWnd, &rcArea);
DWORD dwTextFlags = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
int iGlowSize = 10;
//获取主题句柄
HTHEME hThm = OpenThemeData(GetDesktopWindow(), L"TextStyle");
//创建DIB
HDC hMemDC = CreateCompatibleDC(hDC);
BITMAPINFO bmpinfo = {0};
bmpinfo.bmiHeader.biSize = sizeof(bmpinfo.bmiHeader);
bmpinfo.bmiHeader.biBitCount = 32;
bmpinfo.bmiHeader.biCompression = BI_RGB;
bmpinfo.bmiHeader.biPlanes = 1;
bmpinfo.bmiHeader.biWidth = rcArea.right - rcArea.left;
bmpinfo.bmiHeader.biHeight = -(rcArea.bottom - rcArea.top);
HBITMAP hBmp = CreateDIBSection(hMemDC, &bmpinfo, DIB_RGB_COLORS, 0, NULL, 0);
if (hBmp == NULL) return;
HGDIOBJ hBmpOld = SelectObject(hMemDC, hBmp);
//绘制选项
DTTOPTS dttopts = {0};
dttopts.dwSize = sizeof(DTTOPTS);
dttopts.dwFlags = DTT_GLOWSIZE | DTT_COMPOSITED;
dttopts.iGlowSize = iGlowSize; //发光的范围大小
//绘制文本
RECT rc = {0, 0, rcArea.right - rcArea.left, rcArea.bottom - rcArea.top};
DWORD dwNum = MultiByteToWideChar (CP_ACP, 0, szText, -1, NULL, 0);
wchar_t *pwText;
pwText = new wchar_t[dwNum];
MultiByteToWideChar (CP_ACP, 0, szText, -1, pwText, dwNum);
HRESULT hr = DrawThemeTextEx(hThm, hMemDC, TEXT_LABEL, 0, pwText, -1, dwTextFlags , &rc, &dttopts);
if(FAILED(hr)) return;
BitBlt(hDC, rcArea.left, rcArea.top, rcArea.right - rcArea.left,
rcArea.bottom - rcArea.top, hMemDC, 0, 0, SRCCOPY | CAPTUREBLT);
//Clear
SelectObject(hMemDC, hBmpOld);
DeleteObject(hBmp);
DeleteDC(hMemDC);
CloseThemeData(hThm);
}
bool UGXPThemes::GetThemeString(LPCWSTR theme, int iPartId, int iStateId, int iPropId, LPWSTR pszBuff, int cchMaxBuffChars)
{
bool success = false;
if (useThemes)
{
HANDLE themeHandle = OpenThemeData(NULL, theme);
if (!themeHandle)
return false;
success = SUCCEEDED(GetThemeString(themeHandle, iPartId, iStateId, iPropId, pszBuff, cchMaxBuffChars));
}
return success;
}
bool UGXPThemes::GetThemePartSize(LPCWSTR theme, HDC dc, int iPartId, int iStateId, RECT * pRect, int eSize, SIZE *psz)
{
bool success = false;
if (useThemes)
{
HANDLE themeHandle = OpenThemeData(NULL, theme);
if (themeHandle)
{
HRESULT hr = GetThemePartSize(themeHandle, dc, iPartId, iStateId, pRect, eSize, psz);
success = SUCCEEDED(hr);
}
}
return success;
}
void ColourButton::OnCustomDraw(NMHDR* nmhdr, LRESULT* result)
{
NMCUSTOMDRAW* nmcd = (NMCUSTOMDRAW*)nmhdr;
*result = CDRF_DODEFAULT;
switch (nmcd->dwDrawStage)
{
case CDDS_PREPAINT:
{
CDC* dc = CDC::FromHandle(nmcd->hdc);
CRect r(nmcd->rc);
bool selected = ((nmcd->uItemState & CDIS_SELECTED) != 0);
bool disabled = ((nmcd->uItemState & CDIS_DISABLED) != 0);
bool focus = ((nmcd->uItemState & CDIS_FOCUS) != 0);
if (SendMessage(WM_QUERYUISTATE) & UISF_HIDEFOCUS)
focus = false;
if (IsAppThemed())
{
HTHEME theme = OpenThemeData(this,L"Button");
if (theme)
{
// Get the area to draw into
GetThemeBackgroundContentRect(theme,dc,BP_PUSHBUTTON,PBS_NORMAL,r);
CloseThemeData(theme);
}
}
else
{
UINT state = DFCS_BUTTONPUSH|DFCS_ADJUSTRECT;
if (disabled)
state |= DFCS_INACTIVE;
if (selected)
state |= DFCS_PUSHED;
dc->DrawFrameControl(r,DFC_BUTTON,state);
if (selected)
r.OffsetRect(1,1);
}
DrawControl(dc,r,disabled,focus);
*result = CDRF_SKIPDEFAULT;
}
break;
}
}
/********************************************
DrawEdge
Purpose
Provides a more straightforward way to draw the edge by wrapping all the calls required into the dll,
as well as using our theme data mappings to find the core info required.
Params
hwnd - the HWND of the control we draw to, or NUL
hdc - the device context for the dll to draw to
type - the cell type we want to draw
state - the state of the cell we want to draw
pRect - represents the area we want to draw to
uEdge - specifies the type of inner and outer edges to draw.
This parameter must be a combination of one inner-border flag and one outer-border flag,
or one of the combination flags.
uFlags - specifies the type of border to draw.
pContentRect - is exposed, but is almost always NULL
Return
A bool to indicate success or failure, which is used to control drawing in the old style throughout the library
*********************************************/
bool UGXPThemes::DrawEdge(HWND hwnd, HDC hdc, UGXPCellType type, UGXPThemeState state,
const RECT *pRect, UINT uEdge, UINT uFlags, RECT *pContentRect)
{
bool success = false;
if (useThemes)
{
UGThemeData * td = LookupThemeData(type, state);
if (!td)
{
return false;
}
HANDLE hTheme = OpenThemeData(hwnd, td->GetThemeName());
short edgeFormat = (uEdge & UG_BDR_RAISED) ? BDR_RAISEDINNER | BDR_SUNKENOUTER : BDR_SUNKENINNER | BDR_RAISEDOUTER;
if(hTheme)
{
success = SUCCEEDED(DrawThemeEdge(hTheme, hdc, td->GetPartID(), td->GetStateID(), pRect, edgeFormat, uFlags, pContentRect));
// We populate pContentRect with the rect to draw content in.
if (success && pContentRect)
{
*pContentRect = *pRect;
// Because the grid draws itself multiple times, this was causing areas
// to become undrawn. May need some investigation, may just be unnecessary.
/*
// 3602 = TMT_CONTENTMARGINS
XPMARGINS margins;
if (SUCCEEDED(UGXPThemes::GetThemeMargins(hTheme, hdc, td->GetPartID(), td->GetStateID(), 3602, const_cast<RECT*>(pRect), &margins)))
{
*pContentRect = *pRect;
pContentRect->bottom -= margins.cyBottomHeight;
pContentRect->right -= margins.cxRightWidth;
pContentRect->top += margins.cyTopHeight;
pContentRect->left += margins.cxLeftWidth;
}*/
}
// CloseThemeData(hTheme);
}
}
return success;
}
HIMAGELIST makeCheckboxImageList(HWND hwnddc, HTHEME *theme)
{
if (*theme != NULL) {
HRESULT res;
res = CloseThemeData(*theme);
if (res != S_OK)
xpanichresult("error closing theme", res);
*theme = NULL;
}
// ignore error; if it can't be done, we can fall back to DrawFrameControl()
if (*theme == NULL) // try to open the theme
*theme = OpenThemeData(hwnddc, L"button");
if (*theme != NULL) // use the theme
return newCheckboxImageList(hwnddc, themeSize, themeImage, *theme);
// couldn't open; fall back
return newCheckboxImageList(hwnddc, dfcSize, dfcImage, *theme);
}
bool UGXPThemes::DrawEdge(HWND hwnd, HDC hdc, LPCWSTR theme, int partID, int stateID,
const RECT *pRect, UINT uEdge, UINT uFlags, RECT *pContentRect)
{
bool success = false;
if (useThemes)
{
HANDLE themeHandle = OpenThemeData(hwnd, theme);
if (themeHandle)
{
HRESULT hr = DrawThemeEdge(themeHandle, hdc, partID, stateID, pRect, uEdge, uFlags, pContentRect);
success = SUCCEEDED(hr);
}
}
return success;
}
BOOL CPropPageFrameDefault::OnEraseBkgnd(CDC* pDC)
{
if (IsAppThemed())
{
HTHEME hTheme = OpenThemeData(m_hWnd, L"TREEVIEW");
if (hTheme)
{
CRect rect;
GetClientRect(rect);
DrawThemeBackground(hTheme, pDC->m_hDC, 0, 0, rect, nullptr);
CloseThemeData(hTheme);
}
return TRUE;
}
else
{
return CWnd::OnEraseBkgnd(pDC);
}
}
bool UGXPThemes::GetThemeRect(LPCWSTR theme, int iPartId, int iStateId, RECT *pRect)
{
bool success = false;
if (useThemes)
{
HANDLE themeHandle = OpenThemeData(NULL, theme);
if (themeHandle)
{
//const int TMT_DEFAULTPANESIZE = 5002;
//HRESULT hr = GetThemeRect(themeHandle, iPartId, iStateId, TMT_DEFAULTPANESIZE, pRect);
HRESULT hr = GetThemeRect(themeHandle, iPartId, iStateId, 5002, pRect);
success = SUCCEEDED(hr);
}
}
return success;
}
void CEditWithButton_Base::DrawButton(CRect rectButton)
{
CWindowDC dc(this);
HTHEME hButtonTheme = OpenThemeData(m_hWnd, _T("Button"));
if (hButtonTheme)
{
int ButtonState = GetButtonThemeState();
// If necessary, first fill with the edit control's background color.
if (IsThemeBackgroundPartiallyTransparent(hButtonTheme, BP_PUSHBUTTON, ButtonState))
{
HTHEME hEditTheme = OpenThemeDataEx(m_hWnd, _T("Edit"), OTD_NONCLIENT);
COLORREF BgColor = RGB(0, 0, 0);
BgColor = GetThemeSysColor(hEditTheme, (GetStyle() & (ES_READONLY | WS_DISABLED)) ? COLOR_3DFACE : COLOR_WINDOW);
dc.FillSolidRect(rectButton, BgColor);
CloseThemeData(hEditTheme);
}
DrawThemeBackground(hButtonTheme, dc, BP_PUSHBUTTON, ButtonState, rectButton, NULL);
DrawButtonContent(dc, rectButton, hButtonTheme);
CloseThemeData(hButtonTheme);
}
else
{
UINT uState = DFCS_BUTTONPUSH;
if (GetStyle() & (ES_READONLY | WS_DISABLED))
uState |= DFCS_INACTIVE;
else if (m_IsButtonPressed)
uState |= DFCS_PUSHED;
dc.DrawFrameControl(rectButton, DFC_BUTTON, uState);
// If the button is in a pressed state, then contents should move slightly as part of the "push" effect.
if (m_IsButtonPressed)
rectButton.OffsetRect(1, 1);
DrawButtonContent(dc, rectButton, NULL);
}
}
VOID PhpSearchInitializeTheme(
_Inout_ PEDIT_CONTEXT Context
)
{
Context->CXWidth = PH_SCALE_DPI(20);
Context->BrushNormal = GetSysColorBrush(COLOR_WINDOW);
Context->BrushHot = CreateSolidBrush(RGB(205, 232, 255));
Context->BrushPushed = CreateSolidBrush(RGB(153, 209, 255));
if (IsThemeActive())
{
HTHEME themeDataHandle;
if (themeDataHandle = OpenThemeData(Context->WindowHandle, VSCLASS_EDIT))
{
//IsThemePartDefined_I(themeDataHandle, EP_EDITBORDER_NOSCROLL, EPSHV_NORMAL);
if (!SUCCEEDED(GetThemeInt(
themeDataHandle,
EP_EDITBORDER_NOSCROLL,
EPSHV_NORMAL,
TMT_BORDERSIZE,
&Context->CXBorder
)))
{
Context->CXBorder = GetSystemMetrics(SM_CXBORDER) * 2;
}
CloseThemeData(themeDataHandle);
}
else
{
Context->CXBorder = GetSystemMetrics(SM_CXBORDER) * 2;
}
}
else
{
Context->CXBorder = GetSystemMetrics(SM_CXBORDER) * 2;
}
}
