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

2273 lines
66 KiB
ObjectPascal
Raw Blame History

{******************************************************************************}
{ }
{ Shell32 API Interface Unit for Object Pascal }
{ }
{ Portions created by Microsoft are Copyright (C) 1995-2005 Microsoft }
{ Corporation. All Rights Reserved. }
{ }
{ The initial developer of the original translation is Rudy Velthuis }
{ }
{ Portions created by Rudy Velthuis are Copyright (C) 2005-2008 }
{ All Rights Reserved. }
{ }
{ Adapted for JEDI API Library by Christian Wimmer }
{ }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
{ The original code is: shellapi.h, released 2005. }
{ }
{ You may retrieve the latest version of this file at the Project JEDI }
{ APILIB home page, located at http://jedi-apilib.sourceforge.net }
{ }
{ The contents of this file are used with permission, subject to the Mozilla }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at }
{ http://www.mozilla.org/MPL/MPL-1.1.html }
{ }
{ Software distributed under the License is distributed on an "AS IS" basis, }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License. }
{ }
{ Alternatively, the contents of this file may be used under the terms of the }
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
{ provisions of the LGPL License are applicable instead of those above. }
{ If you wish to allow use of your version of this file only under the terms }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting the provisions above and }
{ replace them with the notice and other provisions required by the LGPL }
{ License. If you do not delete the provisions above, a recipient may use }
{ your version of this file under either the MPL or the LGPL License. }
{ }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ }
{ }
{******************************************************************************}
{$IFNDEF JWA_OMIT_SECTIONS}
unit JwaShellAPI;
{$I ..\Includes\JediAPILib.inc}
interface
uses
JwaWinBase, JwaWinUser, JwaWinType;
{
Delphi7 does not contain:
PStartupInfoW
}
{$HPPEMIT '#include <shellapi.h>'}
{$ENDIF JWA_OMIT_SECTIONS}
{$IFNDEF JWA_IMPLEMENTATIONSECTION}
type
{$EXTERNALSYM HDROP}
HDROP = THandle;
{$IFNDEF JWA_INCLUDEMODE}
PPWideChar = ^PWideChar;
{$ENDIF JWA_INCLUDEMODE}
{$EXTERNALSYM DragQueryFileA}
function DragQueryFileA(hDrop: HDROP; iFile: UINT; lpszFile: PAnsiChar; cch: UINT): UINT; stdcall;
{$EXTERNALSYM DragQueryFileW}
function DragQueryFileW(hDrop: HDROP; iFile: UINT; lpszFile: PWideChar; cch: UINT): UINT; stdcall;
{$EXTERNALSYM DragQueryFile}
function DragQueryFile(hDrop: HDROP; iFile: UINT; lpszFile: PTSTR; cch: UINT): UINT; stdcall;
{$EXTERNALSYM DragQueryPoint}
function DragQueryPoint(hDrop: HDROP; var lppt: TPOINT): BOOL; stdcall;
{$EXTERNALSYM DragFinish}
procedure DragFinish(hDrop: HDROP); stdcall;
{$EXTERNALSYM DragAcceptFiles}
procedure DragAcceptFiles(HWnd: HWND; fAccept: BOOL); stdcall;
{$EXTERNALSYM ShellExecuteA}
function ShellExecuteA(hwnd: HWND; lpOperation, lpFile, lpParameters, lpDirectory: PAnsiChar; nShowCmd: Integer): THandle; stdcall;
{$EXTERNALSYM ShellExecuteW}
function ShellExecuteW(hwnd: HWND; lpOperation, lpFile, lpParameters, lpDirectory: PWideChar; nShowCmd: Integer): THandle; stdcall;
{$EXTERNALSYM ShellExecute}
function ShellExecute(hwnd: HWND; lpOperation, lpFile, lpParameters, lpDirectory: PTSTR; nShowCmd: Integer): THandle; stdcall;
{$EXTERNALSYM FindExecutableA}
function FindExecutableA(lpFile, lpDirectory, lpResult: PAnsiChar): THandle; stdcall;
{$EXTERNALSYM FindExecutableW}
function FindExecutableW(lpFile, lpDirectory, lpResult: PWideChar): THandle; stdcall;
{$EXTERNALSYM FindExecutable}
function FindExecutable(lpFile, lpDirectory, lpResult: PTSTR): THandle; stdcall;
{$EXTERNALSYM CommandLineToArgvW}
function CommandLineToArgvW(lpCmdLine: PWideChar; var pNumArgs: Integer): PPWideChar; stdcall;
{$EXTERNALSYM ShellAboutA}
function ShellAboutA(hWnd: HWND; szApp, szOtherStuff: PAnsiChar; hIcon: HICON): Integer; stdcall;
{$EXTERNALSYM ShellAboutW}
function ShellAboutW(hWnd: HWND; szApp, szOtherStuff: PWideChar; hIcon: HICON): Integer; stdcall;
{$EXTERNALSYM ShellAbout}
function ShellAbout(hWnd: HWND; szApp, szOtherStuff: PTSTR; hIcon: HICON): Integer; stdcall;
{$EXTERNALSYM DuplicateIcon}
function DuplicateIcon(hInst: THandle; hIcon: HICON): HICON; stdcall;
{$EXTERNALSYM ExtractAssociatedIconA}
function ExtractAssociatedIconA(hInst: THandle; lpIconPath: PAnsiChar; var lpiIcon: Word): HICON; stdcall;
{$EXTERNALSYM ExtractAssociatedIconW}
function ExtractAssociatedIconW(hInst: THandle; lpIconPath: PWideChar; var lpiIcon: Word): HICON; stdcall;
{$EXTERNALSYM ExtractAssociatedIcon}
function ExtractAssociatedIcon(hInst: THandle; lpIconPath: PTSTR; var lpiIcon: Word): HICON; stdcall;
{$EXTERNALSYM ExtractAssociatedIconExA}
function ExtractAssociatedIconExA(hInst: THandle; lpIconPath: PAnsiChar; var lpiIconIndex, lpiIconId: Word): HICON; stdcall;
{$EXTERNALSYM ExtractAssociatedIconExW}
function ExtractAssociatedIconExW(hInst: THandle; lpIconPath: PWideChar; var lpiIconIndex, lpiIconId: Word): HICON; stdcall;
{$EXTERNALSYM ExtractAssociatedIconEx}
function ExtractAssociatedIconEx(hInst: THandle; lpIconPath: PTSTR; var lpiIconIndex, lpiIconId: Word): HICON; stdcall;
{$EXTERNALSYM ExtractIconA}
function ExtractIconA(hInst: THandle; lpszExeFileName: PAnsiChar; nIconIndex: UINT): HICON; stdcall;
{$EXTERNALSYM ExtractIconW}
function ExtractIconW(hInst: THandle; lpszExeFileName: PWideChar; nIconIndex: UINT): HICON; stdcall;
{$EXTERNALSYM ExtractIcon}
function ExtractIcon(hInst: THandle; lpszExeFileName: PTSTR; nIconIndex: UINT): HICON; stdcall;
type
PDragInfoA = ^TDragInfoA;
{$EXTERNALSYM _DRAGINFOA}
_DRAGINFOA = packed record
uSize: UINT; { init with sizeof(DRAGINFO) }
pt: TPoint;
fNC: BOOL;
lpFileList: PAnsiChar;
grfKeyState: DWORD;
end;
{$EXTERNALSYM DRAGINFOA}
DRAGINFOA = _DRAGINFOA;
TDragInfoA = DRAGINFOA;
PDragInfoW = ^TDragInfoW;
{$EXTERNALSYM _DRAGINFOW}
_DRAGINFOW = packed record
uSize: UINT; { init with sizeof(DRAGINFO) }
pt: TPoint;
fNC: BOOL;
lpFileList: PWideChar;
grfKeyState: DWORD;
end;
{$EXTERNALSYM DRAGINFOW}
DRAGINFOW = _DRAGINFOW;
TDragInfoW = DRAGINFOW;
{$IFDEF UNICODE}
{$EXTERNALSYM DRAGINFO}
DRAGINFO = DRAGINFOW;
TDragInfo = TDragInfoW;
PDragInfo = PDragInfoW;
{$ELSE}
{$EXTERNALSYM DRAGINFO}
DRAGINFO = DRAGINFOA;
TDragInfo = TDragInfoA;
PDragInfo = PDragInfoA;
{$ENDIF}
////
//// AppBar stuff
////
const
{$EXTERNALSYM ABM_NEW}
ABM_NEW = $00000000;
{$EXTERNALSYM ABM_REMOVE}
ABM_REMOVE = $00000001;
{$EXTERNALSYM ABM_QUERYPOS}
ABM_QUERYPOS = $00000002;
{$EXTERNALSYM ABM_SETPOS}
ABM_SETPOS = $00000003;
{$EXTERNALSYM ABM_GETSTATE}
ABM_GETSTATE = $00000004;
{$EXTERNALSYM ABM_GETTASKBARPOS}
ABM_GETTASKBARPOS = $00000005;
{$EXTERNALSYM ABM_ACTIVATE}
ABM_ACTIVATE = $00000006; // lParam == TRUE/FALSE means activate/deactivate
{$EXTERNALSYM ABM_GETAUTOHIDEBAR}
ABM_GETAUTOHIDEBAR = $00000007;
{$EXTERNALSYM ABM_SETAUTOHIDEBAR}
ABM_SETAUTOHIDEBAR = $00000008; // this can fail at any time. MUST check the result
// lParam = TRUE/FALSE Set/Unset
// uEdge = what edge
{$EXTERNALSYM ABM_WINDOWPOSCHANGED}
ABM_WINDOWPOSCHANGED = $00000009;
{$EXTERNALSYM ABM_SETSTATE}
ABM_SETSTATE = $0000000A;
// these are put in the wparam of callback messages
{$EXTERNALSYM ABN_STATECHANGE}
ABN_STATECHANGE = $00000000;
{$EXTERNALSYM ABN_POSCHANGED}
ABN_POSCHANGED = $00000001;
{$EXTERNALSYM ABN_FULLSCREENAPP}
ABN_FULLSCREENAPP = $00000002;
{$EXTERNALSYM ABN_WINDOWARRANGE}
ABN_WINDOWARRANGE = $00000003; // lParam == TRUE means hide
// flags for get state
{$EXTERNALSYM ABS_AUTOHIDE}
ABS_AUTOHIDE = $00000001;
{$EXTERNALSYM ABS_ALWAYSONTOP}
ABS_ALWAYSONTOP = $00000002;
{$EXTERNALSYM ABE_LEFT}
ABE_LEFT = 0;
{$EXTERNALSYM ABE_TOP}
ABE_TOP = 1;
{$EXTERNALSYM ABE_RIGHT}
ABE_RIGHT = 2;
{$EXTERNALSYM ABE_BOTTOM}
ABE_BOTTOM = 3;
type
PAppBarData = ^TAppBarData;
{$EXTERNALSYM _AppBarData}
_AppBarData = packed record
cbSize: DWORD;
hWnd: HWND;
uCallbackMessage: UINT;
uEdge: UINT;
rc: TRect;
lParam: LPARAM; // message specific
end;
{$EXTERNALSYM APPBARDATA}
APPBARDATA = _AppBarData;
TAppBarData = APPBARDATA;
{$EXTERNALSYM SHAppBarMessage}
function SHAppBarMessage(dwMessage: DWORD; var Data: TAppBarData): UINT; stdcall;
////
//// EndAppBar
////
{$EXTERNALSYM DoEnvironmentSubstA}
function DoEnvironmentSubstA(szString: PAnsiChar; cchString: UINT): DWORD; stdcall;
{$EXTERNALSYM DoEnvironmentSubstW}
function DoEnvironmentSubstW(szString: PWideChar; cchString: UINT): DWORD; stdcall;
{$EXTERNALSYM DoEnvironmentSubst}
function DoEnvironmentSubst(szString: PTSTR; cchString: UINT): DWORD; stdcall;
{$EXTERNALSYM EIRESID}
function EIRESID(x: Integer): Integer;
type
PHICON = ^HICON;
{$EXTERNALSYM ExtractIconExA}
function ExtractIconExA(lpszFile: PAnsiChar; nIconIndex: Integer; phiconLarge, phiconSmall: PHICON; nIcons: UINT): UINT; stdcall;
{$EXTERNALSYM ExtractIconExW}
function ExtractIconExW(lpszFile: PWideChar; nIconIndex: Integer; phiconLarge, phiconSmall: PHICON; nIcons: UINT): UINT; stdcall;
{$EXTERNALSYM ExtractIconEx}
function ExtractIconEx(lpszFile: PTSTR; nIconIndex: Integer; phiconLarge, phiconSmall: PHICON; nIcons: UINT): UINT; stdcall;
////
//// Shell File Operations
////
const
{$EXTERNALSYM FO_MOVE}
FO_MOVE = $0001;
{$EXTERNALSYM FO_COPY}
FO_COPY = $0002;
{$EXTERNALSYM FO_DELETE}
FO_DELETE = $0003;
{$EXTERNALSYM FO_RENAME}
FO_RENAME = $0004;
{$EXTERNALSYM FOF_MULTIDESTFILES}
FOF_MULTIDESTFILES = $0001;
{$EXTERNALSYM FOF_CONFIRMMOUSE}
FOF_CONFIRMMOUSE = $0002;
{$EXTERNALSYM FOF_SILENT}
FOF_SILENT = $0004; // don't create progress/report
{$EXTERNALSYM FOF_RENAMEONCOLLISION}
FOF_RENAMEONCOLLISION = $0008;
{$EXTERNALSYM FOF_NOCONFIRMATION}
FOF_NOCONFIRMATION = $0010; // Don't prompt the user.
{$EXTERNALSYM FOF_WANTMAPPINGHANDLE}
FOF_WANTMAPPINGHANDLE = $0020; // Fill in SHFILEOPSTRUCT.hNameMappings
// Must be freed using SHFreeNameMappings
{$EXTERNALSYM FOF_ALLOWUNDO}
FOF_ALLOWUNDO = $0040;
{$EXTERNALSYM FOF_FILESONLY}
FOF_FILESONLY = $0080; // on *.*, do only files
{$EXTERNALSYM FOF_SIMPLEPROGRESS}
FOF_SIMPLEPROGRESS = $0100; // means don't show names of files
{$EXTERNALSYM FOF_NOCONFIRMMKDIR}
FOF_NOCONFIRMMKDIR = $0200; // don't confirm making any needed dirs
{$EXTERNALSYM FOF_NOERRORUI}
FOF_NOERRORUI = $0400; // don't put up error UI
{$EXTERNALSYM FOF_NOCOPYSECURITYATTRIBS}
FOF_NOCOPYSECURITYATTRIBS = $0800; // dont copy NT file Security Attributes
{$EXTERNALSYM FOF_NORECURSION}
FOF_NORECURSION = $1000; // don't recurse into directories.
{$EXTERNALSYM FOF_NO_CONNECTED_ELEMENTS}
FOF_NO_CONNECTED_ELEMENTS = $2000; // don't operate on connected elements.
{$EXTERNALSYM FOF_WANTNUKEWARNING}
FOF_WANTNUKEWARNING = $4000; // during delete operation, warn if nuking instead of recycling (partially overrides FOF_NOCONFIRMATION)
{$EXTERNALSYM FOF_NORECURSEREPARSE}
FOF_NORECURSEREPARSE = $8000; // treat reparse points as objects, not containers
type
{$EXTERNALSYM FILEOP_FLAGS}
FILEOP_FLAGS = Word;
const
{$EXTERNALSYM PO_DELETE}
PO_DELETE = $0013; // printer is being deleted
{$EXTERNALSYM PO_RENAME}
PO_RENAME = $0014; // printer is being renamed
{$EXTERNALSYM PO_PORTCHANGE}
PO_PORTCHANGE = $0020; // port this printer connected to is being changed
// if this id is set, the strings received by
// the copyhook are a doubly-null terminated
// list of strings. The first is the printer
// name and the second is the printer port.
{$EXTERNALSYM PO_REN_PORT}
PO_REN_PORT = $0034; // PO_RENAME and PO_PORTCHANGE at same time.
// no POF_ flags currently defined
type
{$EXTERNALSYM PRINTEROP_FLAGS}
PRINTEROP_FLAGS = Word;
// implicit parameters are:
// if pFrom or pTo are unqualified names the current directories are
// taken from the global current drive/directory settings managed
// by Get/SetCurrentDrive/Directory
//
// the global confirmation settings
type
PSHFileOpStructA = ^TSHFileOpStructA;
{$EXTERNALSYM _SHFILEOPSTRUCTA}
_SHFILEOPSTRUCTA = packed record
hwnd: HWND;
wFunc: UINT;
pFrom: PAnsiChar;
pTo: PAnsiChar;
fFlags: FILEOP_FLAGS;
fAnyOperationsAborted: BOOL;
hNameMappings: Pointer;
lpszProgressTitle: PAnsiChar; // only used if FOF_SIMPLEPROGRESS
end;
{$EXTERNALSYM SHFILEOPSTRUCTA}
SHFILEOPSTRUCTA = _SHFILEOPSTRUCTA;
TSHFileOpStructA = SHFILEOPSTRUCTA;
PSHFileOpStructW = ^TSHFileOpStructW;
{$EXTERNALSYM _SHFILEOPSTRUCTW}
_SHFILEOPSTRUCTW = packed record
hwnd: HWND;
wFunc: UINT;
pFrom: PWideChar;
pTo: PWideChar;
fFlags: FILEOP_FLAGS;
fAnyOperationsAborted: BOOL;
hNameMappings: Pointer;
lpszProgressTitle: PWideChar; // only used if FOF_SIMPLEPROGRESS
end;
{$EXTERNALSYM SHFILEOPSTRUCTW}
SHFILEOPSTRUCTW = _SHFILEOPSTRUCTW;
TSHFileOpStructW = SHFILEOPSTRUCTW;
{$IFDEF UNICODE}
{$EXTERNALSYM SHFILEOPSTRUCT}
SHFILEOPSTRUCT = SHFILEOPSTRUCTW;
TSHFileOpStruct = TSHFileOpStructW;
PSHFileOpStruct = PSHFileOpStructW;
{$ELSE} {$EXTERNALSYM SHFILEOPSTRUCT}
SHFILEOPSTRUCT = SHFILEOPSTRUCTA;
TSHFileOpStruct = TSHFileOpStructA;
PSHFileOpStruct = PSHFileOpStructA;
{$ENDIF}
{$EXTERNALSYM SHFileOperationA}
function SHFileOperationA(var lpFileOp: TSHFileOpStructA): Integer; stdcall;
{$EXTERNALSYM SHFileOperationW}
function SHFileOperationW(var lpFileOp: TSHFileOpStructW): Integer; stdcall;
{$EXTERNALSYM SHFileOperation}
function SHFileOperation(var lpFileOp: TSHFileOpStruct): Integer; stdcall;
{$EXTERNALSYM SHFreeNameMappings}
procedure SHFreeNameMappings(hNameMappings: THandle); stdcall;
type
PSHNameMappingA = ^TSHNameMappingA;
{$EXTERNALSYM _SHNAMEMAPPINGA}
_SHNAMEMAPPINGA = packed record
pszOldPath: PAnsiChar;
pszNewPath: PAnsiChar;
cchOldPath: Integer;
cchNewPath: Integer;
end;
{$EXTERNALSYM SHNAMEMAPPINGA}
SHNAMEMAPPINGA = _SHNAMEMAPPINGA;
TSHNameMappingA = SHNAMEMAPPINGA;
PSHNameMappingW = ^TSHNameMappingW;
{$EXTERNALSYM _SHNAMEMAPPINGW}
_SHNAMEMAPPINGW = packed record
pszOldPath: PWideChar;
pszNewPath: PWideChar;
cchOldPath: Integer;
cchNewPath: Integer;
end;
{$EXTERNALSYM SHNAMEMAPPINGW}
SHNAMEMAPPINGW = _SHNAMEMAPPINGW;
TSHNameMappingW = SHNAMEMAPPINGW;
{$IFDEF UNICODE}
{$EXTERNALSYM SHNAMEMAPPING}
SHNAMEMAPPING = SHNAMEMAPPINGW;
PSHNameMapping = PSHNameMappingW;
TSHNameMapping = TSHNameMappingW;
{$ELSE}
{$EXTERNALSYM SHNAMEMAPPING}
SHNAMEMAPPING = SHNAMEMAPPINGA;
PSHNameMapping = PSHNameMappingA;
TSHNameMapping = TSHNameMappingA;
{$ENDIF}
////
//// End Shell File Operations
////
////
//// Begin ShellExecuteEx and family
////
{ ShellExecute() and ShellExecuteEx() error codes }
{ regular WinExec() codes }
const
{$EXTERNALSYM SE_ERR_FNF}
SE_ERR_FNF = 2; // file not found
{$EXTERNALSYM SE_ERR_PNF}
SE_ERR_PNF = 3; // path not found
{$EXTERNALSYM SE_ERR_ACCESSDENIED}
SE_ERR_ACCESSDENIED = 5; // access denied
{$EXTERNALSYM SE_ERR_OOM}
SE_ERR_OOM = 8; // out of memory
{$EXTERNALSYM SE_ERR_DLLNOTFOUND}
SE_ERR_DLLNOTFOUND = 32;
{ error values for ShellExecute() beyond the regular WinExec() codes }
{$EXTERNALSYM SE_ERR_SHARE}
SE_ERR_SHARE = 26;
{$EXTERNALSYM SE_ERR_ASSOCINCOMPLETE}
SE_ERR_ASSOCINCOMPLETE = 27;
{$EXTERNALSYM SE_ERR_DDETIMEOUT}
SE_ERR_DDETIMEOUT = 28;
{$EXTERNALSYM SE_ERR_DDEFAIL}
SE_ERR_DDEFAIL = 29;
{$EXTERNALSYM SE_ERR_DDEBUSY}
SE_ERR_DDEBUSY = 30;
{$EXTERNALSYM SE_ERR_NOASSOC}
SE_ERR_NOASSOC = 31;
// Note CLASSKEY overrides CLASSNAME
{$EXTERNALSYM SEE_MASK_CLASSNAME}
SEE_MASK_CLASSNAME = $00000001;
{$EXTERNALSYM SEE_MASK_CLASSKEY}
SEE_MASK_CLASSKEY = $00000003;
// Note INVOKEIDLIST overrides IDLIST
{$EXTERNALSYM SEE_MASK_IDLIST}
SEE_MASK_IDLIST = $00000004;
{$EXTERNALSYM SEE_MASK_INVOKEIDLIST}
SEE_MASK_INVOKEIDLIST = $0000000C;
{$EXTERNALSYM SEE_MASK_ICON}
SEE_MASK_ICON = $00000010;
{$EXTERNALSYM SEE_MASK_HOTKEY}
SEE_MASK_HOTKEY = $00000020;
{$EXTERNALSYM SEE_MASK_NOCLOSEPROCESS}
SEE_MASK_NOCLOSEPROCESS = $00000040;
{$EXTERNALSYM SEE_MASK_CONNECTNETDRV}
SEE_MASK_CONNECTNETDRV = $00000080;
{$EXTERNALSYM SEE_MASK_NOASYNC}
SEE_MASK_NOASYNC = $00000100;
{$EXTERNALSYM SEE_MASK_FLAG_DDEWAIT}
SEE_MASK_FLAG_DDEWAIT = SEE_MASK_NOASYNC;
{$EXTERNALSYM SEE_MASK_DOENVSUBST}
SEE_MASK_DOENVSUBST = $00000200;
{$EXTERNALSYM SEE_MASK_FLAG_NO_UI}
SEE_MASK_FLAG_NO_UI = $00000400;
{$EXTERNALSYM SEE_MASK_UNICODE}
SEE_MASK_UNICODE = $00004000;
{$EXTERNALSYM SEE_MASK_NO_CONSOLE}
SEE_MASK_NO_CONSOLE = $00008000;
{$EXTERNALSYM SEE_MASK_ASYNCOK}
SEE_MASK_ASYNCOK = $00100000;
{$EXTERNALSYM SEE_MASK_HMONITOR}
SEE_MASK_HMONITOR = $00200000;
{$EXTERNALSYM SEE_MASK_NOZONECHECKS}
SEE_MASK_NOZONECHECKS = $00800000;
{$EXTERNALSYM SEE_MASK_NOQUERYCLASSSTORE}
SEE_MASK_NOQUERYCLASSSTORE = $01000000;
{$EXTERNALSYM SEE_MASK_WAITFORINPUTIDLE}
SEE_MASK_WAITFORINPUTIDLE = $02000000;
{$EXTERNALSYM SEE_MASK_FLAG_LOG_USAGE}
SEE_MASK_FLAG_LOG_USAGE = $04000000;
type
PShellExecuteInfoA = ^TShellExecuteInfoA;
{$EXTERNALSYM _SHELLEXECUTEINFOA}
_SHELLEXECUTEINFOA = packed record
cbSize: DWORD;
fMask: ULONG;
hwnd: HWND;
lpVerb: PAnsiChar;
lpFile: PAnsiChar;
lpParameters: PAnsiChar;
lpDirectory: PAnsiChar;
nShow: Integer;
hInstApp: THandle;
// Optional fields
lpIDList: Pointer;
lpClass: PAnsiChar;
hkeyClass: HKEY;
dwHotKey: DWORD;
u: packed record
case Byte of
0: (hIcon: THandle);
1: (hMonitor: THandle);
end;
hProcess: THandle;
end;
{$EXTERNALSYM SHELLEXECUTEINFOA}
SHELLEXECUTEINFOA = _SHELLEXECUTEINFOA;
TShellExecuteInfoA = SHELLEXECUTEINFOA;
PShellExecuteInfoW = ^TShellExecuteInfoW;
{$EXTERNALSYM _SHELLEXECUTEINFOW}
_SHELLEXECUTEINFOW = packed record
cbSize: DWORD;
fMask: ULONG;
hwnd: HWND;
lpVerb: PWideChar;
lpFile: PWideChar;
lpParameters: PWideChar;
lpDirectory: PWideChar;
nShow: Integer;
hInstApp: THandle;
// Optional fields
lpIDList: Pointer;
lpClass: PWideChar;
hkeyClass: HKEY;
dwHotKey: DWORD;
u: packed record
case Byte of
0: (hIcon: THandle);
1: (hMonitor: THandle);
end;
hProcess: THandle;
end;
{$EXTERNALSYM SHELLEXECUTEINFOA}
SHELLEXECUTEINFOW = _SHELLEXECUTEINFOW;
TShellExecuteInfoW = SHELLEXECUTEINFOW;
{$IFDEF UNICODE}
{$EXTERNALSYM SHELLEXECUTEINFO}
SHELLEXECUTEINFO = SHELLEXECUTEINFOW;
PShellExecuteInfo = PShellExecuteInfoW;
TShellExecuteInfo = TShellExecuteInfoW;
{$ELSE}
{$EXTERNALSYM SHELLEXECUTEINFO}
SHELLEXECUTEINFO = SHELLEXECUTEINFOA;
PShellExecuteInfo = PShellExecuteInfoA;
TShellExecuteInfo = TShellExecuteInfoA;
{$ENDIF}
{$EXTERNALSYM ShellExecuteExA}
function ShellExecuteExA(var lpExecInfo: TShellExecuteInfoA): BOOL; stdcall;
{$EXTERNALSYM ShellExecuteExW}
function ShellExecuteExW(var lpExecInfo: TShellExecuteInfoW): BOOL; stdcall;
{$EXTERNALSYM ShellExecuteEx}
function ShellExecuteEx(var lpExecInfo: TShellExecuteInfo): BOOL; stdcall;
var
{$EXTERNALSYM WinExecErrorA}
WinExecErrorA: procedure(hwnd: HWND; error: Integer; lpstrFileName, lpstrTitle: PAnsiChar); stdcall;
{$EXTERNALSYM WinExecErrorW}
WinExecErrorW: procedure(hwnd: HWND; error: Integer; lpstrFileName, lpstrTitle: PWideChar); stdcall;
{$EXTERNALSYM WinExecError}
WinExecError: procedure(hwnd: HWND; error: Integer; lpstrFileName, lpstrTitle: PTSTR); stdcall;
//
// SHCreateProcessAsUser()
type
PSHCreateProcessInfoW = ^TSHCreateProcessInfoW;
{$EXTERNALSYM _SHCREATEPROCESSINFOW}
_SHCREATEPROCESSINFOW = packed record
cbSize: DWORD;
fMask: ULONG;
hwnd: HWND;
pszFile: PWideChar;
pszParameters: PWideChar;
pszCurrentDirectory: PWideChar;
hUserToken: THandle;
lpProcessAttributes: PSecurityAttributes;
lpThreadAttributes: PSecurityAttributes;
bInheritHandles: BOOL;
dwCreationFlags: DWORD;
lpStartupInfo: PStartupInfoW;
lpProcessInformation: PProcessInformation;
end;
{$EXTERNALSYM SHCREATEPROCESSINFOW}
SHCREATEPROCESSINFOW = _SHCREATEPROCESSINFOW;
TSHCreateProcessInfoW = SHCREATEPROCESSINFOW;
{$EXTERNALSYM SHCreateProcessAsUserW}
function SHCreateProcessAsUserW(var pscpi: TSHCreateProcessInfoW): BOOL; stdcall;
////
//// End ShellExecuteEx and family
////
//
// RecycleBin
//
// struct for query recycle bin info
type
PSHQueryRBInfo = ^TSHQueryRBInfo;
{$EXTERNALSYM _SHQUERYRBINFO}
_SHQUERYRBINFO = packed record
cbSize: DWORD;
i64Size: Int64;
i64NumItems: Int64;
end;
{$EXTERNALSYM SHQUERYRBINFO}
SHQUERYRBINFO = _SHQUERYRBINFO;
TSHQueryRBInfo = SHQUERYRBINFO;
// flags for SHEmptyRecycleBin
const
{$EXTERNALSYM SHERB_NOCONFIRMATION}
SHERB_NOCONFIRMATION = $00000001;
{$EXTERNALSYM SHERB_NOPROGRESSUI}
SHERB_NOPROGRESSUI = $00000002;
{$EXTERNALSYM SHERB_NOSOUND}
SHERB_NOSOUND = $00000004;
{$EXTERNALSYM SHQueryRecycleBinA}
function SHQueryRecycleBinA(pszRootPath: PAnsiChar; var pSHQueryRBInfo: TSHQueryRBInfo): HRESULT; stdcall;
{$EXTERNALSYM SHQueryRecycleBinW}
function SHQueryRecycleBinW(pszRootPath: PWideChar; var pSHQueryRBInfo: TSHQueryRBInfo): HRESULT; stdcall;
{$EXTERNALSYM SHQueryRecycleBin}
function SHQueryRecycleBin(pszRootPath: PTSTR; var pSHQueryRBInfo: TSHQueryRBInfo): HRESULT; stdcall;
{$EXTERNALSYM SHEmptyRecycleBinA}
function SHEmptyRecycleBinA(hwnd: HWND; pszRootPath: PAnsiChar; dwFlags: DWORD): HRESULT; stdcall;
{$EXTERNALSYM SHEmptyRecycleBinW}
function SHEmptyRecycleBinW(hwnd: HWND; pszRootPath: PWideChar; dwFlags: DWORD): HRESULT; stdcall;
{$EXTERNALSYM SHEmptyRecycleBin}
function SHEmptyRecycleBin(hwnd: HWND; pszRootPath: PTSTR; dwFlags: DWORD): HRESULT; stdcall;
////
//// end of RecycleBin
////
//// Tray notification definitions
////
type
PNotifyIconDataA = ^TNotifyIconDataA;
{$EXTERNALSYM _NOTIFYICONDATAA}
_NOTIFYICONDATAA = packed record
cbSize: DWORD;
hWnd: HWND;
uID: UINT;
uFlags: UINT;
uCallbackMessage: UINT;
hIcon: HICON;
szTip: array[0..127] of AnsiChar;
dwState: DWORD;
dwStateMask: DWORD;
szInfo: array[0..255] of AnsiChar;
u: packed record
case Byte of
0: (uTimeout: UINT);
1: (uVersion: UINT);
end;
szInfoTitle: array[0..63] of AnsiChar;
dwInfoFlags: DWORD;
guidItem: TGUID;
end;
{$EXTERNALSYM NOTIFYICONDATAA}
NOTIFYICONDATAA = _NOTIFYICONDATAA;
TNotifyIconDataA = NOTIFYICONDATAA;
PNotifyIcondataW = ^TNotifyIconDataW;
{$EXTERNALSYM _NOTIFYICONDATAW}
_NOTIFYICONDATAW = packed record
cbSize: DWORD;
hWnd: HWND;
uID: UINT;
uFlags: UINT;
uCallbackMessage: UINT;
hIcon: HICON;
szTip: array[0..127] of WideChar;
dwState: DWORD;
dwStateMask: DWORD;
szInfo: array[0..255] of WideChar;
u: packed record
case Byte of
0: (uTimeout: UINT);
1: (uVersion: UINT);
end;
szInfoTitle: array[0..63] of WideChar;
dwInfoFlags: DWORD;
guidItem: TGUID;
end;
{$EXTERNALSYM NOTIFYICONDATAW}
NOTIFYICONDATAW = _NOTIFYICONDATAW;
TNotifyIconDataW = NOTIFYICONDATAW;
{$EXTERNALSYM NOTIFYICONDATA}
NOTIFYICONDATA = NOTIFYICONDATAA;
PNotifyIconData = PNotifyiconDataA;
TNotifyIconData = TNotifyIcondataA;
const
{$EXTERNALSYM NIN_SELECT}
NIN_SELECT = WM_USER + 0;
{$EXTERNALSYM NINF_KEY}
NINF_KEY = $1;
{$EXTERNALSYM NIN_KEYSELECT}
NIN_KEYSELECT = NIN_SELECT or NINF_KEY;
{$EXTERNALSYM NIN_BALLOONSHOW}
NIN_BALLOONSHOW = WM_USER + 2;
{$EXTERNALSYM NIN_BALLOONHIDE}
NIN_BALLOONHIDE = WM_USER + 3;
{$EXTERNALSYM NIN_BALLOONTIMEOUT}
NIN_BALLOONTIMEOUT = WM_USER + 4;
{$EXTERNALSYM NIN_BALLOONUSERCLICK}
NIN_BALLOONUSERCLICK = WM_USER + 5;
{$EXTERNALSYM NIM_ADD}
NIM_ADD = $00000000;
{$EXTERNALSYM NIM_MODIFY}
NIM_MODIFY = $00000001;
{$EXTERNALSYM NIM_DELETE}
NIM_DELETE = $00000002;
{$EXTERNALSYM NIM_SETFOCUS}
NIM_SETFOCUS = $00000003;
{$EXTERNALSYM NIM_SETVERSION}
NIM_SETVERSION = $00000004;
{$EXTERNALSYM NOTIFYICON_VERSION}
NOTIFYICON_VERSION = 3;
{$EXTERNALSYM NIF_MESSAGE}
NIF_MESSAGE = $00000001;
{$EXTERNALSYM NIF_ICON}
NIF_ICON = $00000002;
{$EXTERNALSYM NIF_TIP}
NIF_TIP = $00000004;
{$EXTERNALSYM NIF_STATE}
NIF_STATE = $00000008;
{$EXTERNALSYM NIF_INFO}
NIF_INFO = $00000010;
{$EXTERNALSYM NIF_GUID}
NIF_GUID = $00000020;
{$EXTERNALSYM NIS_HIDDEN}
NIS_HIDDEN = $00000001;
{$EXTERNALSYM NIS_SHAREDICON}
NIS_SHAREDICON = $00000002;
// says this is the source of a shared icon
// Notify Icon Infotip flags
{$EXTERNALSYM NIIF_NONE}
NIIF_NONE = $00000000;
// icon flags are mutually exclusive
// and take only the lowest 2 bits
{$EXTERNALSYM NIIF_INFO}
NIIF_INFO = $00000001;
{$EXTERNALSYM NIIF_WARNING}
NIIF_WARNING = $00000002;
{$EXTERNALSYM NIIF_ERROR}
NIIF_ERROR = $00000003;
{$EXTERNALSYM NIIF_USER}
NIIF_USER = $00000004;
{$EXTERNALSYM NIIF_ICON_MASK}
NIIF_ICON_MASK = $0000000F;
{$EXTERNALSYM NIIF_NOSOUND}
NIIF_NOSOUND = $00000010;
{$EXTERNALSYM Shell_NotifyIconA}
function Shell_NotifyIconA(dwMessage: DWORD; lpData: PNOTIFYICONDATAA): BOOL; stdcall;
{$EXTERNALSYM Shell_NotifyIconW}
function Shell_NotifyIconW(dwMessage: DWORD; lpData: PNOTIFYICONDATAW): BOOL; stdcall;
{$EXTERNALSYM Shell_NotifyIcon}
function Shell_NotifyIcon(dwMessage: DWORD; lpData: PNOTIFYICONDATA): BOOL; stdcall;
////
//// End Tray Notification Icons
////
////
//// Begin SHGetFileInfo
////
{
* The SHGetFileInfo API provides an easy way to get attributes
* for a file given a pathname.
*
* PARAMETERS
*
* pszPath file name to get info about
* dwFileAttributes file attribs, only used with SHGFI_USEFILEATTRIBUTES
* psfi place to return file info
* cbFileInfo size of structure
* uFlags flags
*
* RETURN
* TRUE if things worked
}
type
PSHFileInfoA = ^TSHFileInfoA;
{$EXTERNALSYM _SHFILEINFOA}
_SHFILEINFOA = packed record
hIcon: HICON; // out: icon
iIcon: Integer; // out: icon index
dwAttributes: DWORD; // out: SFGAO_ flags
szDisplayName: array[0..MAX_PATH - 1] of AnsiChar; // out: display name (or path)
szTypeName: array[0..79] of AnsiChar; // out: type name
end;
{$EXTERNALSYM SHFILEINFOA}
SHFILEINFOA = _SHFILEINFOA;
TSHFileInfoA = _SHFILEINFOA;
PSHFileInfoW = ^TSHFileInfoW;
{$EXTERNALSYM _SHFILEINFOW}
_SHFILEINFOW = packed record
hIcon: HICON; // out: icon
iIcon: Integer; // out: icon index
dwAttributes: DWORD; // out: SFGAO_ flags
szDisplayName: array[0..MAX_PATH - 1] of WideChar; // out: display name (or path)
szTypeName: array[0..79] of WideChar; // out: type name
end;
{$EXTERNALSYM SHFILEINFOW}
SHFILEINFOW = _SHFILEINFOW;
TSHFileInfoW = _SHFILEINFOW;
{$EXTERNALSYM SHFILEINFO}
SHFILEINFO = SHFILEINFOA;
TSHFileInfo = TSHFileInfoA;
PSHFIleInfo = PSHFileInfoA;
const
{$EXTERNALSYM SHGFI_ICON}
SHGFI_ICON = $000000100; // get icon
{$EXTERNALSYM SHGFI_DISPLAYNAME}
SHGFI_DISPLAYNAME = $000000200; // get display name
{$EXTERNALSYM SHGFI_TYPENAME}
SHGFI_TYPENAME = $000000400; // get type name
{$EXTERNALSYM SHGFI_ATTRIBUTES}
SHGFI_ATTRIBUTES = $000000800; // get attributes
{$EXTERNALSYM SHGFI_ICONLOCATION}
SHGFI_ICONLOCATION = $000001000; // get icon location
{$EXTERNALSYM SHGFI_EXETYPE}
SHGFI_EXETYPE = $000002000; // return exe type
{$EXTERNALSYM SHGFI_SYSICONINDEX}
SHGFI_SYSICONINDEX = $000004000; // get system icon index
{$EXTERNALSYM SHGFI_LINKOVERLAY}
SHGFI_LINKOVERLAY = $000008000; // put a link overlay on icon
{$EXTERNALSYM SHGFI_SELECTED}
SHGFI_SELECTED = $000010000; // show icon in selected state
{$EXTERNALSYM SHGFI_ATTR_SPECIFIED}
SHGFI_ATTR_SPECIFIED = $000020000; // get only specified attributes
{$EXTERNALSYM SHGFI_LARGEICON}
SHGFI_LARGEICON = $000000000; // get large icon
{$EXTERNALSYM SHGFI_SMALLICON}
SHGFI_SMALLICON = $000000001; // get small icon
{$EXTERNALSYM SHGFI_OPENICON}
SHGFI_OPENICON = $000000002; // get open icon
{$EXTERNALSYM SHGFI_SHELLICONSIZE}
SHGFI_SHELLICONSIZE = $000000004; // get shell size icon
{$EXTERNALSYM SHGFI_PIDL}
SHGFI_PIDL = $000000008; // pszPath is a pidl
{$EXTERNALSYM SHGFI_USEFILEATTRIBUTES}
SHGFI_USEFILEATTRIBUTES = $000000010; // use passed dwFileAttribute
{$EXTERNALSYM SHGFI_ADDOVERLAYS}
SHGFI_ADDOVERLAYS = $000000020; // apply the appropriate overlays
{$EXTERNALSYM SHGFI_OVERLAYINDEX}
SHGFI_OVERLAYINDEX = $000000040; // Get the index of the overlay
// in the upper 8 bits of the iIcon
{$EXTERNALSYM SHGetFileInfoA}
function SHGetFileInfoA(pszPath: PAnsiChar; dwFileAttributes: DWORD; var psfi: TSHFileInfoA; cbFileInfo, uFlags: UINT): DWORD; stdcall;
{$EXTERNALSYM SHGetFileInfoW}
function SHGetFileInfoW(pszPath: PWideChar; dwFileAttributes: DWORD; var psfi: TSHFileInfoW; cbFileInfo, uFlags: UINT): DWORD; stdcall;
{$EXTERNALSYM SHGetFileInfo}
function SHGetFileInfo(pszPath: PTSTR; dwFileAttributes: DWORD; var psfi: TSHFileInfo; cbFileInfo, uFlags: UINT): DWORD; stdcall;
{$EXTERNALSYM SHGetDiskFreeSpaceExA}
function SHGetDiskFreeSpaceExA(pszDirectoryName: PAnsiChar; var pulFreeBytesAvailableToCaller, pulTotalNumberOfBytes, pulTotalNumberOfFreeBytes: ULARGE_INTEGER): BOOL; stdcall;
{$EXTERNALSYM SHGetDiskFreeSpaceExW}
function SHGetDiskFreeSpaceExW(pszDirectoryName: PWideChar; var pulFreeBytesAvailableToCaller, pulTotalNumberOfBytes, pulTotalNumberOfFreeBytes: ULARGE_INTEGER): BOOL; stdcall;
{$EXTERNALSYM SHGetDiskFreeSpaceEx}
function SHGetDiskFreeSpaceEx(pszDirectoryName: PTSTR; var pulFreeBytesAvailableToCaller, pulTotalNumberOfBytes, pulTotalNumberOfFreeBytes: ULARGE_INTEGER): BOOL; stdcall;
{$EXTERNALSYM SHGetDiskFreeSpaceA}
function SHGetDiskFreeSpaceA(pszDirectoryName: PAnsiChar; var pulFreeBytesAvailableToCaller, pulTotalNumberOfBytes, pulTotalNumberOfFreeBytes: ULARGE_INTEGER): BOOL; stdcall;
{$EXTERNALSYM SHGetDiskFreeSpaceW}
function SHGetDiskFreeSpaceW(pszDirectoryName: PWideChar; var pulFreeBytesAvailableToCaller, pulTotalNumberOfBytes, pulTotalNumberOfFreeBytes: ULARGE_INTEGER): BOOL; stdcall;
{$EXTERNALSYM SHGetDiskFreeSpace}
function SHGetDiskFreeSpace(pszDirectoryName: PTSTR; var pulFreeBytesAvailableToCaller, pulTotalNumberOfBytes, pulTotalNumberOfFreeBytes: ULARGE_INTEGER): BOOL; stdcall;
{$EXTERNALSYM SHGetNewLinkInfoA}
function SHGetNewLinkInfoA(pszLinkTo, pszDir, pszName: PAnsiChar; var pfMustCopy: BOOL; uFlags: UINT): BOOL; stdcall;
{$EXTERNALSYM SHGetNewLinkInfoW}
function SHGetNewLinkInfoW(pszLinkTo, pszDir, pszName: PWideChar; var pfMustCopy: BOOL; uFlags: UINT): BOOL; stdcall;
{$EXTERNALSYM SHGetNewLinkInfo}
function SHGetNewLinkInfo(pszLinkTo, pszDir, pszName: PTSTR; var pfMustCopy: BOOL; uFlags: UINT): BOOL; stdcall;
const
{$EXTERNALSYM SHGNLI_PIDL}
SHGNLI_PIDL = $000000001; // pszLinkTo is a pidl
{$EXTERNALSYM SHGNLI_PREFIXNAME}
SHGNLI_PREFIXNAME = $000000002; // Make name "Shortcut to xxx"
{$EXTERNALSYM SHGNLI_NOUNIQUE}
SHGNLI_NOUNIQUE = $000000004; // don't do the unique name generation
{$EXTERNALSYM SHGNLI_NOLNK}
SHGNLI_NOLNK = $000000008; // don't add ".lnk" extension
////
//// End SHGetFileInfo
////
// Printer stuff
const
{$EXTERNALSYM PRINTACTION_OPEN}
PRINTACTION_OPEN = 0;
{$EXTERNALSYM PRINTACTION_PROPERTIES}
PRINTACTION_PROPERTIES = 1;
{$EXTERNALSYM PRINTACTION_NETINSTALL}
PRINTACTION_NETINSTALL = 2;
{$EXTERNALSYM PRINTACTION_NETINSTALLLINK}
PRINTACTION_NETINSTALLLINK = 3;
{$EXTERNALSYM PRINTACTION_TESTPAGE}
PRINTACTION_TESTPAGE = 4;
{$EXTERNALSYM PRINTACTION_OPENNETPRN}
PRINTACTION_OPENNETPRN = 5;
{$EXTERNALSYM PRINTACTION_DOCUMENTDEFAULTS}
PRINTACTION_DOCUMENTDEFAULTS = 6;
{$EXTERNALSYM PRINTACTION_SERVERPROPERTIES}
PRINTACTION_SERVERPROPERTIES = 7;
{$EXTERNALSYM SHInvokePrinterCommandA}
function SHInvokePrinterCommandA(hwnd: HWND; uAction: UINT; lpBuf1, lpBuf2: PAnsiChar; fModal: BOOL): BOOL; stdcall;
{$EXTERNALSYM SHInvokePrinterCommandW}
function SHInvokePrinterCommandW(hwnd: HWND; uAction: UINT; lpBuf1, lpBuf2: PWideChar; fModal: BOOL): BOOL; stdcall;
{$EXTERNALSYM SHInvokePrinterCommand}
function SHInvokePrinterCommand(hwnd: HWND; uAction: UINT; lpBuf1, lpBuf2: PTSTR; fModal: BOOL): BOOL; stdcall;
//
// The SHLoadNonloadedIconOverlayIdentifiers API causes the shell's
// icon overlay manager to load any registered icon overlay
// identifers that are not currently loaded. This is useful if an
// overlay identifier did not load at shell startup but is needed
// and can be loaded at a later time. Identifiers already loaded
// are not affected. Overlay identifiers implement the
// IShellIconOverlayIdentifier interface.
//
// Returns:
// S_OK
//
{$EXTERNALSYM SHLoadNonloadedIconOverlayIdentifiers}
function SHLoadNonloadedIconOverlayIdentifiers: HRESULT; stdcall;
//
// The SHIsFileAvailableOffline API determines whether a file
// or folder is available for offline use.
//
// Parameters:
// pwszPath file name to get info about
// pdwStatus (optional) OFFLINE_STATUS_* flags returned here
//
// Returns:
// S_OK File/directory is available offline, unless
// OFFLINE_STATUS_INCOMPLETE is returned.
// E_INVALIDARG Path is invalid, or not a net path
// E_FAIL File/directory is not available offline
//
// Notes:
// OFFLINE_STATUS_INCOMPLETE is never returned for directories.
// Both OFFLINE_STATUS_LOCAL and OFFLINE_STATUS_REMOTE may be returned,
// indicating "open in both places." This is common when the server is online.
//
{$EXTERNALSYM SHIsFileAvailableOffline}
function SHIsFileAvailableOffline(pwszPath: PWideChar; var pdwStatus: DWORD): HRESULT; stdcall;
const
{$EXTERNALSYM OFFLINE_STATUS_LOCAL}
OFFLINE_STATUS_LOCAL = $0001; // If open, it's open locally
{$EXTERNALSYM OFFLINE_STATUS_REMOTE}
OFFLINE_STATUS_REMOTE = $0002; // If open, it's open remotely
{$EXTERNALSYM OFFLINE_STATUS_INCOMPLETE}
OFFLINE_STATUS_INCOMPLETE = $0004; // The local copy is currently imcomplete.
// The file will not be available offline
// until it has been synchronized.
// sets the specified path to use the string resource
// as the UI instead of the file system name
{$EXTERNALSYM SHSetLocalizedName}
function SHSetLocalizedName(pszPath, pszResModule: PWideChar; idsRes: Integer): HRESULT; stdcall;
//====== ShellMessageBox ================================================
// If lpcTitle is NULL, the title is taken from hWnd
// If lpcText is NULL, this is assumed to be an Out Of Memory message
// If the selector of lpcTitle or lpcText is NULL, the offset should be a
// string resource ID
// The variable arguments must all be 32-bit values (even if fewer bits
// are actually used)
// lpcText (or whatever string resource it causes to be loaded) should
// be a formatting string similar to wsprintf except that only the
// following formats are available:
// %% formats to a single '%'
// %nn%s the nn-th arg is a string which is inserted
// %nn%ld the nn-th arg is a DWORD, and formatted decimal
// %nn%lx the nn-th arg is a DWORD, and formatted hex
// note that lengths are allowed on the %s, %ld, and %lx, just
// like wsprintf
//
{$IFDEF DELPHI6_UP}
//variable arguments are not supported in delphi 5
//maybe this also applies to d6
{$EXTERNALSYM ShellMessageBoxA}
function ShellMessageBoxA(hAppInst: THandle; hWnd: HWND; lpcText, lpcTitle: PAnsiChar; fuStyle: UINT): Integer; cdecl; varargs;
{$EXTERNALSYM ShellMessageBoxW}
function ShellMessageBoxW(hAppInst: THandle; hWnd: HWND; lpcText, lpcTitle: PWideChar; fuStyle: UINT): Integer; cdecl; varargs;
{$EXTERNALSYM ShellMessageBox}
function ShellMessageBox(hAppInst: THandle; hWnd: HWND; lpcText, lpcTitle: PTSTR; fuStyle: UINT): Integer; cdecl; varargs;
{$ENDIF DELPHI6_UP}
{$EXTERNALSYM IsLFNDriveA}
function IsLFNDriveA(pszPath: PAnsiChar): BOOL; stdcall;
{$EXTERNALSYM IsLFNDriveW}
function IsLFNDriveW(pszPath: PWideChar): BOOL; stdcall;
{$EXTERNALSYM IsLFNDrive}
function IsLFNDrive(pszPath: PTSTR): BOOL; stdcall;
{The following 3 functions are only available as unicode version.
MSDN states this correctly, however all SDK's define also an ansicode version.
We just define W variant!
}
function SHGetUnreadMailCountW(hKeyUser: Thandle; pszMailAddress: PWideChar; out pdwCount: DWORD; var pFileTime: TFileTime; pszShellExecuteCommand: PWideChar;
cchShellExecuteCommand: Integer): HRESULT; stdcall;
function SHEnumerateUnreadMailAccountsW(hKeyUser: THandle; dwIndex: DWORD; pszMailAddress: PWideChar; cchMailAddress: Integer): HRESULT; stdcall;
function SHSetUnreadMailCountW(pszMailAddress: PWideChar; dwCount: DWORD; pszShellExecuteCommand: PWideChar): HRESULT; stdcall;
{$EXTERNALSYM SHTestTokenMembership}
function SHTestTokenMembership(hToken: THandle; ulRID: ULONG): BOOL; stdcall;
{$EXTERNALSYM SHGetImageList}
function SHGetImageList(iImageList: Integer; riid: TGUID; out ppvObj: Pointer): HRESULT; stdcall;
const
{$EXTERNALSYM SHIL_LARGE}
SHIL_LARGE = 0; // normally 32x32
{$EXTERNALSYM SHIL_SMALL}
SHIL_SMALL = 1; // normally 16x16
{$EXTERNALSYM SHIL_EXTRALARGE}
SHIL_EXTRALARGE = 2;
{$EXTERNALSYM SHIL_SYSSMALL}
SHIL_SYSSMALL = 3; // like SHIL_SMALL, but tracks system small icon metric correctly
{$EXTERNALSYM SHIL_LAST}
SHIL_LAST = SHIL_SYSSMALL;
// Function call types for ntshrui folder sharing helpers
type
{$EXTERNALSYM PFNCANSHAREFOLDERW}
PFNCANSHAREFOLDERW = function(pszPath: PWideChar): HRESULT stdcall;
TFnCanShareFolderW = PFNCANSHAREFOLDERW;
{$EXTERNALSYM PFNSHOWSHAREFOLDERUIW}
PFNSHOWSHAREFOLDERUIW = function(hwndParent: HWND; pszPath: PWideChar): HRESULT stdcall;
TFnShowShareFolderUIW = PFNSHOWSHAREFOLDERUIW;
{$ENDIF JWA_IMPLEMENTATIONSECTION}
{$IFNDEF JWA_OMIT_SECTIONS}
implementation
uses JwaWinDLLNames;
{$ENDIF JWA_OMIT_SECTIONS}
{$IFNDEF JWA_INCLUDEMODE}
const
{$IFDEF UNICODE}
AWSuffix = 'W';
{$ELSE}
AWSuffix = 'A';
{$ENDIF UNICODE}
{$ENDIF JWA_INCLUDEMODE}
{$IFNDEF JWA_INTERFACESECTION}
// Macro function
function EIRESID(x: Integer): Integer;
begin
Result := -x;
end;
{$IFDEF DELPHI6_UP}
//cannot be dynamical because of varargs
function ShellMessageBoxA; external Shell32 name 'ShellMessageBoxA';
function ShellMessageBoxW; external Shell32 name 'ShellMessageBoxW';
function ShellMessageBox; external Shell32 name 'ShellMessageBox'+ AWSuffix;
{$ENDIF}
{$IFNDEF DYNAMIC_LINK}
function DragQueryFileA; external Shell32 name 'DragQueryFileA';
function DragQueryFileW; external Shell32 name 'DragQueryFileW';
function DragQueryFile; external Shell32 name 'DragQueryFile' + AWSuffix;
function DragQueryPoint; external Shell32 name 'DragQueryPoint';
procedure DragFinish; external Shell32 name 'DragFinish';
procedure DragAcceptFiles; external Shell32 name 'DragAcceptFiles';
function ShellExecuteA; external Shell32 name 'ShellExecuteA';
function ShellExecuteW; external Shell32 name 'ShellExecuteW';
function ShellExecute; external Shell32 name 'ShellExecute' + AWSuffix;
function FindExecutableA; external Shell32 name 'FindExecutableA';
function FindExecutableW; external Shell32 name 'FindExecutableW';
function FindExecutable; external Shell32 name 'FindExecutable' + AWSuffix;
function CommandLineToArgvW; external Shell32 name 'CommandLineToArgvW';
function ShellAboutA; external Shell32 name 'ShellAboutA';
function ShellAboutW; external Shell32 name 'ShellAboutW';
function ShellAbout; external Shell32 name 'ShellAbout' + AWSuffix;
function DuplicateIcon; external Shell32 name 'DuplicateIcon';
function ExtractAssociatedIconA; external Shell32 name 'ExtractAssociatedIconA';
function ExtractAssociatedIconW; external Shell32 name 'ExtractAssociatedIconW';
function ExtractAssociatedIcon; external Shell32 name 'ExtractAssociatedIcon' + AWSuffix;
function ExtractAssociatedIconExA; external Shell32 name 'ExtractAssociatedIconExA';
function ExtractAssociatedIconExW; external Shell32 name 'ExtractAssociatedIconExW';
function ExtractAssociatedIconEx; external Shell32 name 'ExtractAssociatedIconEx' + AWSuffix;
function ExtractIconA; external Shell32 name 'ExtractIconA';
function ExtractIconW; external Shell32 name 'ExtractIconW';
function ExtractIcon; external Shell32 name 'ExtractIcon' + AWSuffix;
function SHAppBarMessage; external Shell32 name 'SHAppBarMessage';
function DoEnvironmentSubstA; external Shell32 name 'DoEnvironmentSubstA';
function DoEnvironmentSubstW; external Shell32 name 'DoEnvironmentSubstW';
function DoEnvironmentSubst; external Shell32 name 'DoEnvironmentSubst' + AWSuffix;
function ExtractIconExA; external Shell32 name 'ExtractIconExA';
function ExtractIconExW; external Shell32 name 'ExtractIconExW';
function ExtractIconEx; external Shell32 name 'ExtractIconEx' + AWSuffix;
function SHFileOperationA; external Shell32 name 'SHFileOperationA';
function SHFileOperationW; external Shell32 name 'SHFileOperationW';
function SHFileOperation; external Shell32 name 'SHFileOperation' + AWSuffix;
procedure SHFreeNameMappings; external Shell32 name 'SHFreeNameMappings';
function ShellExecuteExA; external Shell32 name 'ShellExecuteExA';
function ShellExecuteExW; external Shell32 name 'ShellExecuteExW';
function ShellExecuteEx; external Shell32 name 'ShellExecuteEx' + AWSuffix;
function SHCreateProcessAsUserW; external Shell32 name 'SHCreateProcessAsUserW';
function SHQueryRecycleBinA; external Shell32 name 'SHQueryRecycleBinA';
function SHQueryRecycleBinW; external Shell32 name 'SHQueryRecycleBinW';
function SHQueryRecycleBin; external Shell32 name 'SHQueryRecycleBin' + AWSuffix;
function SHEmptyRecycleBinA; external Shell32 name 'SHEmptyRecycleBinA';
function SHEmptyRecycleBinW; external Shell32 name 'SHEmptyRecycleBinW';
function SHEmptyRecycleBin; external Shell32 name 'SHEmptyRecycleBin'+ AWSuffix;
function Shell_NotifyIconA; external Shell32 name 'Shell_NotifyIconA';
function Shell_NotifyIconW; external Shell32 name 'Shell_NotifyIconW';
function Shell_NotifyIcon; external Shell32 name 'Shell_NotifyIcon'+ AWSuffix;
function SHGetFileInfoA; external Shell32 name 'SHGetFileInfoA';
function SHGetFileInfoW; external Shell32 name 'SHGetFileInfoW';
function SHGetFileInfo; external Shell32 name 'SHGetFileInfo'+ AWSuffix;
function SHGetDiskFreeSpaceExA; external Shell32 name 'SHGetDiskFreeSpaceExA';
function SHGetDiskFreeSpaceExW; external Shell32 name 'SHGetDiskFreeSpaceExW';
function SHGetDiskFreeSpaceEx; external Shell32 name 'SHGetDiskFreeSpaceEx'+ AWSuffix;
function SHGetDiskFreeSpaceA; external Shell32 name 'SHGetDiskFreeSpaceExA';
function SHGetDiskFreeSpaceW; external Shell32 name 'SHGetDiskFreeSpaceExW';
function SHGetDiskFreeSpace; external Shell32 name 'SHGetDiskFreeSpaceEx'+ AWSuffix;
function SHGetNewLinkInfoA; external Shell32 name 'SHGetNewLinkInfoA';
function SHGetNewLinkInfoW; external Shell32 name 'SHGetNewLinkInfoW';
function SHGetNewLinkInfo; external Shell32 name 'SHGetNewLinkInfo'+ AWSuffix;
function SHInvokePrinterCommandA; external Shell32 name 'SHInvokePrinterCommandA';
function SHInvokePrinterCommandW; external Shell32 name 'SHInvokePrinterCommandW';
function SHInvokePrinterCommand; external Shell32 name 'SHInvokePrinterCommand'+ AWSuffix;
function SHLoadNonloadedIconOverlayIdentifiers; external Shell32 name 'SHLoadNonloadedIconOverlayIdentifiers';
function SHIsFileAvailableOffline; external Shell32 name 'SHIsFileAvailableOffline';
function SHSetLocalizedName; external Shell32 name 'SHSetLocalizedName';
function IsLFNDriveA; external Shell32 name 'IsLFNDriveA';
function IsLFNDriveW; external Shell32 name 'IsLFNDriveW';
function IsLFNDrive; external Shell32 name 'IsLFNDrive'+ AWSuffix;
function SHTestTokenMembership; external Shell32 name 'SHTestTokenMembership';
function SHGetImageList; external Shell32 name 'SHGetImageList';
function SHGetUnreadMailCountW; external Shell32 name 'SHGetUnreadMailCountW';
function SHEnumerateUnreadMailAccountsW; external Shell32 name 'SHEnumerateUnreadMailAccountsW';
function SHSetUnreadMailCountW; external Shell32 name 'SHSetUnreadMailCountW';
{$ELSE}
var
_DragQueryFileA: Pointer;
function DragQueryFileA;
begin
GetProcedureAddress(_DragQueryFileA, Shell32, 'DragQueryFileA');
asm
MOV ESP, EBP
POP EBP
JMP [_DragQueryFileA]
end;
end;
var
_DragQueryFileW: Pointer;
function DragQueryFileW;
begin
GetProcedureAddress(_DragQueryFileW, Shell32, 'DragQueryFileW');
asm
MOV ESP, EBP
POP EBP
JMP [_DragQueryFileW]
end;
end;
var
_DragQueryFile: Pointer;
function DragQueryFile;
begin
GetProcedureAddress(_DragQueryFile, Shell32, 'DragQueryFile'+ AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_DragQueryFile]
end;
end;
var
_DragQueryPoint: Pointer;
function DragQueryPoint;
begin
GetProcedureAddress(_DragQueryPoint, Shell32, 'DragQueryPoint');
asm
MOV ESP, EBP
POP EBP
JMP [_DragQueryPoint]
end;
end;
var
_DragFinish: Pointer;
procedure DragFinish;
begin
GetProcedureAddress(_DragFinish, Shell32, 'DragFinish');
asm
MOV ESP, EBP
POP EBP
JMP [_DragFinish]
end;
end;
var
_DragAcceptFiles: Pointer;
procedure DragAcceptFiles;
begin
GetProcedureAddress(_DragAcceptFiles, Shell32, 'DragAcceptFiles');
asm
MOV ESP, EBP
POP EBP
JMP [_DragAcceptFiles]
end;
end;
var
_ShellExecuteA: Pointer;
function ShellExecuteA;
begin
GetProcedureAddress(_ShellExecuteA, Shell32, 'ShellExecuteA');
asm
MOV ESP, EBP
POP EBP
JMP [_ShellExecuteA]
end;
end;
var
_ShellExecuteW: Pointer;
function ShellExecuteW;
begin
GetProcedureAddress(_ShellExecuteW, Shell32, 'ShellExecuteW');
asm
MOV ESP, EBP
POP EBP
JMP [_ShellExecuteW]
end;
end;
var
_ShellExecute: Pointer;
function ShellExecute;
begin
GetProcedureAddress(_ShellExecute, Shell32, 'ShellExecute'+ AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_ShellExecute]
end;
end;
var
_FindExecutableA: Pointer;
function FindExecutableA;
begin
GetProcedureAddress(_FindExecutableA, Shell32, 'FindExecutableA');
asm
MOV ESP, EBP
POP EBP
JMP [_FindExecutableA]
end;
end;
var
_FindExecutableW: Pointer;
function FindExecutableW;
begin
GetProcedureAddress(_FindExecutableW, Shell32, 'FindExecutableW');
asm
MOV ESP, EBP
POP EBP
JMP [_FindExecutableW]
end;
end;
var
_FindExecutable: Pointer;
function FindExecutable;
begin
GetProcedureAddress(_FindExecutable, Shell32, 'FindExecutable'+ AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_FindExecutable]
end;
end;
var
_CommandLineToArgvW: Pointer;
function CommandLineToArgvW;
begin
GetProcedureAddress(_CommandLineToArgvW, Shell32, 'CommandLineToArgvW');
asm
MOV ESP, EBP
POP EBP
JMP [_CommandLineToArgvW]
end;
end;
var
_ShellAboutA: Pointer;
function ShellAboutA;
begin
GetProcedureAddress(_ShellAboutA, Shell32, 'ShellAboutA');
asm
MOV ESP, EBP
POP EBP
JMP [_ShellAboutA]
end;
end;
var
_ShellAboutW: Pointer;
function ShellAboutW;
begin
GetProcedureAddress(_ShellAboutW, Shell32, 'ShellAboutW');
asm
MOV ESP, EBP
POP EBP
JMP [_ShellAboutW]
end;
end;
var
_ShellAbout: Pointer;
function ShellAbout;
begin
GetProcedureAddress(_ShellAbout, Shell32, 'ShellAbout'+ AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_ShellAbout]
end;
end;
var
_DuplicateIcon: Pointer;
function DuplicateIcon;
begin
GetProcedureAddress(_DuplicateIcon, Shell32, 'DuplicateIcon');
asm
MOV ESP, EBP
POP EBP
JMP [_DuplicateIcon]
end;
end;
var
_ExtractAssociatedIconA: Pointer;
function ExtractAssociatedIconA;
begin
GetProcedureAddress(_ExtractAssociatedIconA, Shell32, 'ExtractAssociatedIconA');
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractAssociatedIconA]
end;
end;
var
_ExtractAssociatedIconW: Pointer;
function ExtractAssociatedIconW;
begin
GetProcedureAddress(_ExtractAssociatedIconW, Shell32, 'ExtractAssociatedIconW');
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractAssociatedIconW]
end;
end;
var
_ExtractAssociatedIcon: Pointer;
function ExtractAssociatedIcon;
begin
GetProcedureAddress(_ExtractAssociatedIcon, Shell32, 'ExtractAssociatedIcon'+ AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractAssociatedIcon]
end;
end;
var
_ExtractAssociatedIconExA: Pointer;
function ExtractAssociatedIconExA;
begin
GetProcedureAddress(_ExtractAssociatedIconExA, Shell32, 'ExtractAssociatedIconExA');
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractAssociatedIconExA]
end;
end;
var
_ExtractAssociatedIconExW: Pointer;
function ExtractAssociatedIconExW;
begin
GetProcedureAddress(_ExtractAssociatedIconExW, Shell32, 'ExtractAssociatedIconExW');
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractAssociatedIconExW]
end;
end;
var
_ExtractAssociatedIconEx: Pointer;
function ExtractAssociatedIconEx;
begin
GetProcedureAddress(_ExtractAssociatedIconEx, Shell32, 'ExtractAssociatedIconEx'+ AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractAssociatedIconEx]
end;
end;
var
_ExtractIconA: Pointer;
function ExtractIconA;
begin
GetProcedureAddress(_ExtractIconA, Shell32, 'ExtractIconA');
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractIconA]
end;
end;
var
_ExtractIconW: Pointer;
function ExtractIconW;
begin
GetProcedureAddress(_ExtractIconW, Shell32, 'ExtractIconW');
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractIconW]
end;
end;
var
_ExtractIcon: Pointer;
function ExtractIcon;
begin
GetProcedureAddress(_ExtractIcon, Shell32, 'ExtractIcon' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractIcon]
end;
end;
var
_SHAppBarMessage: Pointer;
function SHAppBarMessage;
begin
GetProcedureAddress(_SHAppBarMessage, Shell32, 'SHAppBarMessage');
asm
MOV ESP, EBP
POP EBP
JMP [_SHAppBarMessage]
end;
end;
var
_DoEnvironmentSubstA: Pointer;
function DoEnvironmentSubstA;
begin
GetProcedureAddress(_DoEnvironmentSubstA, Shell32, 'DoEnvironmentSubstA');
asm
MOV ESP, EBP
POP EBP
JMP [_DoEnvironmentSubstA]
end;
end;
var
_DoEnvironmentSubstW: Pointer;
function DoEnvironmentSubstW;
begin
GetProcedureAddress(_DoEnvironmentSubstW, Shell32, 'DoEnvironmentSubstW');
asm
MOV ESP, EBP
POP EBP
JMP [_DoEnvironmentSubstW]
end;
end;
var
_DoEnvironmentSubst: Pointer;
function DoEnvironmentSubst;
begin
GetProcedureAddress(_DoEnvironmentSubst, Shell32, 'DoEnvironmentSubst' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_DoEnvironmentSubst]
end;
end;
var
_ExtractIconExA: Pointer;
function ExtractIconExA;
begin
GetProcedureAddress(_ExtractIconExA, Shell32, 'ExtractIconExA');
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractIconExA]
end;
end;
var
_ExtractIconExW: Pointer;
function ExtractIconExW;
begin
GetProcedureAddress(_ExtractIconExW, Shell32, 'ExtractIconExW');
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractIconExW]
end;
end;
var
_ExtractIconEx: Pointer;
function ExtractIconEx;
begin
GetProcedureAddress(_ExtractIconEx, Shell32, 'ExtractIconEx' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_ExtractIconEx]
end;
end;
var
_SHFileOperationA: Pointer;
function SHFileOperationA;
begin
GetProcedureAddress(_SHFileOperationA, Shell32, 'SHFileOperationA');
asm
MOV ESP, EBP
POP EBP
JMP [_SHFileOperationA]
end;
end;
var
_SHFileOperationW: Pointer;
function SHFileOperationW;
begin
GetProcedureAddress(_SHFileOperationW, Shell32, 'SHFileOperationW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHFileOperationW]
end;
end;
var
_SHFileOperation: Pointer;
function SHFileOperation;
begin
GetProcedureAddress(_SHFileOperation, Shell32, 'SHFileOperation' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_SHFileOperation]
end;
end;
var
_SHFreeNameMappings: Pointer;
procedure SHFreeNameMappings;
begin
GetProcedureAddress(_SHFreeNameMappings, Shell32, 'SHFreeNameMappings');
asm
MOV ESP, EBP
POP EBP
JMP [_SHFreeNameMappings]
end;
end;
var
_ShellExecuteExA: Pointer;
function ShellExecuteExA;
begin
GetProcedureAddress(_ShellExecuteExA, Shell32, 'ShellExecuteExA');
asm
MOV ESP, EBP
POP EBP
JMP [_ShellExecuteExA]
end;
end;
var
_ShellExecuteExW: Pointer;
function ShellExecuteExW;
begin
GetProcedureAddress(_ShellExecuteExW, Shell32, 'ShellExecuteExW');
asm
MOV ESP, EBP
POP EBP
JMP [_ShellExecuteExW]
end;
end;
var
_ShellExecuteEx: Pointer;
function ShellExecuteEx;
begin
GetProcedureAddress(_ShellExecuteEx, Shell32, 'ShellExecuteEx' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_ShellExecuteEx]
end;
end;
var
_SHCreateProcessAsUserW: Pointer;
function SHCreateProcessAsUserW;
begin
GetProcedureAddress(_SHCreateProcessAsUserW, Shell32, 'SHCreateProcessAsUserW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHCreateProcessAsUserW]
end;
end;
var
_SHQueryRecycleBinA: Pointer;
function SHQueryRecycleBinA;
begin
GetProcedureAddress(_SHQueryRecycleBinA, Shell32, 'SHQueryRecycleBinA');
asm
MOV ESP, EBP
POP EBP
JMP [_SHQueryRecycleBinA]
end;
end;
var
_SHQueryRecycleBinW: Pointer;
function SHQueryRecycleBinW;
begin
GetProcedureAddress(_SHQueryRecycleBinW, Shell32, 'SHQueryRecycleBinW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHQueryRecycleBinW]
end;
end;
var
_SHQueryRecycleBin: Pointer;
function SHQueryRecycleBin;
begin
GetProcedureAddress(_SHQueryRecycleBin, Shell32, 'SHQueryRecycleBin' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_SHQueryRecycleBin]
end;
end;
var
_SHEmptyRecycleBinA: Pointer;
function SHEmptyRecycleBinA;
begin
GetProcedureAddress(_SHEmptyRecycleBinA, Shell32, 'SHEmptyRecycleBinA');
asm
MOV ESP, EBP
POP EBP
JMP [_SHEmptyRecycleBinA]
end;
end;
var
_SHEmptyRecycleBinW: Pointer;
function SHEmptyRecycleBinW;
begin
GetProcedureAddress(_SHEmptyRecycleBinW, Shell32, 'SHEmptyRecycleBinW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHEmptyRecycleBinW]
end;
end;
var
_SHEmptyRecycleBin: Pointer;
function SHEmptyRecycleBin;
begin
GetProcedureAddress(_SHEmptyRecycleBin, Shell32, 'SHEmptyRecycleBin' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_SHEmptyRecycleBin]
end;
end;
var
_Shell_NotifyIconA_NotifyIconA: Pointer;
procedure Shell_NotifyIconA_NotifyIconA;
begin
GetProcedureAddress(_Shell_NotifyIconA_NotifyIconA, Shell32, 'Shell_NotifyIconA_NotifyIconA');
asm
MOV ESP, EBP
POP EBP
JMP [_Shell_NotifyIconA_NotifyIconA]
end;
end;
var
_Shell_NotifyIconW_NotifyIconW: Pointer;
procedure Shell_NotifyIconW_NotifyIconW;
begin
GetProcedureAddress(_Shell_NotifyIconW_NotifyIconW, Shell32, 'Shell_NotifyIconW_NotifyIconW');
asm
MOV ESP, EBP
POP EBP
JMP [_Shell_NotifyIconW_NotifyIconW]
end;
end;
var
_Shell_NotifyIcon_NotifyIcon: Pointer;
procedure Shell_NotifyIcon_NotifyIcon;
begin
GetProcedureAddress(_Shell_NotifyIcon_NotifyIcon, Shell32, 'Shell_NotifyIcon_NotifyIcon' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_Shell_NotifyIcon_NotifyIcon]
end;
end;
var
_SHGetFileInfoA: Pointer;
function SHGetFileInfoA;
begin
GetProcedureAddress(_SHGetFileInfoA, Shell32, 'SHGetFileInfoA');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetFileInfoA]
end;
end;
var
_SHGetFileInfoW: Pointer;
function SHGetFileInfoW;
begin
GetProcedureAddress(_SHGetFileInfoW, Shell32, 'SHGetFileInfoW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetFileInfoW]
end;
end;
var
_SHGetFileInfo: Pointer;
function SHGetFileInfo;
begin
GetProcedureAddress(_SHGetFileInfo, Shell32, 'SHGetFileInfo' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetFileInfo]
end;
end;
var
_SHGetDiskFreeSpaceExA: Pointer;
function SHGetDiskFreeSpaceExA;
begin
GetProcedureAddress(_SHGetDiskFreeSpaceExA, Shell32, 'SHGetDiskFreeSpaceExA');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetDiskFreeSpaceExA]
end;
end;
var
_SHGetDiskFreeSpaceExW: Pointer;
function SHGetDiskFreeSpaceExW;
begin
GetProcedureAddress(_SHGetDiskFreeSpaceExW, Shell32, 'SHGetDiskFreeSpaceExW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetDiskFreeSpaceExW]
end;
end;
var
_SHGetDiskFreeSpaceEx: Pointer;
function SHGetDiskFreeSpaceEx;
begin
GetProcedureAddress(_SHGetDiskFreeSpaceEx, Shell32, 'SHGetDiskFreeSpaceEx' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetDiskFreeSpaceEx]
end;
end;
var
_SHGetDiskFreeSpaceA: Pointer;
function SHGetDiskFreeSpaceA;
begin
GetProcedureAddress(_SHGetDiskFreeSpaceA, Shell32, 'SHGetDiskFreeSpaceA');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetDiskFreeSpaceA]
end;
end;
var
_SHGetDiskFreeSpaceW: Pointer;
function SHGetDiskFreeSpaceW;
begin
GetProcedureAddress(_SHGetDiskFreeSpaceW, Shell32, 'SHGetDiskFreeSpaceW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetDiskFreeSpaceW]
end;
end;
var
_SHGetDiskFreeSpace: Pointer;
function SHGetDiskFreeSpace;
begin
GetProcedureAddress(_SHGetDiskFreeSpace, Shell32, 'SHGetDiskFreeSpace' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetDiskFreeSpace]
end;
end;
var
_SHGetNewLinkInfoA: Pointer;
function SHGetNewLinkInfoA;
begin
GetProcedureAddress(_SHGetNewLinkInfoA, Shell32, 'SHGetNewLinkInfoA');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetNewLinkInfoA]
end;
end;
var
_SHGetNewLinkInfoW: Pointer;
function SHGetNewLinkInfoW;
begin
GetProcedureAddress(_SHGetNewLinkInfoW, Shell32, 'SHGetNewLinkInfoW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetNewLinkInfoW]
end;
end;
var
_SHGetNewLinkInfo: Pointer;
function SHGetNewLinkInfo;
begin
GetProcedureAddress(_SHGetNewLinkInfo, Shell32, 'SHGetNewLinkInfo' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetNewLinkInfo]
end;
end;
var
_SHInvokePrinterCommandA: Pointer;
function SHInvokePrinterCommandA;
begin
GetProcedureAddress(_SHInvokePrinterCommandA, Shell32, 'SHInvokePrinterCommandA');
asm
MOV ESP, EBP
POP EBP
JMP [_SHInvokePrinterCommandA]
end;
end;
var
_SHInvokePrinterCommandW: Pointer;
function SHInvokePrinterCommandW;
begin
GetProcedureAddress(_SHInvokePrinterCommandW, Shell32, 'SHInvokePrinterCommandW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHInvokePrinterCommandW]
end;
end;
var
_SHInvokePrinterCommand: Pointer;
function SHInvokePrinterCommand;
begin
GetProcedureAddress(_SHInvokePrinterCommand, Shell32, 'SHInvokePrinterCommand' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_SHInvokePrinterCommand]
end;
end;
var
//_SHLoadNonloadedIconOverlayIdentifiers: Pointer; //too long name for d5
_SHLoadNonloadedIOI: Pointer;
function SHLoadNonloadedIconOverlayIdentifiers;
begin
GetProcedureAddress(_SHLoadNonloadedIOI, Shell32, 'SHLoadNonloadedIconOverlayIdentifiers');
asm
MOV ESP, EBP
POP EBP
JMP [_SHLoadNonloadedIOI]
end;
end;
var
_SHIsFileAvailableOffline: Pointer;
function SHIsFileAvailableOffline;
begin
GetProcedureAddress(_SHIsFileAvailableOffline, Shell32, 'SHIsFileAvailableOffline');
asm
MOV ESP, EBP
POP EBP
JMP [_SHIsFileAvailableOffline]
end;
end;
var
_SHSetLocalizedName: Pointer;
function SHSetLocalizedName;
begin
GetProcedureAddress(_SHSetLocalizedName, Shell32, 'SHSetLocalizedName');
asm
MOV ESP, EBP
POP EBP
JMP [_SHSetLocalizedName]
end;
end;
var
_IsLFNDriveA: Pointer;
function IsLFNDriveA;
begin
GetProcedureAddress(_IsLFNDriveA, Shell32, 'IsLFNDriveA');
asm
MOV ESP, EBP
POP EBP
JMP [_IsLFNDriveA]
end;
end;
var
_IsLFNDriveW: Pointer;
function IsLFNDriveW;
begin
GetProcedureAddress(_IsLFNDriveW, Shell32, 'IsLFNDriveW');
asm
MOV ESP, EBP
POP EBP
JMP [_IsLFNDriveW]
end;
end;
var
_IsLFNDrive: Pointer;
function IsLFNDrive;
begin
GetProcedureAddress(_IsLFNDrive, Shell32, 'IsLFNDrive' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_IsLFNDrive]
end;
end;
var
_SHTestTokenMembership: Pointer;
function SHTestTokenMembership;
begin
GetProcedureAddress(_SHTestTokenMembership, Shell32, 'SHTestTokenMembership');
asm
MOV ESP, EBP
POP EBP
JMP [_SHTestTokenMembership]
end;
end;
var
_SHGetImageList: Pointer;
function SHGetImageList;
begin
GetProcedureAddress(_SHGetImageList, Shell32, 'SHGetImageList');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetImageList]
end;
end;
var
_SHGetUnreadMailCountW: Pointer;
function SHGetUnreadMailCountW;
begin
GetProcedureAddress(_SHGetUnreadMailCountW, Shell32, 'SHGetUnreadMailCountW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHGetUnreadMailCountW]
end;
end;
var
_SHEnumerateUnreadMailAccountsW: Pointer;
function SHEnumerateUnreadMailAccountsW;
begin
GetProcedureAddress(_SHEnumerateUnreadMailAccountsW, Shell32, 'SHEnumerateUnreadMailAccountsW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHEnumerateUnreadMailAccountsW]
end;
end;
var
_SHSetUnreadMailCountW: Pointer;
function SHSetUnreadMailCountW;
begin
GetProcedureAddress(_SHSetUnreadMailCountW, Shell32, 'SHSetUnreadMailCountW');
asm
MOV ESP, EBP
POP EBP
JMP [_SHSetUnreadMailCountW]
end;
end;
var
_Shell_NotifyIconA: Pointer;
function Shell_NotifyIconA;
begin
GetProcedureAddress(_Shell_NotifyIconA, Shell32, 'Shell_NotifyIconA');
asm
MOV ESP, EBP
POP EBP
JMP [_Shell_NotifyIconA]
end;
end;
var
_Shell_NotifyIconW: Pointer;
function Shell_NotifyIconW;
begin
GetProcedureAddress(_Shell_NotifyIconW, Shell32, 'Shell_NotifyIconW');
asm
MOV ESP, EBP
POP EBP
JMP [_Shell_NotifyIconW]
end;
end;
var
_Shell_NotifyIcon: Pointer;
function Shell_NotifyIcon;
begin
GetProcedureAddress(_Shell_NotifyIcon, Shell32, 'Shell_NotifyIcon' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_Shell_NotifyIcon]
end;
end;
{$ENDIF DYNAMIC_LINK}
{$ENDIF JWA_INTERFACESECTION}
{$IFNDEF JWA_OMIT_SECTIONS}
end.
{$ENDIF JWA_OMIT_SECTIONS}
Reference in a new issue View git blame Copy permalink