UMSKT
/
xpmgr
mirror of https://github.com/UMSKT/xpmgr.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
xpmgr/BuildTools/Include/Uxtheme.h

1769 lines
71 KiB
C
Raw Blame History

//---------------------------------------------------------------------------
//
// uxtheme.h - theming API header file.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
#ifndef _UXTHEME_H_
#define _UXTHEME_H_
#include <commctrl.h>
#include <SpecStrings.h>
#ifndef THEMEAPI
#if !defined(_UXTHEME_)
#define THEMEAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
#define THEMEAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE
#else
#define THEMEAPI STDAPI
#define THEMEAPI_(type) STDAPI_(type)
#endif /* _UXTHEME_ */
#endif /* THEMEAPI */
typedef HANDLE HTHEME; // handle to a section of theme data for class
#if (_WIN32_WINNT >= 0x0600)
#define MAX_THEMECOLOR 64
#define MAX_THEMESIZE 64
#endif
#if (NTDDI_VERSION>= NTDDI_WIN7)
//---------------------------------------------------------------------------
// BeginPanningFeedback - Visual feedback init function related to pan gesture
// - internally called by DefaultGestureHandler
// - called by application
//
// HWND hwnd - The handle to the Target window that will receive feedback
//
//---------------------------------------------------------------------------
BOOL WINAPI
BeginPanningFeedback(
__in HWND hwnd);
//---------------------------------------------------------------------------
// UpdatePanningFeedback : Visual feedback function related to pan gesture
// Can Be called only after a BeginPanningFeedback call
// - internally called by DefaultGestureHandler
// - called by application
//
// HWND hwnd - The handle to the Target window that will receive feedback
// For the method to succeed this must be the same hwnd as provided in
// BeginPanningFeedback
//
// LONG lTotalOverpanOffsetX - The Total displacement that the window has moved in the horizontal direction
// since the end of scrollable region was reached. The API would move the window by the distance specified
// A maximum displacement of 30 pixels is allowed
//
// LONG lTotalOverpanOffsetY - The Total displacement that the window has moved in the horizontal direction
// since the end of scrollable
// region was reached. The API would move the window by the distance specified
// A maximum displacement of 30 pixels is allowed
//
// BOOL fInInertia - Flag dictating whether the Application is handling a WM_GESTURE message with the
// GF_INERTIA FLAG set
//
// Incremental calls to UpdatePanningFeedback should make sure they always pass
// the sum of the increments and not just the increment themselves
// Eg : If the initial displacement is 10 pixels and the next displacement 10 pixels
// the second call would be with the parameter as 20 pixels as opposed to 10
// Eg : UpdatePanningFeedback(hwnd, 10, 10, TRUE)
//
BOOL WINAPI
UpdatePanningFeedback(
__in HWND hwnd,
__in LONG lTotalOverpanOffsetX,
__in LONG lTotalOverpanOffsetY,
__in BOOL fInInertia);
//---------------------------------------------------------------------------
//
// EndPanningFeedback :Visual feedback reset function related to pan gesture
// - internally called by DefaultGestureHandler
// - called by application
// Terminates any existing animation that was in process or set up by BeginPanningFeedback and UpdatePanningFeedback
// The EndPanningFeedBack needs to be called Prior to calling any BeginPanningFeedBack if we have already
// called a BeginPanningFeedBack followed by one/ more UpdatePanningFeedback calls
//
// HWND hwnd - The handle to the Target window that will receive feedback
//
// BOOL fAnimateBack - Flag to indicate whether you wish the displaced window to move back
// to the original position via animation or a direct jump.
// Either ways the method will try to restore the moved window.
// The latter case exists for compatibility with legacy apps.
//
BOOL WINAPI
EndPanningFeedback(
__in HWND hwnd,
__in BOOL fAnimateBack);
#endif
//---------------------------------------------------------------------------
// NOTE: PartId's and StateId's used in the theme API are defined in the
// hdr file <vssym32.h> using the TM_PART and TM_STATE macros. For
// example, "TM_PART(BP, PUSHBUTTON)" defines the PartId "BP_PUSHBUTTON".
//---------------------------------------------------------------------------
// OpenThemeData() - Open the theme data for the specified HWND and
// semi-colon separated list of class names.
//
// OpenThemeData() will try each class name, one at
// a time, and use the first matching theme info
// found. If a match is found, a theme handle
// to the data is returned. If no match is found,
// a "NULL" handle is returned.
//
// When the window is destroyed or a WM_THEMECHANGED
// msg is received, "CloseThemeData()" should be
// called to close the theme handle.
//
// hwnd - window handle of the control/window to be themed
//
// pszClassList - class name (or list of names) to match to theme data
// section. if the list contains more than one name,
// the names are tested one at a time for a match.
// If a match is found, OpenThemeData() returns a
// theme handle associated with the matching class.
// This param is a list (instead of just a single
// class name) to provide the class an opportunity
// to get the "best" match between the class and
// the current theme. For example, a button might
// pass L"OkButton, Button" if its ID=ID_OK. If
// the current theme has an entry for OkButton,
// that will be used. Otherwise, we fall back on
// the normal Button entry.
//---------------------------------------------------------------------------
THEMEAPI_(HTHEME)
OpenThemeData(
HWND hwnd,
LPCWSTR pszClassList
);
#define OTD_FORCE_RECT_SIZING 0x00000001 // make all parts size to rect
#define OTD_NONCLIENT 0x00000002 // set if hTheme to be used for nonclient area
#define OTD_VALIDBITS (OTD_FORCE_RECT_SIZING | \
OTD_NONCLIENT)
//---------------------------------------------------------------------------
// OpenThemeDataEx - Open the theme data for the specified HWND and
// semi-colon separated list of class names.
//
// OpenThemeData() will try each class name, one at
// a time, and use the first matching theme info
// found. If a match is found, a theme handle
// to the data is returned. If no match is found,
// a "NULL" handle is returned.
//
// When the window is destroyed or a WM_THEMECHANGED
// msg is received, "CloseThemeData()" should be
// called to close the theme handle.
//
// hwnd - window handle of the control/window to be themed
//
// pszClassList - class name (or list of names) to match to theme data
// section. if the list contains more than one name,
// the names are tested one at a time for a match.
// If a match is found, OpenThemeData() returns a
// theme handle associated with the matching class.
// This param is a list (instead of just a single
// class name) to provide the class an opportunity
// to get the "best" match between the class and
// the current theme. For example, a button might
// pass L"OkButton, Button" if its ID=ID_OK. If
// the current theme has an entry for OkButton,
// that will be used. Otherwise, we fall back on
// the normal Button entry.
//
// dwFlags - allows certain overrides of std features
// (see OTD_XXX defines above)
//---------------------------------------------------------------------------
THEMEAPI_(HTHEME)
OpenThemeDataEx(
HWND hwnd,
LPCWSTR pszClassList,
DWORD dwFlags
);
//---------------------------------------------------------------------------
// CloseThemeData() - closes the theme data handle. This should be done
// when the window being themed is destroyed or
// whenever a WM_THEMECHANGED msg is received
// (followed by an attempt to create a new Theme data
// handle).
//
// hTheme - open theme data handle (returned from prior call
// to OpenThemeData() API).
//---------------------------------------------------------------------------
THEMEAPI
CloseThemeData(
HTHEME hTheme
);
//---------------------------------------------------------------------------
// functions for basic drawing support
//---------------------------------------------------------------------------
// The following methods are the theme-aware drawing services.
// Controls/Windows are defined in drawable "parts" by their author: a
// parent part and 0 or more child parts. Each of the parts can be
// described in "states" (ex: disabled, hot, pressed).
//---------------------------------------------------------------------------
// For the list of all themed classes and the definition of all
// parts and states, see the file "tmschmea.h".
//---------------------------------------------------------------------------
// Each of the below methods takes a "iPartId" param to specify the
// part and a "iStateId" to specify the state of the part.
// "iStateId=0" refers to the root part. "iPartId" = "0" refers to
// the root class.
//-----------------------------------------------------------------------
// Note: draw operations are always scaled to fit (and not to exceed)
// the specified "Rect".
//-----------------------------------------------------------------------
//------------------------------------------------------------------------
// DrawThemeBackground()
// - draws the theme-specified border and fill for
// the "iPartId" and "iStateId". This could be
// based on a bitmap file, a border and fill, or
// other image description.
//
// hTheme - theme data handle
// hdc - HDC to draw into
// iPartId - part number to draw
// iStateId - state number (of the part) to draw
// pRect - defines the size/location of the part
// pClipRect - optional clipping rect (don't draw outside it)
//------------------------------------------------------------------------
THEMEAPI
DrawThemeBackground(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
LPCRECT pRect,
__in_opt LPCRECT pClipRect
);
//------------------------------------------------------------------------
//---- bits used in dwFlags of DTBGOPTS ----
#define DTBG_CLIPRECT 0x00000001 // rcClip has been specified
#define DTBG_DRAWSOLID 0x00000002 // DEPRECATED: draw transparent/alpha images as solid
#define DTBG_OMITBORDER 0x00000004 // don't draw border of part
#define DTBG_OMITCONTENT 0x00000008 // don't draw content area of part
#define DTBG_COMPUTINGREGION 0x00000010 // TRUE if calling to compute region
#define DTBG_MIRRORDC 0x00000020 // assume the hdc is mirrorred and
// flip images as appropriate (currently
// only supported for bgtype=imagefile)
#define DTBG_NOMIRROR 0x00000040 // don't mirror the output, overrides everything else
#define DTBG_VALIDBITS (DTBG_CLIPRECT | \
DTBG_DRAWSOLID | \
DTBG_OMITBORDER | \
DTBG_OMITCONTENT | \
DTBG_COMPUTINGREGION | \
DTBG_MIRRORDC | \
DTBG_NOMIRROR)
typedef struct _DTBGOPTS
{
DWORD dwSize; // size of the struct
DWORD dwFlags; // which options have been specified
RECT rcClip; // clipping rectangle
} DTBGOPTS, *PDTBGOPTS;
//------------------------------------------------------------------------
// DrawThemeBackgroundEx()
// - draws the theme-specified border and fill for
// the "iPartId" and "iStateId". This could be
// based on a bitmap file, a border and fill, or
// other image description. NOTE: This will be
// merged back into DrawThemeBackground() after
// BETA 2.
//
// hTheme - theme data handle
// hdc - HDC to draw into
// iPartId - part number to draw
// iStateId - state number (of the part) to draw
// pRect - defines the size/location of the part
// pOptions - ptr to optional params
//------------------------------------------------------------------------
THEMEAPI
DrawThemeBackgroundEx(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
LPCRECT pRect,
__in_opt const DTBGOPTS *pOptions
);
//---------------------------------------------------------------------------
//----- DrawThemeText() flags ----
#define DTT_GRAYED 0x00000001 // draw a grayed-out string (this is deprecated)
#define DTT_FLAGS2VALIDBITS (DTT_GRAYED)
//-------------------------------------------------------------------------
// DrawThemeText() - draws the text using the theme-specified
// color and font for the "iPartId" and
// "iStateId".
//
// hTheme - theme data handle
// hdc - HDC to draw into
// iPartId - part number to draw
// iStateId - state number (of the part) to draw
// pszText - actual text to draw
// dwCharCount - number of chars to draw (-1 for all)
// dwTextFlags - same as DrawText() "uFormat" param
// dwTextFlags2 - additional drawing options
// pRect - defines the size/location of the part
//-------------------------------------------------------------------------
THEMEAPI
DrawThemeText(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
__in_ecount(cchText) LPCWSTR pszText,
int cchText,
DWORD dwTextFlags,
DWORD dwTextFlags2,
LPCRECT pRect
);
//-------------------------------------------------------------------------
// GetThemeBackgroundContentRect()
// - gets the size of the content for the theme-defined
// background. This is usually the area inside
// the borders or Margins.
//
// hTheme - theme data handle
// hdc - (optional) device content to be used for drawing
// iPartId - part number to draw
// iStateId - state number (of the part) to draw
// pBoundingRect - the outer RECT of the part being drawn
// pContentRect - RECT to receive the content area
//-------------------------------------------------------------------------
THEMEAPI
GetThemeBackgroundContentRect(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
LPCRECT pBoundingRect,
__out LPRECT pContentRect
);
//-------------------------------------------------------------------------
// GetThemeBackgroundExtent() - calculates the size/location of the theme-
// specified background based on the
// "pContentRect".
//
// hTheme - theme data handle
// hdc - (optional) device content to be used for drawing
// iPartId - part number to draw
// iStateId - state number (of the part) to draw
// pContentRect - RECT that defines the content area
// pBoundingRect - RECT to receive the overall size/location of part
//-------------------------------------------------------------------------
THEMEAPI
GetThemeBackgroundExtent(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
LPCRECT pContentRect,
__out LPRECT pExtentRect
);
//-------------------------------------------------------------------------
// GetThemeBackgroundRegion()
// - computes the region for a regular or partially
// transparent theme-specified background that is
// bound by the specified "pRect".
// If the rectangle is empty, sets the HRGN to NULL
// and return S_FALSE.
//
// hTheme - theme data handle
// hdc - optional HDC to draw into (DPI scaling)
// iPartId - part number to draw
// iStateId - state number (of the part)
// pRect - the RECT used to draw the part
// pRegion - receives handle to calculated region
//-------------------------------------------------------------------------
THEMEAPI
GetThemeBackgroundRegion(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
LPCRECT pRect,
__out HRGN *pRegion
);
enum THEMESIZE
{
TS_MIN, // minimum size
TS_TRUE, // size without stretching
TS_DRAW // size that theme mgr will use to draw part
};
//-------------------------------------------------------------------------
// GetThemePartSize() - returns the specified size of the theme part
//
// hTheme - theme data handle
// hdc - HDC to select font into & measure against
// iPartId - part number to retrieve size for
// iStateId - state number (of the part)
// prc - (optional) rect for part drawing destination
// eSize - the type of size to be retreived
// psz - receives the specified size of the part
//-------------------------------------------------------------------------
THEMEAPI
GetThemePartSize(
HTHEME hTheme,
__in_opt HDC hdc,
int iPartId,
int iStateId,
__in_opt LPCRECT prc,
enum THEMESIZE eSize,
__out SIZE *psz
);
//-------------------------------------------------------------------------
// GetThemeTextExtent() - calculates the size/location of the specified
// text when rendered in the Theme Font.
//
// hTheme - theme data handle
// hdc - HDC to select font & measure into
// iPartId - part number to draw
// iStateId - state number (of the part)
// pszText - the text to be measured
// dwCharCount - number of chars to draw (-1 for all)
// dwTextFlags - same as DrawText() "uFormat" param
// pszBoundingRect - optional: to control layout of text
// pszExtentRect - receives the RECT for text size/location
//-------------------------------------------------------------------------
THEMEAPI
GetThemeTextExtent(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
__in_ecount(cchCharCount) LPCWSTR pszText,
int cchCharCount,
DWORD dwTextFlags,
__in_opt LPCRECT pBoundingRect,
__out LPRECT pExtentRect
);
//-------------------------------------------------------------------------
// GetThemeTextMetrics()
// - returns info about the theme-specified font
// for the part/state passed in.
//
// hTheme - theme data handle
// hdc - optional: HDC for screen context
// iPartId - part number to draw
// iStateId - state number (of the part)
// ptm - receives the font info
//-------------------------------------------------------------------------
THEMEAPI
GetThemeTextMetrics(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
__out TEXTMETRICW *ptm
);
//-------------------------------------------------------------------------
//----- HitTestThemeBackground, HitTestThemeBackgroundRegion flags ----
// Theme background segment hit test flag (default). possible return values are:
// HTCLIENT: hit test succeeded in the middle background segment
// HTTOP, HTLEFT, HTTOPLEFT, etc: // hit test succeeded in the the respective theme background segment.
#define HTTB_BACKGROUNDSEG 0x00000000
// Fixed border hit test option. possible return values are:
// HTCLIENT: hit test succeeded in the middle background segment
// HTBORDER: hit test succeeded in any other background segment
#define HTTB_FIXEDBORDER 0x00000002 // Return code may be either HTCLIENT or HTBORDER.
// Caption hit test option. Possible return values are:
// HTCAPTION: hit test succeeded in the top, top left, or top right background segments
// HTNOWHERE or another return code, depending on absence or presence of accompanying flags, resp.
#define HTTB_CAPTION 0x00000004
// Resizing border hit test flags. Possible return values are:
// HTCLIENT: hit test succeeded in middle background segment
// HTTOP, HTTOPLEFT, HTLEFT, HTRIGHT, etc: hit test succeeded in the respective system resizing zone
// HTBORDER: hit test failed in middle segment and resizing zones, but succeeded in a background border segment
#define HTTB_RESIZINGBORDER_LEFT 0x00000010 // Hit test left resizing border,
#define HTTB_RESIZINGBORDER_TOP 0x00000020 // Hit test top resizing border
#define HTTB_RESIZINGBORDER_RIGHT 0x00000040 // Hit test right resizing border
#define HTTB_RESIZINGBORDER_BOTTOM 0x00000080 // Hit test bottom resizing border
#define HTTB_RESIZINGBORDER (HTTB_RESIZINGBORDER_LEFT | \
HTTB_RESIZINGBORDER_TOP | \
HTTB_RESIZINGBORDER_RIGHT | \
HTTB_RESIZINGBORDER_BOTTOM)
// Resizing border is specified as a template, not just window edges.
// This option is mutually exclusive with HTTB_SYSTEMSIZINGWIDTH; HTTB_SIZINGTEMPLATE takes precedence
#define HTTB_SIZINGTEMPLATE 0x00000100
// Use system resizing border width rather than theme content margins.
// This option is mutually exclusive with HTTB_SIZINGTEMPLATE, which takes precedence.
#define HTTB_SYSTEMSIZINGMARGINS 0x00000200
//-------------------------------------------------------------------------
// HitTestThemeBackground()
// - returns a HitTestCode (a subset of the values
// returned by WM_NCHITTEST) for the point "ptTest"
// within the theme-specified background
// (bound by pRect). "pRect" and "ptTest" should
// both be in the same coordinate system
// (client, screen, etc).
//
// hTheme - theme data handle
// hdc - HDC to draw into
// iPartId - part number to test against
// iStateId - state number (of the part)
// pRect - the RECT used to draw the part
// hrgn - optional region to use; must be in same coordinates as
// - pRect and pTest.
// ptTest - the hit point to be tested
// dwOptions - HTTB_xxx constants
// pwHitTestCode - receives the returned hit test code - one of:
//
// HTNOWHERE, HTLEFT, HTTOPLEFT, HTBOTTOMLEFT,
// HTRIGHT, HTTOPRIGHT, HTBOTTOMRIGHT,
// HTTOP, HTBOTTOM, HTCLIENT
//-------------------------------------------------------------------------
THEMEAPI
HitTestThemeBackground(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
DWORD dwOptions,
LPCRECT pRect,
HRGN hrgn,
POINT ptTest,
__out WORD *pwHitTestCode
);
//------------------------------------------------------------------------
// DrawThemeEdge() - Similar to the DrawEdge() API, but uses part colors
// and is high-DPI aware
// hTheme - theme data handle
// hdc - HDC to draw into
// iPartId - part number to draw
// iStateId - state number of part
// pDestRect - the RECT used to draw the line(s)
// uEdge - Same as DrawEdge() API
// uFlags - Same as DrawEdge() API
// pContentRect - Receives the interior rect if (uFlags & BF_ADJUST)
//------------------------------------------------------------------------
THEMEAPI
DrawThemeEdge(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
LPCRECT pDestRect,
UINT uEdge,
UINT uFlags,
__out_opt LPRECT pContentRect
);
//------------------------------------------------------------------------
// DrawThemeIcon() - draws an image within an imagelist based on
// a (possible) theme-defined effect.
//
// hTheme - theme data handle
// hdc - HDC to draw into
// iPartId - part number to draw
// iStateId - state number of part
// pRect - the RECT to draw the image within
// himl - handle to IMAGELIST
// iImageIndex - index into IMAGELIST (which icon to draw)
//------------------------------------------------------------------------
THEMEAPI
DrawThemeIcon(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
LPCRECT pRect,
HIMAGELIST himl,
int iImageIndex
);
//---------------------------------------------------------------------------
// IsThemePartDefined() - returns TRUE if the theme has defined parameters
// for the specified "iPartId" and "iStateId".
//
// hTheme - theme data handle
// iPartId - part number to find definition for
// iStateId - state number of part
//---------------------------------------------------------------------------
THEMEAPI_(BOOL)
IsThemePartDefined(
HTHEME hTheme,
int iPartId,
int iStateId
);
//---------------------------------------------------------------------------
// IsThemeBackgroundPartiallyTransparent()
// - returns TRUE if the theme specified background for
// the part/state has transparent pieces or
// alpha-blended pieces.
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
//---------------------------------------------------------------------------
THEMEAPI_(BOOL)
IsThemeBackgroundPartiallyTransparent(
HTHEME hTheme,
int iPartId,
int iStateId
);
//---------------------------------------------------------------------------
// lower-level theme information services
//---------------------------------------------------------------------------
// The following methods are getter routines for each of the Theme Data types.
// Controls/Windows are defined in drawable "parts" by their author: a
// parent part and 0 or more child parts. Each of the parts can be
// described in "states" (ex: disabled, hot, pressed).
//---------------------------------------------------------------------------
// Each of the below methods takes a "iPartId" param to specify the
// part and a "iStateId" to specify the state of the part.
// "iStateId=0" refers to the root part. "iPartId" = "0" refers to
// the root class.
//-----------------------------------------------------------------------
// Each method also take a "iPropId" param because multiple instances of
// the same primitive type can be defined in the theme schema.
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// GetThemeColor() - Get the value for the specified COLOR property
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// pColor - receives the value of the property
//-----------------------------------------------------------------------
THEMEAPI
GetThemeColor(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out COLORREF *pColor
);
//-----------------------------------------------------------------------
// GetThemeMetric() - Get the value for the specified metric/size
// property
//
// hTheme - theme data handle
// hdc - (optional) hdc to be drawn into (DPI scaling)
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// piVal - receives the value of the property
//-----------------------------------------------------------------------
THEMEAPI
GetThemeMetric(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
int iPropId,
__out int *piVal
);
//-----------------------------------------------------------------------
// GetThemeString() - Get the value for the specified string property
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// pszBuff - receives the string property value
// cchMaxBuffChars - max. number of chars allowed in pszBuff
//-----------------------------------------------------------------------
THEMEAPI
GetThemeString(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out_ecount(cchMaxBuffChars) LPWSTR pszBuff,
int cchMaxBuffChars
);
//-----------------------------------------------------------------------
// GetThemeBool() - Get the value for the specified BOOL property
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// pfVal - receives the value of the property
//-----------------------------------------------------------------------
THEMEAPI
GetThemeBool(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out BOOL *pfVal
);
//-----------------------------------------------------------------------
// GetThemeInt() - Get the value for the specified int property
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// piVal - receives the value of the property
//-----------------------------------------------------------------------
THEMEAPI
GetThemeInt(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out int *piVal
);
//-----------------------------------------------------------------------
// GetThemeEnumValue() - Get the value for the specified ENUM property
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// piVal - receives the value of the enum (cast to int*)
//-----------------------------------------------------------------------
THEMEAPI
GetThemeEnumValue(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out int *piVal
);
//-----------------------------------------------------------------------
// GetThemePosition() - Get the value for the specified position
// property
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// pPoint - receives the value of the position property
//-----------------------------------------------------------------------
THEMEAPI
GetThemePosition(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out POINT *pPoint
);
//-----------------------------------------------------------------------
// GetThemeFont() - Get the value for the specified font property
//
// hTheme - theme data handle
// hdc - (optional) hdc to be drawn to (DPI scaling)
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// pFont - receives the value of the LOGFONT property
// (scaled for the current logical screen dpi)
//-----------------------------------------------------------------------
THEMEAPI
GetThemeFont(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
int iPropId,
__out LOGFONTW *pFont
);
//-----------------------------------------------------------------------
// GetThemeRect() - Get the value for the specified RECT property
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// pRect - receives the value of the RECT property
//-----------------------------------------------------------------------
THEMEAPI
GetThemeRect(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out LPRECT pRect
);
typedef struct _MARGINS
{
int cxLeftWidth; // width of left border that retains its size
int cxRightWidth; // width of right border that retains its size
int cyTopHeight; // height of top border that retains its size
int cyBottomHeight; // height of bottom border that retains its size
} MARGINS, *PMARGINS;
//-----------------------------------------------------------------------
// GetThemeMargins() - Get the value for the specified MARGINS property
//
// hTheme - theme data handle
// hdc - (optional) hdc to be used for drawing
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// prc - RECT for area to be drawn into
// pMargins - receives the value of the MARGINS property
//-----------------------------------------------------------------------
THEMEAPI
GetThemeMargins(
HTHEME hTheme,
__in_opt HDC hdc,
int iPartId,
int iStateId,
int iPropId,
__in_opt LPCRECT prc,
__out MARGINS *pMargins
);
#if (_WIN32_WINNT >= 0x0600)
#define MAX_INTLIST_COUNT 402
#else
#define MAX_INTLIST_COUNT 10
#endif
typedef struct _INTLIST
{
int iValueCount; // number of values in iValues
int iValues[MAX_INTLIST_COUNT];
} INTLIST, *PINTLIST;
//-----------------------------------------------------------------------
// GetThemeIntList() - Get the value for the specified INTLIST struct
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// pIntList - receives the value of the INTLIST property
//-----------------------------------------------------------------------
THEMEAPI
GetThemeIntList(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out INTLIST *pIntList
);
enum PROPERTYORIGIN
{
PO_STATE, // property was found in the state section
PO_PART, // property was found in the part section
PO_CLASS, // property was found in the class section
PO_GLOBAL, // property was found in [globals] section
PO_NOTFOUND // property was not found
};
//-----------------------------------------------------------------------
// GetThemePropertyOrigin()
// - searches for the specified theme property
// and sets "pOrigin" to indicate where it was
// found (or not found)
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to search for
// pOrigin - receives the value of the property origin
//-----------------------------------------------------------------------
THEMEAPI
GetThemePropertyOrigin(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out enum PROPERTYORIGIN *pOrigin
);
//---------------------------------------------------------------------------
// SetWindowTheme()
// - redirects an existing Window to use a different
// section of the current theme information than its
// class normally asks for.
//
// hwnd - the handle of the window (cannot be NULL)
//
// pszSubAppName - app (group) name to use in place of the calling
// app's name. If NULL, the actual calling app
// name will be used.
//
// pszSubIdList - semicolon separated list of class Id names to
// use in place of actual list passed by the
// window's class. if NULL, the id list from the
// calling class is used.
//---------------------------------------------------------------------------
// The Theme Manager will remember the "pszSubAppName" and the
// "pszSubIdList" associations thru the lifetime of the window (even
// if themes are subsequently changed). The window is sent a
// "WM_THEMECHANGED" msg at the end of this call, so that the new
// theme can be found and applied.
//---------------------------------------------------------------------------
// When "pszSubAppName" or "pszSubIdList" are NULL, the Theme Manager
// removes the previously remember association. To turn off theme-ing for
// the specified window, you can pass an empty string (L"") so it
// won't match any section entries.
//---------------------------------------------------------------------------
THEMEAPI
SetWindowTheme(
HWND hwnd,
LPCWSTR pszSubAppName,
LPCWSTR pszSubIdList
);
//---------------------------------------------------------------------------
// GetThemeFilename() - Get the value for the specified FILENAME property.
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to search for
// pszThemeFileName - output buffer to receive the filename
// cchMaxBuffChars - the size of the return buffer, in chars
//---------------------------------------------------------------------------
THEMEAPI
GetThemeFilename(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out_ecount(cchMaxBuffChars) LPWSTR pszThemeFileName,
int cchMaxBuffChars
);
//---------------------------------------------------------------------------
// GetThemeSysColor() - Get the value of the specified System color.
//
// hTheme - the theme data handle. if non-NULL, will return
// color from [SysMetrics] section of theme.
// if NULL, will return the global system color.
//
// iColorId - the system color index defined in winuser.h
//---------------------------------------------------------------------------
THEMEAPI_(COLORREF)
GetThemeSysColor(
HTHEME hTheme,
int iColorId
);
//---------------------------------------------------------------------------
// GetThemeSysColorBrush()
// - Get the brush for the specified System color.
//
// hTheme - the theme data handle. if non-NULL, will return
// brush matching color from [SysMetrics] section of
// theme. if NULL, will return the brush matching
// global system color.
//
// iColorId - the system color index defined in winuser.h
//---------------------------------------------------------------------------
THEMEAPI_(HBRUSH)
GetThemeSysColorBrush(
HTHEME hTheme,
int iColorId
);
//---------------------------------------------------------------------------
// GetThemeSysBool() - Get the boolean value of specified System metric.
//
// hTheme - the theme data handle. if non-NULL, will return
// BOOL from [SysMetrics] section of theme.
// if NULL, will return the specified system boolean.
//
// iBoolId - the TMT_XXX BOOL number (first BOOL
// is TMT_FLATMENUS)
//---------------------------------------------------------------------------
THEMEAPI_(BOOL)
GetThemeSysBool(
HTHEME hTheme,
int iBoolId
);
//---------------------------------------------------------------------------
// GetThemeSysSize() - Get the value of the specified System size metric.
// (scaled for the current logical screen dpi)
//
// hTheme - the theme data handle. if non-NULL, will return
// size from [SysMetrics] section of theme.
// if NULL, will return the global system metric.
//
// iSizeId - the following values are supported when
// hTheme is non-NULL:
//
// SM_CXBORDER (border width)
// SM_CXVSCROLL (scrollbar width)
// SM_CYHSCROLL (scrollbar height)
// SM_CXSIZE (caption width)
// SM_CYSIZE (caption height)
// SM_CXSMSIZE (small caption width)
// SM_CYSMSIZE (small caption height)
// SM_CXMENUSIZE (menubar width)
// SM_CYMENUSIZE (menubar height)
// SM_CXPADDEDBORDER (padded border width)
//
// when hTheme is NULL, iSizeId is passed directly
// to the GetSystemMetrics() function
//---------------------------------------------------------------------------
THEMEAPI_(int)
GetThemeSysSize(
HTHEME hTheme,
int iSizeId
);
//---------------------------------------------------------------------------
// GetThemeSysFont() - Get the LOGFONT for the specified System font.
//
// hTheme - the theme data handle. if non-NULL, will return
// font from [SysMetrics] section of theme.
// if NULL, will return the specified system font.
//
// iFontId - the TMT_XXX font number (first font
// is TMT_CAPTIONFONT)
//
// plf - ptr to LOGFONT to receive the font value.
// (scaled for the current logical screen dpi)
//---------------------------------------------------------------------------
THEMEAPI
GetThemeSysFont(
HTHEME hTheme,
int iFontId,
__out LOGFONTW *plf
);
//---------------------------------------------------------------------------
// GetThemeSysString() - Get the value of specified System string metric.
//
// hTheme - the theme data handle (required)
//
// iStringId - must be one of the following values:
//
// TMT_CSSNAME
// TMT_XMLNAME
//
// pszStringBuff - the buffer to receive the string value
//
// cchMaxStringChars - max. number of chars that pszStringBuff can hold
//---------------------------------------------------------------------------
THEMEAPI
GetThemeSysString(
HTHEME hTheme,
int iStringId,
__out_ecount(cchMaxStringChars) LPWSTR pszStringBuff,
int cchMaxStringChars
);
//---------------------------------------------------------------------------
// GetThemeSysInt() - Get the value of specified System int.
//
// hTheme - the theme data handle (required)
//
// iIntId - must be one of the following values:
//
// TMT_DPIX
// TMT_DPIY
// TMT_MINCOLORDEPTH
//
// piValue - ptr to int to receive value
//---------------------------------------------------------------------------
THEMEAPI
GetThemeSysInt(
HTHEME hTheme,
int iIntId,
__out int *piValue
);
//---------------------------------------------------------------------------
// IsThemeActive() - can be used to test if a system theme is active
// for the current user session.
//
// use the API "IsAppThemed()" to test if a theme is
// active for the calling process.
//---------------------------------------------------------------------------
THEMEAPI_(BOOL)
IsThemeActive(
VOID
);
//---------------------------------------------------------------------------
// IsAppThemed() - returns TRUE if a theme is active and available to
// the current process
//---------------------------------------------------------------------------
THEMEAPI_(BOOL)
IsAppThemed(
VOID
);
//---------------------------------------------------------------------------
// GetWindowTheme() - if window is themed, returns its most recent
// HTHEME from OpenThemeData() - otherwise, returns
// NULL.
//
// hwnd - the window to get the HTHEME of
//---------------------------------------------------------------------------
THEMEAPI_(HTHEME)
GetWindowTheme(
HWND hwnd
);
#define ETDT_DISABLE 0x00000001
#define ETDT_ENABLE 0x00000002
#define ETDT_USETABTEXTURE 0x00000004
#define ETDT_ENABLETAB (ETDT_ENABLE | \
ETDT_USETABTEXTURE)
#if (_WIN32_WINNT >= 0x0600)
#define ETDT_USEAEROWIZARDTABTEXTURE 0x00000008
#define ETDT_ENABLEAEROWIZARDTAB (ETDT_ENABLE | \
ETDT_USEAEROWIZARDTABTEXTURE)
#define ETDT_VALIDBITS (ETDT_DISABLE | \
ETDT_ENABLE | \
ETDT_USETABTEXTURE | \
ETDT_USEAEROWIZARDTABTEXTURE)
#endif
//---------------------------------------------------------------------------
// EnableThemeDialogTexture()
//
// - Enables/disables dialog background theme. This method can be used to
// tailor dialog compatibility with child windows and controls that
// may or may not coordinate the rendering of their client area backgrounds
// with that of their parent dialog in a manner that supports seamless
// background texturing.
//
// hdlg - the window handle of the target dialog
// dwFlags - ETDT_ENABLE to enable the theme-defined dialog background texturing,
// ETDT_DISABLE to disable background texturing,
// ETDT_ENABLETAB to enable the theme-defined background
// texturing using the Tab texture
//---------------------------------------------------------------------------
THEMEAPI
EnableThemeDialogTexture(
__in HWND hwnd,
__in DWORD dwFlags
);
//---------------------------------------------------------------------------
// IsThemeDialogTextureEnabled()
//
// - Reports whether the dialog supports background texturing.
//
// hdlg - the window handle of the target dialog
//---------------------------------------------------------------------------
THEMEAPI_(BOOL)
IsThemeDialogTextureEnabled(
__in HWND hwnd
);
//---------------------------------------------------------------------------
//---- flags to control theming within an app ----
#define STAP_ALLOW_NONCLIENT (1UL << 0)
#define STAP_ALLOW_CONTROLS (1UL << 1)
#define STAP_ALLOW_WEBCONTENT (1UL << 2)
#define STAP_VALIDBITS (STAP_ALLOW_NONCLIENT | \
STAP_ALLOW_CONTROLS | \
STAP_ALLOW_WEBCONTENT)
//---------------------------------------------------------------------------
// GetThemeAppProperties()
// - returns the app property flags that control theming
//---------------------------------------------------------------------------
THEMEAPI_(DWORD)
GetThemeAppProperties(
VOID
);
//---------------------------------------------------------------------------
// SetThemeAppProperties()
// - sets the flags that control theming within the app
//
// dwFlags - the flag values to be set
//---------------------------------------------------------------------------
THEMEAPI_(void)
SetThemeAppProperties(
DWORD dwFlags
);
//---------------------------------------------------------------------------
// GetCurrentThemeName()
// - Get the name of the current theme in-use.
// Optionally, return the ColorScheme name and the
// Size name of the theme.
//
// pszThemeFileName - receives the theme path & filename
// cchMaxNameChars - max chars allowed in pszNameBuff
//
// pszColorBuff - (optional) receives the canonical color scheme name
// (not the display name)
// cchMaxColorChars - max chars allowed in pszColorBuff
//
// pszSizeBuff - (optional) receives the canonical size name
// (not the display name)
// cchMaxSizeChars - max chars allowed in pszSizeBuff
//---------------------------------------------------------------------------
THEMEAPI GetCurrentThemeName(
__out_ecount(cchMaxNameChars) LPWSTR pszThemeFileName,
int cchMaxNameChars,
__out_ecount_opt(cchMaxColorChars) LPWSTR pszColorBuff,
int cchMaxColorChars,
__out_ecount_opt(cchMaxSizeChars) LPWSTR pszSizeBuff,
int cchMaxSizeChars
);
#define SZ_THDOCPROP_DISPLAYNAME L"DisplayName"
#define SZ_THDOCPROP_CANONICALNAME L"ThemeName"
#define SZ_THDOCPROP_TOOLTIP L"ToolTip"
#define SZ_THDOCPROP_AUTHOR L"author"
THEMEAPI
GetThemeDocumentationProperty(
LPCWSTR pszThemeName,
LPCWSTR pszPropertyName,
__out_ecount(cchMaxValChars) LPWSTR pszValueBuff,
int cchMaxValChars
);
//---------------------------------------------------------------------------
// Theme API Error Handling
//
// All functions in the Theme API not returning an HRESULT (THEMEAPI_)
// use the WIN32 function "SetLastError()" to record any call failures.
//
// To retreive the error code of the last failure on the
// current thread for these type of API's, use the WIN32 function
// "GetLastError()".
//
// All Theme API error codes (HRESULT's and GetLastError() values)
// should be normal win32 errors which can be formatted into
// strings using the Win32 API FormatMessage().
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// DrawThemeParentBackground()
// - used by partially-transparent or alpha-blended
// child controls to draw the part of their parent
// that they appear in front of.
//
// hwnd - handle of the child control
//
// hdc - hdc of the child control
//
// prc - (optional) rect that defines the area to be
// drawn (CHILD coordinates)
//---------------------------------------------------------------------------
THEMEAPI
DrawThemeParentBackground(
HWND hwnd,
HDC hdc,
__in_opt const RECT* prc
);
//---------------------------------------------------------------------------
// EnableTheming() - enables or disables themeing for the current user
// in the current and future sessions.
//
// fEnable - if FALSE, disable theming & turn themes off.
// - if TRUE, enable themeing and, if user previously
// had a theme active, make it active now.
//---------------------------------------------------------------------------
THEMEAPI
EnableTheming(
BOOL fEnable
);
#define GBF_DIRECT 0x00000001 // direct dereferencing.
#define GBF_COPY 0x00000002 // create a copy of the bitmap
#define GBF_VALIDBITS (GBF_DIRECT | \
GBF_COPY)
#if (_WIN32_WINNT >= 0x0600)
#define DTPB_WINDOWDC 0x00000001
#define DTPB_USECTLCOLORSTATIC 0x00000002
#define DTPB_USEERASEBKGND 0x00000004
//---------------------------------------------------------------------------
// DrawThemeParentBackgroundEx()
// - used by partially-transparent or alpha-blended
// child controls to draw the part of their parent
// that they appear in front of.
// Sends a WM_ERASEBKGND message followed by a WM_PRINTCLIENT.
//
// hwnd - handle of the child control
//
// hdc - hdc of the child control
//
// dwFlags - if 0, only returns S_OK if the parent handled
// WM_PRINTCLIENT.
// - if DTPB_WINDOWDC is set, hdc is assumed to be a window DC,
// not a client DC.
// - if DTPB_USEERASEBKGND is set, the function will return S_OK
// without sending a WM_CTLCOLORSTATIC message if the parent
// actually painted on WM_ERASEBKGND.
// - if DTPB_CTLCOLORSTATIC is set, the function will send
// a WM_CTLCOLORSTATIC message to the parent and use the
// brush if one is provided, else COLOR_BTNFACE.
//
// prc - (optional) rect that defines the area to be
// drawn (CHILD coordinates)
//
// Return value - S_OK if something was painted, S_FALSE if not.
//---------------------------------------------------------------------------
THEMEAPI
DrawThemeParentBackgroundEx(
HWND hwnd,
HDC hdc,
DWORD dwFlags,
__in_opt const RECT* prc
);
enum WINDOWTHEMEATTRIBUTETYPE
{
WTA_NONCLIENT = 1
};
typedef struct _WTA_OPTIONS
{
DWORD dwFlags; // values for each style option specified in the bitmask
DWORD dwMask; // bitmask for flags that are changing
// valid options are: WTNCA_NODRAWCAPTION, WTNCA_NODRAWICON, WTNCA_NOSYSMENU
} WTA_OPTIONS, *PWTA_OPTIONS;
#define WTNCA_NODRAWCAPTION 0x00000001 // don't draw the window caption
#define WTNCA_NODRAWICON 0x00000002 // don't draw the system icon
#define WTNCA_NOSYSMENU 0x00000004 // don't expose the system menu icon functionality
#define WTNCA_NOMIRRORHELP 0x00000008 // don't mirror the question mark, even in RTL layout
#define WTNCA_VALIDBITS (WTNCA_NODRAWCAPTION | \
WTNCA_NODRAWICON | \
WTNCA_NOSYSMENU | \
WTNCA_NOMIRRORHELP)
THEMEAPI
SetWindowThemeAttribute(
HWND hwnd,
enum WINDOWTHEMEATTRIBUTETYPE eAttribute,
__in_bcount(cbAttribute) PVOID pvAttribute,
DWORD cbAttribute
);
__inline HRESULT SetWindowThemeNonClientAttributes(HWND hwnd, DWORD dwMask, DWORD dwAttributes)
{
WTA_OPTIONS wta;
wta.dwFlags = dwAttributes;
wta.dwMask = dwMask;
return SetWindowThemeAttribute(hwnd, WTA_NONCLIENT, (void*)&(wta), sizeof(wta));
}
#endif // #if (_WIN32_WINNT >= 0x0600)
//---------------------------------------------------------------------------
//
// DrawThemeTextEx
//
// Note: DrawThemeTextEx only exists on Windows Vista and higher, but the
// following declarations are provided to enable declaring its prototype when
// compiling for all platforms.
// Callback function used by DrawThemeTextEx, instead of DrawText
typedef
int
(WINAPI *DTT_CALLBACK_PROC)
(
__in HDC hdc,
__inout_ecount(cchText) LPWSTR pszText,
__in int cchText,
__inout LPRECT prc,
__in UINT dwFlags,
__in LPARAM lParam);
//---- bits used in dwFlags of DTTOPTS ----
#define DTT_TEXTCOLOR (1UL << 0) // crText has been specified
#define DTT_BORDERCOLOR (1UL << 1) // crBorder has been specified
#define DTT_SHADOWCOLOR (1UL << 2) // crShadow has been specified
#define DTT_SHADOWTYPE (1UL << 3) // iTextShadowType has been specified
#define DTT_SHADOWOFFSET (1UL << 4) // ptShadowOffset has been specified
#define DTT_BORDERSIZE (1UL << 5) // iBorderSize has been specified
#define DTT_FONTPROP (1UL << 6) // iFontPropId has been specified
#define DTT_COLORPROP (1UL << 7) // iColorPropId has been specified
#define DTT_STATEID (1UL << 8) // IStateId has been specified
#define DTT_CALCRECT (1UL << 9) // Use pRect as and in/out parameter
#define DTT_APPLYOVERLAY (1UL << 10) // fApplyOverlay has been specified
#define DTT_GLOWSIZE (1UL << 11) // iGlowSize has been specified
#define DTT_CALLBACK (1UL << 12) // pfnDrawTextCallback has been specified
#define DTT_COMPOSITED (1UL << 13) // Draws text with antialiased alpha (needs a DIB section)
#define DTT_VALIDBITS (DTT_TEXTCOLOR | \
DTT_BORDERCOLOR | \
DTT_SHADOWCOLOR | \
DTT_SHADOWTYPE | \
DTT_SHADOWOFFSET | \
DTT_BORDERSIZE | \
DTT_FONTPROP | \
DTT_COLORPROP | \
DTT_STATEID | \
DTT_CALCRECT | \
DTT_APPLYOVERLAY | \
DTT_GLOWSIZE | \
DTT_COMPOSITED)
typedef struct _DTTOPTS
{
DWORD dwSize; // size of the struct
DWORD dwFlags; // which options have been specified
COLORREF crText; // color to use for text fill
COLORREF crBorder; // color to use for text outline
COLORREF crShadow; // color to use for text shadow
int iTextShadowType; // TST_SINGLE or TST_CONTINUOUS
POINT ptShadowOffset; // where shadow is drawn (relative to text)
int iBorderSize; // Border radius around text
int iFontPropId; // Font property to use for the text instead of TMT_FONT
int iColorPropId; // Color property to use for the text instead of TMT_TEXTCOLOR
int iStateId; // Alternate state id
BOOL fApplyOverlay; // Overlay text on top of any text effect?
int iGlowSize; // Glow radious around text
DTT_CALLBACK_PROC pfnDrawTextCallback; // Callback for DrawText
LPARAM lParam; // Parameter for callback
} DTTOPTS, *PDTTOPTS;
#if (_WIN32_WINNT >= 0x0600)
THEMEAPI
DrawThemeTextEx(
HTHEME hTheme,
HDC hdc,
int iPartId,
int iStateId,
__in_ecount(cchText) LPCWSTR pszText,
int cchText,
DWORD dwTextFlags,
__inout LPRECT pRect,
__in_opt const DTTOPTS *pOptions
);
//-----------------------------------------------------------------------
// GetThemeStream() - Get the value for the specified STREAM property
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// ppvStream - if non-null receives the value of the STREAM property (not to be freed)
// pcbStream - if non-null receives the size of the STREAM property
// hInst - NULL when iPropId==TMT_STREAM, HINSTANCE of a loaded msstyles
// file when iPropId==TMT_DISKSTREAM (use GetCurrentThemeName
// and LoadLibraryEx(LOAD_LIBRARY_AS_DATAFILE)
//-----------------------------------------------------------------------
THEMEAPI
GetThemeBitmap(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
ULONG dwFlags,
__out HBITMAP* phBitmap
);
//-----------------------------------------------------------------------
// GetThemeStream() - Get the value for the specified STREAM property
//
// hTheme - theme data handle
// iPartId - part number
// iStateId - state number of part
// iPropId - the property number to get the value for
// ppvStream - if non-null receives the value of the STREAM property (not to be freed)
// pcbStream - if non-null receives the size of the STREAM property
// hInst - NULL when iPropId==TMT_STREAM, HINSTANCE of a loaded msstyles
// file when iPropId==TMT_DISKSTREAM (use GetCurrentThemeName
// and LoadLibraryEx(LOAD_LIBRARY_AS_DATAFILE)
//-----------------------------------------------------------------------
THEMEAPI
GetThemeStream(
HTHEME hTheme,
int iPartId,
int iStateId,
int iPropId,
__out VOID **ppvStream,
__out_opt DWORD *pcbStream,
__in_opt HINSTANCE hInst
);
//------------------------------------------------------------------------
// BufferedPaintInit() - Initialize the Buffered Paint API.
// Should be called prior to BeginBufferedPaint,
// and should have a matching BufferedPaintUnInit.
//------------------------------------------------------------------------
THEMEAPI
BufferedPaintInit(
VOID
);
//------------------------------------------------------------------------
// BufferedPaintUnInit() - Uninitialize the Buffered Paint API.
// Should be called once for each call to BufferedPaintInit,
// when calls to BeginBufferedPaint are no longer needed.
//------------------------------------------------------------------------
THEMEAPI
BufferedPaintUnInit(
VOID
);
//------------------------------------------------------------------------
// BeginBufferedPaint() - Begins a buffered paint operation.
//
// hdcTarget - Target DC on which the buffer will be painted
// rcTarget - Rectangle specifying the area of the target DC to paint to
// dwFormat - Format of the buffer (see BP_BUFFERFORMAT)
// pPaintParams - Paint operation parameters (see BP_PAINTPARAMS)
// phBufferedPaint - Pointer to receive handle to new buffered paint context
//------------------------------------------------------------------------
// HPAINTBUFFER
typedef HANDLE HPAINTBUFFER; // handle to a buffered paint context
// BP_BUFFERFORMAT
typedef enum _BP_BUFFERFORMAT
{
BPBF_COMPATIBLEBITMAP, // Compatible bitmap
BPBF_DIB, // Device-independent bitmap
BPBF_TOPDOWNDIB, // Top-down device-independent bitmap
BPBF_TOPDOWNMONODIB // Top-down monochrome device-independent bitmap
} BP_BUFFERFORMAT;
#define BPBF_COMPOSITED BPBF_TOPDOWNDIB
// BP_ANIMATIONSTYLE
typedef enum _BP_ANIMATIONSTYLE
{
BPAS_NONE, // No animation
BPAS_LINEAR, // Linear fade animation
BPAS_CUBIC, // Cubic fade animation
BPAS_SINE // Sinusoid fade animation
} BP_ANIMATIONSTYLE;
// BP_ANIMATIONPARAMS
typedef struct _BP_ANIMATIONPARAMS
{
DWORD cbSize;
DWORD dwFlags; // BPAF_ flags
BP_ANIMATIONSTYLE style;
DWORD dwDuration;
} BP_ANIMATIONPARAMS, *PBP_ANIMATIONPARAMS;
#define BPPF_ERASE 0x0001 // Empty the buffer during BeginBufferedPaint()
#define BPPF_NOCLIP 0x0002 // Don't apply the target DC's clip region to the double buffer
#define BPPF_NONCLIENT 0x0004 // Using a non-client DC
// BP_PAINTPARAMS
typedef struct _BP_PAINTPARAMS
{
DWORD cbSize;
DWORD dwFlags; // BPPF_ flags
const RECT * prcExclude;
const BLENDFUNCTION * pBlendFunction;
} BP_PAINTPARAMS, *PBP_PAINTPARAMS;
THEMEAPI_(__success(return != NULL) HPAINTBUFFER)
BeginBufferedPaint(
HDC hdcTarget,
const RECT* prcTarget,
BP_BUFFERFORMAT dwFormat,
__in_opt BP_PAINTPARAMS *pPaintParams,
__out HDC *phdc
);
//------------------------------------------------------------------------
// EndBufferedPaint() - Ends a buffered paint operation.
//
// hBufferedPaint - handle to buffered paint context
// fUpdateTarget - update target DC
//------------------------------------------------------------------------
THEMEAPI
EndBufferedPaint(
HPAINTBUFFER hBufferedPaint,
BOOL fUpdateTarget
);
//------------------------------------------------------------------------
// GetBufferedPaintTargetRect() - Returns the target rectangle specified during BeginBufferedPaint
//
// hBufferedPaint - handle to buffered paint context
// prc - pointer to receive target rectangle
//------------------------------------------------------------------------
THEMEAPI
GetBufferedPaintTargetRect(
HPAINTBUFFER hBufferedPaint,
__out RECT *prc
);
//------------------------------------------------------------------------
// GetBufferedPaintTargetDC() - Returns the target DC specified during BeginBufferedPaint
//
// hBufferedPaint - handle to buffered paint context
//------------------------------------------------------------------------
THEMEAPI_(HDC)
GetBufferedPaintTargetDC(
HPAINTBUFFER hBufferedPaint
);
//------------------------------------------------------------------------
// GetBufferedPaintDC() - Returns the same paint DC returned by BeginBufferedPaint
//
// hBufferedPaint - handle to buffered paint context
//------------------------------------------------------------------------
THEMEAPI_(HDC)
GetBufferedPaintDC(
HPAINTBUFFER hBufferedPaint
);
//------------------------------------------------------------------------
// GetBufferedPaintBits() - Obtains a pointer to the buffer bitmap, if the buffer is a DIB
//
// hBufferedPaint - handle to buffered paint context
// ppbBuffer - pointer to receive pointer to buffer bitmap pixels
// pcxRow - pointer to receive width of buffer bitmap, in pixels;
// this value may not necessarily be equal to the buffer width
//------------------------------------------------------------------------
THEMEAPI
GetBufferedPaintBits(
HPAINTBUFFER hBufferedPaint,
__out RGBQUAD **ppbBuffer,
__out int *pcxRow
);
//------------------------------------------------------------------------
// BufferedPaintClear() - Clears given rectangle to ARGB = {0, 0, 0, 0}
//
// hBufferedPaint - handle to buffered paint context
// prc - rectangle to clear; NULL specifies entire buffer
//------------------------------------------------------------------------
THEMEAPI
BufferedPaintClear(
HPAINTBUFFER hBufferedPaint,
__in_opt const RECT *prc
);
//------------------------------------------------------------------------
// BufferedPaintSetAlpha() - Set alpha to given value in given rectangle
//
// hBufferedPaint - handle to buffered paint context
// prc - rectangle to set alpha in; NULL specifies entire buffer
// alpha - alpha value to set in the given rectangle
//------------------------------------------------------------------------
THEMEAPI
BufferedPaintSetAlpha(
HPAINTBUFFER hBufferedPaint,
__in_opt const RECT *prc,
BYTE alpha
);
// Macro for setting the buffer to opaque (alpha = 255)
#define BufferedPaintMakeOpaque(hBufferedPaint, prc) BufferedPaintSetAlpha(hBufferedPaint, prc, 255)
//------------------------------------------------------------------------
// BufferedPaintStopAllAnimations() - Stop all buffer animations for the given window
//
// hwnd - window on which to stop all animations
//------------------------------------------------------------------------
THEMEAPI
BufferedPaintStopAllAnimations(
HWND hwnd
);
typedef HANDLE HANIMATIONBUFFER; // handle to a buffered paint animation
THEMEAPI_(HANIMATIONBUFFER)
BeginBufferedAnimation(
HWND hwnd,
HDC hdcTarget,
const RECT* prcTarget,
BP_BUFFERFORMAT dwFormat,
__in_opt BP_PAINTPARAMS *pPaintParams,
__in BP_ANIMATIONPARAMS *pAnimationParams,
__out HDC *phdcFrom,
__out HDC *phdcTo
);
THEMEAPI
EndBufferedAnimation(
HANIMATIONBUFFER hbpAnimation,
BOOL fUpdateTarget
);
THEMEAPI_(BOOL)
BufferedPaintRenderAnimation(
HWND hwnd,
HDC hdcTarget
);
//----------------------------------------------------------------------------
// Tells if the DWM is running, and composition effects are possible for this
// process (themes are active).
// Roughly equivalent to "DwmIsCompositionEnabled() && IsAppthemed()"
//----------------------------------------------------------------------------
THEMEAPI_(BOOL) IsCompositionActive();
//------------------------------------------------------------------------
// GetThemeTransitionDuration()
// - Gets the duration for the specified transition
//
// hTheme - theme data handle
// iPartId - part number
// iStateIdFrom - starting state number of part
// iStateIdTo - ending state number of part
// iPropId - property id
// pdwDuration - receives the transition duration
//------------------------------------------------------------------------
THEMEAPI
GetThemeTransitionDuration(
HTHEME hTheme,
int iPartId,
int iStateIdFrom,
int iStateIdTo,
int iPropId,
__out DWORD *pdwDuration
);
#endif // #if (_WIN32_WINNT >= 0x0600)
#endif /* _UXTHEME_H_ */
Reference in New Issue View Git Blame Copy Permalink