erabo/spiegel-keyman
1
0
Fork 0
mirror of https://github.com/keymanapp/keyman.git synced 2026-08-11 11:25:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 13
spiegel-keyman/common/windows/delphi/ext/jwa/Win32API/JwaUxTheme.pas
Marc Durdin fc7917cdca chore(windows): move JWA to common
2022-06-06 08:13:37 +10:00

1816 lines
68 KiB
ObjectPascal
Raw Blame History

{******************************************************************************}
{ }
{ Visual Styles (Themes) API interface Unit for Object Pascal }
{ }
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
{ Corporation. All Rights Reserved. }
{ }
{ The original file is: uxtheme.h, released June 2001. The original Pascal }
{ code is: UxTheme.pas, released July 2001. The initial developer of the }
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl). }
{ }
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
{ Marcel van Brakel. All Rights Reserved. }
{ }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
{ }
{ You may retrieve the latest version of this file at the Project JEDI }
{ APILIB home page, located at http://jedi-apilib.sourceforge.net }
{ }
{ The contents of this file are used with permission, subject to the Mozilla }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at }
{ http://www.mozilla.org/MPL/MPL-1.1.html }
{ }
{ Software distributed under the License is distributed on an "AS IS" basis, }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License. }
{ }
{ Alternatively, the contents of this file may be used under the terms of the }
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
{ provisions of the LGPL License are applicable instead of those above. }
{ If you wish to allow use of your version of this file only under the terms }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting the provisions above and }
{ replace them with the notice and other provisions required by the LGPL }
{ License. If you do not delete the provisions above, a recipient may use }
{ your version of this file under either the MPL or the LGPL License. }
{ }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ }
{******************************************************************************}
// $Id: JwaUxTheme.pas,v 1.11 2007/09/05 11:58:52 dezipaitor Exp $
{$IFNDEF JWA_OMIT_SECTIONS}
unit JwaUxTheme;
{$WEAKPACKAGEUNIT}
{$ENDIF JWA_OMIT_SECTIONS}
{$HPPEMIT ''}
{$HPPEMIT '#include "uxtheme.h"'}
{$HPPEMIT ''}
{$IFNDEF JWA_OMIT_SECTIONS}
{$I ..\Includes\JediAPILib.inc}
interface
uses
JwaWinType, JwaWinGDI;
{$ENDIF JWA_OMIT_SECTIONS}
{$IFNDEF JWA_IMPLEMENTATIONSECTION}
type
HIMAGELIST = HANDLE; // TODO TEMPORARY
type
HTHEME = HANDLE; // handle to a section of theme data for class
{$EXTERNALSYM HTHEME}
//---------------------------------------------------------------------------
// NOTE: PartId's and StateId's used in the theme API are defined in the
// hdr file <tmschema.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.
//---------------------------------------------------------------------------
function OpenThemeData(hwnd: HWND; pszClassList: LPCWSTR): HTHEME; stdcall;
{$EXTERNALSYM OpenThemeData}
//---------------------------------------------------------------------------
// 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).
//---------------------------------------------------------------------------
function CloseThemeData(hTheme: HTHEME): HRESULT; stdcall;
{$EXTERNALSYM CloseThemeData}
//---------------------------------------------------------------------------
// 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)
//------------------------------------------------------------------------
function DrawThemeBackground(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
const pRect: RECT; pClipRect: PRECT): HRESULT; stdcall;
{$EXTERNALSYM DrawThemeBackground}
//---------------------------------------------------------------------------
//----- DrawThemeText() flags ----
const
DTT_GRAYED = $1; // draw a grayed-out string
{$EXTERNALSYM 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
//-------------------------------------------------------------------------
function DrawThemeText(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
pszText: LPCWSTR; iCharCount: Integer; dwTextFlags, dwTextFlags2: DWORD;
const pRect: RECT): HRESULT; stdcall;
{$EXTERNALSYM DrawThemeText}
//-------------------------------------------------------------------------
// 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
//-------------------------------------------------------------------------
function GetThemeBackgroundContentRect(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
const pBoundingRect: RECT; pContentRect: PRECT): HRESULT; stdcall;
{$EXTERNALSYM GetThemeBackgroundContentRect}
//-------------------------------------------------------------------------
// 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
//-------------------------------------------------------------------------
function GetThemeBackgroundExtent(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
const pContentRect: RECT; var pExtentRect: RECT): HRESULT; stdcall;
{$EXTERNALSYM GetThemeBackgroundExtent}
//-------------------------------------------------------------------------
type
THEMESIZE = (
TS_MIN, // minimum size
TS_TRUE, // size without stretching
TS_DRAW); // size that theme mgr will use to draw part
{$EXTERNALSYM THEMESIZE}
TThemeSize = THEMESIZE;
//-------------------------------------------------------------------------
// 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
//-------------------------------------------------------------------------
function GetThemePartSize(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
prc: PRECT; eSize: THEMESIZE; var psz: TSize): HRESULT; stdcall;
{$EXTERNALSYM GetThemePartSize}
//-------------------------------------------------------------------------
// 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
//-------------------------------------------------------------------------
function GetThemeTextExtent(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
pszText: LPCWSTR; iCharCount: Integer; dwTextFlags: DWORD; pBoundingRect: PRECT;
var pExtentRect: RECT): HRESULT; stdcall;
{$EXTERNALSYM GetThemeTextExtent}
//-------------------------------------------------------------------------
// 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
//-------------------------------------------------------------------------
function GetThemeTextMetrics(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
var ptm: TEXTMETRIC): HRESULT; stdcall;
{$EXTERNALSYM GetThemeTextMetrics}
//-------------------------------------------------------------------------
// 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
//-------------------------------------------------------------------------
function GetThemeBackgroundRegion(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
const pRect: RECT; var pRegion: HRGN): HRESULT; stdcall;
{$EXTERNALSYM GetThemeBackgroundRegion}
//-------------------------------------------------------------------------
//----- 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.
const
HTTB_BACKGROUNDSEG = $0000;
{$EXTERNALSYM HTTB_BACKGROUNDSEG}
// 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
HTTB_FIXEDBORDER = $0002; // Return code may be either HTCLIENT or HTBORDER.
{$EXTERNALSYM HTTB_FIXEDBORDER}
// 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.
HTTB_CAPTION = $0004;
{$EXTERNALSYM HTTB_CAPTION}
// 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
HTTB_RESIZINGBORDER_LEFT = $0010; // Hit test left resizing border,
{$EXTERNALSYM HTTB_RESIZINGBORDER_LEFT}
HTTB_RESIZINGBORDER_TOP = $0020; // Hit test top resizing border
{$EXTERNALSYM HTTB_RESIZINGBORDER_TOP}
HTTB_RESIZINGBORDER_RIGHT = $0040; // Hit test right resizing border
{$EXTERNALSYM HTTB_RESIZINGBORDER_RIGHT}
HTTB_RESIZINGBORDER_BOTTOM = $0080; // Hit test bottom resizing border
{$EXTERNALSYM HTTB_RESIZINGBORDER_BOTTOM}
HTTB_RESIZINGBORDER = (HTTB_RESIZINGBORDER_LEFT or HTTB_RESIZINGBORDER_TOP or
HTTB_RESIZINGBORDER_RIGHT or HTTB_RESIZINGBORDER_BOTTOM);
{$EXTERNALSYM HTTB_RESIZINGBORDER}
// Resizing border is specified as a template, not just window edges.
// This option is mutually exclusive with HTTB_SYSTEMSIZINGWIDTH; HTTB_SIZINGTEMPLATE takes precedence
HTTB_SIZINGTEMPLATE = $0100;
{$EXTERNALSYM HTTB_SIZINGTEMPLATE}
// Use system resizing border width rather than theme content margins.
// This option is mutually exclusive with HTTB_SIZINGTEMPLATE, which takes precedence.
HTTB_SYSTEMSIZINGMARGINS = $0200;
{$EXTERNALSYM HTTB_SYSTEMSIZINGMARGINS}
//-------------------------------------------------------------------------
// 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
//-------------------------------------------------------------------------
function HitTestThemeBackground(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
dwOptions: DWORD; const pRect: RECT; hrgn: HRGN; ptTest: POINT; var pwHitTestCode: WORD): HRESULT; stdcall;
{$EXTERNALSYM HitTestThemeBackground}
//------------------------------------------------------------------------
// 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)
//------------------------------------------------------------------------
function DrawThemeEdge(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
const pDestRect: RECT; uEdge, uFlags: UINT; pContentRect: PRECT): HRESULT; stdcall;
{$EXTERNALSYM DrawThemeEdge}
//------------------------------------------------------------------------
// 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)
//------------------------------------------------------------------------
function DrawThemeIcon(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer;
const pRect: RECT; himl: HIMAGELIST; iImageIndex: Integer): HRESULT; stdcall;
{$EXTERNALSYM DrawThemeIcon}
//---------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
function IsThemePartDefined(hTheme: HTHEME; iPartId, iStateId: Integer): BOOL; stdcall;
{$EXTERNALSYM IsThemePartDefined}
//---------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
function IsThemeBackgroundPartiallyTransparent(hTheme: HTHEME; iPartId, iStateId: Integer): BOOL; stdcall;
{$EXTERNALSYM IsThemeBackgroundPartiallyTransparent}
//---------------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemeColor(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
var pColor: COLORREF): HRESULT; stdcall;
{$EXTERNALSYM GetThemeColor}
//-----------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemeMetric(hTheme: HTHEME; hdc: HDC; iPartId, iStateId, iPropId: Integer;
var piVal: Integer): HRESULT; stdcall;
{$EXTERNALSYM GetThemeMetric}
//-----------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemeString(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
pszBuff: LPWSTR; cchMaxBuffChars: Integer): HRESULT; stdcall;
{$EXTERNALSYM GetThemeString}
//-----------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemeBool(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
var pfVal: BOOL): HRESULT; stdcall;
{$EXTERNALSYM GetThemeBool}
//-----------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemeInt(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
var piVal: Integer): HRESULT; stdcall;
{$EXTERNALSYM GetThemeInt}
//-----------------------------------------------------------------------
// 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*)
//-----------------------------------------------------------------------
function GetThemeEnumValue(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
var piVal: Integer): HRESULT; stdcall;
{$EXTERNALSYM GetThemeEnumValue}
//-----------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemePosition(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
var pPoint: POINT): HRESULT; stdcall;
{$EXTERNALSYM GetThemePosition}
//-----------------------------------------------------------------------
// 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)
//-----------------------------------------------------------------------
function GetThemeFont(hTheme: HTHEME; hdc: HDC; iPartId, iStateId, iPropId: Integer;
var pFont: LOGFONT): HRESULT; stdcall;
{$EXTERNALSYM GetThemeFont}
//-----------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemeRect(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
var pRect: RECT): HRESULT; stdcall;
{$EXTERNALSYM GetThemeRect}
//-----------------------------------------------------------------------
type
_MARGINS = record
cxLeftWidth: Integer; // width of left border that retains its size
cxRightWidth: Integer; // width of right border that retains its size
cyTopHeight: Integer; // height of top border that retains its size
cyBottomHeight: Integer; // height of bottom border that retains its size
end;
{$EXTERNALSYM _MARGINS}
MARGINS = _MARGINS;
{$EXTERNALSYM MARGINS}
PMARGINS = ^MARGINS;
{$EXTERNALSYM PMARGINS}
TMargins = MARGINS;
//-----------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemeMargins(hTheme: HTHEME; hdc: HDC; iPartId, iStateId, iPropId: Integer;
prc: PRECT; var pMargins: MARGINS): HRESULT; stdcall;
{$EXTERNALSYM GetThemeMargins}
//-----------------------------------------------------------------------
const
MAX_INTLIST_COUNT = 10;
{$EXTERNALSYM MAX_INTLIST_COUNT}
type
_INTLIST = record
iValueCount: Integer; // number of values in iValues
iValues: array [0..MAX_INTLIST_COUNT - 1] of Integer;
end;
{$EXTERNALSYM _INTLIST}
INTLIST = _INTLIST;
{$EXTERNALSYM INTLIST}
PINTLIST = ^INTLIST;
{$EXTERNALSYM PINTLIST}
TIntList = INTLIST;
//-----------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemeIntList(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
var pIntList: INTLIST): HRESULT; stdcall;
{$EXTERNALSYM GetThemeIntList}
//-----------------------------------------------------------------------
type
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
{$EXTERNALSYM PROPERTYORIGIN}
TPropertyOrigin = PROPERTYORIGIN;
//-----------------------------------------------------------------------
// 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
//-----------------------------------------------------------------------
function GetThemePropertyOrigin(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
var pOrigin: PROPERTYORIGIN): HRESULT; stdcall;
{$EXTERNALSYM GetThemePropertyOrigin}
//---------------------------------------------------------------------------
// 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.
//---------------------------------------------------------------------------
function SetWindowTheme(hwnd: HWND; pszSubAppName: LPCWSTR; pszSubIdList: LPCWSTR): HRESULT; stdcall;
{$EXTERNALSYM SetWindowTheme}
//---------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
function GetThemeFilename(hTheme: HTHEME; iPartId, iStateId, iPropId: Integer;
pszThemeFileName: LPWSTR; cchMaxBuffChars: Integer): HRESULT; stdcall;
{$EXTERNALSYM GetThemeFilename}
//---------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
function GetThemeSysColor(hTheme: HTHEME; iColorId: Integer): COLORREF; stdcall;
{$EXTERNALSYM GetThemeSysColor}
//---------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
function GetThemeSysColorBrush(hTheme: HTHEME; iColorId: Integer): HBRUSH; stdcall;
{$EXTERNALSYM GetThemeSysColorBrush}
//---------------------------------------------------------------------------
// 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)
//---------------------------------------------------------------------------
function GetThemeSysBool(hTheme: HTHEME; iBoolId: Integer): BOOL; stdcall;
{$EXTERNALSYM GetThemeSysBool}
//---------------------------------------------------------------------------
// 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)
//
// when hTheme is NULL, iSizeId is passed directly
// to the GetSystemMetrics() function
//---------------------------------------------------------------------------
function GetThemeSysSize(hTheme: HTHEME; iSizeId: Integer): Integer; stdcall;
{$EXTERNALSYM GetThemeSysSize}
//---------------------------------------------------------------------------
// 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)
//---------------------------------------------------------------------------
function GetThemeSysFont(hTheme: HTHEME; iFontId: Integer; var plf: LOGFONT): HRESULT; stdcall;
{$EXTERNALSYM GetThemeSysFont}
//---------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
function GetThemeSysString(hTheme: HTHEME; iStringId: Integer;
pszStringBuff: LPWSTR; cchMaxStringChars: Integer): HRESULT; stdcall;
{$EXTERNALSYM GetThemeSysString}
//---------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
function GetThemeSysInt(hTheme: HTHEME; iIntId: Integer; var piValue: Integer): HRESULT; stdcall;
{$EXTERNALSYM GetThemeSysInt}
//---------------------------------------------------------------------------
// 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.
//---------------------------------------------------------------------------
function IsThemeActive: BOOL; stdcall;
{$EXTERNALSYM IsThemeActive}
//---------------------------------------------------------------------------
// IsAppThemed() - returns TRUE if a theme is active and available to
// the current process
//---------------------------------------------------------------------------
function IsAppThemed: BOOL; stdcall;
{$EXTERNALSYM IsAppThemed}
//---------------------------------------------------------------------------
// GetWindowTheme() - if window is themed, returns its most recent
// HTHEME from OpenThemeData() - otherwise, returns
// NULL.
//
// hwnd - the window to get the HTHEME of
//---------------------------------------------------------------------------
function GetWindowTheme(hwnd: HWND): HTHEME; stdcall;
{$EXTERNALSYM GetWindowTheme}
//---------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
const
ETDT_DISABLE = $00000001;
{$EXTERNALSYM ETDT_DISABLE}
ETDT_ENABLE = $00000002;
{$EXTERNALSYM ETDT_ENABLE}
ETDT_USETABTEXTURE = $00000004;
{$EXTERNALSYM ETDT_USETABTEXTURE}
ETDT_ENABLETAB = ETDT_ENABLE or ETDT_USETABTEXTURE;
{$EXTERNALSYM ETDT_ENABLETAB}
function EnableThemeDialogTexture(hwnd: HWND; dwFlags: DWORD): HRESULT; stdcall;
{$EXTERNALSYM EnableThemeDialogTexture}
//---------------------------------------------------------------------------
// IsThemeDialogTextureEnabled()
//
// - Reports whether the dialog supports background texturing.
//
// hdlg - the window handle of the target dialog
//---------------------------------------------------------------------------
function IsThemeDialogTextureEnabled(hwnd: HWND): BOOL; stdcall;
{$EXTERNALSYM IsThemeDialogTextureEnabled}
//---------------------------------------------------------------------------
//---- flags to control theming within an app ----
const
STAP_ALLOW_NONCLIENT = 1 shl 0;
{$EXTERNALSYM STAP_ALLOW_NONCLIENT}
STAP_ALLOW_CONTROLS = 1 shl 1;
{$EXTERNALSYM STAP_ALLOW_CONTROLS}
STAP_ALLOW_WEBCONTENT = 1 shl 2;
{$EXTERNALSYM STAP_ALLOW_WEBCONTENT}
//---------------------------------------------------------------------------
// GetThemeAppProperties()
// - returns the app property flags that control theming
//---------------------------------------------------------------------------
function GetThemeAppProperties: DWORD; stdcall;
{$EXTERNALSYM GetThemeAppProperties}
//---------------------------------------------------------------------------
// SetThemeAppProperties()
// - sets the flags that control theming within the app
//
// dwFlags - the flag values to be set
//---------------------------------------------------------------------------
procedure SetThemeAppProperties(dwFlags: DWORD); stdcall;
{$EXTERNALSYM SetThemeAppProperties}
//---------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
function GetCurrentThemeName(pszThemeFileName: LPWSTR; cchMaxNameChars: Integer; pszColorBuff: LPWSTR;
cchMaxColorChars: Integer; pszSizeBuff: LPWSTR; cchMaxSizeChars: Integer): HRESULT; stdcall;
{$EXTERNALSYM GetCurrentThemeName}
//---------------------------------------------------------------------------
// GetThemeDocumentationProperty()
// - Get the value for the specified property name from
// the [documentation] section of the themes.ini file
// for the specified theme. If the property has been
// localized in the theme files string table, the
// localized version of the property value is returned.
//
// pszThemeFileName - filename of the theme file to query
// pszPropertyName - name of the string property to retreive a value for
// pszValueBuff - receives the property string value
// cchMaxValChars - max chars allowed in pszValueBuff
//---------------------------------------------------------------------------
const
SZ_THDOCPROP_DISPLAYNAME = WideString('DisplayName');
{$EXTERNALSYM SZ_THDOCPROP_DISPLAYNAME}
SZ_THDOCPROP_CANONICALNAME = WideString('ThemeName');
{$EXTERNALSYM SZ_THDOCPROP_CANONICALNAME}
SZ_THDOCPROP_TOOLTIP = WideString('ToolTip');
{$EXTERNALSYM SZ_THDOCPROP_TOOLTIP}
SZ_THDOCPROP_AUTHOR = WideString('author');
{$EXTERNALSYM SZ_THDOCPROP_AUTHOR}
function GetThemeDocumentationProperty(pszThemeName, pszPropertyName: LPCWSTR;
pszValueBuff: LPWSTR; cchMaxValChars: Integer): HRESULT; stdcall;
{$EXTERNALSYM GetThemeDocumentationProperty}
//---------------------------------------------------------------------------
// 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)
//---------------------------------------------------------------------------
function DrawThemeParentBackground(hwnd: HWND; hdc: HDC; prc: PRECT): HRESULT; stdcall;
{$EXTERNALSYM DrawThemeParentBackground}
//---------------------------------------------------------------------------
// 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.
//---------------------------------------------------------------------------
function EnableTheming(fEnable: BOOL): HRESULT; stdcall;
{$EXTERNALSYM EnableTheming}
//------------------------------------------------------------------------
//---- bits used in dwFlags of DTBGOPTS ----
const
DTBG_CLIPRECT = $00000001; // rcClip has been specified
{$EXTERNALSYM DTBG_CLIPRECT}
DTBG_DRAWSOLID = $00000002; // draw transparent/alpha images as solid
{$EXTERNALSYM DTBG_DRAWSOLID}
DTBG_OMITBORDER = $00000004; // don't draw border of part
{$EXTERNALSYM DTBG_OMITBORDER}
DTBG_OMITCONTENT = $00000008; // don't draw content area of part
{$EXTERNALSYM DTBG_OMITCONTENT}
DTBG_COMPUTINGREGION = $00000010; // TRUE if calling to compute region
{$EXTERNALSYM DTBG_COMPUTINGREGION}
DTBG_MIRRORDC = $00000020; // assume the hdc is mirrorred and
// flip images as appropriate (currently
// only supported for bgtype=imagefile)
{$EXTERNALSYM DTBG_MIRRORDC}
//------------------------------------------------------------------------
type
_DTBGOPTS = record
dwSize: DWORD; // size of the struct
dwFlags: DWORD; // which options have been specified
rcClip: RECT; // clipping rectangle
end;
{$EXTERNALSYM _DTBGOPTS}
DTBGOPTS = _DTBGOPTS;
{$EXTERNALSYM DTBGOPTS}
PDTBGOPTS = ^DTBGOPTS;
TDtbgOpts = DTBGOPTS;
//------------------------------------------------------------------------
// 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
//------------------------------------------------------------------------
function DrawThemeBackgroundEx(hTheme: HTHEME; hdc: HDC; iPartId, iStateId: Integer; pRect: LPRECT; pOptions: PDTBGOPTS): HRESULT; stdcall;
{$EXTERNALSYM DrawThemeBackgroundEx}
{$ENDIF JWA_IMPLEMENTATIONSECTION}
{$IFNDEF JWA_OMIT_SECTIONS}
implementation
//uses ...
{$ENDIF JWA_OMIT_SECTIONS}
{$IFNDEF JWA_INTERFACESECTION}
{$IFNDEF JWA_INCLUDEMODE}
const
themelib = 'uxtheme.dll';
{$ENDIF JWA_INCLUDEMODE}
{$IFDEF DYNAMIC_LINK}
var
_OpenThemeData: Pointer;
function OpenThemeData;
begin
GetProcedureAddress(_OpenThemeData, themelib, 'OpenThemeData');
asm
MOV ESP, EBP
POP EBP
JMP [_OpenThemeData]
end;
end;
var
_CloseThemeData: Pointer;
function CloseThemeData;
begin
GetProcedureAddress(_CloseThemeData, themelib, 'CloseThemeData');
asm
MOV ESP, EBP
POP EBP
JMP [_CloseThemeData]
end;
end;
var
_DrawThemeBackground: Pointer;
function DrawThemeBackground;
begin
GetProcedureAddress(_DrawThemeBackground, themelib, 'DrawThemeBackground');
asm
MOV ESP, EBP
POP EBP
JMP [_DrawThemeBackground]
end;
end;
var
_DrawThemeText: Pointer;
function DrawThemeText;
begin
GetProcedureAddress(_DrawThemeText, themelib, 'DrawThemeText');
asm
MOV ESP, EBP
POP EBP
JMP [_DrawThemeText]
end;
end;
var
_GetThemeBackgroundContentRect: Pointer;
function GetThemeBackgroundContentRect;
begin
GetProcedureAddress(_GetThemeBackgroundContentRect, themelib, 'GetThemeBackgroundContentRect');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeBackgroundContentRect]
end;
end;
var
_GetThemeBackgroundExtent: Pointer;
function GetThemeBackgroundExtent;
begin
GetProcedureAddress(_GetThemeBackgroundExtent, themelib, 'GetThemeBackgroundContentRect');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeBackgroundExtent]
end;
end;
var
_GetThemePartSize: Pointer;
function GetThemePartSize;
begin
GetProcedureAddress(_GetThemePartSize, themelib, 'GetThemePartSize');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemePartSize]
end;
end;
var
_GetThemeTextExtent: Pointer;
function GetThemeTextExtent;
begin
GetProcedureAddress(_GetThemeTextExtent, themelib, 'GetThemeTextExtent');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeTextExtent]
end;
end;
var
_GetThemeTextMetrics: Pointer;
function GetThemeTextMetrics;
begin
GetProcedureAddress(_GetThemeTextMetrics, themelib, 'GetThemeTextMetrics');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeTextMetrics]
end;
end;
var
_GetThemeBackgroundRegion: Pointer;
function GetThemeBackgroundRegion;
begin
GetProcedureAddress(_GetThemeBackgroundRegion, themelib, 'GetThemeBackgroundRegion');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeBackgroundRegion]
end;
end;
var
_HitTestThemeBackground: Pointer;
function HitTestThemeBackground;
begin
GetProcedureAddress(_HitTestThemeBackground, themelib, 'HitTestThemeBackground');
asm
MOV ESP, EBP
POP EBP
JMP [_HitTestThemeBackground]
end;
end;
var
_DrawThemeEdge: Pointer;
function DrawThemeEdge;
begin
GetProcedureAddress(_DrawThemeEdge, themelib, 'DrawThemeEdge');
asm
MOV ESP, EBP
POP EBP
JMP [_DrawThemeEdge]
end;
end;
var
_DrawThemeIcon: Pointer;
function DrawThemeIcon;
begin
GetProcedureAddress(_DrawThemeIcon, themelib, 'DrawThemeIcon');
asm
MOV ESP, EBP
POP EBP
JMP [_DrawThemeIcon]
end;
end;
var
_IsThemePartDefined: Pointer;
function IsThemePartDefined;
begin
GetProcedureAddress(_IsThemePartDefined, themelib, 'IsThemePartDefined');
asm
MOV ESP, EBP
POP EBP
JMP [_IsThemePartDefined]
end;
end;
var
_IsThemeBackgroundPartialTrans: Pointer;
function IsThemeBackgroundPartiallyTransparent;
begin
GetProcedureAddress(_IsThemeBackgroundPartialTrans, themelib, 'IsThemeBackgroundPartiallyTransparent');
asm
MOV ESP, EBP
POP EBP
JMP [_IsThemeBackgroundPartialTrans]
end;
end;
var
_GetThemeColor: Pointer;
function GetThemeColor;
begin
GetProcedureAddress(_GetThemeColor, themelib, 'GetThemeColor');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeColor]
end;
end;
var
_GetThemeMetric: Pointer;
function GetThemeMetric;
begin
GetProcedureAddress(_GetThemeMetric, themelib, 'GetThemeMetric');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeMetric]
end;
end;
var
_GetThemeString: Pointer;
function GetThemeString;
begin
GetProcedureAddress(_GetThemeString, themelib, 'GetThemeString');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeString]
end;
end;
var
_GetThemeBool: Pointer;
function GetThemeBool;
begin
GetProcedureAddress(_GetThemeBool, themelib, 'GetThemeBool');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeBool]
end;
end;
var
_GetThemeInt: Pointer;
function GetThemeInt;
begin
GetProcedureAddress(_GetThemeInt, themelib, 'GetThemeInt');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeInt]
end;
end;
var
_GetThemeEnumValue: Pointer;
function GetThemeEnumValue;
begin
GetProcedureAddress(_GetThemeEnumValue, themelib, 'GetThemeEnumValue');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeEnumValue]
end;
end;
var
_GetThemePosition: Pointer;
function GetThemePosition;
begin
GetProcedureAddress(_GetThemePosition, themelib, 'GetThemePosition');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemePosition]
end;
end;
var
_GetThemeFont: Pointer;
function GetThemeFont;
begin
GetProcedureAddress(_GetThemeFont, themelib, 'GetThemeFont');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeFont]
end;
end;
var
_GetThemeRect: Pointer;
function GetThemeRect;
begin
GetProcedureAddress(_GetThemeRect, themelib, 'GetThemeRect');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeRect]
end;
end;
var
_GetThemeMargins: Pointer;
function GetThemeMargins;
begin
GetProcedureAddress(_GetThemeMargins, themelib, 'GetThemeMargins');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeMargins]
end;
end;
var
_GetThemeIntList: Pointer;
function GetThemeIntList;
begin
GetProcedureAddress(_GetThemeIntList, themelib, 'GetThemeIntList');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeIntList]
end;
end;
var
_GetThemePropertyOrigin: Pointer;
function GetThemePropertyOrigin;
begin
GetProcedureAddress(_GetThemePropertyOrigin, themelib, 'GetThemePropertyOrigin');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemePropertyOrigin]
end;
end;
var
_SetWindowTheme: Pointer;
function SetWindowTheme;
begin
GetProcedureAddress(_SetWindowTheme, themelib, 'SetWindowTheme');
asm
MOV ESP, EBP
POP EBP
JMP [_SetWindowTheme]
end;
end;
var
_GetThemeFilename: Pointer;
function GetThemeFilename;
begin
GetProcedureAddress(_GetThemeFilename, themelib, 'GetThemeFilename');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeFilename]
end;
end;
var
_GetThemeSysColor: Pointer;
function GetThemeSysColor;
begin
GetProcedureAddress(_GetThemeSysColor, themelib, 'GetThemeSysColor');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeSysColor]
end;
end;
var
_GetThemeSysColorBrush: Pointer;
function GetThemeSysColorBrush;
begin
GetProcedureAddress(_GetThemeSysColorBrush, themelib, 'GetThemeSysColorBrush');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeSysColorBrush]
end;
end;
var
_GetThemeSysBool: Pointer;
function GetThemeSysBool;
begin
GetProcedureAddress(_GetThemeSysBool, themelib, 'GetThemeSysBool');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeSysBool]
end;
end;
var
_GetThemeSysSize: Pointer;
function GetThemeSysSize;
begin
GetProcedureAddress(_GetThemeSysSize, themelib, 'GetThemeSysSize');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeSysSize]
end;
end;
var
_GetThemeSysFont: Pointer;
function GetThemeSysFont;
begin
GetProcedureAddress(_GetThemeSysFont, themelib, 'GetThemeSysFont');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeSysFont]
end;
end;
var
_GetThemeSysString: Pointer;
function GetThemeSysString;
begin
GetProcedureAddress(_GetThemeSysString, themelib, 'GetThemeSysString');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeSysString]
end;
end;
var
_GetThemeSysInt: Pointer;
function GetThemeSysInt;
begin
GetProcedureAddress(_GetThemeSysInt, themelib, 'GetThemeSysInt');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeSysInt]
end;
end;
var
_IsThemeActive: Pointer;
function IsThemeActive;
begin
GetProcedureAddress(_IsThemeActive, themelib, 'IsThemeActive');
asm
MOV ESP, EBP
POP EBP
JMP [_IsThemeActive]
end;
end;
var
_IsAppThemed: Pointer;
function IsAppThemed;
begin
GetProcedureAddress(_IsAppThemed, themelib, 'IsAppThemed');
asm
MOV ESP, EBP
POP EBP
JMP [_IsAppThemed]
end;
end;
var
_GetWindowTheme: Pointer;
function GetWindowTheme;
begin
GetProcedureAddress(_GetWindowTheme, themelib, 'GetWindowTheme');
asm
MOV ESP, EBP
POP EBP
JMP [_GetWindowTheme]
end;
end;
var
_EnableThemeDialogTexture: Pointer;
function EnableThemeDialogTexture;
begin
GetProcedureAddress(_EnableThemeDialogTexture, themelib, 'EnableThemeDialogTexture');
asm
MOV ESP, EBP
POP EBP
JMP [_EnableThemeDialogTexture]
end;
end;
var
_IsThemeDialogTextureEnabled: Pointer;
function IsThemeDialogTextureEnabled;
begin
GetProcedureAddress(_IsThemeDialogTextureEnabled, themelib, 'IsThemeDialogTextureEnabled');
asm
MOV ESP, EBP
POP EBP
JMP [_IsThemeDialogTextureEnabled]
end;
end;
var
_GetThemeAppProperties: Pointer;
function GetThemeAppProperties;
begin
GetProcedureAddress(_GetThemeAppProperties, themelib, 'GetThemeAppProperties');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeAppProperties]
end;
end;
var
_SetThemeAppProperties: Pointer;
procedure SetThemeAppProperties;
begin
GetProcedureAddress(_SetThemeAppProperties, themelib, 'SetThemeAppProperties');
asm
MOV ESP, EBP
POP EBP
JMP [_SetThemeAppProperties]
end;
end;
var
_GetCurrentThemeName: Pointer;
function GetCurrentThemeName;
begin
GetProcedureAddress(_GetCurrentThemeName, themelib, 'GetCurrentThemeName');
asm
MOV ESP, EBP
POP EBP
JMP [_GetCurrentThemeName]
end;
end;
var
_GetThemeDocumentationProperty: Pointer;
function GetThemeDocumentationProperty;
begin
GetProcedureAddress(_GetThemeDocumentationProperty, themelib, 'GetThemeDocumentationProperty');
asm
MOV ESP, EBP
POP EBP
JMP [_GetThemeDocumentationProperty]
end;
end;
var
_DrawThemeParentBackground: Pointer;
function DrawThemeParentBackground;
begin
GetProcedureAddress(_DrawThemeParentBackground, themelib, 'DrawThemeParentBackground');
asm
MOV ESP, EBP
POP EBP
JMP [_DrawThemeParentBackground]
end;
end;
var
_EnableTheming: Pointer;
function EnableTheming;
begin
GetProcedureAddress(_EnableTheming, themelib, 'EnableTheming');
asm
MOV ESP, EBP
POP EBP
JMP [_EnableTheming]
end;
end;
var
_DrawThemeBackgroundEx: Pointer;
function DrawThemeBackgroundEx;
begin
GetProcedureAddress(_DrawThemeBackgroundEx, themelib, 'DrawThemeBackgroundEx');
asm
MOV ESP, EBP
POP EBP
JMP [_DrawThemeBackgroundEx]
end;
end;
{$ELSE}
function OpenThemeData; external themelib name 'OpenThemeData';
function CloseThemeData; external themelib name 'CloseThemeData';
function DrawThemeBackground; external themelib name 'DrawThemeBackground';
function DrawThemeText; external themelib name 'DrawThemeText';
function GetThemeBackgroundContentRect; external themelib name 'GetThemeBackgroundContentRect';
function GetThemeBackgroundExtent; external themelib name 'GetThemeBackgroundContentRect';
function GetThemePartSize; external themelib name 'GetThemePartSize';
function GetThemeTextExtent; external themelib name 'GetThemeTextExtent';
function GetThemeTextMetrics; external themelib name 'GetThemeTextMetrics';
function GetThemeBackgroundRegion; external themelib name 'GetThemeBackgroundRegion';
function HitTestThemeBackground; external themelib name 'HitTestThemeBackground';
function DrawThemeEdge; external themelib name 'DrawThemeEdge';
function DrawThemeIcon; external themelib name 'DrawThemeIcon';
function IsThemePartDefined; external themelib name 'IsThemePartDefined';
function IsThemeBackgroundPartiallyTransparent; external themelib name 'IsThemeBackgroundPartiallyTransparent';
function GetThemeColor; external themelib name 'GetThemeColor';
function GetThemeMetric; external themelib name 'GetThemeMetric';
function GetThemeString; external themelib name 'GetThemeString';
function GetThemeBool; external themelib name 'GetThemeBool';
function GetThemeInt; external themelib name 'GetThemeInt';
function GetThemeEnumValue; external themelib name 'GetThemeEnumValue';
function GetThemePosition; external themelib name 'GetThemePosition';
function GetThemeFont; external themelib name 'GetThemeFont';
function GetThemeRect; external themelib name 'GetThemeRect';
function GetThemeMargins; external themelib name 'GetThemeMargins';
function GetThemeIntList; external themelib name 'GetThemeIntList';
function GetThemePropertyOrigin; external themelib name 'GetThemePropertyOrigin';
function SetWindowTheme; external themelib name 'SetWindowTheme';
function GetThemeFilename; external themelib name 'GetThemeFilename';
function GetThemeSysColor; external themelib name 'GetThemeSysColor';
function GetThemeSysColorBrush; external themelib name 'GetThemeSysColorBrush';
function GetThemeSysBool; external themelib name 'GetThemeSysBool';
function GetThemeSysSize; external themelib name 'GetThemeSysSize';
function GetThemeSysFont; external themelib name 'GetThemeSysFont';
function GetThemeSysString; external themelib name 'GetThemeSysString';
function GetThemeSysInt; external themelib name 'GetThemeSysInt';
function IsThemeActive; external themelib name 'IsThemeActive';
function IsAppThemed; external themelib name 'IsAppThemed';
function GetWindowTheme; external themelib name 'GetWindowTheme';
function EnableThemeDialogTexture; external themelib name 'EnableThemeDialogTexture';
function IsThemeDialogTextureEnabled; external themelib name 'IsThemeDialogTextureEnabled';
function GetThemeAppProperties; external themelib name 'GetThemeAppProperties';
procedure SetThemeAppProperties; external themelib name 'SetThemeAppProperties';
function GetCurrentThemeName; external themelib name 'GetCurrentThemeName';
function GetThemeDocumentationProperty; external themelib name 'GetThemeDocumentationProperty';
function DrawThemeParentBackground; external themelib name 'DrawThemeParentBackground';
function EnableTheming; external themelib name 'EnableTheming';
function DrawThemeBackgroundEx; external themelib name 'DrawThemeBackgroundEx';
{$ENDIF DYNAMIC_LINK}
{$ENDIF JWA_INTERFACESECTION}
{$IFNDEF JWA_OMIT_SECTIONS}
end.
{$ENDIF JWA_OMIT_SECTIONS}
Reference in a new issue View git blame Copy permalink