/********************************************
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 void GB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused)
{
static const int states[] = { GBS_NORMAL, GBS_DISABLED, GBS_NORMAL, GBS_NORMAL, GBS_NORMAL };
RECT bgRect, textRect, contentRect;
int state = states[ drawState ];
WCHAR *text = get_button_text(hwnd);
LOGFONTW lf;
HFONT font, hPrevFont = NULL;
BOOL created_font = FALSE;
HRESULT hr = GetThemeFont(theme, hDC, BP_GROUPBOX, state, TMT_FONT, &lf);
if (SUCCEEDED(hr)) {
font = CreateFontIndirectW(&lf);
if (!font)
TRACE("Failed to create font\n");
else {
hPrevFont = SelectObject(hDC, font);
created_font = TRUE;
}
} else {
font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0);
hPrevFont = SelectObject(hDC, font);
}
GetClientRect(hwnd, &bgRect);
textRect = bgRect;
if (text)
{
SIZE textExtent;
GetTextExtentPoint32W(hDC, text, lstrlenW(text), &textExtent);
bgRect.top += (textExtent.cy / 2);
textRect.left += 10;
textRect.bottom = textRect.top + textExtent.cy;
textRect.right = textRect.left + textExtent.cx + 4;
ExcludeClipRect(hDC, textRect.left, textRect.top, textRect.right, textRect.bottom);
}
GetThemeBackgroundContentRect(theme, hDC, BP_GROUPBOX, state, &bgRect, &contentRect);
ExcludeClipRect(hDC, contentRect.left, contentRect.top, contentRect.right, contentRect.bottom);
if (IsThemeBackgroundPartiallyTransparent(theme, BP_GROUPBOX, state))
DrawThemeParentBackground(hwnd, hDC, NULL);
DrawThemeBackground(theme, hDC, BP_GROUPBOX, state, &bgRect, NULL);
SelectClipRgn(hDC, NULL);
if (text)
{
InflateRect(&textRect, -2, 0);
DrawThemeText(theme, hDC, BP_GROUPBOX, state, text, lstrlenW(text), 0, 0, &textRect);
HeapFree(GetProcessHeap(), 0, text);
}
if (created_font) DeleteObject(font);
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
HRESULT xpt_DrawThemeText(XPTHANDLE xptHandle, HDC hdc, int type, int state, LPCTSTR lpStr, int len, DWORD flag1, DWORD flag2, const RECT *textRect)
{
mir_cslock lck(xptCS);
if (xpt_IsThemed(xptHandle))
DrawThemeText(((XPTObject*)xptHandle)->hThemeHandle, hdc, type, state, (LPCWSTR)lpStr, len, flag1, flag2, textRect);
else
ske_DrawText(hdc, lpStr, len, (RECT*)textRect, flag1);
return S_OK;
}
static void
STATUSBAR_DrawPart (const STATUS_INFO *infoPtr, HDC hdc, const STATUSWINDOWPART *part, int itemID)
{
RECT r = part->bound;
UINT border = BDR_SUNKENOUTER;
HTHEME theme = GetWindowTheme (infoPtr->Self);
int themePart = SP_PANE;
int x = 0;
TRACE("part bound %s\n", wine_dbgstr_rect(&r));
if (part->style & SBT_POPOUT)
border = BDR_RAISEDOUTER;
else if (part->style & SBT_NOBORDERS)
border = 0;
if (theme)
{
if ((GetWindowLongW (infoPtr->Self, GWL_STYLE) & SBARS_SIZEGRIP)
&& (infoPtr->simple || (itemID == (infoPtr->numParts-1))))
themePart = SP_GRIPPERPANE;
DrawThemeBackground(theme, hdc, themePart, 0, &r, NULL);
}
else
DrawEdge(hdc, &r, border, BF_RECT|BF_ADJUST);
if (part->hIcon) {
INT cy = r.bottom - r.top;
DrawIconEx (hdc, r.left + 2, r.top, part->hIcon, cy, cy, 0, 0, DI_NORMAL);
x = 2 + cy;
}
if (part->style & SBT_OWNERDRAW) {
DRAWITEMSTRUCT dis;
dis.CtlID = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
dis.itemID = itemID;
dis.hwndItem = infoPtr->Self;
dis.hDC = hdc;
dis.rcItem = r;
dis.itemData = (ULONG_PTR)part->text;
SendMessageW (infoPtr->Notify, WM_DRAWITEM, dis.CtlID, (LPARAM)&dis);
} else {
r.left += x;
#ifdef __REACTOS__
if (!theme)
DrawStatusTextW (hdc, &r, part->text, SBT_NOBORDERS);
else
DrawThemeText(theme, hdc, SP_PANE, 0, part->text, -1, DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX, 0, &r);
#else
DrawStatusTextW (hdc, &r, part->text, SBT_NOBORDERS);
#endif
}
}
static void CB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags)
{
static const int cb_states[3][5] =
{
{ CBS_UNCHECKEDNORMAL, CBS_UNCHECKEDDISABLED, CBS_UNCHECKEDHOT, CBS_UNCHECKEDPRESSED, CBS_UNCHECKEDNORMAL },
{ CBS_CHECKEDNORMAL, CBS_CHECKEDDISABLED, CBS_CHECKEDHOT, CBS_CHECKEDPRESSED, CBS_CHECKEDNORMAL },
{ CBS_MIXEDNORMAL, CBS_MIXEDDISABLED, CBS_MIXEDHOT, CBS_MIXEDPRESSED, CBS_MIXEDNORMAL }
};
static const int rb_states[2][5] =
{
{ RBS_UNCHECKEDNORMAL, RBS_UNCHECKEDDISABLED, RBS_UNCHECKEDHOT, RBS_UNCHECKEDPRESSED, RBS_UNCHECKEDNORMAL },
{ RBS_CHECKEDNORMAL, RBS_CHECKEDDISABLED, RBS_CHECKEDHOT, RBS_CHECKEDPRESSED, RBS_CHECKEDNORMAL }
};
static const int cb_size = 13;
RECT bgRect, textRect;
HFONT font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0);
HFONT hPrevFont = font ? SelectObject(hDC, font) : NULL;
LRESULT checkState = SendMessageW(hwnd, BM_GETCHECK, 0, 0);
DWORD dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
int part = ((dwStyle & BUTTON_TYPE) == BS_RADIOBUTTON) || ((dwStyle & BUTTON_TYPE) == BS_AUTORADIOBUTTON)
? BP_RADIOBUTTON
: BP_CHECKBOX;
int state = (part == BP_CHECKBOX)
? cb_states[ checkState ][ drawState ]
: rb_states[ checkState ][ drawState ];
WCHAR *text = get_button_text(hwnd);
GetClientRect(hwnd, &bgRect);
GetThemeBackgroundContentRect(theme, hDC, part, state, &bgRect, &textRect);
if (dtFlags & DT_SINGLELINE) /* Center the checkbox / radio button to the text. */
bgRect.top = bgRect.top + (textRect.bottom - textRect.top - cb_size) / 2;
/* adjust for the check/radio marker */
bgRect.bottom = bgRect.top + cb_size;
bgRect.right = bgRect.left + cb_size;
textRect.left = bgRect.right + 6;
if (IsThemeBackgroundPartiallyTransparent(theme, part, state))
DrawThemeParentBackground(hwnd, hDC, NULL);
DrawThemeBackground(theme, hDC, part, state, &bgRect, NULL);
if (text)
{
DrawThemeText(theme, hDC, part, state, text, lstrlenW(text), dtFlags, 0, &textRect);
HeapFree(GetProcessHeap(), 0, text);
}
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
void winx_msg OnPaint(HWND hWnd)
{
winx::PaintDC dc(hWnd);
winx::ClientRect rect(hWnd);
if(m_hTheme != NULL)
{
DrawThemeText(
dc, BP_PUSHBUTTON, PBS_NORMAL,
L"MyView", -1, DT_SINGLELINE | DT_CENTER | DT_VCENTER, 0, &rect);
}
else
{
dc.DrawText(_T("MyView"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
}
}
void CTheme::DrawThemeText( HDC dc,
int iPartId,
int iStateId,
LPCSTR pszText,
int iCharCount,
DWORD dwTextFlags,
DWORD dwTextFlags2,
const RECT *pRect
)
{
if(m_hTheme && zDrawThemeText)
{
//Convert string to unicode
int length = iCharCount;
if(iCharCount == -1)
{
length = _mbstrlen(pszText);
}
//Use api convert routine
wchar_t* wbuffer = new wchar_t[length+1];
MultiByteToWideChar( CP_THREAD_ACP,
0,
pszText,
length,
wbuffer,
length+1);
wbuffer[length] = '\0';
DrawThemeText( dc,
iPartId,
iStateId,
wbuffer,
iCharCount,
dwTextFlags,
dwTextFlags2,
pRect );
delete [] wbuffer;
}
}
static void GB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags)
{
static const int states[] = { GBS_NORMAL, GBS_DISABLED, GBS_NORMAL, GBS_NORMAL, GBS_NORMAL };
RECT bgRect, textRect, contentRect;
HFONT font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0);
HFONT hPrevFont = font ? SelectObject(hDC, font) : NULL;
int state = states[ drawState ];
WCHAR *text = get_button_text(hwnd);
GetClientRect(hwnd, &bgRect);
textRect = bgRect;
if (text)
{
SIZE textExtent;
GetTextExtentPoint32W(hDC, text, lstrlenW(text), &textExtent);
bgRect.top += (textExtent.cy / 2);
textRect.left += 10;
textRect.bottom = textRect.top + textExtent.cy;
textRect.right = textRect.left + textExtent.cx + 4;
ExcludeClipRect(hDC, textRect.left, textRect.top, textRect.right, textRect.bottom);
}
GetThemeBackgroundContentRect(theme, hDC, BP_GROUPBOX, state, &bgRect, &contentRect);
ExcludeClipRect(hDC, contentRect.left, contentRect.top, contentRect.right, contentRect.bottom);
if (IsThemeBackgroundPartiallyTransparent(theme, BP_GROUPBOX, state))
DrawThemeParentBackground(hwnd, hDC, NULL);
DrawThemeBackground(theme, hDC, BP_GROUPBOX, state, &bgRect, NULL);
SelectClipRgn(hDC, NULL);
if (text)
{
textRect.left += 2;
textRect.right -= 2;
DrawThemeText(theme, hDC, BP_GROUPBOX, state, text, lstrlenW(text), 0, 0, &textRect);
HeapFree(GetProcessHeap(), 0, text);
}
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
void CEditWithButton::DrawButtonContent(CDC& dc, CRect rectButton, HTHEME hButtonTheme)
{
CFont* pOldFont = dc.SelectObject(GetFont());
if (hButtonTheme) {
DrawThemeText(hButtonTheme, dc.m_hDC, BP_PUSHBUTTON, GetButtonThemeState(),
m_ButtonText, m_ButtonText.GetLength(),
DT_CENTER | DT_VCENTER | DT_SINGLELINE, 0, rectButton);
} else {
if (GetStyle() & (ES_READONLY | WS_DISABLED)) {
dc.SetTextColor(GetSysColor(COLOR_GRAYTEXT));
}
dc.SetBkMode(TRANSPARENT);
dc.DrawText(m_ButtonText, m_ButtonText.GetLength(),
rectButton, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
}
dc.SelectObject(pOldFont);
}
static void PB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused)
{
static const int states[] = { PBS_NORMAL, PBS_DISABLED, PBS_HOT, PBS_PRESSED, PBS_DEFAULTED };
RECT bgRect, textRect;
HFONT font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0);
HFONT hPrevFont = font ? SelectObject(hDC, font) : NULL;
int state = states[ drawState ];
WCHAR *text = get_button_text(hwnd);
GetClientRect(hwnd, &bgRect);
GetThemeBackgroundContentRect(theme, hDC, BP_PUSHBUTTON, state, &bgRect, &textRect);
if (IsThemeBackgroundPartiallyTransparent(theme, BP_PUSHBUTTON, state))
DrawThemeParentBackground(hwnd, hDC, NULL);
DrawThemeBackground(theme, hDC, BP_PUSHBUTTON, state, &bgRect, NULL);
if (text)
{
DrawThemeText(theme, hDC, BP_PUSHBUTTON, state, text, lstrlenW(text), dtFlags, 0, &textRect);
HeapFree(GetProcessHeap(), 0, text);
}
if (focused)
{
MARGINS margins;
RECT focusRect = bgRect;
GetThemeMargins(theme, hDC, BP_PUSHBUTTON, state, TMT_CONTENTMARGINS, NULL, &margins);
focusRect.left += margins.cxLeftWidth;
focusRect.top += margins.cyTopHeight;
focusRect.right -= margins.cxRightWidth;
focusRect.bottom -= margins.cyBottomHeight;
DrawFocusRect( hDC, &focusRect );
}
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
static void PB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags)
{
static const int states[] = { PBS_NORMAL, PBS_DISABLED, PBS_HOT, PBS_PRESSED, PBS_DEFAULTED };
RECT bgRect, textRect;
HFONT font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0);
HFONT hPrevFont = font ? SelectObject(hDC, font) : NULL;
int state = states[ drawState ];
WCHAR *text = get_button_text(hwnd);
GetClientRect(hwnd, &bgRect);
GetThemeBackgroundContentRect(theme, hDC, BP_PUSHBUTTON, state, &bgRect, &textRect);
if (IsThemeBackgroundPartiallyTransparent(theme, BP_PUSHBUTTON, state))
DrawThemeParentBackground(hwnd, hDC, NULL);
DrawThemeBackground(theme, hDC, BP_PUSHBUTTON, state, &bgRect, NULL);
if (text)
{
DrawThemeText(theme, hDC, BP_PUSHBUTTON, state, text, lstrlenW(text), dtFlags, 0, &textRect);
HeapFree(GetProcessHeap(), 0, text);
}
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
static void GB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused)
#endif
{
static const int states[] = { GBS_NORMAL, GBS_NORMAL, GBS_NORMAL, GBS_DISABLED, GBS_NORMAL };
RECT bgRect, textRect, contentRect;
int state = states[ drawState ];
WCHAR *text = get_button_text(hwnd);
LOGFONTW lf;
HFONT font, hPrevFont = NULL;
BOOL created_font = FALSE;
#ifdef __REACTOS__ /* r74406 */
HWND parent;
HBRUSH hBrush;
RECT clientRect;
#endif
HRESULT hr = GetThemeFont(theme, hDC, BP_GROUPBOX, state, TMT_FONT, &lf);
if (SUCCEEDED(hr)) {
font = CreateFontIndirectW(&lf);
if (!font)
TRACE("Failed to create font\n");
else {
hPrevFont = SelectObject(hDC, font);
created_font = TRUE;
}
} else {
#ifdef __REACTOS__ /* r73885 */
font = get_button_font(hwnd);
#else
font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0);
#endif
hPrevFont = SelectObject(hDC, font);
}
GetClientRect(hwnd, &bgRect);
textRect = bgRect;
if (text)
{
SIZE textExtent;
GetTextExtentPoint32W(hDC, text, lstrlenW(text), &textExtent);
bgRect.top += (textExtent.cy / 2);
textRect.left += 10;
textRect.bottom = textRect.top + textExtent.cy;
textRect.right = textRect.left + textExtent.cx + 4;
ExcludeClipRect(hDC, textRect.left, textRect.top, textRect.right, textRect.bottom);
}
GetThemeBackgroundContentRect(theme, hDC, BP_GROUPBOX, state, &bgRect, &contentRect);
ExcludeClipRect(hDC, contentRect.left, contentRect.top, contentRect.right, contentRect.bottom);
#ifdef __REACTOS__ /* r73885 & r74149 */
if (prfFlag == 0)
{
if (IsThemeBackgroundPartiallyTransparent(theme, BP_GROUPBOX, state))
DrawThemeParentBackground(hwnd, hDC, NULL);
}
#else
if (IsThemeBackgroundPartiallyTransparent(theme, BP_GROUPBOX, state))
DrawThemeParentBackground(hwnd, hDC, NULL);
#endif
#ifdef __REACTOS__ /* r74406 */
parent = GetParent(hwnd);
if (!parent) parent = hwnd;
hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hDC, (LPARAM)hwnd);
if (!hBrush) /* did the app forget to call defwindowproc ? */
hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hDC, (LPARAM)hwnd );
GetClientRect(hwnd, &clientRect);
FillRect( hDC, &clientRect, hBrush );
#endif
DrawThemeBackground(theme, hDC, BP_GROUPBOX, state, &bgRect, NULL);
SelectClipRgn(hDC, NULL);
if (text)
{
InflateRect(&textRect, -2, 0);
DrawThemeText(theme, hDC, BP_GROUPBOX, state, text, lstrlenW(text), 0, 0, &textRect);
HeapFree(GetProcessHeap(), 0, text);
}
if (created_font) DeleteObject(font);
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
static void CB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused, LPARAM prfFlag)
{
static const int cb_states[3][5] =
{
{ CBS_UNCHECKEDNORMAL, CBS_UNCHECKEDHOT, CBS_UNCHECKEDPRESSED, CBS_UNCHECKEDDISABLED, CBS_UNCHECKEDNORMAL },
{ CBS_CHECKEDNORMAL, CBS_CHECKEDHOT, CBS_CHECKEDPRESSED, CBS_CHECKEDDISABLED, CBS_CHECKEDNORMAL },
{ CBS_MIXEDNORMAL, CBS_MIXEDHOT, CBS_MIXEDPRESSED, CBS_MIXEDDISABLED, CBS_MIXEDNORMAL }
};
static const int rb_states[2][5] =
{
{ RBS_UNCHECKEDNORMAL, RBS_UNCHECKEDHOT, RBS_UNCHECKEDPRESSED, RBS_UNCHECKEDDISABLED, RBS_UNCHECKEDNORMAL },
{ RBS_CHECKEDNORMAL, RBS_CHECKEDHOT, RBS_CHECKEDPRESSED, RBS_CHECKEDDISABLED, RBS_CHECKEDNORMAL }
};
SIZE sz;
RECT bgRect, textRect;
HFONT font, hPrevFont = NULL;
LRESULT checkState = get_button_state(hwnd) & 3;
DWORD dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
int part = ((dwStyle & BUTTON_TYPE) == BS_RADIOBUTTON) || ((dwStyle & BUTTON_TYPE) == BS_AUTORADIOBUTTON)
? BP_RADIOBUTTON
: BP_CHECKBOX;
int state = (part == BP_CHECKBOX)
? cb_states[ checkState ][ drawState ]
: rb_states[ checkState ][ drawState ];
WCHAR *text;
LOGFONTW lf;
BOOL created_font = FALSE;
HWND parent;
HBRUSH hBrush;
DWORD cdrf;
HRESULT hr = GetThemeFont(theme, hDC, part, state, TMT_FONT, &lf);
if (SUCCEEDED(hr)) {
font = CreateFontIndirectW(&lf);
if (!font)
TRACE("Failed to create font\n");
else {
TRACE("font = %s\n", debugstr_w(lf.lfFaceName));
hPrevFont = SelectObject(hDC, font);
created_font = TRUE;
}
} else {
font = get_button_font(hwnd);
hPrevFont = SelectObject(hDC, font);
}
if (FAILED(GetThemePartSize(theme, hDC, part, state, NULL, TS_DRAW, &sz)))
sz.cx = sz.cy = 13;
GetClientRect(hwnd, &bgRect);
if (prfFlag == 0)
{
DrawThemeParentBackground(hwnd, hDC, NULL);
}
parent = GetParent(hwnd);
if (!parent) parent = hwnd;
hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hDC, (LPARAM)hwnd);
if (!hBrush) /* did the app forget to call defwindowproc ? */
hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hDC, (LPARAM)hwnd );
FillRect( hDC, &bgRect, hBrush );
cdrf = BUTTON_SendCustomDraw(hwnd, hDC, CDDS_PREERASE, &bgRect);
if (cdrf == CDRF_SKIPDEFAULT)
goto cleanup;
GetThemeBackgroundContentRect(theme, hDC, part, state, &bgRect, &textRect);
if (dtFlags & DT_SINGLELINE) /* Center the checkbox / radio button to the text. */
bgRect.top = bgRect.top + (textRect.bottom - textRect.top - sz.cy) / 2;
/* adjust for the check/radio marker */
bgRect.bottom = bgRect.top + sz.cy;
bgRect.right = bgRect.left + sz.cx;
textRect.left = bgRect.right + 6;
DrawThemeBackground(theme, hDC, part, state, &bgRect, NULL);
if (cdrf == CDRF_NOTIFYPOSTERASE)
BUTTON_SendCustomDraw(hwnd, hDC, CDDS_POSTERASE, &bgRect);
cdrf = BUTTON_SendCustomDraw(hwnd, hDC, CDDS_PREPAINT, &bgRect);
if (cdrf == CDRF_SKIPDEFAULT)
goto cleanup;
text = get_button_text(hwnd);
if (text)
{
DrawThemeText(theme, hDC, part, state, text, lstrlenW(text), dtFlags, 0, &textRect);
if (focused)
{
RECT focusRect;
focusRect = textRect;
DrawTextW(hDC, text, lstrlenW(text), &focusRect, dtFlags | DT_CALCRECT);
if (focusRect.right < textRect.right) focusRect.right++;
focusRect.bottom = textRect.bottom;
DrawFocusRect( hDC, &focusRect );
}
HeapFree(GetProcessHeap(), 0, text);
}
if (cdrf == CDRF_NOTIFYPOSTPAINT)
BUTTON_SendCustomDraw(hwnd, hDC, CDDS_POSTPAINT, &bgRect);
cleanup:
if (created_font) DeleteObject(font);
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
static void PB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused, LPARAM prfFlag)
{
static const int states[] = { PBS_NORMAL, PBS_HOT, PBS_PRESSED, PBS_DISABLED, PBS_DEFAULTED };
RECT bgRect, textRect;
HFONT font = get_button_font(hwnd);
HFONT hPrevFont = font ? SelectObject(hDC, font) : NULL;
int state = states[ drawState ];
WCHAR *text;
PBUTTON_DATA pdata = _GetButtonData(hwnd);
HWND parent;
DWORD cdrf;
GetClientRect(hwnd, &bgRect);
GetThemeBackgroundContentRect(theme, hDC, BP_PUSHBUTTON, state, &bgRect, &textRect);
if (prfFlag == 0)
{
if (IsThemeBackgroundPartiallyTransparent(theme, BP_PUSHBUTTON, state))
DrawThemeParentBackground(hwnd, hDC, NULL);
}
parent = GetParent(hwnd);
if (!parent) parent = hwnd;
SendMessageW( parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)hwnd );
cdrf = BUTTON_SendCustomDraw(hwnd, hDC, CDDS_PREERASE, &bgRect);
if (cdrf == CDRF_SKIPDEFAULT)
goto cleanup;
DrawThemeBackground(theme, hDC, BP_PUSHBUTTON, state, &bgRect, NULL);
if (cdrf == CDRF_NOTIFYPOSTERASE)
BUTTON_SendCustomDraw(hwnd, hDC, CDDS_POSTERASE, &bgRect);
cdrf = BUTTON_SendCustomDraw(hwnd, hDC, CDDS_PREPAINT, &bgRect);
if (cdrf == CDRF_SKIPDEFAULT)
goto cleanup;
BUTTON_DrawIml(hDC, &pdata->imlData, &textRect, FALSE, drawState);
text = get_button_text(hwnd);
if (text)
{
DrawThemeText(theme, hDC, BP_PUSHBUTTON, state, text, lstrlenW(text), dtFlags, 0, &textRect);
HeapFree(GetProcessHeap(), 0, text);
}
if (focused)
{
MARGINS margins;
RECT focusRect = bgRect;
GetThemeMargins(theme, hDC, BP_PUSHBUTTON, state, TMT_CONTENTMARGINS, NULL, &margins);
focusRect.left += margins.cxLeftWidth;
focusRect.top += margins.cyTopHeight;
focusRect.right -= margins.cxRightWidth;
focusRect.bottom -= margins.cyBottomHeight;
DrawFocusRect( hDC, &focusRect );
}
if (cdrf == CDRF_NOTIFYPOSTPAINT)
BUTTON_SendCustomDraw(hwnd, hDC, CDDS_POSTPAINT, &bgRect);
cleanup:
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
static LRESULT CALLBACK OptionsFilterSubclassProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
if (message != WM_PAINT && message != WM_PRINT)
return mir_callNextSubclass(hWnd, OptionsFilterSubclassProc, message, wParam, lParam);
if (GetFocus() == hWnd || GetWindowTextLength(hWnd))
return mir_callNextSubclass(hWnd, OptionsFilterSubclassProc, message, wParam, lParam);
RECT rc;
GetClientRect(hWnd, &rc);
HDC hdc;
PAINTSTRUCT paint;
if (message == WM_PAINT)
hdc = BeginPaint(hWnd, &paint);
else
hdc = (HDC)wParam;
TCHAR buf[255];
if (bSearchState == 1 && FilterLoadProgress < 100 && FilterLoadProgress > 0)
mir_sntprintf(buf, SIZEOF(buf), TranslateT("Loading... %d%%"), FilterLoadProgress);
else
mir_sntprintf(buf, SIZEOF(buf), TranslateT("Search"));
BOOL bDrawnByTheme = FALSE;
int oldMode = SetBkMode(hdc, TRANSPARENT);
HTHEME hTheme = OpenThemeData(hWnd, L"EDIT");
if (hTheme) {
if (IsThemeBackgroundPartiallyTransparent(hTheme, EP_EDITTEXT, ETS_NORMAL))
DrawThemeParentBackground(hWnd, hdc, &rc);
RECT rc2;
GetThemeBackgroundContentRect(hTheme, hdc, EP_EDITTEXT, ETS_NORMAL, &rc, &rc2);
rc2.top = 2 * rc.top - rc2.top;
rc2.left = 2 * rc.left - rc2.left;
rc2.bottom = 2 * rc.bottom - rc2.bottom;
rc2.right = 2 * rc.right - rc2.right;
DrawThemeBackground(hTheme, hdc, EP_EDITTEXT, ETS_NORMAL, &rc2, &rc);
HFONT hFont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0);
HFONT oldFont = (HFONT)SelectObject(hdc, hFont);
wchar_t *bufW = mir_t2u(buf);
DrawThemeText(hTheme, hdc, EP_EDITTEXT, ETS_DISABLED, bufW, -1, 0, 0, &rc);
mir_free(bufW);
SelectObject(hdc, oldFont);
CloseThemeData(hTheme);
bDrawnByTheme = TRUE;
}
SetBkMode(hdc, oldMode);
if (!bDrawnByTheme) {
HFONT hFont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0);
HFONT oldFont = (HFONT)SelectObject(hdc, hFont);
SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
FillRect(hdc, &rc, GetSysColorBrush(COLOR_WINDOW));
int oldMode = SetBkMode(hdc, TRANSPARENT);
DrawText(hdc, buf, -1, &rc, 0);
SetBkMode(hdc, oldMode);
SelectObject(hdc, oldFont);
}
if (message == WM_PAINT)
EndPaint(hWnd, &paint);
return 0;
}
static void CB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused)
{
static const int cb_states[3][5] =
{
{ CBS_UNCHECKEDNORMAL, CBS_UNCHECKEDDISABLED, CBS_UNCHECKEDHOT, CBS_UNCHECKEDPRESSED, CBS_UNCHECKEDNORMAL },
{ CBS_CHECKEDNORMAL, CBS_CHECKEDDISABLED, CBS_CHECKEDHOT, CBS_CHECKEDPRESSED, CBS_CHECKEDNORMAL },
{ CBS_MIXEDNORMAL, CBS_MIXEDDISABLED, CBS_MIXEDHOT, CBS_MIXEDPRESSED, CBS_MIXEDNORMAL }
};
static const int rb_states[2][5] =
{
{ RBS_UNCHECKEDNORMAL, RBS_UNCHECKEDDISABLED, RBS_UNCHECKEDHOT, RBS_UNCHECKEDPRESSED, RBS_UNCHECKEDNORMAL },
{ RBS_CHECKEDNORMAL, RBS_CHECKEDDISABLED, RBS_CHECKEDHOT, RBS_CHECKEDPRESSED, RBS_CHECKEDNORMAL }
};
static const int cb_size = 13;
RECT bgRect, textRect;
HFONT font, hPrevFont = NULL;
LRESULT checkState = SendMessageW(hwnd, BM_GETCHECK, 0, 0);
DWORD dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
int part = ((dwStyle & BUTTON_TYPE) == BS_RADIOBUTTON) || ((dwStyle & BUTTON_TYPE) == BS_AUTORADIOBUTTON)
? BP_RADIOBUTTON
: BP_CHECKBOX;
int state = (part == BP_CHECKBOX)
? cb_states[ checkState ][ drawState ]
: rb_states[ checkState ][ drawState ];
WCHAR *text = get_button_text(hwnd);
LOGFONTW lf;
BOOL created_font = FALSE;
HRESULT hr = GetThemeFont(theme, hDC, part, state, TMT_FONT, &lf);
if (SUCCEEDED(hr)) {
font = CreateFontIndirectW(&lf);
if (!font)
TRACE("Failed to create font\n");
else {
TRACE("font = %s\n", debugstr_w(lf.lfFaceName));
hPrevFont = SelectObject(hDC, font);
created_font = TRUE;
}
} else
font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0);
GetClientRect(hwnd, &bgRect);
GetThemeBackgroundContentRect(theme, hDC, part, state, &bgRect, &textRect);
if (dtFlags & DT_SINGLELINE) /* Center the checkbox / radio button to the text. */
bgRect.top = bgRect.top + (textRect.bottom - textRect.top - cb_size) / 2;
/* adjust for the check/radio marker */
bgRect.bottom = bgRect.top + cb_size;
bgRect.right = bgRect.left + cb_size;
textRect.left = bgRect.right + 6;
DrawThemeParentBackground(hwnd, hDC, NULL);
DrawThemeBackground(theme, hDC, part, state, &bgRect, NULL);
if (text)
{
DrawThemeText(theme, hDC, part, state, text, lstrlenW(text), dtFlags, 0, &textRect);
if (focused)
{
RECT focusRect;
focusRect = textRect;
DrawTextW(hDC, text, lstrlenW(text), &focusRect, dtFlags | DT_CALCRECT);
if (focusRect.right < textRect.right) focusRect.right++;
focusRect.bottom = textRect.bottom;
DrawFocusRect( hDC, &focusRect );
}
HeapFree(GetProcessHeap(), 0, text);
}
if (created_font) DeleteObject(font);
if (hPrevFont) SelectObject(hDC, hPrevFont);
}
/**
* name: PaintThemeButton
* desc: Draws the themed button
* param: ctl - BTNCTRL structure for the button
* hdcMem - device context to draw to
* rcClient - rectangle of the whole button
* return: nothing
**/
static void __fastcall PaintThemeButton(BTNCTRL *ctl, HDC hdcMem, LPRECT rcClient)
{
RECT rcText = { 0, 0, 0, 0 };
WCHAR wszText[MAX_PATH] = { 0 };
WORD ccText;
// Draw the flat button
if ((ctl->dwStyle & MBS_FLAT) && ctl->hThemeToolbar) {
int state = IsWindowEnabled(ctl->hwnd)
? (ctl->stateId == PBS_NORMAL && ctl->defbutton
? PBS_DEFAULTED
: ctl->stateId)
: PBS_DISABLED;
if (IsThemeBackgroundPartiallyTransparent(ctl->hThemeToolbar, TP_BUTTON, TBStateConvert2Flat(state))) {
if (SUCCEEDED(DrawThemeParentBackground(ctl->hwnd, hdcMem, rcClient)))
DrawThemeParentBackground(GetParent(ctl->hwnd), hdcMem, rcClient);
}
DrawThemeBackground(ctl->hThemeToolbar, hdcMem, TP_BUTTON, TBStateConvert2Flat(state), rcClient, rcClient);
}
else {
// draw themed button background
if (ctl->hThemeButton) {
int state = IsWindowEnabled(ctl->hwnd)
? (ctl->stateId == PBS_NORMAL && ctl->defbutton
? PBS_DEFAULTED
: ctl->stateId)
: PBS_DISABLED;
if (IsThemeBackgroundPartiallyTransparent(ctl->hThemeButton, BP_PUSHBUTTON, state)) {
if (SUCCEEDED(DrawThemeParentBackground(ctl->hwnd, hdcMem, rcClient)))
DrawThemeParentBackground(GetParent(ctl->hwnd), hdcMem, rcClient);
}
DrawThemeBackground(ctl->hThemeButton, hdcMem, BP_PUSHBUTTON, state, rcClient, rcClient);
}
}
// calculate text rect
{
RECT sizeText;
HFONT hOldFont;
ccText = GetWindowTextW(ctl->hwnd, wszText, _countof(wszText));
if (ccText > 0) {
hOldFont = (HFONT)SelectObject(hdcMem, ctl->hFont);
GetThemeTextExtent(
ctl->hThemeButton,
hdcMem,
BP_PUSHBUTTON,
IsWindowEnabled(ctl->hwnd) ? ctl->stateId : PBS_DISABLED,
wszText,
ccText,
DST_PREFIXTEXT,
NULL,
&sizeText);
if (ctl->cHot) {
RECT rcHot;
GetThemeTextExtent(ctl->hThemeButton,
hdcMem,
BP_PUSHBUTTON,
IsWindowEnabled(ctl->hwnd) ? ctl->stateId : PBS_DISABLED,
L"&",
1,
DST_PREFIXTEXT,
NULL,
&rcHot);
sizeText.right -= (rcHot.right - rcHot.left);
}
SelectObject(hdcMem, hOldFont);
rcText.left = (ctl->hIcon) ? 0 : (rcClient->right - rcClient->left - (sizeText.right - sizeText.left)) / 2;
rcText.top = (rcClient->bottom - rcClient->top - (sizeText.bottom - sizeText.top)) / 2;
rcText.right = rcText.left + (sizeText.right - sizeText.left);
rcText.bottom = rcText.top + (sizeText.bottom - sizeText.top);
if (ctl->stateId == PBS_PRESSED) {
OffsetRect(&rcText, 1, 1);
}
}
}
PaintIcon(ctl, hdcMem, &ccText, rcClient, &rcText);
// draw text
if (ccText > 0 && ctl->hThemeButton) {
HFONT hOldFont = (HFONT)SelectObject(hdcMem, ctl->hFont);
DrawThemeText(ctl->hThemeButton, hdcMem, BP_PUSHBUTTON, IsWindowEnabled(ctl->hwnd) ? ctl->stateId : PBS_DISABLED, wszText, ccText, DST_PREFIXTEXT, 0, &rcText);
SelectObject(hdcMem, hOldFont);
}
}
static LRESULT IPADDRESS_Draw (const IPADDRESS_INFO *infoPtr, HDC hdc)
{
static const WCHAR dotW[] = { '.', 0 };
RECT rect, rcPart;
COLORREF bgCol, fgCol;
HTHEME theme;
int i, state = ETS_NORMAL;
TRACE("\n");
GetClientRect (infoPtr->Self, &rect);
theme = OpenThemeData(infoPtr->Self, WC_EDITW);
if (theme) {
DWORD dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
if (!infoPtr->Enabled)
state = ETS_DISABLED;
else if (dwStyle & ES_READONLY)
state = ETS_READONLY;
else if (GetFocus() == infoPtr->Self)
state = ETS_FOCUSED;
GetThemeColor(theme, EP_EDITTEXT, state, TMT_FILLCOLOR, &bgCol);
GetThemeColor(theme, EP_EDITTEXT, state, TMT_TEXTCOLOR, &fgCol);
if (IsThemeBackgroundPartiallyTransparent (theme, EP_EDITTEXT, state))
DrawThemeParentBackground(infoPtr->Self, hdc, &rect);
DrawThemeBackground (theme, hdc, EP_EDITTEXT, state, &rect, 0);
} else {
if (infoPtr->Enabled) {
bgCol = comctl32_color.clrWindow;
fgCol = comctl32_color.clrWindowText;
} else {
bgCol = comctl32_color.clr3dFace;
fgCol = comctl32_color.clrGrayText;
}
FillRect (hdc, &rect, (HBRUSH)(DWORD_PTR)(bgCol+1));
DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
}
SetBkColor (hdc, bgCol);
SetTextColor(hdc, fgCol);
for (i = 0; i < 3; i++) {
GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
rect.left = rcPart.right;
GetWindowRect (infoPtr->Part[i+1].EditHwnd, &rcPart);
MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
rect.right = rcPart.left;
if (theme)
DrawThemeText(theme, hdc, EP_EDITTEXT, state, dotW, 1, DT_SINGLELINE | DT_CENTER | DT_BOTTOM, 0, &rect);
else
DrawTextW(hdc, dotW, 1, &rect, DT_SINGLELINE | DT_CENTER | DT_BOTTOM);
}
if (theme)
CloseThemeData(theme);
return 0;
}
static int CALLBACK CheckboxWndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
CCheckboxData *dat = (CCheckboxData*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
if (!dat)
return 0;
switch (Msg) {
case UM_INITCHECKBOX:
{
HFONT hFont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0);
if (!hFont)
hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
LOGFONT lf;
GetObject(hFont, sizeof(lf), &lf);
lf.lfWeight = FW_BOLD;
dat->hFont = CreateFontIndirect(&lf);
SendMessage(hWnd, UM_AUTOSIZE, 0, 0);
}
return 0;
case UM_AUTOSIZE:
{
HTHEME hTheme = OpenThemeData(hWnd, L"BUTTON");
int Len = GetWindowTextLength(hWnd) + 1;
HDC hdc = GetDC(hWnd);
HFONT hOldFont = (HFONT)SelectObject(hdc, dat->hFont);
RECT rcText = { 0 };
if (hTheme) {
WCHAR *szText = (WCHAR*)_alloca(Len * sizeof(WCHAR));
GetWindowTextW(hWnd, szText, Len);
GetThemeTextExtent(hTheme, hdc, BP_GROUPBOX, IsWindowEnabled(hWnd) ? GBS_NORMAL : GBS_DISABLED, szText, -1, DT_CALCRECT | DT_LEFT | DT_VCENTER | DT_SINGLELINE, nullptr, &rcText);
}
else {
SIZE size;
wchar_t *szText = (wchar_t*)_alloca(Len * sizeof(wchar_t));
GetWindowText(hWnd, szText, Len);
GetTextExtentPoint32(hdc, szText, (int)mir_wstrlen(szText), &size);
rcText.right = size.cx;
rcText.bottom = size.cy;
}
SelectObject(hdc, hOldFont);
ReleaseDC(hWnd, hdc);
if (hTheme)
CloseThemeData(hTheme);
OffsetRect(&rcText, CG_CHECKBOX_INDENT + CG_CHECKBOX_WIDTH + CG_TEXT_INDENT, 0);
RECT rc;
GetClientRect(hWnd, &rc);
SetWindowPos(hWnd, nullptr, 0, 0, rcText.right + CG_ADDITIONAL_WIDTH, rc.bottom, SWP_NOMOVE | SWP_NOZORDER);
}
break;
case BM_CLICK:
SendMessage(hWnd, WM_LBUTTONDOWN, 0, 0);
SendMessage(hWnd, WM_LBUTTONUP, 0, 0);
return 0;
case BM_GETCHECK:
return dat->State & CGSM_ISCHECKED;
case BM_SETCHECK:
if ((wParam != BST_UNCHECKED && wParam != BST_CHECKED && wParam != BST_INDETERMINATE) || (wParam == BST_INDETERMINATE && dat->Style != BS_3STATE && dat->Style != BS_AUTO3STATE))
wParam = BST_CHECKED;
dat->State &= ~CGSM_ISCHECKED;
dat->State |= wParam;
InvalidateRect(hWnd, nullptr, false);
SendMessage(GetParent(hWnd), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(hWnd), BN_CLICKED), (LPARAM)hWnd);
return 0;
case BM_SETSTATE:
if (wParam)
dat->State |= CGS_PRESSED;
else
dat->State &= ~CGS_PRESSED;
InvalidateRect(hWnd, nullptr, false);
return 0;
case BM_GETSTATE:
return (dat->State & CGSM_GETSTATE) | ((GetFocus() == hWnd) ? BST_FOCUS : 0);
case WM_GETDLGCODE:
return DLGC_BUTTON;
case WM_THEMECHANGED:
case WM_ENABLE:
InvalidateRect(hWnd, nullptr, false);
return 0;
case WM_SETTEXT:
if (CallWindowProc(dat->OldWndProc, hWnd, Msg, wParam, lParam))
SendMessage(hWnd, UM_AUTOSIZE, 0, 0);
return 0;
case WM_KEYDOWN:
if (wParam == VK_SPACE)
SendMessage(hWnd, BM_SETSTATE, true, 0);
return 0;
case WM_KEYUP:
if (wParam == VK_SPACE) {
SendMessage(hWnd, BM_SETCHECK, (SendMessage(hWnd, BM_GETCHECK, 0, 0) + 1) % ((dat->Style == BS_AUTO3STATE) ? 3 : 2), 0);
SendMessage(hWnd, BM_SETSTATE, false, 0);
}
return 0;
case WM_CAPTURECHANGED:
SendMessage(hWnd, BM_SETSTATE, false, 0);
return 0;
case WM_ERASEBKGND:
return true;
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
SetFocus(hWnd);
SendMessage(hWnd, BM_SETSTATE, true, 0);
SetCapture(hWnd);
return 0;
case WM_LBUTTONUP:
if (GetCapture() == hWnd)
ReleaseCapture();
SendMessage(hWnd, BM_SETSTATE, false, 0);
if (dat->State & CGS_HOVERED && (dat->Style == BS_AUTOCHECKBOX || dat->Style == BS_AUTO3STATE))
SendMessage(hWnd, BM_SETCHECK, (SendMessage(hWnd, BM_GETCHECK, 0, 0) + 1) % ((dat->Style == BS_AUTO3STATE) ? 3 : 2), 0);
return 0;
case WM_MOUSEMOVE:
{
TRACKMOUSEEVENT tme = { 0 };
tme.cbSize = sizeof(tme);
tme.dwFlags = TME_LEAVE;
tme.dwHoverTime = HOVER_DEFAULT;
tme.hwndTrack = hWnd;
_TrackMouseEvent(&tme);
}
POINT pt;
GetCursorPos(&pt);
if ((WindowFromPoint(pt) == hWnd) ^ ((dat->State & CGS_HOVERED) != 0)) {
dat->State ^= CGS_HOVERED;
InvalidateRect(hWnd, nullptr, false);
}
return 0;
case WM_MOUSELEAVE:
if (dat->State & CGS_HOVERED) {
dat->State &= ~CGS_HOVERED;
InvalidateRect(hWnd, nullptr, false);
}
return 0;
case WM_SETFOCUS:
case WM_KILLFOCUS:
case WM_SYSCOLORCHANGE:
InvalidateRect(hWnd, nullptr, false);
return 0;
case WM_PAINT:
{
HDC hdc;
PAINTSTRUCT ps;
hdc = BeginPaint(hWnd, &ps);
RECT rc;
GetClientRect(hWnd, &rc);
HDC hdcMem = CreateCompatibleDC(hdc);
HBITMAP hbmMem = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbmMem);
HTHEME hTheme = OpenThemeData(hWnd, L"BUTTON");
if (hTheme)
DrawThemeParentBackground(hWnd, hdcMem, nullptr);
else
FillRect(hdcMem, &rc, GetSysColorBrush(COLOR_3DFACE));
int StateID = 0;
switch (SendMessage(hWnd, BM_GETCHECK, 0, 0)) {
case BST_CHECKED:
StateID += CBSCHECK_CHECKED;
break;
case BST_UNCHECKED:
StateID += CBSCHECK_UNCHECKED;
break;
case BST_INDETERMINATE:
StateID += CBSCHECK_MIXED;
break;
}
if (!IsWindowEnabled(hWnd))
StateID += CBSSTATE_DISABLED;
else if (dat->State & CGS_PRESSED && (GetCapture() != hWnd || dat->State & CGS_HOVERED))
StateID += CBSSTATE_PRESSED;
else if (dat->State & CGS_PRESSED || dat->State & CGS_HOVERED)
StateID += CBSSTATE_HOT;
rc.left += CG_CHECKBOX_INDENT;
rc.right = rc.left + CG_CHECKBOX_WIDTH; // left-align the image in the client area
rc.top += CG_CHECKBOX_VERTINDENT;
rc.bottom = rc.top + CG_CHECKBOX_WIDTH; // exact rc dimensions are necessary for DrawFrameControl to draw correctly
if (hTheme)
DrawThemeBackground(hTheme, hdcMem, BP_CHECKBOX, StateID, &rc, &rc);
else {
int dfcStates[] =
{ 0, 0, DFCS_PUSHED, DFCS_INACTIVE,
DFCS_CHECKED, DFCS_CHECKED, DFCS_CHECKED | DFCS_PUSHED, DFCS_CHECKED | DFCS_INACTIVE,
DFCS_BUTTON3STATE | DFCS_CHECKED, DFCS_BUTTON3STATE | DFCS_CHECKED, DFCS_BUTTON3STATE | DFCS_INACTIVE | DFCS_CHECKED | DFCS_PUSHED, DFCS_BUTTON3STATE | DFCS_INACTIVE | DFCS_CHECKED | DFCS_PUSHED };
_ASSERT(StateID >= 1 && StateID <= _countof(dfcStates));
DrawFrameControl(hdcMem, &rc, DFC_BUTTON, dfcStates[StateID - 1]);
}
GetClientRect(hWnd, &rc);
rc.left += CG_CHECKBOX_INDENT + CG_CHECKBOX_WIDTH + CG_TEXT_INDENT;
int Len = GetWindowTextLength(hWnd) + 1;
wchar_t *szTextT = (wchar_t*)_alloca(Len * sizeof(wchar_t));
GetWindowText(hWnd, szTextT, Len);
HFONT hOldFont = (HFONT)SelectObject(hdcMem, dat->hFont);
SetBkMode(hdcMem, TRANSPARENT);
if (hTheme)
DrawThemeText(hTheme, hdcMem, BP_GROUPBOX, IsWindowEnabled(hWnd) ? GBS_NORMAL : GBS_DISABLED, szTextT, -1, DT_LEFT | DT_VCENTER | DT_SINGLELINE, 0, &rc);
else
DrawText(hdcMem, szTextT, -1, &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
if (GetFocus() == hWnd) {
RECT rcText = { 0 };
if (hTheme)
GetThemeTextExtent(hTheme, hdcMem, BP_GROUPBOX, IsWindowEnabled(hWnd) ? GBS_NORMAL : GBS_DISABLED, szTextT, -1, DT_CALCRECT | DT_LEFT | DT_VCENTER | DT_SINGLELINE, nullptr, &rcText);
else {
SIZE size;
GetTextExtentPoint32(hdcMem, szTextT, (int)mir_wstrlen(szTextT), &size);
rcText.right = size.cx;
rcText.bottom = size.cy;
}
rcText.bottom = rc.bottom;
OffsetRect(&rcText, rc.left, 0);
InflateRect(&rcText, 1, -1);
DrawFocusRect(hdcMem, &rcText);
}
SelectObject(hdcMem, hOldFont);
if (hTheme)
CloseThemeData(hTheme);
BitBlt(hdc, 0, 0, rc.right, rc.bottom, hdcMem, 0, 0, SRCCOPY);
SelectObject(hdcMem, hbmOld);
DeleteObject(hbmMem);
DeleteDC(hdcMem);
EndPaint(hWnd, &ps);
}
return 0;
case WM_DESTROY:
if (dat->hFont)
DeleteObject(dat->hFont);
SetWindowLongPtr(hWnd, GWLP_USERDATA, 0);
CallWindowProc(dat->OldWndProc, hWnd, Msg, wParam, lParam);
delete dat;
return 0;
}
return CallWindowProc(dat->OldWndProc, hWnd, Msg, wParam, lParam);
}
static HRESULT drawButtonPart(HRESULT hr, struct drawState *s)
{
uiTableValue *value;
WCHAR *wstr;
bool enabled;
HTHEME theme;
RECT r;
TEXTMETRICW tm;
if (hr != S_OK)
return hr;
if (s->p->buttonModelColumn == -1)
return S_OK;
value = uiprivTableModelCellValue(s->model, s->iItem, s->p->buttonModelColumn);
wstr = toUTF16(uiTableValueString(value));
uiFreeTableValue(value);
enabled = uiprivTableModelCellEditable(s->model, s->iItem, s->p->buttonClickableModelColumn);
theme = OpenThemeData(s->t->hwnd, L"button");
if (GetTextMetricsW(s->dc, &tm) == 0) {
logLastError(L"GetTextMetricsW()");
hr = E_FAIL;
goto fail;
}
r = s->m->subitemBounds;
if (theme != NULL) {
int state;
state = PBS_NORMAL;
if (!enabled)
state = PBS_DISABLED;
hr = DrawThemeBackground(theme, s->dc,
BP_PUSHBUTTON, state,
&r, NULL);
if (hr != S_OK) {
logHRESULT(L"DrawThemeBackground()", hr);
goto fail;
}
// TODO DT_EDITCONTROL?
// TODO DT_PATH_ELLIPSIS DT_WORD_ELLIPSIS instead of DT_END_ELLIPSIS? a middle-ellipsis option would be ideal here
// TODO is there a theme property we can get instead of hardcoding these flags? if not, make these flags a macro
hr = DrawThemeText(theme, s->dc,
BP_PUSHBUTTON, state,
wstr, -1,
DT_CENTER | DT_VCENTER | DT_END_ELLIPSIS | DT_SINGLELINE | DT_NOPREFIX, 0,
&r);
if (hr != S_OK) {
logHRESULT(L"DrawThemeText()", hr);
goto fail;
}
} else {
UINT state;
HBRUSH color, prevColor;
int prevBkMode;
// TODO check errors
// TODO explain why we're not doing this in the themed case (it has to do with extra transparent pixels)
InflateRect(&r, -1, -1);
state = DFCS_BUTTONPUSH;
if (!enabled)
state |= DFCS_INACTIVE;
if (DrawFrameControl(s->dc, &r, DFC_BUTTON, state) == 0) {
logLastError(L"DrawFrameControl()");
hr = E_FAIL;
goto fail;
}
color = GetSysColorBrush(COLOR_BTNTEXT);
// TODO check errors for these two
prevColor = (HBRUSH) SelectObject(s->dc, color);
prevBkMode = SetBkMode(s->dc, TRANSPARENT);
// TODO DT_EDITCONTROL?
// TODO DT_PATH_ELLIPSIS DT_WORD_ELLIPSIS instead of DT_END_ELLIPSIS? a middle-ellipsis option would be ideal here
if (DrawTextW(s->dc, wstr, -1, &r, DT_CENTER | DT_VCENTER | DT_END_ELLIPSIS | DT_SINGLELINE | DT_NOPREFIX) == 0) {
logLastError(L"DrawTextW()");
hr = E_FAIL;
goto fail;
}
// TODO check errors for these two
SetBkMode(s->dc, prevBkMode);
SelectObject(s->dc, prevColor);
}
hr = S_OK;
fail:
// TODO check errors
if (theme != NULL)
CloseThemeData(theme);
uiprivFree(wstr);
return hr;
}
void CIconStatic::SetIcon(LPCTSTR pszIconID)
{
m_strIconID = pszIconID;
// If this function is called for the first time and we did not yet call 'SetWindowText', we take
// the window label which is already specified for the window (the label which comes from the resource)
CString strText;
CStatic::GetWindowText(strText);
CStatic::SetWindowText(_T(""));
if (!strText.IsEmpty() && m_strText.IsEmpty())
m_strText = strText;
CRect rRect;
GetClientRect(rRect);
CDC *pDC = GetDC();
CDC MemDC;
CBitmap *pOldBMP;
VERIFY( MemDC.CreateCompatibleDC(pDC) );
CFont *pOldFont = MemDC.SelectObject(GetFont());
CRect rCaption(0,0,0,0);
MemDC.DrawText(m_strText, rCaption, DT_CALCRECT);
ASSERT( rCaption.Width() >= 0 );
ASSERT( rCaption.Height() >= 0 );
if (rCaption.Height() < 16)
rCaption.bottom = rCaption.top + 16;
rCaption.right += 25;
if (rRect.Width() >= 16 && rCaption.Width() > rRect.Width() - 16)
rCaption.right = rCaption.left + rRect.Width() - 16;
if (m_MemBMP.m_hObject)
VERIFY( m_MemBMP.DeleteObject() );
VERIFY( m_MemBMP.CreateCompatibleBitmap(pDC, rCaption.Width(), rCaption.Height()) );
pOldBMP = MemDC.SelectObject(&m_MemBMP);
// Get the background color from the parent window. This way the controls which are
// embedded in a dialog window can get painted with the same background color as
// the dialog window.
HBRUSH hbr = (HBRUSH)GetParent()->SendMessage(WM_CTLCOLORSTATIC, (WPARAM)MemDC.m_hDC, (LPARAM)m_hWnd);
FillRect(MemDC, &rCaption, hbr);
if (!m_strIconID.IsEmpty())
VERIFY( DrawState( MemDC.m_hDC, NULL, NULL, (LPARAM)(HICON)CTempIconLoader(m_strIconID, 16, 16), NULL, 3, 0, 16, 16, DST_ICON | DSS_NORMAL) );
// clear all alpha channel data
BITMAP bmMem;
if (m_MemBMP.GetObject(sizeof bmMem, &bmMem) >= sizeof bmMem && bmMem.bmBitsPixel == 32)
{
DWORD dwSize = m_MemBMP.GetBitmapBits(0, NULL);
if (dwSize)
{
LPBYTE pPixels = (LPBYTE)malloc(dwSize);
if (pPixels)
{
if (m_MemBMP.GetBitmapBits(dwSize, pPixels) == dwSize)
{
LPBYTE pLine = pPixels;
int iLines = bmMem.bmHeight;
while (iLines-- > 0)
{
LPDWORD pdwPixel = (LPDWORD)pLine;
for (int x = 0; x < bmMem.bmWidth; x++)
*pdwPixel++ &= 0x00FFFFFF;
pLine += bmMem.bmWidthBytes;
}
m_MemBMP.SetBitmapBits(dwSize, pPixels);
}
free(pPixels);
}
}
}
rCaption.left += 22;
if(IsThemeActive() && IsAppThemed())
{
HTHEME hTheme = OpenThemeData(NULL, L"BUTTON");
DrawThemeText(hTheme, MemDC.m_hDC, BP_GROUPBOX, GBS_NORMAL, m_strText, m_strText.GetLength(),
DT_WORDBREAK | DT_CENTER | DT_WORD_ELLIPSIS, NULL, &rCaption);
CloseThemeData(hTheme);
}
else
{
MemDC.SetTextColor(GetSysColor(COLOR_WINDOWTEXT));
MemDC.DrawText(m_strText, rCaption, DT_SINGLELINE | DT_LEFT | DT_END_ELLIPSIS);
}
ReleaseDC(pDC);
MemDC.SelectObject(pOldBMP);
MemDC.SelectObject(pOldFont);
if (m_wndPicture.m_hWnd == NULL)
m_wndPicture.Create(NULL, WS_CHILD | WS_VISIBLE | SS_BITMAP, CRect(0,0,0,0), this);
m_wndPicture.SetWindowPos(NULL, rRect.left+8, rRect.top, rCaption.Width()+22, rCaption.Height(), SWP_SHOWWINDOW);
m_wndPicture.SetBitmap(m_MemBMP);
CRect r;
GetWindowRect(r);
r.bottom = r.top + 20;
GetParent()->ScreenToClient(&r);
GetParent()->RedrawWindow(r);
}
void CToolTipCtrlX::CustomPaint(LPNMTTCUSTOMDRAW pNMCD)
{
CWnd* pwnd = CWnd::FromHandle(pNMCD->nmcd.hdr.hwndFrom);
CDC* pdc = CDC::FromHandle(pNMCD->nmcd.hdc);
// Windows Vista (General)
// -----------------------
// *Need* to use (some aspects) of the 'TOOLTIP' theme to get typical Vista tooltips.
//
// Windows Vista *without* SP1
// ---------------------------
// The Vista 'TOOLTIP' theme offers a bold version of the standard tooltip font via
// the TTP_STANDARDTITLE part id. Furthermore TTP_STANDARDTITLE is the same font as
// the standard tooltip font (TTP_STANDARD). So, the 'TOOLTIP' theme can get used
// thoroughly.
//
// Windows Vista *with* SP1
// ------------------------
// The Vista SP1(!) 'TOOLTIP' theme does though *not* offer a bold font. Keep
// in mind that TTP_STANDARDTITLE does not return a bold font. Keep also in mind
// that TTP_STANDARDTITLE is even a *different* font than TTP_STANDARD!
// Which means, that TTP_STANDARDTITLE should *not* be used within the same line
// as TTP_STANDARD. It just looks weird. TTP_STANDARDTITLE could be used for a
// single line (the title line), but it would though not give us a bold font.
// So, actually we can use the Vista 'TOOLTIP' theme only for getting the proper
// tooltip background.
//
// Windows XP
// ----------
// Can *not* use the 'TOOLTIP' theme at all because it would give us only a (non-bold)
// black font on a white tooltip window background. Seems that the 'TOOLTIP' theme under
// WinXP is just using the default Window values (black+white) and does not
// use any of the tooltip specific Window metrics...
//
bool bUseEmbeddedThemeFonts = false;
HTHEME hTheme = NULL;
if (theApp.IsVistaThemeActive()) {
hTheme = OpenThemeData(*pwnd, L"TOOLTIP");
// Using the theme's fonts works only under Vista without SP1. When SP1
// is installed the fonts which are used for TTP_STANDARDTITLE and TTP_STANDARD
// do no longer match (should not get displayed within the same text line).
if (hTheme) bUseEmbeddedThemeFonts = true;
}
CString strText;
pwnd->GetWindowText(strText);
CRect rcWnd;
pwnd->GetWindowRect(&rcWnd);
CFont* pOldDCFont = NULL;
if (hTheme == NULL || !bUseEmbeddedThemeFonts)
{
// If we have a theme, we try to query the correct fonts from it
if (m_fontNormal.m_hObject == NULL && hTheme) {
// Windows Vista Ultimate, 6.0.6001 SP1 Build 6001, English with German Language Pack
// ----------------------------------------------------------------------------------
// TTP_STANDARD, TTSS_NORMAL
// Height -12
// Weight 400
// CharSet 1
// Quality 5
// FaceName "Segoe UI"
//
// TTP_STANDARDTITLE, TTSS_NORMAL
// Height -12
// Weight 400
// CharSet 1
// Quality 5
// FaceName "Segoe UI Fett" (!!!) Note: "Fett" (that is German !?)
//
// That font name ("Segoe UI *Fett*") looks quite suspicious. I would not be surprised
// if that eventually leads to a problem within the font mapper which may not be capable
// of finding the (english) version of that font and thus falls back to the standard
// system font. At least this would explain why the TTP_STANDARD and TTP_STANDARDTITLE
// fonts are *different* on that particular Windows Vista system.
LOGFONT lf = {0};
if (GetThemeFont(hTheme, pdc->m_hDC, TTP_STANDARD, TTSS_NORMAL, TMT_FONT, &lf) == S_OK) {
VERIFY( m_fontNormal.CreateFontIndirect(&lf) );
if (m_bCol1Bold && m_fontBold.m_hObject == NULL) {
memset(&lf, 0, sizeof(lf));
if (GetThemeFont(hTheme, pdc->m_hDC, TTP_STANDARDTITLE, TTSS_NORMAL, TMT_FONT, &lf) == S_OK)
VERIFY( m_fontBold.CreateFontIndirect(&lf) );
}
// Get the tooltip font color
COLORREF crText;
if (GetThemeColor(hTheme, TTP_STANDARD, TTSS_NORMAL, TMT_TEXTCOLOR, &crText) == S_OK)
m_crTooltipTextColor = crText;
}
}
// If needed, create the standard tooltip font which was queried from the system metrics
if (m_fontNormal.m_hObject == NULL && m_lfNormal.lfHeight != 0)
VERIFY( m_fontNormal.CreateFontIndirect(&m_lfNormal) );
// Select the tooltip font
if (m_fontNormal.m_hObject != NULL) {
pOldDCFont = pdc->SelectObject(&m_fontNormal);
// If needed, create the bold version of the tooltip font by deriving it from the standard font
if (m_bCol1Bold && m_fontBold.m_hObject == NULL) {
LOGFONT lf;
m_fontNormal.GetLogFont(&lf);
lf.lfWeight = FW_BOLD;
VERIFY( m_fontBold.CreateFontIndirect(&lf) );
}
}
// Set the font color (queried from system metrics or queried from theme)
pdc->SetTextColor(m_crTooltipTextColor);
}
// Auto-format the text only if explicitly requested. Otherwise we would also format
// single line tooltips for regular list items, and if those list items contain ':'
// characters they would be shown partially in bold. For performance reasons, the
// auto-format is to be requested by appending the TOOLTIP_AUTOFORMAT_SUFFIX_CH
// character. Appending, because we can remove that character efficiently without
// re-allocating the entire string.
bool bAutoFormatText = strText.GetLength() > 0 && strText[strText.GetLength() - 1] == TOOLTIP_AUTOFORMAT_SUFFIX_CH;
if (bAutoFormatText)
strText.Truncate(strText.GetLength() - 1); // truncate the TOOLTIP_AUTOFORMAT_SUFFIX_CH char by setting it to NUL
bool bShowFileIcon = m_bShowFileIcon && bAutoFormatText;
if (bShowFileIcon) {
int iPosNL = strText.Find(_T('\n'));
if (iPosNL > 0) {
int iPosColon = strText.Find(_T(':'));
if (iPosColon < iPosNL)
bShowFileIcon = false; // 1st line does not contain a filename
}
}
int iTextHeight = 0;
int iMaxCol1Width = 0;
int iMaxCol2Width = 0;
int iMaxSingleLineWidth = 0;
CSize sizText(0);
int iPos = 0;
int iCaptionHeight = 0;
const int iCaptionEnd = bShowFileIcon ? max(strText.Find(_T("\n<br_head>\n")), 0) : 0; // special tooltip with file icon
const int iLineHeightOff = 1;
const int iIconMinYBorder = bShowFileIcon ? 3 : 0;
const int iIconWidth = bShowFileIcon ? theApp.GetBigSytemIconSize().cx : 0;
const int iIconHeight = bShowFileIcon ? theApp.GetBigSytemIconSize().cy : 0;
const int iIconDrawingWidth = bShowFileIcon ? (iIconWidth + 9) : 0;
while (iPos != -1)
{
CString strLine = GetNextString(strText, _T('\n'), iPos);
int iColon = bAutoFormatText ? strLine.Find(_T(':')) : -1;
if (iColon != -1) {
CSize siz;
if (hTheme && bUseEmbeddedThemeFonts) {
CRect rcExtent;
CRect rcBounding(0, 0, 32767, 32767);
GetThemeTextExtent(hTheme, *pdc, m_bCol1Bold ? TTP_STANDARDTITLE : TTP_STANDARD, TTSS_NORMAL, strLine, iColon + 1, m_dwCol1DrawTextFlags, &rcBounding, &rcExtent);
siz.cx = rcExtent.Width();
siz.cy = rcExtent.Height();
}
else {
CFont* pOldFont = m_bCol1Bold ? pdc->SelectObject(&m_fontBold) : NULL;
siz = pdc->GetTextExtent(strLine, iColon + 1);
if (pOldFont)
pdc->SelectObject(pOldFont);
}
iMaxCol1Width = max<int>(iMaxCol1Width, siz.cx + ((bShowFileIcon && iPos <= iCaptionEnd + strLine.GetLength()) ? iIconDrawingWidth : 0));
iTextHeight = siz.cy + iLineHeightOff; // update height with 'col1' string, because 'col2' string might be empty and therefore has no height
if (iPos <= iCaptionEnd)
iCaptionHeight += siz.cy + iLineHeightOff;
else
sizText.cy += siz.cy + iLineHeightOff;
LPCTSTR pszCol2 = (LPCTSTR)strLine + iColon + 1;
while (_istspace((_TUCHAR)*pszCol2))
pszCol2++;
if (*pszCol2 != _T('\0')) {
if (hTheme && bUseEmbeddedThemeFonts) {
CRect rcExtent;
CRect rcBounding(0, 0, 32767, 32767);
GetThemeTextExtent(hTheme, *pdc, TTP_STANDARD, TTSS_NORMAL, pszCol2, ((LPCTSTR)strLine + strLine.GetLength()) - pszCol2, m_dwCol2DrawTextFlags, &rcBounding, &rcExtent);
siz.cx = rcExtent.Width();
siz.cy = rcExtent.Height();
}
else {
siz = pdc->GetTextExtent(pszCol2, ((LPCTSTR)strLine + strLine.GetLength()) - pszCol2);
}
iMaxCol2Width = max<int>(iMaxCol2Width, siz.cx);
}
}
else if (bShowFileIcon && iPos <= iCaptionEnd && iPos == strLine.GetLength() + 1){
// file name, printed bold on top without any tabbing or desc
CSize siz;
if (hTheme && bUseEmbeddedThemeFonts) {
CRect rcExtent;
CRect rcBounding(0, 0, 32767, 32767);
GetThemeTextExtent(hTheme, *pdc, m_bCol1Bold ? TTP_STANDARDTITLE : TTP_STANDARD, TTSS_NORMAL, strLine, strLine.GetLength(), m_dwCol1DrawTextFlags, &rcBounding, &rcExtent);
siz.cx = rcExtent.Width();
siz.cy = rcExtent.Height();
}
else {
CFont* pOldFont = m_bCol1Bold ? pdc->SelectObject(&m_fontBold) : NULL;
siz = pdc->GetTextExtent(strLine);
if (pOldFont)
pdc->SelectObject(pOldFont);
}
iMaxSingleLineWidth = max<int>(iMaxSingleLineWidth, siz.cx + iIconDrawingWidth);
iCaptionHeight += siz.cy + iLineHeightOff;
}
else if (!strLine.IsEmpty() && strLine.Compare(_T("<br>")) != 0 && strLine.Compare(_T("<br_head>")) != 0) {
CSize siz;
if (hTheme && bUseEmbeddedThemeFonts) {
CRect rcExtent;
CRect rcBounding(0, 0, 32767, 32767);
GetThemeTextExtent(hTheme, *pdc, TTP_STANDARD, TTSS_NORMAL, strLine, strLine.GetLength(), m_dwCol2DrawTextFlags, &rcBounding, &rcExtent);
siz.cx = rcExtent.Width();
siz.cy = rcExtent.Height();
}
else {
siz = pdc->GetTextExtent(strLine);
}
iMaxSingleLineWidth = max<int>(iMaxSingleLineWidth, siz.cx + ((bShowFileIcon && iPos <= iCaptionEnd) ? iIconDrawingWidth : 0));
if (bShowFileIcon && iPos <= iCaptionEnd + strLine.GetLength())
iCaptionHeight += siz.cy + iLineHeightOff;
else
sizText.cy += siz.cy + iLineHeightOff;
}
else{
CSize siz;
if (hTheme && bUseEmbeddedThemeFonts) {
CRect rcExtent;
CRect rcBounding(0, 0, 32767, 32767);
GetThemeTextExtent(hTheme, *pdc, TTP_STANDARD, TTSS_NORMAL, _T(" "), 1, m_dwCol2DrawTextFlags, &rcBounding, &rcExtent);
siz.cx = rcExtent.Width();
siz.cy = rcExtent.Height();
}
else {
// TODO: Would need to use 'GetTabbedTextExtent' here, but do we actually use 'tabbed' text here at all ??
siz = pdc->GetTextExtent(_T(" "), 1);
}
sizText.cy += siz.cy + iLineHeightOff;
}
}
if (bShowFileIcon && iCaptionEnd > 0)
iCaptionHeight = max<int>(iCaptionHeight, theApp.GetBigSytemIconSize().cy + (2*iIconMinYBorder));
sizText.cy += iCaptionHeight;
if (hTheme && theApp.m_ullComCtrlVer >= MAKEDLLVERULL(6,16,0,0))
sizText.cy += 2; // extra bottom margin for Vista/Theme
iMaxCol1Width = min(m_iScreenWidth4, iMaxCol1Width);
iMaxCol2Width = min(m_iScreenWidth4*2, iMaxCol2Width);
const int iMiddleMargin = 6;
iMaxSingleLineWidth = max(iMaxSingleLineWidth, iMaxCol1Width + iMiddleMargin + iMaxCol2Width);
if (iMaxSingleLineWidth > m_iScreenWidth4*3)
iMaxSingleLineWidth = m_iScreenWidth4*3;
sizText.cx = iMaxSingleLineWidth;
if (pNMCD->uDrawFlags & DT_CALCRECT)
{
pNMCD->nmcd.rc.left = rcWnd.left;
pNMCD->nmcd.rc.top = rcWnd.top;
pNMCD->nmcd.rc.right = rcWnd.left + sizText.cx;
pNMCD->nmcd.rc.bottom = rcWnd.top + sizText.cy;
}
else
{
pwnd->ScreenToClient(&rcWnd);
int iOldBkColor = -1;
if (hTheme) {
int iPartId = TTP_STANDARD;
int iStateId = TTSS_NORMAL;
if (IsThemeBackgroundPartiallyTransparent(hTheme, iPartId, iStateId))
DrawThemeParentBackground(m_hWnd, pdc->m_hDC, &rcWnd);
DrawThemeBackground(hTheme, pdc->m_hDC, iPartId, iStateId, &rcWnd, NULL);
}
else {
::FillRect(*pdc, &rcWnd, GetSysColorBrush(COLOR_INFOBK));
iOldBkColor = pdc->SetBkColor(m_crTooltipBkColor);
// Vista: Need to draw the window border explicitly !?
if (theApp.m_ullComCtrlVer >= MAKEDLLVERULL(6,16,0,0)) {
CPen pen;
pen.CreatePen(0, 1, m_crTooltipTextColor);
CPen *pOP = pdc->SelectObject(&pen);
pdc->MoveTo(rcWnd.left, rcWnd.top);
pdc->LineTo(rcWnd.right - 1, rcWnd.top);
pdc->LineTo(rcWnd.right - 1, rcWnd.bottom - 1);
pdc->LineTo(rcWnd.left, rcWnd.bottom - 1);
pdc->LineTo(rcWnd.left, rcWnd.top);
pdc->SelectObject(pOP);
pen.DeleteObject();
}
}
int iOldBkMode = 0;
if ((hTheme && !bUseEmbeddedThemeFonts) || (hTheme == NULL && iOldBkColor != -1))
iOldBkMode = pdc->SetBkMode(TRANSPARENT);
CPoint ptText(pNMCD->nmcd.rc.left, pNMCD->nmcd.rc.top);
iPos = 0;
while (iPos != -1)
{
CString strLine = GetNextString(strText, _T('\n'), iPos);
int iColon = bAutoFormatText ? strLine.Find(_T(':')) : -1;
CRect rcDT;
if (!bShowFileIcon || (unsigned)iPos > (unsigned)iCaptionEnd + strLine.GetLength())
rcDT.SetRect(ptText.x, ptText.y, ptText.x + iMaxCol1Width, ptText.y + iTextHeight);
else
rcDT.SetRect(ptText.x + iIconDrawingWidth, ptText.y, ptText.x + iMaxCol1Width, ptText.y + iTextHeight);
if (iColon != -1) {
// don't draw empty <col1> strings (they are still handy to use for skipping the <col1> space)
if (iColon > 0) {
if (hTheme && bUseEmbeddedThemeFonts)
DrawThemeText(hTheme, pdc->m_hDC, m_bCol1Bold ? TTP_STANDARDTITLE : TTP_STANDARD, TTSS_NORMAL, strLine, iColon + 1, m_dwCol1DrawTextFlags, 0, &rcDT);
else {
CFont* pOldFont = m_bCol1Bold ? pdc->SelectObject(&m_fontBold) : NULL;
pdc->DrawText(strLine, iColon + 1, &rcDT, m_dwCol1DrawTextFlags);
if (pOldFont)
pdc->SelectObject(pOldFont);
}
}
LPCTSTR pszCol2 = (LPCTSTR)strLine + iColon + 1;
while (_istspace((_TUCHAR)*pszCol2))
pszCol2++;
if (*pszCol2 != _T('\0')) {
rcDT.left = ptText.x + iMaxCol1Width + iMiddleMargin;
rcDT.right = rcDT.left + iMaxCol2Width;
if (hTheme && bUseEmbeddedThemeFonts)
DrawThemeText(hTheme, pdc->m_hDC, TTP_STANDARD, TTSS_NORMAL, pszCol2, ((LPCTSTR)strLine + strLine.GetLength()) - pszCol2, m_dwCol2DrawTextFlags, 0, &rcDT);
else
pdc->DrawText(pszCol2, ((LPCTSTR)strLine + strLine.GetLength()) - pszCol2, &rcDT, m_dwCol2DrawTextFlags);
}
ptText.y += iTextHeight;
}
else if (bShowFileIcon && iPos <= iCaptionEnd && iPos == strLine.GetLength() + 1){
// first line on special fileicon tab - draw icon and bold filename
if (hTheme && bUseEmbeddedThemeFonts)
DrawThemeText(hTheme, pdc->m_hDC, m_bCol1Bold ? TTP_STANDARDTITLE : TTP_STANDARD, TTSS_NORMAL, strLine, strLine.GetLength(), m_dwCol1DrawTextFlags, 0, &CRect(ptText.x + iIconDrawingWidth, ptText.y, ptText.x + iMaxSingleLineWidth, ptText.y + iTextHeight));
else {
CFont* pOldFont = m_bCol1Bold ? pdc->SelectObject(&m_fontBold) : NULL;
pdc->DrawText(strLine, CRect(ptText.x + iIconDrawingWidth, ptText.y, ptText.x + iMaxSingleLineWidth, ptText.y + iTextHeight), m_dwCol1DrawTextFlags);
if (pOldFont)
pdc->SelectObject(pOldFont);
}
ptText.y += iTextHeight;
int iImage = (int) theApp.GetFileTypeSystemImageIdx(strLine, -1, true);
if (theApp.GetBigSystemImageList() != NULL) {
int iPosY = rcDT.top;
if (iCaptionHeight > iIconHeight)
iPosY += (iCaptionHeight - iIconHeight) / 2;
::ImageList_Draw(theApp.GetBigSystemImageList(), iImage, pdc->GetSafeHdc(), ptText.x, iPosY, ILD_TRANSPARENT);
}
}
else {
bool bIsBrHeadLine = false;
if (bAutoFormatText && (strLine.Compare(_T("<br>")) == 0 || (bIsBrHeadLine = strLine.Compare(_T("<br_head>")) == 0) == true)){
CPen pen;
pen.CreatePen(0, 1, m_crTooltipTextColor);
CPen *pOP = pdc->SelectObject(&pen);
if (bIsBrHeadLine)
ptText.y = iCaptionHeight;
pdc->MoveTo(ptText.x, ptText.y + ((iTextHeight - 2) / 2));
pdc->LineTo(ptText.x + iMaxSingleLineWidth, ptText.y + ((iTextHeight - 2) / 2));
ptText.y += iTextHeight;
pdc->SelectObject(pOP);
pen.DeleteObject();
}
else{
if (hTheme && bUseEmbeddedThemeFonts) {
CRect rcLine(ptText.x, ptText.y, 32767, 32767);
DrawThemeText(hTheme, pdc->m_hDC, TTP_STANDARD, TTSS_NORMAL, strLine, strLine.GetLength(), DT_EXPANDTABS | m_dwCol2DrawTextFlags, 0, &rcLine);
ptText.y += iTextHeight;
}
else {
// Text is written in the currently selected font. If 'nTabPositions' is 0 and 'lpnTabStopPositions' is NULL,
// tabs are expanded to eight times the average character width.
CSize siz;
if (strLine.IsEmpty()) // Win98: To draw an empty line we need to output at least a space.
siz = pdc->TabbedTextOut(ptText.x, ptText.y, _T(" "), 1, NULL, 0);
else
siz = pdc->TabbedTextOut(ptText.x, ptText.y, strLine, strLine.GetLength(), NULL, 0);
ptText.y += siz.cy + iLineHeightOff;
}
}
}
}
if (iOldBkColor != -1)
pdc->SetBkColor(iOldBkColor);
if (hTheme && !bUseEmbeddedThemeFonts)
pdc->SetBkMode(iOldBkMode);
}
if (pOldDCFont)
pdc->SelectObject(pOldDCFont);
if (hTheme)
CloseThemeData(hTheme);
}
