unit my_apitest;
{$DEFINE _DEBUG}

interface
uses
	Classes,
	Windows,
	Graphics;

type
	T_ExecuteFunc = function(): String of object;

type
	T_Execute = class(TObject)
		FsName     : String;
		FFunc      : T_ExecuteFunc;

		constructor Create(sName: String; AFunc: T_ExecuteFunc);
		property Name: String         read FsName;
		property Func: T_ExecuteFunc  read FFunc;
	end;

type
	T_MyAPITest = class(TObject)
	private
		FTestItems  : TStrings; //テストするAPIのリスト
		FTestParams : TStrings; //テストするAPIの(結果を返すための)パラメータリスト
		FParamHints : TStrings; //パラメータのヒント

		FsDeclaration : String;   //関数宣言
		FsDescription : String;   //関数の説明

		FhWindowHandle : HWND;    //対象ウィンドウのハンドル
		FptMousePos    : TPoint;  //マウスポインタの位置(必要とするAPIのため)

		FsTestAPI      : String;  //テストするAPI
		FiParamIndex   : Integer; //テストするAPIのパラメータのインデックス

		procedure FSetName(sName: String);
		procedure FAddFunc(sName: String; AFunc: T_ExecuteFunc);
		function  FGetParamHint: String;

//以下テストするAPIのラッパー関数
		function FDwmGetWindowAttribute: String;
		function FGetAncestor: String;
//		function FGetClassInfoEx: String;
//		function FGetClassLong: String;
//		function FGetClassName: String;
//		function FGetClientRect: String;
		function FGetComboboxInfo: String;
		function FGetLayeredWindowAttributes: String;
		function FGetListBoxInfo: String;
		function FGetNextWindow: String;
		function FGetParent: String;
//		function FGetScrollBarInfo: String;
//		function FGetScrollInfo: String;
//		function FGetScrollPos: String;
//		function FGetScrollRange: String;
//		function FGetTitleBarInfo: String;
		function FGetTopWindow: String;
		function FGetWindow: String;
//		function FGetWindowInfo: String;
//		function FGetWindowLong: String;
		function FGetWindowPlacement: String;
//		function FGetWindowRect: String;
		function FGetWindowText: String;
		function FGetWindowTextLength: String;
//		function FIsWindowEnabled: String;
//		function FIsWindowUnicode: String;
//		function FRealGetWindowClass: String;

{
//TPointを引数にとるAPI
		function FChildWindowFromPoint: String;
		function FChildWindowFromPointEx: String;
		function FRealChildWindowFromPoint: String;
}
//メッセージ
//ComboBoxとListBox共通
		function FGet_LBIntValue (iValue: DWORD): String;
		function FGet_CBIntValue (iValue: DWORD): String;
		function FCBLB_GetCount  (hHandle: HWND; iMessage: UINT): String;
		function FCBLB_GetText   (hHandle: HWND; iMessage: UINT): String;
		function FCBLB_GetTextLen(hHandle: HWND; iMessage: UINT): String;

//ComboBox
		function FCB_GetCount: String;
		function FCB_GetCurSel: String;
		function FCB_GetLBText: String;
		function FCB_GetLBTextLen: String;

//ListBox
		function FLB_GetCount: String;
		function FLB_GetCurSel: String;
		function FLB_GetText: String;
		function FLB_GetTextLen: String;

//TrackBar
//		function FTBM_GETCHANNELRECT: String;
		function FTBM_GETNUMTICS: String;
		function FTBM_GETPOS: String;
		function FTBM_GETRANGEMAX: String;
		function FTBM_GETRANGEMIN: String;
		function FTBM_GETTHUMBLENGTH: String;
//		function FTBM_GETTHUMBRECT: String;
		function FTBM_GETTIC: String;
		function FTBM_GETTICPOS: String;

//WM_〜
		function FWM_GetText: String;
		function FWM_GetTextLength: String;
	protected
		procedure FAddParam(sParam, sHint: String);

		function  FGetBoolValue  (bValue: Boolean): String;
		function  FGetColorName  (clColor: TColor): String;
		function  FGetIntValue   (iValue: Integer): String;
		function  FGetHexValue   (iValue: DWORD; iPrec: Integer): String; overload;
		function  FGetHexValue   (iValue: Integer): String;               overload;
		function  FGetHexValue   (iValue: DWORD): String;                 overload;
		function  FGetPointValue (APoint: TPoint): String;
		function  FGetRectValue  (ARect: TRect): String;                overload;
		function  FGetRectValue  (ARect: TRect; bRet: Boolean): String; overload;
		function  FGetWindowValue(hHandle: HWND): String;
	public
		constructor Create;
		destructor  Destroy; override;
		procedure Clear;
		function IsNowAPI(sDeclaration: String): Boolean;
		function Execute(sTestAPI: String; hWindow: HWND; ptPos: TPoint; iParamIndex: Integer): String;

		property Name : String  read FsTestAPI write FSetName;
		property Index: Integer read FiParamIndex write FiParamIndex;

		property Declaration: String read  FsDeclaration write FsDeclaration;
		property Description: String read  FsDescription write FsDescription;
		property Items     : TStrings read FTestItems;
		property Params    : TStrings read FTestParams;
//		property ParamHints: TStrings read FParamHints;
		property ParamHint: String read FGetParamHint;
	end;


implementation
uses
{$IFDEF _DEBUG}
	_myDebug,
{$ENDIF}
	SysUtils,
	Messages,
	CommCtrl,
	general;


const
//constの定義でどうしても必要となる
	lcsCRLF = #13#10;
	lcsTITLE_CRLF  = #13#10; //#13#10;
	lcsSTRUCT_CRLF = #13#10;

	lcsSTRUCT_POINT =
lcsSTRUCT_CRLF +
'typedef struct tagPOINT {' + lcsCRLF +
'  LONG x;  //点のX座標' + lcsCRLF +
'  LONG y;  //点のY座標' + lcsCRLF +
'} POINT;'
;

	lcsSTRUCT_RECT =
lcsSTRUCT_CRLF +
'typedef struct tagRECT {' + lcsCRLF +
'  LONG left;    //左上隅のX座標' + lcsCRLF +
'  LONG top;     //左上隅のY座標' + lcsCRLF +
'  LONG right;   //右下隅のX座標' + lcsCRLF +
'  LONG bottom;  //右下隅のY座標' + lcsCRLF +
'} RECT;'
;


// T_Execute -------------------------------------------------------------------
constructor T_Execute.Create(sName: String; AFunc: T_ExecuteFunc);
begin
	FsName := sName;
	FFunc  := AFunc;
end;


// T_MyAPITest -----------------------------------------------------------------
procedure T_MyAPITest.FAddFunc(sName: String; AFunc: T_ExecuteFunc);
begin
	FTestItems.AddObject(sName, T_Execute.Create(sName, AFunc));
end;

constructor T_MyAPITest.Create;
begin
	inherited;

	FTestItems  := TStringList.Create;
	FTestParams := TStringList.Create;
	FParamHints := TStringList.Create;

	FAddFunc('DwmGetWindowAttribute',      FDwmGetWindowAttribute);

//ウィンドウ取得
	FAddFunc('GetAncestor',                FGetAncestor);
//	FAddFunc('GetClassInfoEx',             FGetClassInfoEx);
//	FAddFunc('GetClassLong',               FGetClassLong);
//	FAddFunc('GetClassName',               FGetClassName);
//	FAddFunc('GetClientRect',              FGetClientRect);
	FAddFunc('GetComboBoxInfo',            FGetComboBoxInfo);
	FAddFunc('GetLayeredWindowAttributes', FGetLayeredWindowAttributes);
	FAddFunc('GetListBoxInfo',             FGetListBoxInfo);
	FAddFunc('GetNextWindow',              FGetNextWindow);
	FAddFunc('GetParent',                  FGetParent);
	FAddFunc('GetTopWindow',               FGetTopWindow);
	FAddFunc('GetWindow',                  FGetWindow);
//	FAddFunc('GetWindowInfo',              FGetWindowInfo);
//	FAddFunc('GetWindowLong',              FGetWindowLong);
	FAddFunc('GetWindowPlacement',         FGetWindowPlacement);
//	FAddFunc('GetWindowRect',              FGetWindowRect);
	FAddFunc('GetWindowText',              FGetWindowText);
	FAddFunc('GetWindowTextLength',        FGetWindowTextLength);

{
	FAddFunc('GetScrollBarInfo',           FGetScrollBarInfo);
	FAddFunc('GetScrollInfo',              FGetScrollInfo);
	FAddFunc('GetScrollPos',               FGetScrollPos);
	FAddFunc('GetScrollRange',             FGetScrollRange);

	FAddFunc('GetTitleBarInfo',            FGetTitleBarInfo);

	FAddFunc('RealGetWindowClass',         FRealGetWindowClass);

//座標を引数に求める系
	FAddFunc('ChildWindowFromPoint',       FChildWindowFromPoint);
	FAddFunc('ChildWindowFromPointEx',     FChildWindowFromPointEx);
	FAddFunc('RealChildWindowFromPoint',   FRealChildWindowFromPoint);
}
//コンボボックスメッセージ
	FAddFunc('CB_GETCOUNT',     FCB_GetCount);
	FAddFunc('CB_GETCURSEL',    FCB_GetCurSel);
	FAddFunc('CB_GETLBTEXT',    FCB_GetLBText);
	FAddFunc('CB_GETLBTEXTLEN', FCB_GetLBTextLen);
//リストボックスメッセージ
	FAddFunc('LB_GETCOUNT',     FLB_GetCount);
	FAddFunc('LB_GETCURSEL',    FLB_GetCurSel);
	FAddFunc('LB_GETTEXT',      FLB_GetText);
	FAddFunc('LB_GETTEXTLEN',   FLB_GetTextLen);

//トラックバーメッセージ
//他のアプリの値を取得できないどころかエラーを吐かせてしまうこともあるのでコメントアウト
//	FAddFunc('TBM_GETCHANNELRECT', FTBM_GetChannelRECT);
	FAddFunc('TBM_GETNUMTICS',     FTBM_GetNumTics);
	FAddFunc('TBM_GETPOS',         FTBM_GetPos);
	FAddFunc('TBM_GETRANGEMAX',    FTBM_GetRangeMax);
	FAddFunc('TBM_GETRANGEMIN',    FTBM_GetRangeMin);
	FAddFunc('TBM_GETTHUMBLENGTH', FTBM_GetThumbLength);
//他のアプリの値を取得できないどころかエラーを吐かせてしまうこともあるのでコメントアウト
//	FAddFunc('TBM_GETTHUMBRECT',   FTBM_GetThumbRect);
	FAddFunc('TBM_GETTIC',         FTBM_GetTic);
	FAddFunc('TBM_GETTICPOS',      FTBM_GetTicPos);

//WM〜メッセージ
	FAddFunc('WM_GETTEXT',          FWM_GetText);
	FAddFunc('WM_GETTEXTLENGTH',    FWM_GetTextLength);
end;

destructor T_MyAPITest.Destroy;
var
	i: Integer;
begin
	Self.Clear;

	for i := 0 to FTestItems.Count -1
	do begin
		FTestItems.Objects[i].Free;
	end;
	FTestItems.Free;
	FTestParams.Free;
	FParamHints.Free;

	inherited;
end;

function T_MyAPITest.Execute(sTestAPI: String; hWindow: HWND; ptPos: TPoint; iParamIndex: Integer): String;
var
	i : Integer;
	l_Execute : T_Execute;
begin
	FhWindowHandle := hWindow;
	FptMousePos    := ptPos;
	FiParamIndex   := iParamIndex;

	for i := 0 to FTestItems.Count -1
	do begin
		l_Execute := T_Execute(FTestItems.Objects[i]);
		if (l_Execute.Name = sTestAPI)
		then begin
			Result := l_Execute.Func;
Exit;
		end;
	end;

	Result := '';
end;

procedure T_MyAPITest.FSetName(sName: String);
var
	i : Integer;
	l_Execute : T_Execute;
begin
	FsTestAPI := sName;

	for i := 0 to FTestItems.Count -1
	do begin
		l_Execute := T_Execute(FTestItems.Objects[i]);
		if (l_Execute.Name = sName)
		then begin
			Self.Clear;
			l_Execute.Func;
Exit;
		end;
	end;
end;

function T_MyAPITest.FGetParamHint: String;
begin
	if  (FiParamIndex >= 0)
	and (FiParamIndex < FParamHints.Count)
	then begin
		Result := FParamHints[FiParamIndex];
	end
	else
	begin
		Result := '';
  end;
end;

function T_MyAPITest.IsNowAPI(sDeclaration: String): Boolean;
begin
	Result := (Self.Declaration <> '') and (Self.Declaration = sDeclaration);
end;

procedure T_MyAPITest.Clear;
begin
	FsTestAPI     := '';
	FiParamIndex  := 0;
	FsDeclaration := ''; //関数宣言
	FsDescription := ''; //関数の説明
	FTestParams.Clear;
	FParamHints.Clear;
end;

procedure T_MyAPITest.FAddParam(sParam, sHint: String);
begin
	FTestParams.Add(sParam);
	FParamHints.Add(sHint);
end;

function T_MyAPITest.FGetWindowValue(hHandle: HWND): String;
	function _LimitText(sText: String): String;
	const
		lci_MAXLENGTH = 64;
	begin
		if (Length(sText) > lci_MAXLENGTH)
		then begin
			Result := Copy(sText, 1, lci_MAXLENGTH) + '…';
		end
		else
		begin
			Result := sText;
		end;
	end;
begin
	if (IsWindow(hHandle))
	then begin
//		Result := Format('0x%0:.8x %0:d %s "%s"', [hHandle, gfnsClassNameGet(hHandle), gfnsWindowTextGet(hHandle)]);
		Result := Format('0x%0:.8x %0:d %s "%s"', [hHandle, gfnsClassNameGet(hHandle), _LimitText(gfnsWindowTextGet(hHandle))]);
	end
	else
	begin
		Result := Format('0x%0:.8x %0:d ウィンドウハンドルが無効です', [hHandle]);
	end;
end;

function T_MyAPITest.FGetBoolValue(bValue: Boolean): String;
begin
	Result := gfnsBoolToStr(bValue);
end;

function T_MyAPITest.FGetColorName(clColor: TColor): String;
begin
	case clColor of
		$CD5C5C: Result := 'IndianRed';
		$F08080: Result := 'LightCoral';
		$FA8072: Result := 'Salmon';
		$E9967A: Result := 'DarkSalmon';
		$FFA07A: Result := 'LightSalmon';
		$DC143C: Result := 'Crimson';
		$FF0000: Result := 'Red';
		$B22222: Result := 'FireBrick';
		$8B0000: Result := 'DarkRed';
		$FFC0CB: Result := 'Pink';
		$FFB6C1: Result := 'LightPink';
		$FF69B4: Result := 'HotPink';
		$FF1493: Result := 'DeepPink';
		$C71585: Result := 'MediumVioletRed';
		$DB7093: Result := 'PaleVioletRed';
		$FF7F50: Result := 'Coral';
		$FF6347: Result := 'Tomato';
		$FF4500: Result := 'OrangeRed';
		$FF8C00: Result := 'DarkOrange';
		$FFA500: Result := 'Orange';
		$FFD700: Result := 'Gold';
		$FFFF00: Result := 'Yellow';
		$FFFFE0: Result := 'LightYellow';
		$FFFACD: Result := 'LemonChiffon';
		$FAFAD2: Result := 'LightGoldenrodYellow';
		$FFEFD5: Result := 'PapayaWhip';
		$FFE4B5: Result := 'Moccasin';
		$FFDAB9: Result := 'PeachPuff';
		$EEE8AA: Result := 'PaleGoldenrod';
		$F0E68C: Result := 'Khaki';
		$BDB76B: Result := 'DarkKhaki';
		$E6E6FA: Result := 'Lavender';
		$D8BFD8: Result := 'Thistle';
		$DDA0DD: Result := 'Plum';
		$EE82EE: Result := 'Violet';
		$DA70D6: Result := 'Orchid';
		$FF00FF: Result := 'Fuchsia/Magenta';
		$BA55D3: Result := 'MediumOrchid';
		$9370DB: Result := 'MediumPurple';
		$9966CC: Result := 'Amethyst';
		$8A2BE2: Result := 'BlueViolet';
		$9400D3: Result := 'DarkViolet';
		$9932CC: Result := 'DarkOrchid';
		$8B008B: Result := 'DarkMagenta';
		$800080: Result := 'Purple';
		$4B0082: Result := 'Indigo';
		$6A5ACD: Result := 'SlateBlue';
		$483D8B: Result := 'DarkSlateBlue';
		$7B68EE: Result := 'MediumSlateBlue';
		$ADFF2F: Result := 'GreenYellow';
		$7FFF00: Result := 'Chartreuse';
		$7CFC00: Result := 'LawnGreen';
		$00FF00: Result := 'Lime';
		$32CD32: Result := 'LimeGreen';
		$98FB98: Result := 'PaleGreen';
		$90EE90: Result := 'LightGreen';
		$00FA9A: Result := 'MediumSpringGreen';
		$00FF7F: Result := 'SpringGreen';
		$3CB371: Result := 'MediumSeaGreen';
		$2E8B57: Result := 'SeaGreen';
		$228B22: Result := 'ForestGreen';
		$008000: Result := 'Green';
		$006400: Result := 'DarkGreen';
		$9ACD32: Result := 'YellowGreen';
		$6B8E23: Result := 'OliveDrab';
		$808000: Result := 'Olive';
		$556B2F: Result := 'DarkOliveGreen';
		$66CDAA: Result := 'MediumAquamarine';
		$8FBC8F: Result := 'DarkSeaGreen';
		$20B2AA: Result := 'LightSeaGreen';
		$008B8B: Result := 'DarkCyan';
		$008080: Result := 'Teal';
		$00FFFF: Result := 'Aqua/Cyan';
		$E0FFFF: Result := 'LightCyan';
		$AFEEEE: Result := 'PaleTurquoise';
		$7FFFD4: Result := 'Aquamarine';
		$40E0D0: Result := 'Turquoise';
		$48D1CC: Result := 'MediumTurquoise';
		$00CED1: Result := 'DarkTurquoise';
		$5F9EA0: Result := 'CadetBlue';
		$4682B4: Result := 'SteelBlue';
		$B0C4DE: Result := 'LightSteelBlue';
		$B0E0E6: Result := 'PowderBlue';
		$ADD8E6: Result := 'LightBlue';
		$87CEEB: Result := 'SkyBlue';
		$87CEFA: Result := 'LightSkyBlue';
		$00BFFF: Result := 'DeepSkyBlue';
		$1E90FF: Result := 'DodgerBlue';
		$6495ED: Result := 'CornflowerBlue';
		$4169E1: Result := 'RoyalBlue';
		$0000FF: Result := 'Blue';
		$0000CD: Result := 'MediumBlue';
		$00008B: Result := 'DarkBlue';
		$000080: Result := 'Navy';
		$191970: Result := 'MidnightBlue';
		$FFF8DC: Result := 'Cornsilk';
		$FFEBCD: Result := 'BlanchedAlmond';
		$FFE4C4: Result := 'Bisque';
		$FFDEAD: Result := 'NavajoWhite';
		$F5DEB3: Result := 'Wheat';
		$DEB887: Result := 'BurlyWood';
		$D2B48C: Result := 'Tan';
		$BC8F8F: Result := 'RosyBrown';
		$F4A460: Result := 'SandyBrown';
		$DAA520: Result := 'Goldenrod';
		$B8860B: Result := 'DarkGoldenrod';
		$CD853F: Result := 'Peru';
		$D2691E: Result := 'Chocolate';
		$8B4513: Result := 'SaddleBrown';
		$A0522D: Result := 'Sienna';
		$A52A2A: Result := 'Brown';
		$800000: Result := 'Maroon';
		$FFFFFF: Result := 'White';
		$FFFAFA: Result := 'Snow';
		$F0FFF0: Result := 'Honeydew';
		$F5FFFA: Result := 'MintCream';
		$F0FFFF: Result := 'Azure';
		$F0F8FF: Result := 'AliceBlue';
		$F8F8FF: Result := 'GhostWhite';
		$F5F5F5: Result := 'WhiteSmoke';
		$FFF5EE: Result := 'Seashell';
		$F5F5DC: Result := 'Beige';
		$FDF5E6: Result := 'OldLace';
		$FFFAF0: Result := 'FloralWhite';
		$FFFFF0: Result := 'Ivory';
		$FAEBD7: Result := 'AntiqueWhite';
		$FAF0E6: Result := 'Linen';
		$FFF0F5: Result := 'LavenderBlush';
		$FFE4E1: Result := 'MistyRose';
		$DCDCDC: Result := 'Gainsboro';
		$D3D3D3: Result := 'LightGrey';
		$C0C0C0: Result := 'Silver';
		$A9A9A9: Result := 'DarkGray';
		$808080: Result := 'Gray';
		$696969: Result := 'DimGray';
		$778899: Result := 'LightSlateGray';
		$708090: Result := 'SlateGray';
		$2F4F4F: Result := 'DarkSlateGray';
		$000000: Result := 'Black';
		else Result := '';
	end;
end;

function T_MyAPITest.FGetIntValue(iValue: Integer): String;
begin
	Result := Format('%d', [iValue]);
end;

function T_MyAPITest.FGetHexValue(iValue: DWORD; iPrec: Integer): String;
var
	ls_Format : String;
begin
	if (iPrec <= 0)
	then begin
		ls_Format := '0x%0:x %0:u';
	end
	else
	begin
		ls_Format := '0x%0:.' + IntToStr(iPrec) + 'x %0:u';
	end;
	Result := Format(ls_Format, [DWORD(iValue)]);
end;
function T_MyAPITest.FGetHexValue(iValue: Integer): String;
begin
	Result := Self.FGetHexValue(DWORD(iValue), 8);
end;
function T_MyAPITest.FGetHexValue(iValue: DWORD): String;
begin
	Result := Self.FGetHexValue(iValue, 8);
end;

function T_MyAPITest.FGetPointValue(APoint: TPoint): String;
begin
	Result := Format('(%d, %d)', [APoint.X, APoint.Y]);
end;

function T_MyAPITest.FGetRectValue(ARect: TRect): String;
begin
	Result := Format('(%d, %d, %d, %d)', [ARect.Left, ARect.Top, ARect.Right, ARect.Bottom]);
end;
function T_MyAPITest.FGetRectValue(ARect: TRect; bRet: Boolean): String;
begin
	if (bRet)
	then
		Result := FGetRectValue(ARect)
	else
		Result := '-';
end;

//==============================================================================
//テストするAPIを実装

// DwmGetWindowAttribute -------------------------------------------------------
//------------------------------------------------------------------------------
const
	DWMWA_NCRENDERING_ENABLED         =  1;
	DWMWA_NCRENDERING_POLICY          =  2;
	DWMWA_TRANSITIONS_FORCEDISABLED   =  3;
	DWMWA_ALLOW_NCPAINT               =  4;
	DWMWA_CAPTION_BUTTON_BOUNDS       =  5;
	DWMWA_NONCLIENT_RTL_LAYOUT        =  6;
	DWMWA_FORCE_ICONIC_REPRESENTATION =  7;
	DWMWA_FLIP3D_POLICY               =  8;
	DWMWA_EXTENDED_FRAME_BOUNDS       =  9;
	DWMWA_HAS_ICONIC_BITMAP           = 10;
	DWMWA_DISALLOW_PEEK               = 11;
	DWMWA_EXCLUDED_FROM_PEEK          = 12;
	DWMWA_CLOAK                       = 13;
	DWMWA_CLOAKED                     = 14;
	DWMWA_FREEZE_REPRESENTATION       = 15;
	DWMWA_LAST                        = 16;


//function DwmGetWindowAttribute(hwnd: HWND; dwAttribute: DWORD; pvAttribute: Pointer; cbAttribute: DWORD): HResult; stdcall; external 'Dwmapi.dll';
type
	TDwmGetWindowAttribute = function(hwnd: HWND; dwAttribute: DWORD; pvAttribute: Pointer; cbAttribute: DWORD): HResult; stdcall;
function DwmGetWindowAttribute(hwnd: HWND; dwAttribute: DWORD; pvAttribute: Pointer; cbAttribute: DWORD): HResult;
{2013-11-17:
}
var
	ls_Path   : String;
	lh_Module : HMODULE;
	l_DwmGetWindowAttribute : TDwmGetWindowAttribute;
begin
	Result := E_NOTIMPL;

	ls_Path := gfnsSystem32DirGet;
	lh_Module := LoadLibrary(PChar(ls_Path + 'Dwmapi.dll'));
	if (lh_Module <> 0)
	then begin
		try
			// DwmGetWindowAttribute の関数ポインタを取得
			@l_DwmGetWindowAttribute := GetProcAddress(lh_Module, 'DwmGetWindowAttribute');
			if (@l_DwmGetWindowAttribute <> nil)
			then begin
				Result := l_DwmGetWindowAttribute(
					hwnd,
					dwAttribute,
					pvAttribute,
					cbAttribute
				);
			end;
		finally
			FreeLibrary(lh_Module);
		end;
	end;
end;
function T_MyAPITest.FDwmGetWindowAttribute: String;
const
	lcs_DECLARATION = 'HRESULT DwmGetWindowAttribute(HWND hwnd, DWORD dwAttribute, pvAttribute, DWORD cbAttribute);';
	lcs_DESCRIPTION =
'指定されたウィンドウのデスクトップウィンドウマネージャーの属性を調べます。'          + lcsTITLE_CRLF +
'hwnd        調べたいウィンドウのトップレベルウィンドウのハンドルを指定します。'      + lcsCRLF +
'dwAttribute 調べる属性を指定します。'                                                + lcsCRLF +
'pvAttribute dwAttributeで指定した属性の値を受け取る変数のポインタを指定します。'     + lcsCRLF +
'cbAttribute pvAttributeで指定した変数のサイズを指定します。'                         + lcsCRLF +
'戻り値      関数が成功したらS_OKが、失敗したらエラーのHRESULT値が返ります。' + lcsCRLF + lcsCRLF +
'dwAttributeで指定する値によりpvAttributeに指定する変数の型が変わります。'    + lcsCRLF +
'hwndに子ウィンドウを指定するとこの関数は失敗します。' + lcsCRLF +
'dwAttributeには以下の値があります。' + lcsCRLF +
' DWMWA_NCRENDERING_ENABLED   非クライアントのレンダリングが有効になっているかを調べます。取得する値はBOOL型で非クライアントのレンダリングが有効な場合はTrue、そうでなければFalseになります。' + lcsCRLF +
' DWMWA_CAPTION_BUTTON_BOUNDS タイトルバーのボタン部分の矩形領域(RECT)を調べます。取得する値はRECT型でタイトルバーの左上隅からの相対座標の値になります。' + lcsCRLF +
' DWMWA_EXTENDED_FRAME_BOUNDS ウィンドウのフレームの拡張部分も含めた矩形領域(RECT)を調べます。取得する値はRECT型で、スクリーン座標での値になります。' + lcsCRLF +
' DWMWA_CLOAK                 Cloaks the window such that it is not visible to the user. The window is still composed by DWM.' + lcsCRLF +
' DWMWA_CLOAKED               If the window is cloaked, provides one of the following values explaining why:'
;
	function _GetHResult(iRet: HResult): String;
	begin
		if (Succeeded(iRet))
		then begin
			Result := 'S_OK';
		end
		else
		begin
			case iRet of
				E_UNEXPECTED   : Result := 'E_UNEXPECTED';   //Catastrophic failure
				E_NOTIMPL      : Result := 'E_NOTIMPL';      //Not implemented
				E_OUTOFMEMORY  : Result := 'E_OUTOFMEMORY';  //Ran out of memory
				E_INVALIDARG   : Result := 'E_INVALIDARG';   //One or more arguments are invalid
				E_NOINTERFACE  : Result := 'E_NOINTERFACE';  //No such interface supported
				E_POINTER      : Result := 'E_POINTER';      //Invalid pointer
				E_HANDLE       : Result := 'E_HANDLE';       //Invalid handle
				E_ABORT        : Result := 'E_ABORT';        //Operation aborted
				E_FAIL         : Result := 'E_FAIL';         //Unspecified error
				E_ACCESSDENIED : Result := 'E_ACCESSDENIED'; //General access denied error
				E_PENDING      : Result := 'E_PENDING';      //The data necessary to complete this operation is not yet available.
				else             Result := 'その他のエラー';
			end;
		end;
	end;

	function _GetBoolValue(iRet: HResult; bValue: BOOL): String;
	begin
		Result := Format('%s %s', [_GetHResult(iRet), FGetBoolValue(bValue)]);
	end;
	function _GetRectValue(iRet: HResult; ARect: TRect): String;
	begin
		Result := Format('%s %s', [_GetHResult(iRet), FGetRectValue(ARect, Succeeded(iRet))]);
	end;
	function _GetCloakedValue(iRet: HResult; iCloaked: DWORD): String;
	const
		DWM_CLOAKED_APP	      = $1; //The window was cloaked by its owner application.
		DWM_CLOAKED_SHELL     = $2; //The window was cloaked by the Shell.
		DWM_CLOAKED_INHERITED = $4; //The cloak value was inherited from its owner window.
	begin
		Result := Format('%s 0x%1:.8x %1:u', [_GetHResult(iRet), iCloaked]);
	end;
var
	li_Ret  : HResult;
	lb_Bool : BOOL;
	l_Rect  : TRect;
	li_Cloaked : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('dwAttribute: DWMWA_NCRENDERING_ENABLED',   '非クライアントのレンダリングが有効になっているかを調べます。' + lcsCRLF + '取得する値はBOOL型で、非クライアントのレンダリングが有効な場合はTrue、そうでなければFalseになります。');
		FAddParam('dwAttribute: DWMWA_CAPTION_BUTTON_BOUNDS', 'タイトルバーのボタン部分の矩形領域(RECT)を調べます。' + lcsCRLF + '取得する値はRECT型で、タイトルバーの左上隅からの相対座標の値になります。');
		FAddParam('dwAttribute: DWMWA_EXTENDED_FRAME_BOUNDS', 'ウィンドウのフレームの拡張部分も含めた矩形領域(RECT)を調べます。' + lcsCRLF + '取得する値はRECT型で、スクリーン座標での値になります。');
		FAddParam('dwAttribute: DWMWA_CLOAK',                 'Cloaks the window such that it is not visible to the user. The window is still composed by DWM.');
		FAddParam('dwAttribute: DWMWA_CLOAKED',               'If the window is cloaked, provides one of the following values explaining why:');
Exit;
	end;

	case FiParamIndex of
		0
		:begin
			//非クライアントのレンダリングが有効かどうか
			lb_Bool := False;
			li_Ret  := DwmGetWindowAttribute(FhWindowHandle, DWMWA_NCRENDERING_ENABLED, @lb_Bool, SizeOf(lb_Bool));
			Result  := _GetBoolValue(li_Ret, lb_Bool);
		end;
		1
		:begin
			//タイトルバーのボタン部分のRect
			l_Rect := Rect(0, 0, 0, 0);
			li_Ret := DwmGetWindowAttribute(FhWindowHandle, DWMWA_CAPTION_BUTTON_BOUNDS, @l_Rect, SizeOf(l_Rect));
			Result := _GetRectValue(li_Ret, l_Rect);
		end;
		2
		:begin
			//拡張フレームのRect
			l_Rect := Rect(0, 0, 0, 0);
			li_Ret := DwmGetWindowAttribute(FhWindowHandle, DWMWA_EXTENDED_FRAME_BOUNDS, @l_Rect, SizeOf(l_Rect));
			Result := _GetRectValue(li_Ret, l_Rect);
		end;
		3
		:begin
			//DWMWA_CLOAK
			lb_Bool := False;
			li_Ret  := DwmGetWindowAttribute(FhWindowHandle, DWMWA_CLOAK, @lb_Bool, SizeOf(lb_Bool));
			Result  := _GetBoolValue(li_Ret, lb_Bool);
		end;
		4
		:begin
			//DWMWA_CLOAKED
			li_Cloaked := 0;
			li_Ret := DwmGetWindowAttribute(FhWindowHandle, DWMWA_CLOAKED, @li_Cloaked, SizeOf(li_Cloaked));
			Result := _GetCloakedValue(li_Ret, li_Cloaked);
		end;
	end;
end;

// GetAncestor -----------------------------------------------------------------
function T_MyAPITest.FGetAncestor: String;
const
	lcs_DECLARATION = 'HWND GetAncestor(HWND hwnd, UINT gaFlags)';
	lcs_DESCRIPTION =
'指定されたウィンドウの祖先のハンドルを返します。' + lcsTITLE_CRLF +
'hwnd    調べたいウィンドウのハンドルを指定します。' + lcsCRLF +
'gaFlags 取得する祖先を指定する以下の値を指定します。' + lcsCRLF +
' GA_PARENT    親ウィンドウを取得します。' + lcsCRLF +
' GA_ROOT      親ウィンドウのチェーンをたどってルートウィンドウを取得します。' + lcsCRLF +
' GA_ROOTOWNER 親ウィンドウのチェーンをたどって所有されているルートウィンドウを取得します。' + lcsCRLF +
'戻り値 指定の祖先のウィンドウのハンドルが返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('gaFlags: GA_PARENT',    'gaFlagsにGA_PARENTを指定した時の戻り値。'    + lcsCRLF + '親ウィンドウを取得します。GetParent関数と違いオーナーウィンドウは取得しません。');
		FAddParam('gaFlags: GA_ROOT',      'gaFlagsにGA_ROOTを指定した時の戻り値。'      + lcsCRLF + '親ウィンドウのチェーンをたどってルートウィンドウを取得します。');
		FAddParam('gaFlags: GA_ROOTOWNER', 'gaFlagsにGA_ROOTOWNERを指定した時の戻り値。' + lcsCRLF + 'GetParent関数が返す親ウィンドウのチェーンをたどって所有されているルートウィンドウを取得します。');
Exit;
	end;

	case FiParamIndex of
		0: Result := FGetWindowValue(GetAncestor(FhWindowHandle, GA_PARENT));
		1: Result := FGetWindowValue(GetAncestor(FhWindowHandle, GA_ROOT));
		2: Result := FGetWindowValue(GetAncestor(FhWindowHandle, GA_ROOTOWNER));
	end;
end;

(*
// GetClassInfoEx --------------------------------------------------------------
procedure T_MyAPITest.FGetClassInfoEx: String;
const
lcsSTRUCT_WNDCLASSEX = lcsSTRUCT_CRLF +
'typedef struct tagWNDCLASSEX {' + lcsCRLF +
'  UINT      cbSize;         //構造体のサイズ(必ずセットすること)' + lcsCRLF +
'  UINT      style;          //クラスのスタイル' + lcsCRLF +
'  WNDPROC   lpfnWndProc;    //ウインドウプロシージャ' + lcsCRLF +
'  int       cbClsExtra;     //拡張クラスデータのサイズ' + lcsCRLF +
'  int       cbWndExtra;     //拡張ウインドウデータのサイズ' + lcsCRLF +
'  HINSTANCE hInstance;      //インスタンスのハンドル' + lcsCRLF +
'  HICON     hIcon;          //アイコンのハンドル' + lcsCRLF +
'  HCURSOR   hCursor;        //カーソルのハンドル' + lcsCRLF +
'  HBRUSH    hbrBackground;  //背景ブラシのハンドル' + lcsCRLF +
'  LPCTSTR   lpszMenuName;   //メニューバーの識別文字列' + lcsCRLF +
'  LPCTSTR   lpszClassName;  //ウインドウのクラス文字列' + lcsCRLF +
'  HICON     hIconSm;        //小さいアイコンのハンドル' + lcsCRLF +
'} WNDCLASSEX, *LPWNDCLASSEX;'
;
const
	lcs_DECLARATION = 'BOOL GetClassInfoEx(HINSTANCE hinst, LPCTSTR lpszClass, LPWNDCLASSEX lpwcx);';
	lcs_DESCRIPTION =
'ウィンドウクラスの情報を取得します。ウィンドウクラスに関連付けられている小さいアイコンのハンドルも取得できます。' + lcsTITLE_CRLF +
'hinst     アプリケーションインスタンスのハンドルを指定' + lcsCRLF +
'lpszClass クラス名を指定' + lcsCRLF +
'lpwcx     クラスの情報を受け取るWNDCLASSEX構造体の変数のポインタを指定' + lcsCRLF +
'戻り値    指定したクラスが見つかり情報の取得に成功したら0以外の値(True)が返ります。指定したクラスが見つからず情報の取得に失敗したら0(False)が返ります' + lcsCRLF +
lcsSTRUCT_WNDCLASSEX
;
var
	lb_Ret       : BOOL;
	lh_Instance  : HINST;
	ls_ClassName : String;
	l_Info       : TWndClassEx;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('対象ウィンドウ',      '調べたいウィンドウ');
		FAddElement('hinst',               'クラスを作成したアプリケーションのインスタンスハンドルを指定します。');
		FAddElement('lpszClass',           '調べたいクラス名を指定します。');
		FAddElement('lpwcx.cbSize',        '構造体のサイズ(必ずセットすること)');
		FAddElement('lpwcx.style',         'クラスのスタイル');
		FAddElement('lpwcx.lpfnWndProc',   'ウインドウプロシージャ');
		FAddElement('lpwcx.cbClsExtra',    '拡張クラスデータのサイズ');
		FAddElement('lpwcx.cbWndExtra',    '拡張ウインドウデータのサイズ');
		FAddElement('lpwcx.hInstance',     'インスタンスのハンドル');
		FAddElement('lpwcx.hIcon',         'アイコンのハンドル');
		FAddElement('lpwcx.hCursor',       'カーソルのハンドル');
		FAddElement('lpwcx.hbrBackground', '背景ブラシのハンドル');
		FAddElement('lpwcx.lpszMenuName',  'メニューバーの識別文字列');
		FAddElement('lpwcx.lpszClassName', 'ウインドウのクラス文字列');
		FAddElement('lpwcx.hIconSm',       '小さいアイコンのハンドル');
		FAddElement('戻り値',              '指定したクラスが見つかり情報の取得に成功したら0以外の値(True)が返ります。指定したクラスが見つからず情報の取得に失敗したら0(False)が返ります');
		FAddElement('lpwcxダンプ');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		lh_Instance  := HINST(GetWindowLong(FhWndHandle, GWL_HINSTANCE));
		ls_ClassName := gfnsClassNameGet(FhWndHandle);
		FillChar(l_Info, 0, SizeOf(l_Info));
		l_Info.cbSize := SizeOf(l_Info);
		lb_Ret := GetClassInfoEx(lh_Instance, PChar(ls_ClassName), l_Info);

		FAddHexValue(lh_Instance);
		FAddStrValue(ls_ClassName);
		if (lb_Ret)
		then begin
			FAddIntValue(l_Info.cbSize);
			FAddHexValue(l_Info.style);
			FAddHexValue(Integer(l_Info.lpfnWndProc));
			FAddHexValue(l_Info.cbClsExtra);
			FAddHexValue(l_Info.cbWndExtra);
			FAddHexValue(l_Info.hInstance);
			FAddHexValue(l_Info.hIcon);
			FAddHexValue(l_Info.hCursor);
			FAddHexValue(l_Info.hbrBackground);
			FAddStrValue(String(l_Info.lpszMenuName));
			FAddStrValue(String(l_Info.lpszClassName));
			FAddHexValue(l_Info.hIconSm);
		end
		else
		begin
			FAddIntValue(l_Info.cbSize);
			FAddHexValue(l_Info.style);
			FAddHexValue(Integer(l_Info.lpfnWndProc));
			FAddHexValue(l_Info.cbClsExtra);
			FAddHexValue(l_Info.cbWndExtra);
			FAddHexValue(l_Info.hInstance);
			FAddHexValue(l_Info.hIcon);
			FAddHexValue(l_Info.hCursor);
			FAddHexValue(l_Info.hbrBackground);
			FAddHexValue(Integer(l_Info.lpszMenuName));
			FAddHexValue(Integer(l_Info.lpszClassName));
//			FAddStrValue(String(l_Info.lpszMenuName));
//			FAddStrValue(String(l_Info.lpszClassName));
			FAddHexValue(l_Info.hIconSm);
		end;
		FAddBoolValue(lb_Ret);

		FAddDumpValue(@l_Info, l_Info.cbSize);
	end;
end;

// GetClassLong ----------------------------------------------------------------
procedure T_MyAPIValue.FGetClassLong;
const
	lcs_DECLARATION = 'DWORD GetClassLong(HWND hWnd, int nIndex);';
	lcs_DESCRIPTION =
'指定されたウィンドウに関係付けられている構造体から指定された32ビットのデータを取得します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定' + lcsCRLF +
'nIndex 取得するデータのインデックスを指定' + lcsCRLF +
' GCW_ATOM          ウィンドウクラスを一意的に識別するアトム値を取得' + lcsCRLF +
' GCL_CBCLSEXTRA    指定したクラスに関連付けられている拡張クラスメモリのサイズをバイト単位で取得' + lcsCRLF +
' GCL_CBWNDEXTRA    ウィンドウに関連付けられている拡張ウィンドウメモリのサイズをバイト単位で取得' + lcsCRLF +
' GCL_HBRBACKGROUND クラスに関連付けられている背景ブラシのハンドルを取得' + lcsCRLF +
' GCL_HCURSOR       クラスに関連付けられているマウスカーソルのハンドルを取得' + lcsCRLF +
' GCL_HICON         クラスに関連付けられているアイコンのハンドルを取得' + lcsCRLF +
' GCL_HICONSM       クラスに関連付けられている小さいアイコンのハンドルを取得' + lcsCRLF +
' GCL_HMODULE       クラスを登録したモジュールのハンドルを取得' + lcsCRLF +
' GCL_MENUNAME      メニュー名が入った文字列へのポインタ(またはメニューのID)を取得' + lcsCRLF +
' GCL_STYLE         ウィンドウクラスのスタイルビットを取得' + lcsCRLF +
' GCL_WNDPROC       ウィンドウプロシージャのアドレスまたはウィンドウプロシージャのアドレスを示すハンドルを取得' + lcsCRLF +
'戻り値 関数が成功すると要求した32ビットのデータが返ります。関数が失敗すると0が返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',                      '調べたいウィンドウのハンドルを指定します。');
		FAddElement('nIndex: GCW_ATOM',	         'nIndexにGCW_ATOMを指定した時の戻り値。'          + lcsCRLF + 'ウィンドウクラスを一意的に識別するアトム値を取得します。');
		FAddElement('nIndex: GCL_CBCLSEXTRA',    'nIndexにGCL_CBCLSEXTRAを指定した時の戻り値。'    + lcsCRLF + '指定したクラスに関連付けられている拡張クラスメモリのサイズをバイト単位で取得します。');
		FAddElement('nIndex: GCL_CBWNDEXTRA',    'nIndexにGCL_CBWNDEXTRAを指定した時の戻り値。'    + lcsCRLF + 'ウィンドウに関連付けられている拡張ウィンドウメモリのサイズをバイト単位で取得します。');
		FAddElement('nIndex: GCL_HBRBACKGROUND', 'nIndexにGCL_HBRBACKGROUNDを指定した時の戻り値。' + lcsCRLF + 'クラスに関連付けられている背景ブラシのハンドルを取得します。');
		FAddElement('nIndex: GCL_HCURSOR',       'nIndexにGCL_HCURSORを指定した時の戻り値。'       + lcsCRLF + 'クラスに関連付けられているマウスカーソルのハンドルを取得します。');
		FAddElement('nIndex: GCL_HICON',         'nIndexにGCL_HICONを指定した時の戻り値。'         + lcsCRLF + 'クラスに関連付けられているアイコンのハンドルを取得します。');
		FAddElement('nIndex: GCL_HICONSM',       'nIndexにGCL_HICONSMを指定した時の戻り値。'       + lcsCRLF + 'クラスに関連付けられている小さいアイコンのハンドルを取得します。');
		FAddElement('nIndex: GCL_HMODULE',       'nIndexにGCL_HMODULEを指定した時の戻り値。'       + lcsCRLF + 'クラスを登録したモジュールのハンドルを取得します。');
		FAddElement('nIndex: GCL_MENUNAME',      'nIndexにGCL_MENUNAMEを指定した時の戻り値。'      + lcsCRLF + 'メニュー名が入った文字列へのポインタ(またはメニューのID)を取得します。');
		FAddElement('nIndex: GCL_STYLE',         'nIndexにGCL_STYLEを指定した時の戻り値。'         + lcsCRLF + 'ウィンドウクラスのスタイルビットを取得します。');
		FAddElement('nIndex: GCL_WNDPROC',       'nIndexにGCL_WNDPROCを指定した時の戻り値。'       + lcsCRLF + 'ウィンドウプロシージャのアドレスまたはウィンドウプロシージャのアドレスを示すハンドルを取得します。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		FAddHexValue(GetClassLong(FhWndHandle, GCW_ATOM));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_CBCLSEXTRA));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_CBWNDEXTRA));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_HBRBACKGROUND));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_HCURSOR));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_HICON));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_HICONSM));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_HMODULE));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_MENUNAME));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_STYLE));
		FAddHexValue(GetClassLong(FhWndHandle, GCL_WNDPROC));
	end;
end;

// GetClassName ----------------------------------------------------------------
procedure T_MyAPIValue.FGetClassName;
const
	lcs_DECLARATION = 'int GetClassName(HWND hWnd, LPTSTR lpClassName, int nMaxCount);';
	lcs_DESCRIPTION =
'指定されたウィンドウのクラス名を取得します。' + lcsTITLE_CRLF +
'hwnd        調べたいウィンドウのハンドルを指定' + lcsCRLF +
'lpClassName クラス名を受け取る変数のポインタを指定' + lcsCRLF +
'nMaxCount   lpClassNameが受け取るデータの最大長を指定(このテストでは255を指定)' + lcsCRLF +
'戻り値      関数が成功するとlpClassNameが受け取ったデータの長さが返ります。関数が失敗すると0が返ります。'
;
const
	lci_LEN = 255;
var
	li_Ret   : Integer;
	lp_Buff  : PChar;
	ls_Class : String;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',        '調べたいウィンドウのハンドルを指定します。');
		FAddElement('lpClassName', 'クラス名を受け取る変数のポインタを指定します。');
		FAddElement('戻り値',      '関数が成功するとlpClassNameが受け取ったデータの長さが返ります。関数が失敗すると0が返ります。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		lp_Buff:= AllocMem((lci_LEN +1) * SizeOf(Char));
		try
			li_Ret := GetClassName(FhWndHandle, lp_Buff, lci_LEN);
			ls_Class := String(lp_Buff);
		finally
			FreeMem(lp_Buff);
		end;

		FAddStrValue(ls_Class);
		FAddIntValue(li_Ret);
	end;
end;

// GetClientRect ---------------------------------------------------------------
procedure T_MyAPIValue.FGetClientRect;
const
	lcs_DECLARATION = 'BOOL GetClientRect(HWND hWnd, LPRECT lpRect);';
	lcs_DESCRIPTION =
'指定されたウィンドウのクライアント領域の値をクライアント座標で取得します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定' + lcsCRLF +
'lpRect 値を受け取るRECT構造体の変数のポインタを指定' + lcsCRLF +
'戻り値 関数が成功すると0以外の値(True)が、失敗すると0(False)が返ります。' + lcsCRLF +
lcsSTRUCT_RECT
;
var
	lb_Ret : BOOL;
	l_Rect : TRect;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',   '調べたいウィンドウのハンドルを指定します。');
		FAddElement('lpRect', '値を受け取るRECT構造体の変数のポインタを指定します。' + lcsCRLF + 'この構造体にクライアント領域の座標がクライアント座標で格納されます。クライアント座標なのでleftメンバとtopメンバは常に0になります。rightメンバとbottomメンバはクライアント領域の幅と高さになります。');
		FAddElement('戻り値', '関数が成功すると0以外の値(True)が、失敗すると0(False)が返ります。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		lb_Ret := Windows.GetClientRect(FhWndHandle, l_Rect);
		FAddRectValue(l_Rect);
		FAddBoolValue(lb_Ret);
	end;
end;
*)

// GetComboboxInfo -------------------------------------------------------------
function T_MyAPITest.FGetComboboxInfo: String;
const
lcs_STRUCT_COMBOBOXINFO = lcsSTRUCT_CRLF +
'typedef struct tagCOMBOBOXINFO {' + lcsCRLF +
'  DWORD cbSize;       //構造体のサイズ(必ずセットすること)' + lcsCRLF +
'  RECT  rcItem;       //エディットボックスの矩形領域(RECT)' + lcsCRLF +
'  RECT  rcButton;     //ボタン部分も含めたコンボボックスの矩形領域(RECT)' + lcsCRLF +
'  DWORD stateButton;  //コンボボックスのボタンの状態' + lcsCRLF +
'  HWND  hwndCombo;    //コンボボックスのハンドル' + lcsCRLF +
'  HWND  hwndItem;     //エディットボックスのハンドル' + lcsCRLF +
'  HWND  hwndList;     //ドロップダウンリストのハンドル' + lcsCRLF +
'} COMBOBOXINFO, *PCOMBOBOXINFO, *LPCOMBOBOXINFO;'
;
const
	lcs_DECLARATION = 'BOOL GetComboBoxInfo(HWND hwndCombo, PCOMBOBOXINFO pcbi);';
	lcs_DESCRIPTION =
'指定されたコンボボックスに関する情報を取得します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定します。' + lcsCRLF +
'pcbi   情報を受け取るCOMBOBOXINFO構造体へのポインタを指定します。' + lcsCRLF +
'戻り値 関数が成功すると0以外の値(True)が返ります。関数が失敗すると0(False)が返ります。' + lcsCRLF +
lcs_STRUCT_COMBOBOXINFO + lcsCRLF +
'pcbi.stateButtonの内容' + lcsCRLF +
'0                      (0x00000000)ボタンは存在し押されていない。' + lcsCRLF +
'STATE_SYSTEM_INVISIBLE (0x00008000)ボタンは存在しない。' + lcsCRLF +
'STATE_SYSTEM_PRESSED   (0x00000008)ボタンは存在し押されている。'
;
	function _GetStatusValue(iValue: DWORD): String;
	var
		ls_Status : String;
	begin
		case iValue of
			0                     : ls_Status := 'ボタンは存在し押されていない。';
			STATE_SYSTEM_PRESSED  : ls_Status := 'ボタンは存在しない。';
			STATE_SYSTEM_INVISIBLE: ls_Status := 'ボタンは存在し押されている。';
			else                    ls_Status := '-';
		end;
		Result := Format('0x%0:.8x %s', [iValue, ls_Status]);
	end;
var
	lb_Ret : BOOL;
	l_Info : TComboBoxInfo;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('pcbi.rcItem',      'エディットボックスの矩形領域(RECT)');
		FAddParam('pcbi.rcButton',    'ボタン部分も含めたコンボボックスの矩形領域(RECT)');
		FAddParam('pcbi.stateButton', 'コンボボックスのボタンの状態');
		FAddParam('pcbi.hwndCombo',   'コンボボックスのハンドル');
		FAddParam('pcbi.hwndItem',    'エディットボックスのハンドル');
		FAddParam('pcbi.hwndList',    'ドロップダウンリストのハンドル');
		FAddParam('戻り値',           '関数が成功すると0以外の値(True)が、失敗すると0(False)が返ります。');
Exit;
	end;

	FillChar(l_Info, 0, SizeOf(l_Info));
	l_Info.cbSize := SizeOf(l_Info);
	lb_Ret := GetComboboxInfo(FhWindowHandle, l_Info);

	case FiParamIndex of
		0: Result := FGetRectValue(l_Info.rcItem,   lb_Ret);
		1: Result := FGetRectValue(l_Info.rcButton, lb_Ret);
		2: Result := _GetStatusValue(l_Info.stateButton);
		3: Result := FGetWindowValue(l_Info.hwndCombo);
		4: Result := FGetWindowValue(l_Info.hwndItem);
		5: Result := FGetWindowValue(l_Info.hwndList);
		6: Result := FGetBoolValue(lb_Ret);
	end;
end;

// GetLayeredWindowAttributes --------------------------------------------------
type
	TGetLayeredWindowAttributes = function(hwnd: HWND; var crKey: COLORREF; var bAlpha: BYTE; var dwFlags: DWORD): BOOL; stdcall;
function gfnbGetLayeredWindowAttributes(hHandle: HWND; var crKey: COLORREF; var bAlpha: BYTE; var dwFlags: DWORD): Boolean;
{2015-03-10:
}
var
	ls_Path   : String;
	lh_Module : HMODULE;
	l_GetLayeredWindowAttributes : TGetLayeredWindowAttributes;
begin
	Result := False;

	ls_Path := gfnsSystem32DirGet;
	lh_Module := LoadLibrary(PChar(ls_Path + 'user32.dll'));
	if (lh_Module <> 0)
	then begin
		try
			// GetLayeredWindowAttributes の関数ポインタを取得
			@l_GetLayeredWindowAttributes := GetProcAddress(lh_Module, 'GetLayeredWindowAttributes');
			if (@l_GetLayeredWindowAttributes <> nil)
			then begin
				Result := l_GetLayeredWindowAttributes(
					hHandle,
					crKey,
					bAlpha,
					dwFlags
				);
			end;
		finally
			FreeLibrary(lh_Module);
		end;
	end;
end;

function T_MyAPITest.FGetLayeredWindowAttributes: String;
const
	lcs_DECLARATION = 'BOOL WINAPI GetLayeredWindowAttributes(HWND hwnd, COLORREF *pcrKey, BYTE *pbAlpha, DWORD *pdwFlags);';
	lcs_DESCRIPTION =
'レイヤードウィンドウの透明度および透明にするカラーキーを取得します。' + lcsTITLE_CRLF +
'hwnd     調べたいウィンドウが属すトップレベルウィンドウのハンドルを指定します。' + lcsCRLF +
'pcrKey   透明にするカラーキーを受け取る変数のポインタを指定します。' + lcsCRLF +
'pbAlpha  ウィンドウの透明度(アルファブレンド値)を受け取る変数のポインタを指定します。' + lcsCRLF +
'pdwFlags レイヤードウィンドウのフラグ(透明度を使うのか透明にするカラーキーを使うのか)を受け取る変数のポインタを指定します。' + lcsCRLF +
'戻り値   関数が成功すると0以外の値(True)が、失敗すると0(False)が返ります。' + lcsCRLF +
'この関数はhwndに子ウィンドウを指定すると失敗します。'
;
	function _IsLayeredWindow: String;
	var
		li_ExStyle : DWORD;
	begin
		li_ExStyle := GetWindowLong(FhWindowHandle, GWL_EXSTYLE);
		if  (gfnbFlagCheck(li_ExStyle, WS_EX_LAYERED))
		and (gfnbFlagCheck(li_ExStyle, WS_EX_TRANSPARENT))
		then begin
			//レイヤードウィンドウだった
			Result := 'エラー';
		end
		else
		begin
			Result := 'レイヤードウィンドウではありません';
		end;
	end;

	function _GetColorKey(bRet: Boolean; iKey: COLORREF; iFlag: DWORD): String;
	begin
		if (bRet)
		then begin
			if (gfnbFlagCheck(iFlag, LWA_COLORKEY))
			then begin
				//カラーキー指定あり
				Result := FGetColorName(iKey);
			end
			else
			begin
				Result := '指定無し';
			end;
		end
		else
		begin
			Result := _IsLayeredWindow;
		end;
	end;

	function _GetAlpha(bRet: Boolean; iAlpha: Byte; iFlag: DWORD): String;
	begin
		if (bRet)
		then begin
			if (gfnbFlagCheck(iFlag, LWA_ALPHA))
			then begin
				//アルファ値指定あり
				Result := FGetIntValue(iAlpha);
			end
			else
			begin
				Result := '指定無し';
			end;
		end
		else
		begin
			Result := _IsLayeredWindow;
		end;
	end;

	function _GetLayeredFlag(bRet: Boolean; iFlag: DWORD): String;
	const
		LWA_ALPHA    = $2;
		LWA_COLORKEY = $1;
	begin
		if (bRet)
		then begin
			case iFlag of
				LWA_ALPHA:    Result := 'LWA_ALPHA';
				LWA_COLORKEY: Result := 'LWA_COLORKEY';
				else          Result := 'エラー';
			end;
			Result := Format('%s 0x%1:.8x %1:u', [Result, iFlag]);
		end
		else
		begin
			Result := _IsLayeredWindow;
		end;
	end;
var
	lb_Ret   : Boolean;
	li_Key   : COLORREF;
	li_Alpha : BYTE;
	li_Flags : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値',   '関数が成功すると0以外の値(True)が、失敗すると0(False)が返ります。' + lcsCRLF + 'hwndに子ウィンドウを指定するとこの関数は失敗します。');
		FAddParam('pcrKey',   '透明にするカラーキーを受け取る変数のポインタを指定します。' + lcsCRLF + 'pdwFlagsにLWA_COLORKEY(0x00000001)が指定されていないと"指定なし"になります。');
		FAddParam('pbAlpha',  'ウィンドウの透明度(アルファブレンド値)を受け取る変数のポインタを指定します。' + lcsCRLF + 'pdwFlagsにLWA_ALPHA(0x00000002)が指定されていないと"指定なし"になります。');
		FAddParam('pdwFlags', 'レイヤードウィンドウのフラグを受け取る変数のポインタを指定します。' + lcsCRLF + '透明にするカラーキー(pcrKey)を使う場合はLWA_COLORKEY(0x00000001)が、透明度(pbAlpha)を使う場合はLWA_ALPHA(0x00000002)が返ります。');
Exit;
	end;

	lb_Ret := gfnbGetLayeredWindowAttributes(FhWindowHandle, li_Key, li_Alpha, li_Flags);
	case FiParamIndex of
		0: Result := FGetBoolValue(lb_Ret);
		1: Result := _GetColorKey(lb_Ret, li_Key,   li_Flags);
		2: Result := _GetAlpha   (lb_Ret, li_Alpha, li_Flags);
		3: Result := _GetLayeredFlag(lb_Ret, li_Flags);
	end;
end;

// GetListBoxInfo --------------------------------------------------------------
function T_MyAPITest.FGetListBoxInfo: String;
const
	lcs_DECLARATION = 'DWORD GetListBoxInfo(HWND hwnd);';
	lcs_DESCRIPTION =
'指定されたリストボックスに関する情報を取得します。' + lcsTITLE_CRLF +
'hwnd   調べたいリストボックスのハンドルを指定します。' + lcsCRLF +
'戻り値 リストボックス内の項目数が返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', 'リストボックス内の項目数が返ります。');
Exit;
	end;

	Result := FGetIntValue(GetListBoxInfo(FhWindowHandle));
end;

// GetNextWindow ---------------------------------------------------------------
function T_MyAPITest.FGetNextWindow: String;
const
	lcs_DECLARATION = 'HWND GetNextWindow(HWND hWnd, UINT wCmd);';
	lcs_DESCRIPTION =
'指定されたウィンドウの次または一つ前の兄弟ウィンドウのハンドルを返します。' + lcsTITLE_CRLF +
'hwnd 調べたいウィンドウのハンドルを指定します。' + lcsCRLF +
'wCmd 次か前、どちらのウィンドウを取得するかを指定します。' + lcsCRLF +
' GW_HWNDNEXT 指定したウィンドウの次(下)にある兄弟ウィンドウを取得します。' + lcsCRLF +
' GW_HWNDPREV 指定したウィンドウの一つ前(上)にある兄弟ウィンドウを取得します。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('wCmd: GW_HWNDNEXT', 'wCmdにGW_HWNDNEXTを指定した時の戻り値。' + lcsCRLF + '指定ウィンドウの次(下)にある兄弟ウィンドウのハンドルが返ります。');
		FAddParam('wCmd: GW_HWNDPREV', 'wCmdにGW_HWNDPREVを指定した時の戻り値。' + lcsCRLF + '指定したウィンドウの一つ前(上)にある兄弟ウィンドウのハンドルが返ります。');
Exit;
	end;

	case FiParamIndex of
		0: Result := FGetWindowValue(GetNextWindow(FhWindowHandle, GW_HWNDNEXT));
		1: Result := FGetWindowValue(GetNextWindow(FhWindowHandle, GW_HWNDPREV));
	end;
end;

// GetParent -------------------------------------------------------------------
function T_MyAPITest.FGetParent: String;
const
	lcs_DECLARATION = 'HWND GetParent(HWND hWnd);';
	lcs_DESCRIPTION =
'指定されたウィンドウの親ウィンドウまたはオーナーウィンドウのハンドルを返します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定します。' + lcsCRLF +
'戻り値 指定したウィンドウの親ウィンドウまたはオーナーウィンドウのハンドルが返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', '指定したウィンドウが子ウィンドウの場合は親ウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウがトップレベルウィンドウの場合はオーナーウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウがオーナーを持たないトップレベルウィンドウだった場合および関数が失敗した場合は0(NULL)が返ります。');
Exit;
	end;

	Result := FGetWindowValue(GetParent(FhWindowHandle));
end;

(*
// GetScrollBarInfo ------------------------------------------------------------
procedure T_MyAPIValue.FGetScrollBarInfo;
const
	lcsSTRUCT_SCROLLBARINFO = lcsSTRUCT_CRLF +
'typedef struct tagSCROLLBARINFO {' + lcsCRLF +
'  DWORD cbSize;                         //この構造体のサイズ(必ずセットすること)' + lcsCRLF +
'  RECT  rcScrollBar;                    //スクロールバーの矩形領域(RECT)' + lcsCRLF +
'  int   dxyLineButton;                  //つまみの高さまたは幅' + lcsCRLF +
'  int   xyThumbTop;                     //つまみのTopまたはLeftの値' + lcsCRLF +
'  int   xyThumbBottom;                  //つまみのBottomまたはRightの値' + lcsCRLF +
'  int   reserved;                       //予約' + lcsCRLF +
'  DWORD rgstate[CCHILDREN_SCROLLBAR+1]; //スクロールバーの各要素の状態' + lcsCRLF +
'} SCROLLBARINFO, *PSCROLLBARINFO, *LPSCROLLBARINFO;'
;
const
	lcs_DECLARATION = 'BOOL GetScrollBarInfo(HWND hwnd, LONG idObject, PSCROLLBARINFO psbi);';
	lcs_DESCRIPTION =
'指定されたスクロールバーの情報を取得します。' + lcsCRLF +
'hwnd     調べたいスクロールバーに関連付けられたウィンドウのハンドルを指定' + lcsCRLF +
'idObject スクロールバーの種類を指定' + lcsCRLF +
' OBJID_CLIENT	hwndはスクロールバーコントロールのハンドル' + lcsCRLF +
' OBJID_HSCROLL	hwndで指定したウィンドウの水平スクロールバー' + lcsCRLF +
' OBJID_VSCROLL	hwndで指定したウィンドウの垂直スクロールバー' + lcsCRLF +
'psbi     情報を受け取るSCROLLBARINFO構造体の変数のポインタを指定' + lcsCRLF +
'戻り値   関数が成功すると0以外の値(True)が返り、失敗すると0(False)が返ります。' + lcsCRLF +
lcsSTRUCT_SCROLLBARINFO +
lcsCRLF + lcsCRLF +
'rgstate配列の内容' + lcsCRLF +
'0 スクロールバーの状態' + lcsCRLF +
'1 ↑または→ボタンの状態' + lcsCRLF +
'2 ページアップエリアの状態' + lcsCRLF +
'3 つまみの状態' + lcsCRLF +
'4 ページダウンエリアの状態' + lcsCRLF +
'5 ↓または←ボタンの状態' + lcsCRLF +// lcsCRLF +
'状態の内容' + lcsCRLF +
'STATE_SYSTEM_INVISIBLE   = 0x00008000 非表示' + lcsCRLF +
'STATE_SYSTEM_OFFSCREEN   = 0x00010000 非可視状態' + lcsCRLF +
'STATE_SYSTEM_PRESSED     = 0x00000008 押下状態' + lcsCRLF +
'STATE_SYSTEM_UNAVAILABLE = 0x00000001 無効'
;
	function _GetStateValue(sStr: String; iState: DWORD): String;
	var
		ls_State : String;
	begin
		ls_State := '';
		if (gfnbFlagCheck(iState, STATE_SYSTEM_INVISIBLE))   then ls_State := ls_State + ' 非表示';
		if (gfnbFlagCheck(iState, STATE_SYSTEM_OFFSCREEN))   then ls_State := ls_State + ' 非可視状態';
		if (gfnbFlagCheck(iState, STATE_SYSTEM_PRESSED))     then ls_State := ls_State + ' 押下状態';
		if (gfnbFlagCheck(iState, STATE_SYSTEM_UNAVAILABLE)) then ls_State := ls_State + ' 無効';
		Result := Format('0x%.8x (%s)%s', [iState, sStr, ls_State]);
	end;
var
	l_Psbi : TScrollBarInfo;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',                    '情報を取得するスクロールバーのハンドルを指定します。');
		FAddElement('idObject: OBJID_CLIENT',  'hwndはスクロールバー自身');
		FAddElement(' psbi.rcScrollBar',       'スクロールバーのRECT。');
		FAddElement(' psbi.dxyLineButton',     'つまみの高さまたは幅。');
		FAddElement(' psbi.xyThumbTop',        'つまみのTopまたはLeftの値。');
		FAddElement(' psbi.xyThumbBottom',     'つまみのBottomまたはRightの値。');
		FAddElement(' psbi.rgstate[0]',        'スクロールバーの状態。');
		FAddElement(' psbi.rgstate[1]',        '↑または→ボタンの状態。');
		FAddElement(' psbi.rgstate[2]',        'ページアップエリアの状態。');
		FAddElement(' psbi.rgstate[3]',        'つまみの状態。');
		FAddElement(' psbi.rgstate[4]',        'ページダウンエリアの状態。');
		FAddElement(' psbi.rgstate[5]',        '↓または←ボタンの状態。');

		FAddElement('idObject: OBJID_HSCROLL', 'hwndで指定したウィンドウの水平スクロールバー');
		FAddElement(' psbi.rcScrollBar',       'スクロールバーのRECT。');
		FAddElement(' psbi.dxyLineButton',     'つまみの高さ。');
		FAddElement(' psbi.xyThumbTop',        'つまみのLeftの値。');
		FAddElement(' psbi.xyThumbBottom',     'つまみのRightの値。');
		FAddElement(' psbi.rgstate[0]',        'スクロールバーの状態。');
		FAddElement(' psbi.rgstate[1]',        '↑または→ボタンの状態。');
		FAddElement(' psbi.rgstate[2]',        'ページアップエリアの状態。');
		FAddElement(' psbi.rgstate[3]',        'つまみの状態。');
		FAddElement(' psbi.rgstate[4]',        'ページダウンエリアの状態。');
		FAddElement(' psbi.rgstate[5]',        '↓または←ボタンの状態。');

		FAddElement('idObject: OBJID_VSCROLL', 'hwndで指定したウィンドウの垂直スクロールバー');
		FAddElement(' psbi.rcScrollBar',       'スクロールバーのRECT。');
		FAddElement(' psbi.dxyLineButton',     'つまみの幅。');
		FAddElement(' psbi.xyThumbTop',        'つまみのTopの値。');
		FAddElement(' psbi.xyThumbBottom',     'つまみのBottomの値。');
		FAddElement(' psbi.rgstate[0]',        'スクロールバーの状態。');
		FAddElement(' psbi.rgstate[1]',        '↑または→ボタンの状態。');
		FAddElement(' psbi.rgstate[2]',        'ページアップエリアの状態。');
		FAddElement(' psbi.rgstate[3]',        'つまみの状態。');
		FAddElement(' psbi.rgstate[4]',        'ページダウンエリアの状態。');
		FAddElement(' psbi.rgstate[5]',        '↓または←ボタンの状態。');
		FAddElement('戻り値',                  '関数が成功すると0以外の値(True)が返り、失敗すると0(False)が返ります。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		FillChar(l_Psbi, 0, SizeOf(l_Psbi));
		l_Psbi.cbSize := SizeOf(l_Psbi);
		FAddBoolValue(GetScrollBarInfo(FhWndHandle, Longint(OBJID_CLIENT), l_Psbi));
		FAddRectValue(l_Psbi.rcScrollBar);
		FAddIntValue (l_Psbi.dxyLineButton);
		FAddIntValue (l_Psbi.xyThumbTop);
		FAddIntValue (l_Psbi.xyThumbBottom);
		FAddStrValue (_GetStateValue ('スクロールバー',     l_Psbi.rgstate[0]));
		FAddStrValue (_GetStateValue ('↑または→ボタン',   l_Psbi.rgstate[1]));
		FAddStrValue (_GetStateValue ('ページアップエリア', l_Psbi.rgstate[2]));
		FAddStrValue (_GetStateValue ('つまみ',             l_Psbi.rgstate[3]));
		FAddStrValue (_GetStateValue ('ページダウンエリア', l_Psbi.rgstate[4]));
		FAddStrValue (_GetStateValue ('↓または←ボタン',   l_Psbi.rgstate[5]));

//横スクロール
		FillChar(l_Psbi, 0, SizeOf(l_Psbi));
		l_Psbi.cbSize := SizeOf(l_Psbi);
		FAddBoolValue(GetScrollBarInfo(FhWndHandle, Longint(OBJID_HSCROLL), l_Psbi));
		FAddRectValue(l_Psbi.rcScrollBar);
		FAddIntValue (l_Psbi.dxyLineButton);
		FAddIntValue (l_Psbi.xyThumbTop);
		FAddIntValue (l_Psbi.xyThumbBottom);
		FAddStrValue (_GetStateValue ('スクロールバー',     l_Psbi.rgstate[0]));
		FAddStrValue (_GetStateValue ('↑または→ボタン',   l_Psbi.rgstate[1]));
		FAddStrValue (_GetStateValue ('ページアップエリア', l_Psbi.rgstate[2]));
		FAddStrValue (_GetStateValue ('つまみ',             l_Psbi.rgstate[3]));
		FAddStrValue (_GetStateValue ('ページダウンエリア', l_Psbi.rgstate[4]));
		FAddStrValue (_GetStateValue ('↓または←ボタン',   l_Psbi.rgstate[5]));

//縦スクロール
		FillChar(l_Psbi, 0, SizeOf(l_Psbi));
		l_Psbi.cbSize := SizeOf(l_Psbi);
		FAddBoolValue(GetScrollBarInfo(FhWndHandle, Longint(OBJID_VSCROLL), l_Psbi));
		FAddRectValue(l_Psbi.rcScrollBar);
		FAddIntValue (l_Psbi.dxyLineButton);
		FAddIntValue (l_Psbi.xyThumbTop);
		FAddIntValue (l_Psbi.xyThumbBottom);
		FAddStrValue (_GetStateValue ('スクロールバー',     l_Psbi.rgstate[0]));
		FAddStrValue (_GetStateValue ('↑または→ボタン',   l_Psbi.rgstate[1]));
		FAddStrValue (_GetStateValue ('ページアップエリア', l_Psbi.rgstate[2]));
		FAddStrValue (_GetStateValue ('つまみ',             l_Psbi.rgstate[3]));
		FAddStrValue (_GetStateValue ('ページダウンエリア', l_Psbi.rgstate[4]));
		FAddStrValue (_GetStateValue ('↓または←ボタン',   l_Psbi.rgstate[5]));
	end;
end;

// GetScrollInfo ---------------------------------------------------------------
procedure T_MyAPIValue.FGetScrollInfo;
const
	lcsSTRUCT_SCROLLINFO = lcsSTRUCT_CRLF +
'typedef struct tagSCROLLINFO {' + lcsCRLF +
'  UINT cbSize;    //構造体のサイズ' + lcsCRLF +
'  UINT fMask;     //設定・変更用フラグ' + lcsCRLF +
'  int  nMin;      //スクロールする最小値' + lcsCRLF +
'  int  nMax;      //スクロールする最大値' + lcsCRLF +
'  UINT nPage;     //ページサイズ' + lcsCRLF +
'  int  nPos;      //スクロールバーのつまみの現在の位置' + lcsCRLF +
'  int  nTrackPos; //現在のトラッキング位置' + lcsCRLF +
'} SCROLLINFO;'
;
const
	//function GetScrollInfo(hWnd: HWND; BarFlag: Integer; var ScrollInfo: TScrollInfo): BOOL; stdcall;
	lcs_DECLARATION = 'BOOL GetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi);';
	lcs_DESCRIPTION =
'指定されたスクロールバーのさまざまなパラメータを取得します。' + lcsCRLF +
'hwnd     調べたいスクロールバーに関連付けられたウィンドウのハンドルを指定' + lcsCRLF +
'fnBar    スクロールバーの種類を指定' + lcsCRLF +
' SB_CTL  hwndはスクロールバーコントロールのハンドル' + lcsCRLF +
' SB_HORZ hwndで指定したウィンドウの水平スクロールバー' + lcsCRLF +
' SB_VERT hwndで指定したウィンドウの垂直スクロールバー' + lcsCRLF +
'lpsi     情報を受け取るSCROLLINFO構造体の変数のポインタを指定' + lcsCRLF +
'戻り値   なんらかの情報を取得した場合0以外の値が、何も情報も取得しなかった場合0が返ります。' + lcsCRLF +
lcsSTRUCT_SCROLLINFO
;
var
	l_ScrollInfo : TScrollInfo;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',            '情報を取得するスクロールバーのハンドルを指定します。');
		FAddElement('fnBar: SB_CTL',   'hwndはスクロールバー自身のハンドルでその各種パラメータを取得します。');
		FAddElement(' lpsi.nMin',      'スクロールする最小値。');
		FAddElement(' lpsi.nMax',      'スクロールする最大値。');
		FAddElement(' lpsi.nPage',     'ページサイズ。');
		FAddElement(' lpsi.nPos',      'スクロールバーのつまみの現在の位置。');
		FAddElement(' lpsi.nTrackPos', '現在のトラッキング位置。');
		FAddElement('fnBar: SB_HORZ',  'hwndで指定したウィンドウの水平スクロールバーの各種パラメータを取得します。');
		FAddElement(' lpsi.nMin',      'スクロールする最小値。');
		FAddElement(' lpsi.nMax',      'スクロールする最大値。');
		FAddElement(' lpsi.nPage',     'ページサイズ。');
		FAddElement(' lpsi.nPos',      'スクロールバーのつまみの現在の位置。');
		FAddElement(' lpsi.nTrackPos', '現在のトラッキング位置。');
		FAddElement('fnBar: SB_VERT',  'hwndで指定したウィンドウの垂直スクロールバーの各種パラメータを取得します。');
		FAddElement(' lpsi.nMin',      'スクロールする最小値。');
		FAddElement(' lpsi.nMax',      'スクロールする最大値。');
		FAddElement(' lpsi.nPage',     'ページサイズ。');
		FAddElement(' lpsi.nPos',      'スクロールバーのつまみの現在の位置。');
		FAddElement(' lpsi.nTrackPos', '現在のトラッキング位置。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		FillChar(l_ScrollInfo, 0, SizeOf(l_ScrollInfo));
		l_ScrollInfo.cbSize := SizeOf(l_ScrollInfo);
		l_ScrollInfo.fMask  := SIF_ALL;
		FAddBoolValue(GetScrollInfo(FhWndHandle, SB_CTL, l_ScrollInfo));
		FAddIntValue (l_ScrollInfo.nMin);
		FAddIntValue (l_ScrollInfo.nMax);
		FAddIntValue (l_ScrollInfo.nPage);
		FAddIntValue (l_ScrollInfo.nPos);
		FAddIntValue (l_ScrollInfo.nTrackPos);

		FillChar(l_ScrollInfo, 0, SizeOf(l_ScrollInfo));
		l_ScrollInfo.cbSize := SizeOf(l_ScrollInfo);
		l_ScrollInfo.fMask  := SIF_ALL;
		FAddBoolValue(GetScrollInfo(FhWndHandle, SB_HORZ, l_ScrollInfo));
		FAddIntValue (l_ScrollInfo.nMin);
		FAddIntValue (l_ScrollInfo.nMax);
		FAddIntValue (l_ScrollInfo.nPage);
		FAddIntValue (l_ScrollInfo.nPos);
		FAddIntValue (l_ScrollInfo.nTrackPos);

		FillChar(l_ScrollInfo, 0, SizeOf(l_ScrollInfo));
		l_ScrollInfo.cbSize := SizeOf(l_ScrollInfo);
		l_ScrollInfo.fMask  := SIF_ALL;
		FAddBoolValue(GetScrollInfo(FhWndHandle, SB_VERT, l_ScrollInfo));
		FAddIntValue (l_ScrollInfo.nMin);
		FAddIntValue (l_ScrollInfo.nMax);
		FAddIntValue (l_ScrollInfo.nPage);
		FAddIntValue (l_ScrollInfo.nPos);
		FAddIntValue (l_ScrollInfo.nTrackPos);
	end;
end;

// GetScrollPos ----------------------------------------------------------------
procedure T_MyAPIValue.FGetScrollPos;
const
	lcs_DECLARATION = 'int GetScrollPos(HWND hWnd, int nBar);';
	lcs_DESCRIPTION =
'指定されたスクロールバーのつまみの位置を取得します。' + lcsCRLF +
'hWnd     調べたいスクロールバーに関連付けられたウィンドウのハンドルを指定' + lcsCRLF +
'nBar     スクロールバーの種類を指定' + lcsCRLF +
' SB_CTL  hWndはスクロールバーコントロールのハンドル' + lcsCRLF +
' SB_HORZ hWndで指定したウィンドウの水平スクロールバー' + lcsCRLF +
' SB_VERT hWndで指定したウィンドウの垂直スクロールバー' + lcsCRLF +
'戻り値   関数が成功するとスクロールバーのつまみの位置が返り、失敗すると0(False)が返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hWnd',          '情報を取得するスクロールバーのハンドルを指定します。');
		FAddElement('nBar: SB_CTL',  'hWndはスクロールバー自身のハンドルでそのつまみの位置を返します。');
		FAddElement('nBar: SB_HORZ', 'hWndで指定したウィンドウの水平スクロールバーのつまみの位置を返します。');
		FAddElement('nBar: SB_VERT', 'hWndで指定したウィンドウの垂直スクロールバーのつまみの位置を返します。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		FAddIntValue(GetScrollPos(FhWndHandle, SB_CTL));
		FAddIntValue(GetScrollPos(FhWndHandle, SB_HORZ));
		FAddIntValue(GetScrollPos(FhWndHandle, SB_VERT));
	end;
end;

// GetScrollRange --------------------------------------------------------------
procedure T_MyAPIValue.FGetScrollRange;
const
//function GetScrollRange(hWnd: HWND; nBar: Integer; var lpMinPos, lpMaxPos: Integer): BOOL; stdcall;
	lcs_DECLARATION = 'BOOL GetScrollRange(HWND hWnd, int nBar, LPINT lpMinPos, LPINT lpMaxPos);';
	lcs_DESCRIPTION =
'指定されたスクロールバーのつまみの最大位置と最小位置を取得します。' + lcsCRLF +
'hWnd     調べたいスクロールバーに関連付けられたウィンドウのハンドルを指定' + lcsCRLF +
'nBar     スクロールバーの種類を指定' + lcsCRLF +
' SB_CTL  hWndはスクロールバーコントロールのハンドル' + lcsCRLF +
' SB_HORZ hWndで指定したウィンドウの水平スクロールバー' + lcsCRLF +
' SB_VERT hWndで指定したウィンドウの垂直スクロールバー' + lcsCRLF +
'lpMinPos つまみの最小位置が格納される変数へのポインタを指定' + lcsCRLF +
'lpMaxPos つまみの最大位置が格納される変数へのポインタを指定' + lcsCRLF +
'戻り値   関数が成功すると0以外の値(True)が返り、失敗すると0(False)が返ります。'
;
var
	li_MinPos : Integer;
	li_MaxPos : Integer;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hWnd',          '情報を取得するスクロールバーのハンドルを指定します。');
		FAddElement('nBar: SB_CTL',  'hWndはスクロールバー自身のハンドルでそのつまみの最小位置と最大位置を取得します。');
		FAddElement(' lpMinPos',     'つまみの最小位置が格納されます。');
		FAddElement(' lpMaxPos',     'つまみの最大位置が格納されます。');
		FAddElement('nBar: SB_HORZ', 'hWndで指定したウィンドウの水平スクロールバーのつまみの最小位置と最大位置を取得します。');
		FAddElement(' lpMinPos',     'つまみの最小位置が格納されます。');
		FAddElement(' lpMaxPos',     'つまみの最大位置が格納されます。');
		FAddElement('nBar: SB_VERT', 'hWndで指定したウィンドウの垂直スクロールバーのつまみの最小位置と最大位置を取得します。');
		FAddElement(' lpMinPos',     'つまみの最小位置が格納されます。');
		FAddElement(' lpMaxPos',     'つまみの最大位置が格納されます。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		li_MinPos := 0;
		li_MaxPos := 0;
		FAddBoolValue(GetScrollRange(FhWndHandle, SB_CTL, li_MinPos, li_MaxPos));
		FAddIntValue (li_MinPos);
		FAddIntValue (li_MaxPos);
		FAddBoolValue(GetScrollRange(FhWndHandle, SB_HORZ, li_MinPos, li_MaxPos));
		FAddIntValue (li_MinPos);
		FAddIntValue (li_MaxPos);
		FAddBoolValue(GetScrollRange(FhWndHandle, SB_VERT, li_MinPos, li_MaxPos));
		FAddIntValue (li_MinPos);
		FAddIntValue (li_MaxPos);
	end;
end;


// GetTitleBarInfo -------------------------------------------------------------
//D6のGetTitleBarInfoの宣言が間違っているためここで再宣言する。
function GetTitleBarInfo(hwnd: HWND; var pti: TTitleBarInfo): BOOL; stdcall; external user32 name 'GetTitleBarInfo';

procedure T_MyAPIValue.FGetTitleBarInfo;
const
	lcsSTRUCT_TITLEBARINFO = lcsSTRUCT_CRLF +
'typedef struct tagTITLEBARINFO {' + lcsCRLF +
'  DWORD   cbSize;                           //構造体のサイズ(必ずセットすること)' + lcsCRLF +
'  RECT    rcTitleBar;                       //タイトルバーの矩形領域(RECT)' + lcsCRLF +
'  DWORD   rgstate[CCHILDREN_TITLEBAR + 1];  //登録ステータス' + lcsCRLF +
'} TITLEBARINFO, *LPTITLEBARINFO;'
;
const
	lcs_DECLARATION = 'BOOL GetTitleBarInfo(HWND hwnd, PTITLEBARINFO pti);';
	lcs_DESCRIPTION =
'指定されたウィンドウのタイトルバーの情報を取得します。' + lcsCRLF +
'hwnd   調べたいウィンドウのハンドルを指定' + lcsCRLF +
'pti    情報を受け取るTITLEBARINFO構造体の変数のポインタを指定' + lcsCRLF +
'戻り値 関数が成功すると0以外の値(True)が返り、失敗すると0(False)が返ります。' + lcsCRLF +
lcsSTRUCT_TITLEBARINFO +
lcsCRLF + lcsCRLF +
'rgstate配列の内容' + lcsCRLF +
'0 タイトルバーの状態' + lcsCRLF +
'1 予約' + lcsCRLF +
'2 最小化ボタンの状態' + lcsCRLF +
'3 最大化ボタンの状態' + lcsCRLF +
'4 閉じるボタンの状態' + lcsCRLF +
'5 ヘルプボタンの状態' + lcsCRLF +// lcsCRLF +
'状態の内容' + lcsCRLF +
'STATE_SYSTEM_FOCUSABLE   = 0x00100000 フォーカス可能' + lcsCRLF +
'STATE_SYSTEM_INVISIBLE   = 0x00008000 非表示' + lcsCRLF +
'STATE_SYSTEM_OFFSCREEN   = 0x00010000 非可視状態' + lcsCRLF +
'STATE_SYSTEM_UNAVAILABLE = 0x00000001 無効' + lcsCRLF +
'STATE_SYSTEM_PRESSED     = 0x00000008 押下状態'
;
	function _GetStateValue(sStr: String; iState: DWORD): String;
	var
		ls_State : String;
	begin
		ls_State := '';
		if (gfnbFlagCheck(iState, STATE_SYSTEM_FOCUSABLE))   then ls_State := ls_State + ' フォーカス可能';
		if (gfnbFlagCheck(iState, STATE_SYSTEM_INVISIBLE))   then ls_State := ls_State + ' 非表示';
		if (gfnbFlagCheck(iState, STATE_SYSTEM_OFFSCREEN))   then ls_State := ls_State + ' 非可視状態';
		if (gfnbFlagCheck(iState, STATE_SYSTEM_UNAVAILABLE)) then ls_State := ls_State + ' 無効';
		if (gfnbFlagCheck(iState, STATE_SYSTEM_PRESSED))     then ls_State := ls_State + ' 押下状態';
		Result := Format('0x%.8x (%s)%s', [iState, sStr, ls_State]);
	end;
var
	lb_Ret : BOOL;
	l_Pti  : TTitleBarInfo;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',           '情報を取得するタイトルバーのハンドルを指定します。');
		FAddElement('pti.cbSize',     '構造体のサイズをセットします。'#13#10'例) pti.cbSize := SizeOf(pti);');
		FAddElement('pti.rcTitleBar', 'タイトルバーのRECT。ただしシステムメニューの部分は含まない。');
		FAddElement('pti.rgstate[0]', 'タイトルバーの状態。');
		FAddElement('pti.rgstate[1]', '予備');
		FAddElement('pti.rgstate[2]', '最小化ボタンの状態。');
		FAddElement('pti.rgstate[3]', '最大化ボタンの状態。');
		FAddElement('pti.rgstate[4]', 'ヘルプボタンの状態。');
		FAddElement('pti.rgstate[5]', '閉じるボタンの状態。');
		FAddElement('戻り値',         '関数が成功すると0以外の値(True)が返り、失敗すると0(False)が返ります。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		FillChar(l_Pti, 0, SizeOf(l_Pti));
		l_Pti.cbSize := SizeOf(l_Pti);
		lb_Ret := GetTitleBarInfo(FhWndHandle, l_Pti);

		FAddIntValue (l_Pti.cbSize);
		FAddRectValue(l_Pti.rcTitleBar);
		FAddStrValue (_GetStateValue ('タイトルバー', l_Pti.rgstate[0]));
		FAddStrValue (_GetStateValue ('予備',         l_Pti.rgstate[1]));
		FAddStrValue (_GetStateValue ('最小化ボタン', l_Pti.rgstate[2]));
		FAddStrValue (_GetStateValue ('最大化ボタン', l_Pti.rgstate[3]));
		FAddStrValue (_GetStateValue ('ヘルプボタン', l_Pti.rgstate[4]));
		FAddStrValue (_GetStateValue ('閉じるボタン', l_Pti.rgstate[5]));
		FAddBoolValue(lb_Ret);
	end;
end;
*)

// GetTopWindow ----------------------------------------------------------------
function T_MyAPITest.FGetTopWindow: String;
const
	lcs_DECLARATION = 'HWND GetTopWindow(HWND hWnd);';
	lcs_DESCRIPTION =
'指定されたウィンドウが持つ子ウィンドウのうちのZオーダーが一番上のウィンドウのハンドルを返します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定します。' + lcsCRLF +
'戻り値 Zオーダーが一番上(一番手前)の子ウィンドウのハンドルが返ります。指定したウィンドウが子ウィンドウを持たない場合は0(NULL)が返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', '関数が成功するとZオーダーが一番上の子ウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウが子ウィンドウを持たない場合は0(NULL)が返ります。');
Exit;
	end;

	Result := FGetWindowValue(GetTopWindow(FhWindowHandle));
end;

// GetWindow -------------------------------------------------------------------
function T_MyAPITest.FGetWindow: String;
const
	lcs_DECLARATION = 'HWND GetWindow(HWND hWnd, UINT uCmd);';
	lcs_DESCRIPTION =
'指定されたウィンドウと指定された関係にあるウィンドウのハンドルを返します。' + lcsTITLE_CRLF +
'hwnd 調べたいウィンドウのハンドルを指定します。' + lcsCRLF +
'uCmd ウィンドウとの関係を示す以下の値を指定します。' + lcsCRLF +
' GW_CHILD        Zオーダーが一番上の子ウィンドウ。' + lcsCRLF +
' GW_ENABLEDPOPUP 有効なポップアップウィンドウ。' + lcsCRLF +
' GW_HWNDFIRST    同じ種類で最も高いZオーダーを持つウィンドウ。' + lcsCRLF +
' GW_HWNDLAST     同じ種類で最も低いZオーダーを持つウィンドウ。' + lcsCRLF +
' GW_HWNDNEXT     Zオーダーが一つ下のウィンドウ。' + lcsCRLF +
' GW_HWNDPREV     Zオーダーが一つ上のウィンドウ。' + lcsCRLF +
' GW_OWNER        オーナーウィンドウ。'
;
const
	GW_ENABLEDPOPUP = 6;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('uCmd: GW_CHILD',        'uCmdにGW_CHILDを指定した時の戻り値。'        + lcsCRLF + '指定したウィンドウが親ウィンドウの場合はZオーダーが一番上の子ウィンドウのハンドルを取得します。' + lcsCRLF + 'それ以外の場合はNULLが返ります。');
		FAddParam('uCmd: GW_ENABLEDPOPUP', 'uCmdにGW_ENABLEDPOPUPを指定した時の戻り値。' + lcsCRLF + '指定したウィンドウをオーナーとする有効なポップアップウィンドウのハンドルを取得します(この検索ではGW_HWNDNEXTで見つかる最初のウィンドウを使います)。' + lcsCRLF + '有効なポップアップウィンドウがない場合は指定したウィンドウのハンドルが返ります。');
		FAddParam('uCmd: GW_HWNDFIRST',    'uCmdにGW_HWNDFIRSTを指定した時の戻り値。'    + lcsCRLF + '指定したウィンドウと同じ種類で最も高いZオーダーを持つウィンドウのハンドルを取得します。' + lcsCRLF + '指定したウィンドウが最前面ウィンドウの場合は最も高いZオーダーを持つ最前面ウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウがトップレベルウィンドウの場合は最も高いZオーダーを持つトップレベルウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウが子ウィンドウの場合は最も高いZオーダーを持つ兄弟ウィンドウのハンドルが返ります。');
		FAddParam('uCmd: GW_HWNDLAST',     'uCmdにGW_HWNDLASTを指定した時の戻り値。'     + lcsCRLF + '指定したウィンドウと同じ種類で最も低いZオーダーを持つウィンドウのハンドルを取得します。' + lcsCRLF + '指定したウィンドウが最前面ウィンドウの場合は最も低いZオーダーを持つ最前面ウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウがトップレベルウィンドウの場合は最も低いZオーダーを持つトップレベルウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウが子ウィンドウの場合は最も低いZオーダーを持つ兄弟ウィンドウのハンドルが返ります。');
		FAddParam('uCmd: GW_HWNDNEXT',     'uCmdにGW_HWNDNEXTを指定した時の戻り値。'     + lcsCRLF + '指定したウィンドウよりZオーダーが一つ下のウィンドウのハンドルを取得します。' + lcsCRLF + '指定したウィンドウが最前面ウィンドウの場合は一つ下の最前面ウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウがトップレベルウィンドウの場合は一つ下のトップレベルウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウが子ウィンドウの場合は一つ下の兄弟ウィンドウのハンドルが返ります。');
		FAddParam('uCmd: GW_HWNDPREV',     'uCmdにGW_HWNDPREVを指定した時の戻り値。'     + lcsCRLF + '指定したウィンドウよりZオーダーが一つ上のウィンドウのハンドルを取得します。' + lcsCRLF + '指定したウィンドウが最前面ウィンドウの場合は一つ上の最前面ウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウがトップレベルウィンドウの場合は一つ上のトップレベルウィンドウのハンドルが返ります。' + lcsCRLF + '指定したウィンドウが子ウィンドウの場合は一つ上の兄弟ウィンドウのハンドルが返ります。');
		FAddParam('uCmd: GW_OWNER',        'uCmdにGW_OWNERを指定した時の戻り値。'        + lcsCRLF + '指定したウィンドウのオーナーウィンドウのハンドルを取得します。');
Exit;
	end;

	case FiParamIndex of
		0: Result := FGetWindowValue(GetWindow(FhWindowHandle, GW_CHILD));
		1: Result := FGetWindowValue(GetWindow(FhWindowHandle, GW_ENABLEDPOPUP));
		2: Result := FGetWindowValue(GetWindow(FhWindowHandle, GW_HWNDFIRST));
		3: Result := FGetWindowValue(GetWindow(FhWindowHandle, GW_HWNDLAST));
		4: Result := FGetWindowValue(GetWindow(FhWindowHandle, GW_HWNDNEXT));
		5: Result := FGetWindowValue(GetWindow(FhWindowHandle, GW_HWNDPREV));
		6: Result := FGetWindowValue(GetWindow(FhWindowHandle, GW_OWNER));
	end;
end;

(*
// GetWindowInfo ---------------------------------------------------------------
procedure T_MyAPIValue.FGetWindowInfo;
const
	lcsSTRUCT_WINDOWINFO = lcsSTRUCT_CRLF +
'typedef struct tagWINDOWINFO {' + lcsCRLF +
'	DWORD cbSize;           //構造体のサイズ(必ずセットすること)' + lcsCRLF +
'	RECT  rcWindow;         //ウィンドウ全体の矩形領域(RECT)' + lcsCRLF +
'	RECT  rcClient;         //クライアント領域のスクリーン座標での矩形領域(RECT)' + lcsCRLF +
'	DWORD dwStyle;          //ウィンドウスタイル' + lcsCRLF +
'	DWORD dwExStyle;        //拡張ウィンドウスタイル' + lcsCRLF +
'	DWORD dwWindowStatus;   //ウィンドウの状態' + lcsCRLF +
'	UINT  cxWindowBorders;  //フレームの境界線の幅' + lcsCRLF +
'	UINT  cyWindowBorders;  //フレームの境界線の高さ' + lcsCRLF +
'	ATOM  atomWindowType;   //ウィンドウクラスのアトム' + lcsCRLF +
'	WORD  wCreatorVersion;  //Windowsのバージョン番号' + lcsCRLF +
'} WINDOWINFO, *PWINDOWINFO, *LPWINDOWINFO;'
;
const
	lcs_DECLARATION = 'BOOL GetWindowInfo(HWND hwnd, PWINDOWINFO pwi);';
	lcs_DESCRIPTION =
'指定されたウィンドウの情報を取得します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定' + lcsCRLF +
'pwi    情報を受け取るWINDOWINFO構造体の変数のポインタを指定' + lcsCRLF +
'戻り値 関数が成功すると0以外の値(True)が、失敗すると0(False)が返ります。' + lcsCRLF +
lcsSTRUCT_WINDOWINFO
;
var
	lb_Ret : Bool;
	l_Pwi  : TWindowInfo;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',                '調べたいウィンドウのハンドルを指定します。');
		FAddElement('pwi.cbSize',          'この構造体のサイズを指定します。');
		FAddElement('pwi.rcWindow',        'ウィンドウ全体の矩形領域(RECT)がスクリーン座標でセットされます。GetWindowRectで取得される値と同じです。');
		FAddElement('pwi.rcClient',        'ウィンドウのクライアントの矩形領域(RECT)がスクリーン座標でセットされます。GetClientRectで取得される値とは違います。');
		FAddElement('pwi.dwStyle',         'ウィンドウのスタイル。');
		FAddElement('pwi.dwExStyle',       'ウィンドウの拡張スタイル。');
		FAddElement('pwi.dwWindowStatus',  'ウインドウの状態。アクティブの時はWS_ACTIVECAPTION、それ以外の時は0がセットされます。');
		FAddElement('pwi.cxWindowBorders', '境界線の幅(ピクセル)');
		FAddElement('pwi.cyWindowBorders', '境界線の高さ(ピクセル)');
		FAddElement('pwi.atomWindowType',  'ウインドウクラスのアトム');
		FAddElement('pwi.wCreatorVersion', 'ウインドウを作成した時のWindowsのバージョン番号');
		FAddElement('戻り値',              '関数が成功すると0以外の値(True)が返ります。関数が失敗すると0(False)が返ります。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	FillChar(l_Pwi, 0, SizeOf(l_Pwi));
	l_Pwi.cbSize := SizeOf(l_Pwi);
	lb_Ret := GetWindowInfo(FhWndHandle, l_Pwi);

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		FAddIntValue (l_Pwi.cbSize);
		FAddRectValue(l_Pwi.rcWindow);
		FAddRectValue(l_Pwi.rcClient);
		FAddHexValue (l_Pwi.dwStyle);
		FAddHexValue (l_Pwi.dwExStyle);
		FAddHexValue (l_Pwi.dwOtherStuff);
		FAddIntValue (l_Pwi.cxWindowBorders);
		FAddIntValue (l_Pwi.cyWindowBorders);
		FAddHexValue (l_Pwi.atomWindowType, 4);
		FAddIntValue (l_Pwi.wCreatorVersion);
		FAddBoolValue(lb_Ret);
	end;
end;

// GetWindowLong ---------------------------------------------------------------
procedure T_MyAPIValue.FGetWindowLong;
const
	lcs_DECLARATION = 'LONG GetWindowLong(HWND hWnd, int nIndex);';
	lcs_DESCRIPTION =
'指定されたウィンドウに関する情報を取得します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定' + lcsCRLF +
'nIndex 取得するデータのインデックスを指定' + lcsCRLF +
' GWL_EXSTYLE    拡張ウィンドウスタイルを取得' + lcsCRLF +
' GWL_STYLE      ウィンドウスタイルを取得' + lcsCRLF +
' GWL_WNDPROC    ウィンドウプロシージャのアドレスまたはウィンドウプロシージャのアドレスを示すハンドルを取得' + lcsCRLF +
' GWL_HINSTANCE  アプリケーションのインスタンスハンドルを取得' + lcsCRLF +
' GWL_HWNDPARENT 親ウィンドウがあればそのハンドルを取得' + lcsCRLF +
' GWL_ID         ウィンドウのIDを取得' + lcsCRLF +
' GWL_USERDATA   ウィンドウに関連付けられている32ビット値を取得' + lcsCRLF +
'戻り値 関数が成功すると要求した32ビットのデータが返ります。関数が失敗すると0が返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',                   '調べたいウィンドウのハンドルを指定します。');
		FAddElement('nIndex: GWL_EXSTYLE',    'nIndexにGWL_EXSTYLEを指定した時の戻り値。'    + lcsCRLF + '拡張ウィンドウスタイルを取得します。');
		FAddElement('nIndex: GWL_STYLE',      'nIndexにGWL_STYLEを指定した時の戻り値。'      + lcsCRLF + 'ウィンドウスタイルを取得します。');
		FAddElement('nIndex: GWL_WNDPROC',    'nIndexにGWL_WNDPROCを指定した時の戻り値。'    + lcsCRLF + 'ウィンドウプロシージャのアドレスまたはウィンドウプロシージャのアドレスを示すハンドルを取得します。');
		FAddElement('nIndex: GWL_HINSTANCE',  'nIndexにGWL_HINSTANCEを指定した時の戻り値。'  + lcsCRLF + 'アプリケーションのインスタンスハンドルを取得します。');
		FAddElement('nIndex: GWL_HWNDPARENT', 'nIndexにGWL_HWNDPARENTを指定した時の戻り値。' + lcsCRLF + '親ウィンドウがあればそのハンドルを取得します。');
		FAddElement('nIndex: GWL_ID',         'nIndexにGWL_IDを指定した時の戻り値。'         + lcsCRLF + 'ウィンドウのIDを取得します。');
		FAddElement('nIndex: GWL_USERDATA',   'nIndexにGWL_USERDATAを指定した時の戻り値。'   + lcsCRLF + 'ウィンドウに関連付けられている32ビット値を取得します。' + lcsCRLF + '各ウィンドウはそれに対応する32ビットの値を持っています。この値はウィンドウを作成したアプリケーションが自由に使用できるもので、0で初期化されています。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		FAddHexValue(GetWindowLong(FhWndHandle, GWL_EXSTYLE));
		FAddHexValue(GetWindowLong(FhWndHandle, GWL_STYLE));
		FAddHexValue(GetWindowLong(FhWndHandle, GWL_WNDPROC));
		FAddHexValue(GetWindowLong(FhWndHandle, GWL_HINSTANCE));
//		FAddHexValue(GetWindowLong(FhWndHandle, GWL_HWNDPARENT));
		FAddWindowValue(GetWindowLong(FhWndHandle, GWL_HWNDPARENT));
		FAddHexValue(GetWindowLong(FhWndHandle, GWL_ID));
		FAddHexValue(GetWindowLong(FhWndHandle, GWL_USERDATA));
	end;
end;


// GetWindowModuleFileName -----------------------------------------------------
//function GetWindowModuleFileName(hwnd: HWND; pszFileName: PChar; cchFileNameMax: UINT): UINT; stdcall; external user32 name 'GetWindowModuleFileNameW';
type
	TGetWindowModuleFileName = function(hwnd: HWND; pszFileName: PChar; cchFileNameMax: UINT): UINT; stdcall;

function GetWindowModuleFileName(hwnd: HWND; pszFileName: PChar; cchFileNameMax: UINT): UINT;
var
	ls_Path   : String;
	lh_Module : HMODULE;
	l_GetWindowModuleFileName : TGetWindowModuleFileName;
begin
	Result := 0;

	ls_Path := gfnsSystem32DirGet;
	lh_Module := LoadLibrary(PChar(ls_Path + 'user32.dll'));
	if (lh_Module <> 0)
	then begin
		try
			// GetWindowModuleFileName の関数ポインタを取得
			@l_GetWindowModuleFileName := GetProcAddress(lh_Module, 'GetWindowModuleFileNameW');
			if (@l_GetWindowModuleFileName <> nil)
			then begin
				Result := l_GetWindowModuleFileName(
					hwnd,
					pszFileName,
					cchFileNameMax
				);
			end;
		finally
			FreeLibrary(lh_Module);
		end;
	end;
end;
*)

// GetWindowPlacement ----------------------------------------------------------
function T_MyAPITest.FGetWindowPlacement: String;
const
lcsSTRUCT_WINDOWPLACEMENT = lcsSTRUCT_CRLF +
'typedef struct tagWINDOWPLACEMENT {' + lcsCRLF +
'  UINT  length;           //構造体のサイズ(必ずセットすること)' + lcsCRLF +
'  UINT  flags;            //最小化されたウインドウの位置および復帰方法を指定する定数を指定' + lcsCRLF +
'  UINT  showCmd;          //表示状態を指定する定数を指定' + lcsCRLF +
'  POINT ptMinPosition;    //最小化時の表示位置' + lcsCRLF +
'  POINT ptMaxPosition;    //最大化時の表示位置' + lcsCRLF +
'  RECT  rcNormalPosition; //通常時の表示領域(RECT)' + lcsCRLF +
'} WINDOWPLACEMENT;'
;
const
	lcs_DECLARATION = 'BOOL GetWindowPlacement(HWND hWnd, WINDOWPLACEMENT *lpwndpl);';
	lcs_DESCRIPTION =
'指定されたウィンドウの表示状態、および通常表示のとき、最小化されたとき、最大化されたときの位置をセットします。' + lcsTITLE_CRLF +
'hwnd    調べたいウィンドウのハンドルを指定' + lcsCRLF +
'lpwndpl 値を受け取るWINDOWPLACEMENT構造体の変数のポインタを指定' + lcsCRLF +
'戻り値  関数が成功すると0以外の値(True)が、失敗すると0(False)が返ります。' + lcsCRLF +
lcsSTRUCT_WINDOWPLACEMENT
;
var
	lb_Ret : Bool;
	l_Info : TWindowPlacement;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('ptMinPosition',    '最小化時の表示位置');
		FAddParam('ptMaxPosition',    '最大化時の表示位置');
		FAddParam('rcNormalPosition', '通常時の表示領域(RECT)');
		FAddParam('戻り値',           '関数が成功すると0以外の値(True)が返ります。関数が失敗すると0(False)が返ります。');
Exit;
	end;

	FillChar(l_Info, 0, SizeOf(l_Info));
	l_Info.length := SizeOf(l_Info);
	lb_Ret := GetWindowPlacement(FhWindowHandle, @l_Info);

	case FiParamIndex of
		0: Result := FGetPointValue(l_Info.ptMinPosition);    //最小化時の表示位置
		1: Result := FGetPointValue(l_Info.ptMaxPosition);    //最大化時の表示位置
		2: Result := FGetRectValue (l_Info.rcNormalPosition); //通常時の表示位置
		3: Result := FGetBoolValue (lb_Ret);
	end;
end;

(*
// GetWindowRect ---------------------------------------------------------------
procedure T_MyAPIValue.FGetWindowRect;
const
	lcs_DECLARATION = 'BOOL GetWindowRect(HWND hWnd, LPRECT lpRect);';
	lcs_DESCRIPTION =
'指定されたウィンドウの左上端と右下端の座標をスクリーン座標で取得します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定' + lcsCRLF +
'lpRect 値を受け取るRECT構造体の変数のポインタを指定' + lcsCRLF +
'戻り値 関数が成功すると0以外の値(True)が、失敗すると0(False)が返ります。' + lcsCRLF +
lcsSTRUCT_RECT
;
const
	lci_OUTPUTNUM = 2;
var
	lb_Ret : Bool;
	l_Rect : TRect;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',   '調べるウィンドウのハンドルを指定します。');
		FAddElement('lpRect', '値を受け取るRECT構造体の変数のポインタを指定します。' + lcsCRLF + 'この構造体のleftメンバとtopメンバにスクリーン座標でのウィンドウの左上端の座標が入ります。rightメンバとbottomメンバにはウィンドウの右下端の座標が入ります。');
		FAddElement('戻り値', '関数が成功すると0以外の値(True)が返ります。関数が失敗すると0(False)が返ります。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		lb_Ret := GetWindowRect(FhWndHandle, l_Rect);
		FAddRectValue(l_Rect);
		FAddBoolValue(lb_Ret);
	end;
end;
*)

// GetWindowText ---------------------------------------------------------------
function T_MyAPITest.FGetWindowText: String;
const
	lcs_DECLARATION = 'int GetWindowText(HWND hWnd, LPTSTR lpString, int nMaxCount);';
	lcs_DESCRIPTION =
'指定されたウィンドウのテキストをバッファへコピーします。' +
'他のアプリケーションのエディットコントロールのテキストやリストボックス及びコンボボックスのテキストをこの関数で取得することはできません。' + lcsCRLF +
'hwnd      調べたいウィンドウまたはコントロールのハンドルを指定します。' + lcsCRLF +
'lpString  テキストを受け取るバッファのアドレスを指定します。' + lcsCRLF +
'nMaxCount バッファのサイズを指定します。' + lcsCRLF +
'戻り値    関数が成功するとコピーされたテキストの長さが返ります。' + lcsTITLE_CRLF +
'lpStringのサイズは終端のNULL文字分も含めたバイト数で確保しなければなりません。'
;
var
	li_Ret  : Integer;
	li_Len  : DWORD;
	lp_Buff : PChar;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('lpString', 'バッファへのポインタを指定します。このバッファにテキストが格納されます。バッファのサイズは文字数ではなく、文字列を格納するのに必要なバイト数で確保します。');
		FAddParam('戻り値',   '関数が成功するとコピーされた文字列の文字数が返ります(終端のNULL文字分は含められません)。');
Exit;
	end;

	li_Len  := GetWindowTextLength(FhWindowHandle) +1; //終端のNULL文字分も含めるので+1
	lp_Buff := AllocMem(li_Len * SizeOf(Char));
	try
		li_Ret := GetWindowText(FhWindowHandle, lp_Buff, li_Len);
		case FiParamIndex of
			0: Result := String(lp_Buff);
			1: Result := FGetIntValue(li_Ret);
		end;
	finally
		FreeMem(lp_Buff);
	end;
end;

// GetWindowTextLength ---------------------------------------------------------
function T_MyAPITest.FGetWindowTextLength: String;
const
	lcs_DECLARATION = 'int GetWindowTextLength(HWND hWnd);';
	lcs_DESCRIPTION =
'指定されたウィンドウのテキストの長さを返します。' +
'他のアプリケーションのエディットコントロールのテキストやリストボックス及びコンボボックスのテキストの長さをこの関数で取得することはできません。' + lcsCRLF +
'hwnd   調べたいウィンドウのハンドルを指定します。' + lcsCRLF +
'戻り値 関数が成功するとテキストの長さが返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値',    '関数が成功するとテキストの文字数が返ります。特定の条件の下では、実際のテキスト長よりも大きくなります。ウィンドウがテキストを持たない場合は、0 が返ります。');
Exit;
	end;

	Result := FGetIntValue(GetWindowTextLength(FhWindowHandle));
end;

(*
// IsWindowEnabled -------------------------------------------------------------
function T_MyAPITest.FIsWindowEnabled: String;
const
	lcs_DECLARATION = 'BOOL IsWindowEnabled(HWND hWnd);';
	lcs_DESCRIPTION =
'指定されたウィンドウが有効か無効か(マウスやキーボードの入力を受け付けるかどうか)を調べます。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定' + lcsCRLF +
'戻り値 ウィンドウが有効なときは0以外の値(Ture)が、無効なときは0(False)が返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',   '調べたいウィンドウのハンドルを指定します。');
		FAddElement('戻り値', 'ウィンドウが有効なときは0以外の値(Ture)が、無効なときは0(False)が返ります。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		FAddBoolValue(IsWindowEnabled(FhWndHandle));
	end;
end;

// IsWindowUnicode -------------------------------------------------------------
procedure T_MyAPIValue.FIsWindowUnicode;
const
	lcs_DECLARATION = 'BOOL IsWindowUnicode(HWND hWnd);';
	lcs_DESCRIPTION =
'指定されたウィンドウがUnicode対応かを調べます。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定' + lcsCRLF +
'戻り値 ウィンドウがUnicode対応なら0以外の値(Ture)が、非対応なら0(False)が返ります。'
;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',   '調べたいウィンドウのハンドルを指定します。');
		FAddElement('戻り値', 'ウィンドウがUnicode対応なら0以外の値(Ture)が、非対応なら0(False)が返ります。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		FAddBoolValue(IsWindowUnicode(FhWndHandle));
	end;
end;

// RealGetWindowClass ----------------------------------------------------------
procedure T_MyAPIValue.FRealGetWindowClass;
const
	lcs_DECLARATION = 'UINT RealGetWindowClass(HWND hwnd, LPTSTR pszType, UINT cchType);';
	lcs_DESCRIPTION =
'指定されたウィンドウの種類を表す文字列を取得します。' + lcsTITLE_CRLF +
'hwnd    調べたいウィンドウのハンドルを指定' + lcsCRLF +
'pszType 文字列を受け取るバッファ' + lcsCRLF +
'cchType pszTypeが指すバッファの大きさ(このテストでは255を指定)' + lcsCRLF +
'戻り値  関数が成功するとバッファにコピーされた文字列のサイズが返ります。関数が失敗すると0が返ります。'
;
const
	lci_LENGTH = 255;
var
	li_Ret  : UINT;
	lp_Buff : PChar;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',    '調べたいウィンドウのハンドルを指定します。');
		FAddElement('pszType', '文字列を受け取るバッファ。');
		FAddElement('戻り値',  '関数が成功するとバッファにコピーされた文字列のサイズが返ります。関数が失敗すると0が返ります。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		lp_Buff := AllocMem((lci_LENGTH + 1) * SizeOf(Char));
		try
			li_Ret := RealGetWindowClass(FhWndHandle, lp_Buff, lci_LENGTH);
			FAddStrValue(String(lp_Buff));
		finally
			FreeMem(lp_Buff);
		end;
		FAddIntValue(li_Ret);
	end;
end;



// 座標を引数に取るAPI =========================================================
function F_GetWindow(ptPos: TPoint): HWND;
type
	T_TopWindow = record
		hTop   : HWND;
		pPoint : TPoint;
	end;
	P_TopWindow = ^T_TopWindow;

	function _EnumChildProc(hHandle: HWND; pTopWindow: Pointer): BOOL; stdcall;
	var
		lh_Parent: HWND;
	begin
		Result := True;

		if  (IsWindowVisible(hHandle))
		and (PtInRect(gfnrcWindowRectGet(hHandle), T_TopWindow(pTopWindow^).pPoint))
		then begin
			lh_Parent := gfnhParentWindowGet(hHandle);
			if (lh_Parent = T_TopWindow(pTopWindow^).hTop)
			then begin
				//直前に列挙された対象ウィンドウの子ウィンドウだった
				//hTopを書き換える
				//子ウィンドウがあるかもしれないので処理を続ける
				T_TopWindow(pTopWindow^).hTop := hHandle;
			end
			else
			begin
				//親ウィンドウが同じなら兄弟ウィンドウ。
				//しかし列挙されるのは手前のウィンドウからなのでその場合はhTopは書き換ず処理を抜ける。
				//親ウィンドウが直前のウィンドウでもない
				//おじさんおばさんウィンドウ、あるいはさらに遡ってのウィンドウであるのでこれまたhTopを書き換えず処理を抜ける
				Result := False;
			end;
		end;
	end;

	function _EnumWindowsProc(hHandle: HWND; pTopWindow: Pointer):BOOL; stdcall;
	//トップレベルウィンドウを列挙する
	var
		lrg_Region: HRGN;
		lpt_Pos:    TPoint;
		lrc_Rect, lrc_Client: TRect;
	begin
		lrc_Rect := gfnrcWindowRectGet(hHandle);
		if  (IsWindowVisible(hHandle))	//可視ウィンドウのみ
		and (PtInRect(lrc_Rect, T_TopWindow(pTopWindow^).pPoint))  //ウィンドウのRect内にマウスカーソルがある
		then begin
			Result := False;
			lrg_Region := CreateRectRgn(0, 0, 0, 0);
			try
				if (GetWindowRgn(hHandle, lrg_Region) <> ERROR)
				then begin
					lpt_Pos.X := T_TopWindow(pTopWindow^).pPoint.X - lrc_Rect.Left;
					lpt_Pos.Y := T_TopWindow(pTopWindow^).pPoint.Y - lrc_Rect.Top;
					if (PtInRegion(lrg_Region, lpt_Pos.X, lpt_Pos.Y))
					then begin
						//リージョン内だったので処理を抜ける
					end
					else
					begin
						//リージョン外だったので処理を続ける
						Result := True;
					end;
				end;
			finally
				DeleteObject(lrg_Region);
			end;

			if (Result = False)
			then begin
				T_TopWindow(pTopWindow^).hTop := hHandle;
				lrc_Client := gfnrcClientRectGet(hHandle);
				if (lrc_Client.Right  > 0)
				or (lrc_Client.Bottom > 0)
				then begin
					EnumChildWindows(hHandle, @_EnumChildProc, LPARAM(pTopWindow));
				end;
			end;
		end
		else
		begin
			Result := True;
		end;
	end;
var
	lr_TopWindow : T_TopWindow;
	lh_Toplevel  : HWND;
	li_ExStyle   : DWORD;
	li_ColorKey  : COLORREF;
	li_Alpha     : BYTE;
	li_Flag      : DWORD;
begin
	Result := WindowFromPoint(ptPos);
{
	if (Result = ChildWindowFromPoint(Result, gfnptScreenToClient(Result, ptPos)))
	then begin
Exit;
	end;
}
	FillChar(lr_TopWindow, SizeOf(lr_TopWindow), 0);
	lr_TopWindow.pPoint := ptPos;
	EnumWindows(@_EnumWindowsProc, LPARAM(@lr_TopWindow));
//		lh_Handle2 := lr_TopWindow.hTop;

	//WindowFromPoint APIで取得したハンドルとEnumWindows APIで取得したハンドルを比較する。
	if (Result <> lr_TopWindow.hTop)
	then begin
		//違っていたらEnumWindows APIで取得したウィンドウのスタイルを調べる。
		//WS_EX_TRANSPARENTとWS_EX_LAYEREDが同時にセットされていたら見えていても
		//WindowFromPoint APIでは取得できないウィンドウなのでこちらを返す。
		lh_Toplevel := GetAncestor(lr_TopWindow.hTop, GA_ROOT);
		li_ExStyle := GetWindowLong(lh_Toplevel, GWL_EXSTYLE);
		if  ((li_ExStyle and WS_EX_LAYERED)     = WS_EX_LAYERED)
		and ((li_ExStyle and WS_EX_TRANSPARENT) = WS_EX_TRANSPARENT)
		then begin
			if (gfnbGetLayeredWindowAttributes(lh_Toplevel, li_ColorKey, li_Alpha, li_Flag))
			then begin
				if  ((li_Flag and LWA_ALPHA) = LWA_ALPHA)
				and (li_Alpha = 0)
				then begin
Exit;
				end;
			end;
		end;
		//2015-09-29:この上のend;の上に置いていた為EnabledがFalseのウィンドウを補足しなくなっていたミスを修正。
		Result := lr_TopWindow.hTop;
	end;
end;


// ChildWindowFromPoint --------------------------------------------------------
procedure T_MyAPIValue.FChildWindowFromPoint;
const
	lcs_DECLARATION = 'HWND ChildWindowFromPoint(HWND hWndParent, POINT Point);';
	lcs_DESCRIPTION =
'指定されたウィンドウの指定座標上にある子ウィンドウのハンドルを返します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定。' + lcsCRLF +
'Point  指定座標を、調べたいウィンドウのクライアント座標で指定。' + lcsCRLF +
'戻り値 調べたいウィンドウの、指定座標上にある子ウィンドウのハンドルが返ります。' + lcsCRLF +
lcsSTRUCT_POINT
;
var
	lpt_Client: TPoint;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',   '調べたいウィンドウのハンドルを指定します。');
		FAddElement('Point',  '指定座標を、調べたいウィンドウのクライアント座標で指定します。');
		FAddElement('戻り値', '調べたいウィンドウの指定座標上にある子ウィンドウのハンドルが返ります。' + lcsCRLF + '子ウィンドウが非表示の場合や無効化されている場合でもその子ウィンドウのハンドルが返ります。' + lcsCRLF + '指定した座標がウィンドウの外側にある場合は0が返ります。' + lcsCRLF + '指定した座標はウィンドウ内にあるがその座標上に子ウィンドウがない場合はそのウィンドウのハンドルが返ります。');
		FAddElement('参考値', '指定された座標上にある、一番手間にある見えているウィンドウの値。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		//ptPosはスクリーン座標なのでクライアント座標に変換する
		lpt_Client := gfnptScreenToClient(FhWndHandle, FptPos);
		FAddPointValue(lpt_Client);
		FAddWindowValue(ChildWindowFromPoint(FhWndHandle, lpt_Client));
		FAddWindowValue(F_GetWindow(FptPos));
	end;
end;

// ChildWindowFromPointEx ------------------------------------------------------
procedure T_MyAPIValue.FChildWindowFromPointEx;
const
	lcs_DECLARATION = 'HWND ChildWindowFromPointEx(HWND hwndParent, POINT pt, UINT uFlags);';
	lcs_DESCRIPTION =
'指定されたウィンドウの指定座標上にある子ウィンドウのハンドルを返します。' + lcsCRLF + 'オプションの指定で非表示ウィンドウ、無効化されたウィンドウ、透明なウィンドウを無視することができます。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定。' + lcsCRLF +
'pt     指定座標を、調べたいウィンドウのクライアント座標で指定。' + lcsCRLF +
'uFlags 無視するウィンドウの種類を指定。' + lcsCRLF +
'戻り値 調べたいウィンドウの、指定座標上にある子ウィンドウのハンドルが返ります。' + lcsCRLF +
lcsSTRUCT_POINT
;
var
	lpt_Client: TPoint;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',  '調べたいウィンドウのハンドルを指定します。');
		FAddElement('Point', '指定座標を、調べたいウィンドウのクライアント座標で指定します。');
		FAddElement('uFlags: CWP_ALL',             'uFlagsにCWP_ALLを指定したときの戻り値。'             + lcsCRLF + 'どの子ウィンドウも無視しません。');
		FAddElement('uFlags: CWP_SKIPINVISIBLE',   'uFlagsにCWP_SKIPINVISIBLEを指定したときの戻り値。'   + lcsCRLF + '非表示の子ウィンドウを無視します。');
		FAddElement('uFlags: CWP_SKIPDISABLED',    'uFlagsにCWP_SKIPDISABLEDを指定したときの戻り値。'    + lcsCRLF + '無効化されている子ウィンドウを無視します。');
		FAddElement('uFlags: CWP_SKIPTRANSPARENT', 'uFlagsにCWP_SKIPTRANSPARENTを指定したときの戻り値。' + lcsCRLF + '透明な子ウィンドウを無視します。');
		FAddElement('参考値', '指定された座標上にある、一番手間にある見えているウィンドウの値。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		//ptPosはスクリーン座標なのでクライアント座標に変換する
		lpt_Client := gfnptScreenToClient(FhWndHandle, FptPos);
		FAddPointValue(lpt_Client);
		FAddWindowValue(ChildWindowFromPointEx(FhWndHandle, lpt_Client, CWP_ALL));
		FAddWindowValue(ChildWindowFromPointEx(FhWndHandle, lpt_Client, CWP_SKIPINVISIBLE));
		FAddWindowValue(ChildWindowFromPointEx(FhWndHandle, lpt_Client, CWP_SKIPDISABLED));
		FAddWindowValue(ChildWindowFromPointEx(FhWndHandle, lpt_Client, CWP_SKIPTRANSPARENT));
		FAddWindowValue(F_GetWindow(FptPos));
	end;
end;

// RealChildWindowFromPoint ----------------------------------------------------
procedure T_MyAPIValue.FRealChildWindowFromPoint;
const
	lcs_DECLARATION = 'HWND RealChildWindowFromPoint(HWND hwndParent, POINT ptParentClientCoords);';
	lcs_DESCRIPTION =
'指定されたウィンドウの指定座標上にある子ウィンドウのハンドルを返します。' + lcsTITLE_CRLF +
'hwnd   調べたいウィンドウのハンドルを指定。' + lcsCRLF +
'Point  指定座標を、調べたいウィンドウのクライアント座標で指定。' + lcsCRLF +
'戻り値 調べたいウィンドウの、指定座標上にある子ウィンドウのハンドルが返ります。' + lcsCRLF +
lcsSTRUCT_POINT
;
var
	lpt_Client: TPoint;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddElement('hwnd',   '調べたいウィンドウのハンドルを指定します。');
		FAddElement('Point',  '指定座標を、調べたいウィンドウのクライアント座標で指定します。');
		FAddElement('戻り値', '調べたいウィンドウの指定座標上にある子ウィンドウのハンドルが返ります。' + lcsCRLF + '子ウィンドウが非表示の場合や無効化されている場合でもその子ウィンドウのハンドルが返ります。' + lcsCRLF + '指定した座標がウィンドウの外側にある場合は0が返ります。' + lcsCRLF + '指定した座標はウィンドウ内にあるがその座標上に子ウィンドウがない場合はそのウィンドウのハンドルが返ります。');
		FAddElement('参考値', '指定された座標上にある、一番手間にある見えているウィンドウの値。');
	end
	else
	begin
		//値のみ初期化
		FClearValue;
	end;

	if (FAddWindowValue) //調べるウィンドウの簡易情報を表示
	then begin
		//ptPosはスクリーン座標なのでクライアント座標に変換する
		lpt_Client := gfnptScreenToClient(FhWndHandle, FptPos);
		FAddPointValue(lpt_Client);
		FAddWindowValue(RealChildWindowFromPoint(FhWndHandle, lpt_Client));
		FAddWindowValue(F_GetWindow(FptPos));
	end;
end;
*)

// 以下メッセージ ==============================================================

//コンボボックスとリストボックス
function T_MyAPITest.FGet_LBIntValue(iValue: DWORD): String;
begin
	if (iValue = DWORD(LB_ERR))
	then begin
		Result := 'LB_ERR(-1)';
	end
	else
	begin
		Result := FGetIntValue(iValue);
	end;
end;
function T_MyAPITest.FGet_CBIntValue(iValue: DWORD): String;
begin
	if (iValue = DWORD(CB_ERR))
	then begin
		Result  := 'CB_ERR(-1)';
	end
	else
	begin
		Result := FGetIntValue(iValue);
	end;
end;

function T_MyAPITest.FCBLB_GetCount(hHandle: HWND; iMessage: UINT): String;
var
	li_Index: DWORD;
	ls_Declaration: String;
	ls_Description: String;
	ls_ResultMsg:   String;
	ls_Control:     String;
	l_Func: function(iValue: DWORD): String of object;
begin
	l_Func := nil;
	case iMessage of
		CB_GETCOUNT
		:begin
			ls_Control     := 'コンボボックス';
			ls_Declaration := 'CB_GETCOUNT';
			ls_Description := Format('%sのアイテム数を取得します。', [ls_Control]);
			ls_ResultMsg   := Format('%sのアイテム数が返ります。',   [ls_Control]);
			l_Func := FGet_CBIntValue;
		end;
		LB_GETCOUNT
		:begin
			ls_Control     := 'リストボックス';
			ls_Declaration := 'LB_GETCOUNT';
			ls_Description := Format('%sのアイテム数を取得します。', [ls_Control]);
			ls_ResultMsg   := Format('%sのアイテム数が返ります。',   [ls_Control]);
			l_Func := FGet_LBIntValue;
		end;
		CB_GETCURSEL
		:begin
			ls_Control     := 'コンボボックス';
			ls_Declaration := 'CB_GETCURSEL';
			ls_Description := Format('%sの選択アイテムのインデックスを取得します。', [ls_Control]);
			ls_ResultMsg   := '選択アイテムの0ベースのインデックスが返ります。';
			l_Func := FGet_CBIntValue;
		end;
		LB_GETCURSEL
		:begin
			ls_Control     := 'リストボックス';
			ls_Declaration := 'LB_GETCURSEL';
			ls_Description := Format('%sの選択アイテムのインデックスを取得します。', [ls_Control]);
			ls_ResultMsg   := '選択アイテムの0ベースのインデックスが返ります。';
			l_Func := FGet_LBIntValue;
		end;
	end;

	if not(IsNowAPI(ls_Declaration))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := ls_Declaration;
		Description := ls_Declaration + lcsTITLE_CRLF +
			'wParam 使用しません。' + lcsCRLF +
			'lParam 使用しません。' + lcsCRLF +
			'戻り値 ' + ls_ResultMsg
		;

		FAddParam('戻り値', ls_ResultMsg);
Exit;
	end;

	if (SendMessageTimeoutW(hHandle, iMessage, 0, 0, SMTO_ABORTIFHUNG, 500, li_Index) <> 0)
	then begin
		if (Assigned(l_Func))
		then begin
			Result := l_Func(li_Index);
Exit;
		end;
	end;

	Result := '';
end;

function T_MyAPITest.FCBLB_GetText(hHandle: HWND; iMessage: UINT): String;
var
	li_GetCurSel  : UINT;
	li_GetTextLen : UINT;
	li_Err        : Integer;

	li_Index : DWORD;
	li_Len   : DWORD;
	lp_Buff  : PChar;
	ls_Item  : String;

	ls_Declaration: String;
	ls_Control:     String;
begin
	case iMessage of
		CB_GETLBTEXT
		:begin
			ls_Control     := 'コンボボックス';
			ls_Declaration := 'CB_GETLBTEXT';
			li_GetCurSel   := CB_GETCURSEL;
			li_GetTextLen  := CB_GETLBTEXTLEN;
			li_Err         := CB_ERR;
		end;
		LB_GETTEXT
		:begin
			ls_Control     := 'リストボックス';
			ls_Declaration := 'LB_GETTEXT';
			li_GetCurSel   := LB_GETCURSEL;
			li_GetTextLen  := LB_GETTEXTLEN;
			li_Err         := LB_ERR;
		end;
		else
		begin
Exit;
		end;
	end;

	if not(IsNowAPI(ls_Declaration))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := ls_Declaration;
		Description := Format('%sのアイテムの文字列を取得します。', [ls_Control]) + lcsTITLE_CRLF +
			'wParam アイテムのインデックスを指定。このテストでは選択行を指定。' + lcsCRLF +
			'lParam 文字列を受け取るバッファのアドレスを指定。' + lcsCRLF +
			'戻り値 取得したアイテムの文字数が返ります。';
		FAddParam('lParam', 'lParamに指定したバッファにアイテムの文字列がコピーされます。');
		FAddParam('戻り値', '取得したアイテムの文字数が返ります。終端のNULL文字分は含みません。' + lcsCRLF + 'wParamに範囲外のインデックスを指定した場合はエラーが返ります。');
Exit;
	end;

	ls_Item := '';

	//現在の選択行を取得。
	if (SendMessageTimeout(hHandle, li_GetCurSel, 0, 0, SMTO_ABORTIFHUNG, 500, li_Index) <> 0)
	then begin
		if (li_Index = DWORD(li_Err))
		then begin
			li_Index := 0;
		end;
	end
	else
	begin
		li_Index := 0;
	end;

	//文字数を取得
	if (SendMessageTimeout(hHandle, li_GetTextLen, WPARAM(li_Index), 0, SMTO_ABORTIFHUNG, 500, li_Len) <> 0)
	then begin
		if  (li_Len <> DWORD(li_Err))
		and (li_Len > 0)
		then begin
			lp_Buff := AllocMem((li_Len +1) * SizeOf(Char));
			try
				SendMessageTimeout(hHandle, iMessage, WPARAM(li_Index), LPARAM(lp_Buff), SMTO_ABORTIFHUNG, 500, li_Len);
				ls_Item := String(lp_Buff);
			finally
				FreeMem(lp_Buff);
			end;
		end;

		case FiParamIndex of
			0: Result := ls_Item;
			1: Result := FGet_LBIntValue(li_Len);
		end;
	end
	else
	begin
		Result := '';
	end;
end;

function T_MyAPITest.FCBLB_GetTextLen(hHandle: HWND; iMessage: UINT): String;
var
	li_GetCurSel : UINT;
	li_Err       : Integer;

	li_Index : DWORD;
	li_Len   : DWORD;

	ls_Declaration: String;
	ls_Control:     String;
	l_Func: function(iValue: DWORD): String of object;
begin
	case iMessage of
		CB_GETLBTEXTLEN
		:begin
			ls_Control     := 'コンボボックス';
			ls_Declaration := 'CB_GETLBTEXTLEN';
			li_GetCurSel   := CB_GETCURSEL;
			li_Err := CB_ERR;
			l_Func := FGet_CBIntValue;
		end;
		LB_GETTEXTLEN
		:begin
			ls_Control     := 'リストボックス';
			ls_Declaration := 'LB_GETTEXTLEN';
			li_GetCurSel   := LB_GETCURSEL;
			li_Err := LB_ERR;
			l_Func := FGet_LBIntValue;
		end;
		else
		begin
Exit;
		end;
	end;

	if not(IsNowAPI(ls_Declaration))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := ls_Declaration;
		Description := Format('%sのアイテムの文字数を取得します。', [ls_Control]) + lcsTITLE_CRLF +
			'wParam アイテムのインデックスを指定。このテストでは選択行を指定。' + lcsCRLF +
			'lParam 使用しません。' + lcsCRLF +
			'戻り値 アイテムの文字数が返ります。'
		;
		FAddParam('戻り値', 'アイテムの文字数が返ります。終端のNULL文字分は含みません。wParamに範囲外のインデックスを指定した場合はエラーが返ります。');
Exit;
	end;

	//現在の選択行を取得。
	if (SendMessageTimeout(hHandle, li_GetCurSel, 0, 0, SMTO_ABORTIFHUNG, 500, li_Index) <> 0)
	then begin
		if (li_Index = DWORD(li_Err))
		then begin
			li_Index := 0;
		end;
	end
	else
	begin
		li_Index := 0;
	end;

	if (SendMessageTimeout(hHandle, iMessage, li_Index, 0, SMTO_ABORTIFHUNG, 500, li_Len) <> 0)
	then begin
		Result := l_Func(li_Len);
	end
	else
	begin
		Result := '';
	end;
end;

// CB_GETCOUNT -----------------------------------------------------------------
function T_MyAPITest.FCB_GetCount: String;
begin
	Result := FCBLB_GetCount(FhWindowHandle, CB_GETCOUNT);
end;

// CB_GETCURSEL ----------------------------------------------------------------
function T_MyAPITest.FCB_GetCurSel: String;
begin
	Result := FCBLB_GetCount(FhWindowHandle, CB_GETCURSEL);
end;

// CB_GETLBTEXT ----------------------------------------------------------------
function T_MyAPITest.FCB_GetLBText: String;
begin
	Result := FCBLB_GetText(FhWindowHandle, CB_GETLBTEXT);
end;

// CB_GETLBTEXTLEN -------------------------------------------------------------
function T_MyAPITest.FCB_GetLBTextLen: String;
begin
	Result := FCBLB_GetTextLen(FhWindowHandle, CB_GETLBTEXTLEN);
end;

// LB_GETCOUNT -----------------------------------------------------------------
function T_MyAPITest.FLB_GetCount: String;
begin
	Result := FCBLB_GetCount(FhWindowHandle, LB_GETCOUNT);
end;

// LB_GETCURSEL ----------------------------------------------------------------
function T_MyAPITest.FLB_GetCurSel: String;
begin
	Result := FCBLB_GetCount(FhWindowHandle, LB_GETCURSEL);
end;

// LB_GETTEXT ------------------------------------------------------------------
function T_MyAPITest.FLB_GetText: String;
begin
	Result := FCBLB_GetText(FhWindowHandle, LB_GETTEXT);
end;

// LB_GETTEXTLEN ---------------------------------------------------------------
function T_MyAPITest.FLB_GetTextLen: String;
begin
	Result := FCBLB_GetTextLen(FhWindowHandle, LB_GETTEXTLEN);
end;

//トラックバー
(*
// TBM_GETCHANNELRECT ----------------------------------------------------------
function T_MyAPITest.FTBM_GetChannelRECT: String;
const
	lcs_DECLARATION = 'TBM_GETCHANNELRECT';
//	lcs_DECLARATION = 'SendMessage(hwnd, TBM_GETCHANNELRECT, 0, LPARAM(@l_Rect))';
	lcs_DESCRIPTION =
'トラックバーのスライダーが移動する範囲を取得します。' + lcsTITLE_CRLF +
'wParam 使用しません。' + lcsCRLF +
'lParam 値を受け取るRECT構造体の変数のポインタを指定。' + lcsCRLF +
'戻り値 ありません。'
;
var
	li_Ret : DWORD;
	l_Rect  : TRect;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('lParam', '値を受け取るRECT構造体の変数のポインタを指定します。' + lcsCRLF + 'この構造体にスライダーが移動する範囲の矩形領域(RECT)がクライアント座標で格納されます。');
Exit;
	end;

	FillChar(l_Rect, SizeOf(l_Rect), 0);
	SendMessageTimeout(FhWindowHandle, TBM_GETCHANNELRECT, 0, LPARAM(@l_Rect), SMTO_ABORTIFHUNG, 500, li_Ret); //スライダのつまみのRect
//	SendMessageTimeout(FhWindowHandle, WM_USER + 26, 0, LPARAM(@l_Rect), SMTO_ABORTIFHUNG, 500, li_Ret); //スライダのつまみのRect
{
	if (Pos('TrackBar', gfnsClassNameGet(FhWindowHandle)) = 0)
	then begin
		SendMessage(FhWindowHandle, TBM_GETCHANNELRECT, 0, LPARAM(lp_Rect)); //スライダのつまみのRect
	end;
}
	Result := FGetRectValue(l_Rect);
end;
*)

// TBM_GETNUMTICS --------------------------------------------------------------
function T_MyAPITest.FTBM_GeTNumTics: String;
const
	lcs_DECLARATION = 'TBM_GETNUMTICS';
//	lcs_DECLARATION = 'SendMessage(hwnd, TBM_GETNUMTICS, 0, 0)';
	lcs_DESCRIPTION =
'トラックバーの目盛りの数を取得します。' + lcsTITLE_CRLF +
'wParam 使用しません。' + lcsCRLF +
'lParam 使用しません。' + lcsCRLF +
'戻り値 トラックバーの目盛りの数が返ります。'
;
var
	li_Ret : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', 'トラックバーの目盛りの数が返ります。');
Exit;
	end;

	SendMessageTimeout(FhWindowHandle, TBM_GETNUMTICS, 0, 0, SMTO_ABORTIFHUNG, 500, li_Ret); //スライダのつまみのRect
	Result := FGetIntValue(Integer(li_Ret));
end;

// TBM_GETPOS ------------------------------------------------------------------
function T_MyAPITest.FTBM_GetPos: String;
const
	lcs_DECLARATION = 'TBM_GETPOS';
//	lcs_DECLARATION = 'SendMessage(hwnd, TBM_GETPOS, 0, 0)';
	lcs_DESCRIPTION =
'トラックバーのスライダーの現在位置を取得します。' + lcsTITLE_CRLF +
'wParam 使用しません。' + lcsCRLF +
'lParam 使用しません。' + lcsCRLF +
'戻り値 スライダーの現在位置が返ります。'
;
var
	li_Ret : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', 'スライダーの現在位置が返ります。');
Exit;
	end;

	SendMessageTimeout(FhWindowHandle, TBM_GETPOS, 0, 0, SMTO_ABORTIFHUNG, 500, li_Ret); //スライダのつまみのRect
	Result := FGetIntValue(Integer(li_Ret));
end;

// TBM_GETRANGEMAX -------------------------------------------------------------
function T_MyAPITest.FTBM_GetRangeMAX: String;
const
	lcs_DECLARATION = 'TBM_GETRANGEMAX';
//	lcs_DECLARATION = 'SendMessage(hwnd, TBM_GETRANGEMAX, 0, 0)';
	lcs_DESCRIPTION =
'トラックバーの最大値を取得します。' + lcsTITLE_CRLF +
'wParam 使用しません。' + lcsCRLF +
'lParam 使用しません。' + lcsCRLF +
'戻り値 トラックバーの最大値が返ります。'
;
var
	li_Ret : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', 'ラックバーの最大値が返ります。');
Exit;
	end;

	SendMessageTimeout(FhWindowHandle, TBM_GETRANGEMAX, 0, 0, SMTO_ABORTIFHUNG, 500, li_Ret); //スライダのつまみのRect
	Result := FGetIntValue(Integer(li_Ret));
end;

// TBM_GETRANGEMIN -------------------------------------------------------------
function T_MyAPITest.FTBM_GetRangeMIN: String;
const
	lcs_DECLARATION = 'TBM_GETRANGEMIN';
//	lcs_DECLARATION = 'SendMessage(hwnd, TBM_GETRANGEMIN, 0, 0)';
	lcs_DESCRIPTION =
'トラックバーの最小値を取得します。' + lcsTITLE_CRLF +
'wParam 使用しません。' + lcsCRLF +
'lParam 使用しません。' + lcsCRLF +
'戻り値 トラックバーの最小値が返ります。'
;
var
	li_Ret : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', 'トラックバーの最小値が返ります。');
Exit;
	end;

	SendMessageTimeout(FhWindowHandle, TBM_GETRANGEMIN, 0, 0, SMTO_ABORTIFHUNG, 500, li_Ret); //スライダのつまみのRect
	Result := FGetIntValue(Integer(li_Ret));
end;

// TBM_GETTHUMBLENGTH ----------------------------------------------------------
function T_MyAPITest.FTBM_GetThumbLength: String;
const
	lcs_DECLARATION = 'TBM_GETTHUMBLENGTH';
//	lcs_DECLARATION = 'SendMessage(hwnd, TBM_GETTHUMBLENGTH, 0, 0)';
	lcs_DESCRIPTION =
'トラックバーのスライダーの高さを取得します。' + lcsTITLE_CRLF +
'wParam 使用しません。' + lcsCRLF +
'lParam 使用しません。' + lcsCRLF +
'戻り値 スライダーの高さがピクセル数で返ります。'
;
var
	li_Ret : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', 'スライダーの高さがピクセル数で返ります。' + lcsCRLF + 'トラックバーが縦長の場合はスライダーの幅になります。');
Exit;
	end;

	SendMessageTimeout(FhWindowHandle, TBM_GETTHUMBLENGTH, 0, 0, SMTO_ABORTIFHUNG, 500, li_Ret); //スライダのつまみのRect
	Result := FGetIntValue(Integer(li_Ret));
end;

(*
// TBM_GETTHUMBRECT ------------------------------------------------------------
function T_MyAPITest.FTBM_GetThumbRECT: String;
const
	lcs_DECLARATION = 'TBM_GETTHUMBRECT';
//	lcs_DECLARATION = 'SendMessage(hwnd, TBM_GETTHUMBRECT, 0, LPARAM(@l_Rect))';
	lcs_DESCRIPTION =
'トラックバーのスライダーの矩形領域(RECT)を取得します。' + lcsTITLE_CRLF +
'wParam 使用しません。' + lcsCRLF +
'lParam 値を受け取るRECT構造体の変数のポインタを指定。' + lcsCRLF +
'戻り値 ありません。'
;
var
	li_Ret : DWORD;
	l_Rect : TRect;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('lParam', '値を受け取るRECT構造体の変数のポインタを指定します。' + lcsCRLF + 'この構造体にスライダーの矩形領域(RECT)がクライアント座標で格納されます。');
Exit;
	end;

	FillChar(l_Rect, SizeOf(l_Rect), 0);
	SendMessageTimeout(FhWindowHandle, TBM_GETTHUMBRECT, 0, LPARAM(@l_Rect), SMTO_ABORTIFHUNG, 500, li_Ret); //スライダのつまみのRect
	Result := FGetRectValue(l_Rect);
end;
*)

// TBM_GETTIC ------------------------------------------------------------------
function T_MyAPITest.FTBM_GetTic: String;
const
	lcs_DECLARATION = 'TBM_GETTIC';
//	lcs_DECLARATION = 'SendMessage(hwnd, TBM_GETTIC, WPARAM(iIndex), 0)';
	lcs_DESCRIPTION =
'トラックバーの目盛りの位置を取得します。' + lcsTITLE_CRLF +
'wParam 調べたい目盛りの位置を0ベースで指定。' + lcsCRLF +
'lParam 使用しません。' + lcsCRLF +
'戻り値 トラックバーの目盛りの位置が返ります。'
;
var
	li_Pos : DWORD;
	li_Min : DWORD;
	li_Max : DWORD;
	li_Ret : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', '目盛りの位置が返ります。');
Exit;
	end;

	SendMessageTimeout(FhWindowHandle, TBM_GETPOS,      0, 0, SMTO_ABORTIFHUNG, 500, li_Pos);         //スライダの現在位置
	SendMessageTimeout(FhWindowHandle, TBM_GETRANGEMIN, 0, 0, SMTO_ABORTIFHUNG, 500, li_Min);         //トラックバーの最小値
	SendMessageTimeout(FhWindowHandle, TBM_GETRANGEMAX, 0, 0, SMTO_ABORTIFHUNG, 500, li_Max);         //トラックバーの最小値
	if (li_Min <= li_Pos)
	then begin
		if (li_Pos = li_Min)
		then begin
			Result := Format('現在位置がトラックバーの最小値の場合は無効です。(%d)', [li_Pos]);
		end
		else
		if (li_Pos = li_Max)
		then begin
			Result := Format('現在位置がトラックバーの最大値の場合は無効です。(%d)', [li_Pos]);
		end
		else
		begin
			SendMessageTimeout(FhWindowHandle, TBM_GETTIC, WPARAM(li_Pos - li_Min -1), 0, SMTO_ABORTIFHUNG, 500, li_Ret);
//			li_Ret := SendMessageTimeout(FhWindowHandle, TBM_GETTIC, WPARAM(li_Pos - li_Min) -1, 0); //, SMTO_ABORTIFHUNG, 500, li_Ret);
			Result := FGetIntValue(Integer(li_Ret));
		end;
	end
	else
	begin
		Result := 'エラー(恐らくウィンドウはトラックバーではありません)';
	end;
end;

// TBM_GETTICPOS ---------------------------------------------------------------
function T_MyAPITest.FTBM_GetTicPos: String;
const
	lcs_DECLARATION = 'TBM_GETTICPOS';
//	lcs_DECLARATION = 'SendMessage(hwnd, TBM_GETTICPOS, WPARAM(iIndex), 0)';
	lcs_DESCRIPTION =
'トラックバーの目盛りの位置を取得します。' + lcsTITLE_CRLF +
'wParam 調べたい目盛りの位置を0ベースで指定。このテストではスライダーの現在位置を指定。' + lcsCRLF +
'lParam 使用しません。' + lcsCRLF +
'戻り値 トラックバーの目盛りの位置がクライアント座標で返ります。'
;
var
	li_Pos : DWORD;
	li_Min : DWORD;
	li_Max : DWORD;
	li_Ret : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', '目盛りの位置が返ります。');
Exit;
	end;

	SendMessageTimeout(FhWindowHandle, TBM_GETPOS,      0, 0, SMTO_ABORTIFHUNG, 500, li_Pos); //スライダの現在位置
	SendMessageTimeout(FhWindowHandle, TBM_GETRANGEMIN, 0, 0, SMTO_ABORTIFHUNG, 500, li_Min); //トラックバーの最小値
	SendMessageTimeout(FhWindowHandle, TBM_GETRANGEMAX, 0, 0, SMTO_ABORTIFHUNG, 500, li_Max); //トラックバーの最小値
	if (li_Min <= li_Pos)
	then begin
		if (li_Pos = li_Min)
		then begin
			Result := Format('現在位置がトラックバーの最小値の場合は無効です。(%d)', [li_Pos]);
		end
		else
		if (li_Pos = li_Max)
		then begin
			Result := Format('現在位置がトラックバーの最大値の場合は無効です。(%d)', [li_Pos]);
		end
		else
		begin
			SendMessageTimeout(FhWindowHandle, TBM_GETTICPOS, WPARAM(li_Pos - li_Min -1), 0, SMTO_ABORTIFHUNG, 500, li_Ret);
			Result := FGetIntValue(Integer(li_Ret));
		end;
	end
	else
	begin
		Result := 'エラー(恐らくウィンドウはトラックバーではありません)';
	end;
end;

// WM_GETTEXT ------------------------------------------------------------------
function T_MyAPITest.FWM_GetText: String;
const
	lcs_DECLARATION = 'WM_GETTEXT';
	lcs_DESCRIPTION =
'指定されたウィンドウのテキストを取得します。' + lcsTITLE_CRLF +
'wParam 取得するテキストの長さ(文字数)を指定します。'+ lcsCRLF +
'lParam 文字列を受け取るバッファのアドレスを指定します。' + lcsCRLF +
'戻り値 取得したテキストの長さ(文字数)が返ります。'
;
var
	li_Ret  : DWORD;
	li_Len  : DWORD;
	lp_Buff : PChar;
	ls_Text : String;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('lParam', '文字列を受け取るバッファのアドレスを指定します。' + lcsCRLF + 'このバッファにウィンドウのテキストが格納されます。');
		FAddParam('戻り値', '関数が成功するとコピーされたテキストの文字数が返ります(終端のNULL文字分は含められません)。');
Exit;
	end;

	li_Ret  := 0;
	ls_Text := '';

	if (SendMessageTimeout(FhWindowHandle, WM_GETTEXTLENGTH, 0, 0, SMTO_ABORTIFHUNG, 500, li_Len) <> 0)
	then begin
		if (li_Len > 0)
		then begin
			Inc(li_Len);
			lp_Buff := AllocMem(li_Len * SizeOf(Char));
			try
				if (SendMessageTimeout(FhWindowHandle, WM_GETTEXT, WPARAM(li_Len), LPARAM(lp_Buff), SMTO_ABORTIFHUNG, 500, li_Ret) <> 0)
				then begin
					ls_Text := String(lp_Buff);
				end;
			finally
				FreeMem(lp_Buff);
			end;
		end;
	end;

	case FiParamIndex of
		0: Result := ls_Text;
		1: Result := FGetIntValue(li_Ret);
	end;
end;

// WM_GETTEXTLENGTH ------------------------------------------------------------
function T_MyAPITest.FWM_GetTextLength: String;
const
	lcs_DECLARATION = 'WM_GETTEXTLENGTH';
	lcs_DESCRIPTION =
'指定されたウィンドウのテキストの長さを取得します。' + lcsTITLE_CRLF +
'wParam 使用しません。' + lcsCRLF +
'lParam 使用しません。' + lcsCRLF +
'戻り値 テキストの長さが返ります。'
;
var
	li_Len : DWORD;
begin
	if not(IsNowAPI(lcs_DECLARATION))
	then begin
		//グリッド表示をこのAPI用に初期化する。
		Clear;
		Declaration := lcs_DECLARATION;
		Description := lcs_DESCRIPTION;
		FAddParam('戻り値', 'ウィンドウのテキストの長さが返ります(終端のNULL文字分は含められません)。');
Exit;
	end;

	li_Len := 0;
	SendMessageTimeout(FhWindowHandle, WM_GETTEXTLENGTH, 0, 0, SMTO_ABORTIFHUNG, 500, li_Len);
	Result := FGetIntValue(li_Len);
end;


end.