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