home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1996 August / VPR9608A.BIN / del20try / install / data.z / SHELLAPI.PAS < prev    next >
Pascal/Delphi Source File  |  1996-05-08  |  20KB  |  479 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Delphi Runtime Library                          }
  5. {       Windows 32bit API Interface Unit                }
  6. {                                                       }
  7. {       Copyright (c) 1992,96 Borland International     }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit ShellAPI;
  12.  
  13. interface
  14.  
  15. uses Windows;
  16.  
  17. type
  18.   HDROP = Longint;
  19.   PPWideChar = ^PWideChar;
  20.  
  21. function DragQueryFileA(Drop: HDROP; FileIndex: UINT; FileName: PAnsiChar; cb: UINT): UINT; stdcall;
  22. function DragQueryFileW(Drop: HDROP; FileIndex: UINT; FileName: PWideChar; cb: UINT): UINT; stdcall;
  23. function DragQueryFile(Drop: HDROP; FileIndex: UINT; FileName: PChar; cb: UINT): UINT; stdcall;
  24. function DragQueryPoint(Drop: HDROP; var Point: TPoint): BOOL; stdcall;
  25. procedure DragFinish(Drop: HDROP); stdcall;
  26. procedure DragAcceptFiles(Wnd: HWND; Accept: BOOL); stdcall;
  27. function ShellExecuteA(hWnd: HWND; Operation, FileName, Parameters,
  28.   Directory: PAnsiChar; ShowCmd: Integer): HINST; stdcall;
  29. function ShellExecuteW(hWnd: HWND; Operation, FileName, Parameters,
  30.   Directory: PWideChar; ShowCmd: Integer): HINST; stdcall;
  31. function ShellExecute(hWnd: HWND; Operation, FileName, Parameters,
  32.   Directory: PChar; ShowCmd: Integer): HINST; stdcall;
  33. function FindExecutableA(FileName, Directory: PAnsiChar; Result: PAnsiChar): HINST; stdcall;
  34. function FindExecutableW(FileName, Directory: PWideChar; Result: PWideChar): HINST; stdcall;
  35. function FindExecutable(FileName, Directory: PChar; Result: PChar): HINST; stdcall;
  36. function CommandLineToArgvW(lpCmdLine: LPCWSTR; var pNumArgs: Integer): PPWideChar; stdcall;
  37. function ShellAboutA(Wnd: HWND; szApp, szOtherStuff: PAnsiChar; Icon: HICON): Integer; stdcall;
  38. function ShellAboutW(Wnd: HWND; szApp, szOtherStuff: PWideChar; Icon: HICON): Integer; stdcall;
  39. function ShellAbout(Wnd: HWND; szApp, szOtherStuff: PChar; Icon: HICON): Integer; stdcall;
  40. function DuplicateIcon(hInst: HINST; Icon: HICON): HICON; stdcall;
  41. function ExtractAssociatedIconA(hInst: HINST; lpIconPath: PAnsiChar;
  42.   var lpiIcon: Word): HICON; stdcall;
  43. function ExtractAssociatedIconW(hInst: HINST; lpIconPath: PWideChar;
  44.   var lpiIcon: Word): HICON; stdcall;
  45. function ExtractAssociatedIcon(hInst: HINST; lpIconPath: PChar;
  46.   var lpiIcon: Word): HICON; stdcall;
  47. function ExtractIconA(hInst: HINST; lpszExeFileName: PAnsiChar;
  48.   nIconIndex: UINT): HICON; stdcall;
  49. function ExtractIconW(hInst: HINST; lpszExeFileName: PWideChar;
  50.   nIconIndex: UINT): HICON; stdcall;
  51. function ExtractIcon(hInst: HINST; lpszExeFileName: PChar;
  52.   nIconIndex: UINT): HICON; stdcall;
  53.  
  54. type
  55.   PDragInfoA = ^TDragInfoA;
  56.   PDragInfoW = ^TDragInfoW;
  57.   PDragInfo = PDragInfoA;
  58.   TDragInfoA = record
  59.     uSize: UINT;                 { init with SizeOf(DRAGINFO) }
  60.     pt: TPoint;
  61.     fNC: BOOL;
  62.     lpFileList: PAnsiChar;
  63.     grfKeyState: DWORD;
  64.   end;
  65.   TDragInfoW = record
  66.     uSize: UINT;                 { init with SizeOf(DRAGINFO) }
  67.     pt: TPoint;
  68.     fNC: BOOL;
  69.     lpFileList: PWideChar;
  70.     grfKeyState: DWORD;
  71.   end;
  72.   TDragInfo = TDragInfoA;
  73.  
  74. const
  75. { AppBar stuff }
  76.  
  77.   ABM_NEW           = $00000000;
  78.   ABM_REMOVE        = $00000001;
  79.   ABM_QUERYPOS      = $00000002;
  80.   ABM_SETPOS        = $00000003;
  81.   ABM_GETSTATE      = $00000004;
  82.   ABM_GETTASKBARPOS = $00000005;
  83.   ABM_ACTIVATE      = $00000006;  { lParam = True/False means activate/deactivate }
  84.   ABM_GETAUTOHIDEBAR = $00000007;
  85.   ABM_SETAUTOHIDEBAR = $00000008;  { this can fail at any time.  MUST check the result
  86.                                      lParam = TRUE/FALSE  Set/Unset
  87.                                      uEdge = what edge }
  88.   ABM_WINDOWPOSCHANGED = $0000009;
  89.  
  90. { these are put in the wparam of callback messages }
  91.  
  92.   ABN_STATECHANGE    = $0000000;
  93.   ABN_POSCHANGED     = $0000001;
  94.   ABN_FULLSCREENAPP  = $0000002;
  95.   ABN_WINDOWARRANGE  = $0000003; { lParam = True means hide }
  96.  
  97. { flags for get state }
  98.  
  99.   ABS_AUTOHIDE    = $0000001;
  100.   ABS_ALWAYSONTOP = $0000002;
  101.  
  102.   ABE_LEFT        = 0;
  103.   ABE_TOP         = 1;
  104.   ABE_RIGHT       = 2;
  105.   ABE_BOTTOM      = 3;
  106.  
  107. type
  108.   PAppBarData = ^TAppBarData;
  109.   TAppBarData = record
  110.     cbSize: DWORD;
  111.     hWnd: HWND;
  112.     uCallbackMessage: UINT;
  113.     uEdge: UINT;
  114.     rc: TRect;
  115.     lParam: LPARAM; { message specific }
  116.   end;
  117.  
  118. function SHAppBarMessage(dwMessage: DWORD; var pData: TAppBarData): UINT; stdcall;
  119.  
  120.  
  121. function DoEnvironmentSubstA(szString: PAnsiChar; cbString: UINT): DWORD; stdcall;
  122. function DoEnvironmentSubstW(szString: PWideChar; cbString: UINT): DWORD; stdcall;
  123. function DoEnvironmentSubst(szString: PChar; cbString: UINT): DWORD; stdcall;
  124. function FindEnvironmentStringA(szEnvVar: PAnsiChar): PAnsiChar; stdcall;
  125. function FindEnvironmentStringW(szEnvVar: PWideChar): PWideChar; stdcall;
  126. function FindEnvironmentString(szEnvVar: PChar): PChar; stdcall;
  127. function ExtractIconExA(lpszFile: PAnsiChar; nIconIndex: Integer; 
  128.   var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT; stdcall;
  129. function ExtractIconExW(lpszFile: PWideChar; nIconIndex: Integer; 
  130.   var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT; stdcall;
  131. function ExtractIconEx(lpszFile: PChar; nIconIndex: Integer; 
  132.   var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT; stdcall;
  133.  
  134.  
  135. { Shell File Operations }
  136.  
  137. const
  138.   FO_MOVE           = $0001;
  139.   FO_COPY           = $0002;
  140.   FO_DELETE         = $0003;
  141.   FO_RENAME         = $0004;
  142.  
  143.   FOF_MULTIDESTFILES         = $0001;
  144.   FOF_CONFIRMMOUSE           = $0002;
  145.   FOF_SILENT                 = $0004;  { don't create progress/report }
  146.   FOF_RENAMEONCOLLISION      = $0008;
  147.   FOF_NOCONFIRMATION         = $0010;  { Don't prompt the user. }
  148.   FOF_WANTMAPPINGHANDLE      = $0020;  { Fill in SHFILEOPSTRUCT.hNameMappings
  149.                                          Must be freed using SHFreeNameMappings }
  150.   FOF_ALLOWUNDO              = $0040;
  151.   FOF_FILESONLY              = $0080;  { on *.*, do only files }
  152.   FOF_SIMPLEPROGRESS         = $0100;  { means don't show names of files }
  153.   FOF_NOCONFIRMMKDIR         = $0200;  { don't confirm making any needed dirs }
  154.  
  155. type
  156.   FILEOP_FLAGS = Word;
  157.  
  158. const
  159.   PO_DELETE       = $0013;  { printer is being deleted }
  160.   PO_RENAME       = $0014;  { printer is being renamed }
  161.   PO_PORTCHANGE   = $0020;  { port this printer connected to is being changed
  162.                               if this id is set, the strings received by
  163.                               the copyhook are a doubly-null terminated
  164.                               list of strings.  The first is the printer
  165.                               name and the second is the printer port. }
  166.   PO_REN_PORT     = $0034;  { PO_RENAME and PO_PORTCHANGE at same time. }
  167.  
  168. { no POF_ flags currently defined }
  169.  
  170. type
  171.   PRINTEROP_FLAGS = Word;
  172.  
  173. { implicit parameters are:
  174.       if pFrom or pTo are unqualified names the current directories are
  175.       taken from the global current drive/directory settings managed
  176.       by Get/SetCurrentDrive/Directory
  177.  
  178.       the global confirmation settings }
  179.  
  180.   PSHFileOpStructA = ^TSHFileOpStructA;
  181.   PSHFileOpStructW = ^TSHFileOpStructW;
  182.   PSHFileOpStruct = PSHFileOpStructA;
  183.   TSHFileOpStructA = record
  184.     Wnd: HWND;
  185.     wFunc: UINT;
  186.     pFrom: PAnsiChar;
  187.     pTo: PAnsiChar;
  188.     fFlags: FILEOP_FLAGS;
  189.     fAnyOperationsAborted: BOOL;
  190.     hNameMappings: Pointer;
  191.     lpszProgressTitle: PAnsiChar; { only used if FOF_SIMPLEPROGRESS }
  192.   end;
  193.   TSHFileOpStructW = record
  194.     Wnd: HWND;
  195.     wFunc: UINT;
  196.     pFrom: PWideChar;
  197.     pTo: PWideChar;
  198.     fFlags: FILEOP_FLAGS;
  199.     fAnyOperationsAborted: BOOL;
  200.     hNameMappings: Pointer;
  201.     lpszProgressTitle: PWideChar; { only used if FOF_SIMPLEPROGRESS }
  202.   end;
  203.   TSHFileOpStruct = TSHFileOpStructA;
  204.  
  205. function SHFileOperationA(const lpFileOp: TSHFileOpStructA): Integer; stdcall;
  206. function SHFileOperationW(const lpFileOp: TSHFileOpStructW): Integer; stdcall;
  207. function SHFileOperation(const lpFileOp: TSHFileOpStruct): Integer; stdcall;
  208. procedure SHFreeNameMappings(hNameMappings: THandle); stdcall;
  209.  
  210. type
  211.   PSHNameMappingA = ^TSHNameMappingA;
  212.   PSHNameMappingW = ^TSHNameMappingW;
  213.   PSHNameMapping = PSHNameMappingA;
  214.   TSHNameMappingA = record
  215.     pszOldPath: PAnsiChar;
  216.     pszNewPath: PAnsiChar;
  217.     cchOldPath: Integer;
  218.     cchNewPath: Integer;
  219.   end;
  220.   TSHNameMappingW = record
  221.     pszOldPath: PWideChar;
  222.     pszNewPath: PWideChar;
  223.     cchOldPath: Integer;
  224.     cchNewPath: Integer;
  225.   end;
  226.   TSHNameMapping = TSHNameMappingA;
  227.  
  228.  
  229. { ShellExecute() and ShellExecuteEx() error codes }
  230. const
  231. { regular WinExec() codes }
  232.   SE_ERR_FNF              = 2;       { file not found }
  233.   SE_ERR_PNF              = 3;       { path not found }
  234.   SE_ERR_ACCESSDENIED     = 5;       { access denied }
  235.   SE_ERR_OOM              = 8;       { out of memory }
  236.   SE_ERR_DLLNOTFOUND      = 32;
  237.  
  238. { error values for ShellExecute() beyond the regular WinExec() codes }
  239.   SE_ERR_SHARE                    = 26;
  240.   SE_ERR_ASSOCINCOMPLETE          = 27;
  241.   SE_ERR_DDETIMEOUT               = 28;
  242.   SE_ERR_DDEFAIL                  = 29;
  243.   SE_ERR_DDEBUSY                  = 30;
  244.   SE_ERR_NOASSOC                  = 31;
  245.  
  246. { Note CLASSKEY overrides CLASSNAME }
  247.   SEE_MASK_CLASSNAME      = $00000001;
  248.   SEE_MASK_CLASSKEY       = $00000003;
  249. { Note INVOKEIDLIST overrides IDLIST }
  250.   SEE_MASK_IDLIST         = $00000004;
  251.   SEE_MASK_INVOKEIDLIST   = $0000000c;
  252.   SEE_MASK_ICON           = $00000010;
  253.   SEE_MASK_HOTKEY         = $00000020;
  254.   SEE_MASK_NOCLOSEPROCESS = $00000040;
  255.   SEE_MASK_CONNECTNETDRV  = $00000080;
  256.   SEE_MASK_FLAG_DDEWAIT   = $00000100;
  257.   SEE_MASK_DOENVSUBST     = $00000200;
  258.   SEE_MASK_FLAG_NO_UI     = $00000400;
  259.   SEE_MASK_UNICODE        = $00010000;
  260.  
  261. type
  262.   PShellExecuteInfoA = ^TShellExecuteInfoA;
  263.   PShellExecuteInfoW = ^TShellExecuteInfoW;
  264.   PShellExecuteInfo = PShellExecuteInfoA;
  265.   TShellExecuteInfoA = record
  266.     cbSize: DWORD;
  267.     fMask: ULONG;
  268.     Wnd: HWND;
  269.     lpVerb: PAnsiChar;
  270.     lpFile: PAnsiChar;
  271.     lpParameters: PAnsiChar;
  272.     lpDirectory: PAnsiChar;
  273.     nShow: Integer;
  274.     hInstApp: HINST;
  275.     { Optional fields }
  276.     lpIDList: Pointer;
  277.     lpClass: PAnsiChar;
  278.     hkeyClass: HKEY;
  279.     dwHotKey: DWORD;
  280.     hIcon: THandle;
  281.     hProcess: THandle;
  282.   end;
  283.   TShellExecuteInfoW = record
  284.     cbSize: DWORD;
  285.     fMask: ULONG;
  286.     Wnd: HWND;
  287.     lpVerb: PWideChar;
  288.     lpFile: PWideChar;
  289.     lpParameters: PWideChar;
  290.     lpDirectory: PWideChar;
  291.     nShow: Integer;
  292.     hInstApp: HINST;
  293.     { Optional fields }
  294.     lpIDList: Pointer;
  295.     lpClass: PWideChar;
  296.     hkeyClass: HKEY;
  297.     dwHotKey: DWORD;
  298.     hIcon: THandle;
  299.     hProcess: THandle;
  300.   end;
  301.   TShellExecuteInfo = TShellExecuteInfoA;
  302.  
  303. function ShellExecuteExA(lpExecInfo: PShellExecuteInfoA):BOOL; stdcall;
  304. function ShellExecuteExW(lpExecInfo: PShellExecuteInfoW):BOOL; stdcall;
  305. function ShellExecuteEx(lpExecInfo: PShellExecuteInfo):BOOL; stdcall;
  306. procedure WinExecErrorA(Wnd: HWND; error: Integer; lpstrFileName, lpstrTitle: PAnsiChar); stdcall;
  307. procedure WinExecErrorW(Wnd: HWND; error: Integer; lpstrFileName, lpstrTitle: PWideChar); stdcall;
  308. procedure WinExecError(Wnd: HWND; error: Integer; lpstrFileName, lpstrTitle: PChar); stdcall;
  309.  
  310. { Tray notification definitions }
  311.  
  312. type
  313.   PNotifyIconDataA = ^TNotifyIconDataA;
  314.   PNotifyIconDataW = ^TNotifyIconDataW;
  315.   PNotifyIconData = PNotifyIconDataA;
  316.   TNotifyIconDataA = record
  317.     cbSize: DWORD;
  318.     Wnd: HWND;
  319.     uID: UINT;
  320.     uFlags: UINT;
  321.     uCallbackMessage: UINT;
  322.     hIcon: HICON;
  323.     szTip: array [0..63] of AnsiChar;
  324.   end;
  325.   TNotifyIconDataW = record
  326.     cbSize: DWORD;
  327.     Wnd: HWND;
  328.     uID: UINT;
  329.     uFlags: UINT;
  330.     uCallbackMessage: UINT;
  331.     hIcon: HICON;
  332.     szTip: array [0..63] of WideChar;
  333.   end;
  334.   TNotifyIconData = TNotifyIconDataA;
  335.  
  336. const
  337.   NIM_ADD         = $00000000;
  338.   NIM_MODIFY      = $00000001;
  339.   NIM_DELETE      = $00000002;
  340.  
  341.   NIF_MESSAGE     = $00000001;
  342.   NIF_ICON        = $00000002;
  343.   NIF_TIP         = $00000004;
  344.  
  345. function Shell_NotifyIconA(dwMessage: DWORD; lpData: PNotifyIconDataA): BOOL; stdcall;
  346. function Shell_NotifyIconW(dwMessage: DWORD; lpData: PNotifyIconDataW): BOOL; stdcall;
  347. function Shell_NotifyIcon(dwMessage: DWORD; lpData: PNotifyIconData): BOOL; stdcall;
  348.  
  349. { Begin SHGetFileInfo }
  350.  
  351. (*
  352.  * The SHGetFileInfo API provides an easy way to get attributes
  353.  * for a file given a pathname.
  354.  *
  355.  *   PARAMETERS
  356.  *
  357.  *     pszPath              file name to get info about
  358.  *     dwFileAttributes     file attribs, only used with SHGFI_USEFILEATTRIBUTES
  359.  *     psfi                 place to return file info
  360.  *     cbFileInfo           size of structure
  361.  *     uFlags               flags
  362.  *
  363.  *   RETURN
  364.  *     TRUE if things worked
  365.  *)
  366.  
  367. type
  368.   PSHFileInfoA = ^TSHFileInfoA;
  369.   PSHFileInfoW = ^TSHFileInfoW;
  370.   PSHFileInfo = PSHFileInfoA;
  371.   TSHFileInfoA = record
  372.     hIcon: HICON;                      { out: icon }
  373.     iIcon: Integer;                    { out: icon index }
  374.     dwAttributes: DWORD;               { out: SFGAO_ flags }
  375.     szDisplayName: array [0..MAX_PATH-1] of  AnsiChar; { out: display name (or path) }
  376.     szTypeName: array [0..79] of AnsiChar;             { out: type name }
  377.   end;
  378.   TSHFileInfoW = record
  379.     hIcon: HICON;                      { out: icon }
  380.     iIcon: Integer;                    { out: icon index }
  381.     dwAttributes: DWORD;               { out: SFGAO_ flags }
  382.     szDisplayName: array [0..MAX_PATH-1] of  WideChar; { out: display name (or path) }
  383.     szTypeName: array [0..79] of WideChar;             { out: type name }
  384.   end;
  385.   TSHFileInfo = TSHFileInfoA;
  386.  
  387. const
  388.   SHGFI_ICON              = $000000100;     { get icon }
  389.   SHGFI_DISPLAYNAME       = $000000200;     { get display name }
  390.   SHGFI_TYPENAME          = $000000400;     { get type name }
  391.   SHGFI_ATTRIBUTES        = $000000800;     { get attributes }
  392.   SHGFI_ICONLOCATION      = $000001000;     { get icon location }
  393.   SHGFI_EXETYPE           = $000002000;     { return exe type }
  394.   SHGFI_SYSICONINDEX      = $000004000;     { get system icon index }
  395.   SHGFI_LINKOVERLAY       = $000008000;     { put a link overlay on icon }
  396.   SHGFI_SELECTED          = $000010000;     { show icon in selected state }
  397.   SHGFI_LARGEICON         = $000000000;     { get large icon }
  398.   SHGFI_SMALLICON         = $000000001;     { get small icon }
  399.   SHGFI_OPENICON          = $000000002;     { get open icon }
  400.   SHGFI_SHELLICONSIZE     = $000000004;     { get shell size icon }
  401.   SHGFI_PIDL              = $000000008;     { pszPath is a pidl }
  402.   SHGFI_USEFILEATTRIBUTES = $000000010;     { use passed dwFileAttribute }
  403.  
  404. function SHGetFileInfoA(pszPath: PAnsiChar; dwFileAttributes: DWORD; 
  405.   var psfi: TSHFileInfoA; cbFileInfo, uFlags: UINT): DWORD; stdcall;
  406. function SHGetFileInfoW(pszPath: PAnsiChar; dwFileAttributes: DWORD; 
  407.   var psfi: TSHFileInfoW; cbFileInfo, uFlags: UINT): DWORD; stdcall;
  408. function SHGetFileInfo(pszPath: PAnsiChar; dwFileAttributes: DWORD; 
  409.   var psfi: TSHFileInfo; cbFileInfo, uFlags: UINT): DWORD; stdcall;
  410. function SHGetNewLinkInfoA(pszLinkTo, pszDir: PAnsiChar; pszName: PAnsiChar;
  411.   var pfMustCopy: BOOL; uFlags: UINT): BOOL; stdcall;
  412. function SHGetNewLinkInfoW(pszLinkTo, pszDir: PWideChar; pszName: PWideChar;
  413.   var pfMustCopy: BOOL; uFlags: UINT): BOOL; stdcall;
  414. function SHGetNewLinkInfo(pszLinkTo, pszDir: PChar; pszName: PChar;
  415.   var pfMustCopy: BOOL; uFlags: UINT): BOOL; stdcall;
  416.  
  417. const
  418.   SHGNLI_PIDL             = $000000001;     { pszLinkTo is a pidl }
  419.   SHGNLI_PREFIXNAME       = $000000002;     { Make name "Shortcut to xxx" }
  420.  
  421.   shell32 = 'shell32.dll';
  422.  
  423. implementation
  424.  
  425. function CommandLineToArgvW; external shell32 name 'CommandLineToArgvW';
  426. function DoEnvironmentSubstA; external shell32 name 'DoEnvironmentSubstA';
  427. function DoEnvironmentSubstW; external shell32 name 'DoEnvironmentSubstW';
  428. function DoEnvironmentSubst; external shell32 name 'DoEnvironmentSubstA';
  429. procedure DragAcceptFiles; external shell32 name 'DragAcceptFiles';
  430. procedure DragFinish; external shell32 name 'DragFinish';
  431. function DragQueryFileA; external shell32 name 'DragQueryFileA';
  432. function DragQueryFileW; external shell32 name 'DragQueryFileW';
  433. function DragQueryFile; external shell32 name 'DragQueryFileA';
  434. function DragQueryPoint; external shell32 name 'DragQueryPoint';
  435. function DuplicateIcon; external shell32 name 'DuplicateIcon';
  436. function ExtractAssociatedIconA; external shell32 name 'ExtractAssociatedIconA';
  437. function ExtractAssociatedIconW; external shell32 name 'ExtractAssociatedIconW';
  438. function ExtractAssociatedIcon; external shell32 name 'ExtractAssociatedIconA';
  439. function ExtractIconA; external shell32 name 'ExtractIconA';
  440. function ExtractIconW; external shell32 name 'ExtractIconW';
  441. function ExtractIcon; external shell32 name 'ExtractIconA';
  442. function ExtractIconExA; external shell32 name 'ExtractIconExA';
  443. function ExtractIconExW; external shell32 name 'ExtractIconExW';
  444. function ExtractIconEx; external shell32 name 'ExtractIconExA';
  445. function FindEnvironmentStringA; external shell32 name 'FindEnvironmentStringA';
  446. function FindEnvironmentStringW; external shell32 name 'FindEnvironmentStringW';
  447. function FindEnvironmentString; external shell32 name 'FindEnvironmentStringA';
  448. function FindExecutableA; external shell32 name 'FindExecutableA';
  449. function FindExecutableW; external shell32 name 'FindExecutableW';
  450. function FindExecutable; external shell32 name 'FindExecutableA';
  451. function SHAppBarMessage; external shell32 name 'SHAppBarMessage';
  452. function SHFileOperationA; external shell32 name 'SHFileOperationA';
  453. function SHFileOperationW; external shell32 name 'SHFileOperationW';
  454. function SHFileOperation; external shell32 name 'SHFileOperationA';
  455. procedure SHFreeNameMappings; external shell32 name 'SHFreeNameMappings';
  456. function SHGetFileInfoA; external shell32 name 'SHGetFileInfoA';
  457. function SHGetFileInfoW; external shell32 name 'SHGetFileInfoW';
  458. function SHGetFileInfo; external shell32 name 'SHGetFileInfoA';
  459. function SHGetNewLinkInfoA; external shell32 name 'SHGetNewLinkInfoA';
  460. function SHGetNewLinkInfoW; external shell32 name 'SHGetNewLinkInfoW';
  461. function SHGetNewLinkInfo; external shell32 name 'SHGetNewLinkInfoA';
  462. function ShellAboutA; external shell32 name 'ShellAboutA';
  463. function ShellAboutW; external shell32 name 'ShellAboutW';
  464. function ShellAbout; external shell32 name 'ShellAboutA';
  465. function ShellExecuteA; external shell32 name 'ShellExecuteA';
  466. function ShellExecuteW; external shell32 name 'ShellExecuteW';
  467. function ShellExecute; external shell32 name 'ShellExecuteA';
  468. function ShellExecuteExA; external shell32 name 'ShellExecuteExA';
  469. function ShellExecuteExW; external shell32 name 'ShellExecuteExW';
  470. function ShellExecuteEx; external shell32 name 'ShellExecuteExA';
  471. function Shell_NotifyIconA; external shell32 name 'Shell_NotifyIconA';
  472. function Shell_NotifyIconW; external shell32 name 'Shell_NotifyIconW';
  473. function Shell_NotifyIcon; external shell32 name 'Shell_NotifyIconA';
  474. procedure WinExecErrorA; external shell32 name 'WinExecErrorA';
  475. procedure WinExecErrorW; external shell32 name 'WinExecErrorW';
  476. procedure WinExecError; external shell32 name 'WinExecErrorA';
  477.  
  478. end.
  479.