home *** CD-ROM | disk | FTP | other *** search
/ PC World Plus! (NZ) 2001 June / HDC50.iso / Runimage / Delphi50 / Source / Rtl / Win / SHELLAPI.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1999-08-11  |  24.6 KB  |  671 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Borland Delphi Run-time Library                 }
  5. {       Win32 Shell API Interface Unit                  }
  6. {                                                       }
  7. {       Copyright (c) 1985-1999, Microsoft Corporation  }
  8. {                                                       }
  9. {       Translator: Inprise Corporation                 }
  10. {                                                       }
  11. {*******************************************************}
  12.  
  13. unit ShellAPI;
  14.  
  15. {$WEAKPACKAGEUNIT}
  16.  
  17. interface
  18.  
  19. uses Windows;
  20.  
  21. (*$HPPEMIT '#include <shellapi.h>'*)
  22.  
  23.  
  24. type
  25.   {$EXTERNALSYM HDROP}
  26.   HDROP = Longint;
  27.   PPWideChar = ^PWideChar;
  28.  
  29. {$EXTERNALSYM DragQueryFileA}
  30. function DragQueryFileA(Drop: HDROP; FileIndex: UINT; FileName: PAnsiChar; cb: UINT): UINT; stdcall;
  31. {$EXTERNALSYM DragQueryFileW}
  32. function DragQueryFileW(Drop: HDROP; FileIndex: UINT; FileName: PWideChar; cb: UINT): UINT; stdcall;
  33. {$EXTERNALSYM DragQueryFile}
  34. function DragQueryFile(Drop: HDROP; FileIndex: UINT; FileName: PChar; cb: UINT): UINT; stdcall;
  35. {$EXTERNALSYM DragQueryPoint}
  36. function DragQueryPoint(Drop: HDROP; var Point: TPoint): BOOL; stdcall;
  37. {$EXTERNALSYM DragFinish}
  38. procedure DragFinish(Drop: HDROP); stdcall;
  39. {$EXTERNALSYM DragAcceptFiles}
  40. procedure DragAcceptFiles(Wnd: HWND; Accept: BOOL); stdcall;
  41. {$EXTERNALSYM ShellExecuteA}
  42. function ShellExecuteA(hWnd: HWND; Operation, FileName, Parameters,
  43.   Directory: PAnsiChar; ShowCmd: Integer): HINST; stdcall;
  44. {$EXTERNALSYM ShellExecuteW}
  45. function ShellExecuteW(hWnd: HWND; Operation, FileName, Parameters,
  46.   Directory: PWideChar; ShowCmd: Integer): HINST; stdcall;
  47. {$EXTERNALSYM ShellExecute}
  48. function ShellExecute(hWnd: HWND; Operation, FileName, Parameters,
  49.   Directory: PChar; ShowCmd: Integer): HINST; stdcall;
  50. {$EXTERNALSYM FindExecutableA}
  51. function FindExecutableA(FileName, Directory: PAnsiChar; Result: PAnsiChar): HINST; stdcall;
  52. {$EXTERNALSYM FindExecutableW}
  53. function FindExecutableW(FileName, Directory: PWideChar; Result: PWideChar): HINST; stdcall;
  54. {$EXTERNALSYM FindExecutable}
  55. function FindExecutable(FileName, Directory: PChar; Result: PChar): HINST; stdcall;
  56. {$EXTERNALSYM CommandLineToArgvW}
  57. function CommandLineToArgvW(lpCmdLine: LPCWSTR; var pNumArgs: Integer): PPWideChar; stdcall;
  58. {$EXTERNALSYM ShellAboutA}
  59. function ShellAboutA(Wnd: HWND; szApp, szOtherStuff: PAnsiChar; Icon: HICON): Integer; stdcall;
  60. {$EXTERNALSYM ShellAboutW}
  61. function ShellAboutW(Wnd: HWND; szApp, szOtherStuff: PWideChar; Icon: HICON): Integer; stdcall;
  62. {$EXTERNALSYM ShellAbout}
  63. function ShellAbout(Wnd: HWND; szApp, szOtherStuff: PChar; Icon: HICON): Integer; stdcall;
  64. {$EXTERNALSYM DuplicateIcon}
  65. function DuplicateIcon(hInst: HINST; Icon: HICON): HICON; stdcall;
  66. {$EXTERNALSYM ExtractAssociatedIconA}
  67. function ExtractAssociatedIconA(hInst: HINST; lpIconPath: PAnsiChar;
  68.   var lpiIcon: Word): HICON; stdcall;
  69. {$EXTERNALSYM ExtractAssociatedIconW}
  70. function ExtractAssociatedIconW(hInst: HINST; lpIconPath: PWideChar;
  71.   var lpiIcon: Word): HICON; stdcall;
  72. {$EXTERNALSYM ExtractAssociatedIcon}
  73. function ExtractAssociatedIcon(hInst: HINST; lpIconPath: PChar;
  74.   var lpiIcon: Word): HICON; stdcall;
  75. {$EXTERNALSYM ExtractIconA}
  76. function ExtractIconA(hInst: HINST; lpszExeFileName: PAnsiChar;
  77.   nIconIndex: UINT): HICON; stdcall;
  78. {$EXTERNALSYM ExtractIconW}
  79. function ExtractIconW(hInst: HINST; lpszExeFileName: PWideChar;
  80.   nIconIndex: UINT): HICON; stdcall;
  81. {$EXTERNALSYM ExtractIcon}
  82. function ExtractIcon(hInst: HINST; lpszExeFileName: PChar;
  83.   nIconIndex: UINT): HICON; stdcall;
  84.  
  85. type
  86.   PDragInfoA = ^_DRAGINFOA;
  87.   PDragInfoW = ^_DRAGINFOW;
  88.   PDragInfo = PDragInfoA;
  89.   _DRAGINFOA = record
  90.     uSize: UINT;                 { init with SizeOf(DRAGINFO) }
  91.     pt: TPoint;
  92.     fNC: BOOL;
  93.     lpFileList: PAnsiChar;
  94.     grfKeyState: DWORD;
  95.   end;
  96.   TDragInfoA = _DRAGINFOA;
  97.   LPDRAGINFOA = PDragInfoA;
  98.   _DRAGINFOW = record
  99.     uSize: UINT;                 { init with SizeOf(DRAGINFO) }
  100.     pt: TPoint;
  101.     fNC: BOOL;
  102.     lpFileList: PWideChar;
  103.     grfKeyState: DWORD;
  104.   end;
  105.   TDragInfoW = _DRAGINFOW;
  106.   LPDRAGINFOW = PDragInfoW;
  107.   _DRAGINFO = _DRAGINFOA;
  108.  
  109. const
  110. { AppBar stuff }
  111.  
  112.   {$EXTERNALSYM ABM_NEW}
  113.   ABM_NEW           = $00000000;
  114.   {$EXTERNALSYM ABM_REMOVE}
  115.   ABM_REMOVE        = $00000001;
  116.   {$EXTERNALSYM ABM_QUERYPOS}
  117.   ABM_QUERYPOS      = $00000002;
  118.   {$EXTERNALSYM ABM_SETPOS}
  119.   ABM_SETPOS        = $00000003;
  120.   {$EXTERNALSYM ABM_GETSTATE}
  121.   ABM_GETSTATE      = $00000004;
  122.   {$EXTERNALSYM ABM_GETTASKBARPOS}
  123.   ABM_GETTASKBARPOS = $00000005;
  124.   {$EXTERNALSYM ABM_ACTIVATE}
  125.   ABM_ACTIVATE      = $00000006;  { lParam = True/False means activate/deactivate }
  126.   {$EXTERNALSYM ABM_GETAUTOHIDEBAR}
  127.   ABM_GETAUTOHIDEBAR = $00000007;
  128.   {$EXTERNALSYM ABM_SETAUTOHIDEBAR}
  129.   ABM_SETAUTOHIDEBAR = $00000008;  { this can fail at any time.  MUST check the result
  130.                                      lParam = TRUE/FALSE  Set/Unset
  131.                                      uEdge = what edge }
  132.   {$EXTERNALSYM ABM_WINDOWPOSCHANGED}
  133.   ABM_WINDOWPOSCHANGED = $0000009;
  134.  
  135. { these are put in the wparam of callback messages }
  136.  
  137.   {$EXTERNALSYM ABN_STATECHANGE}
  138.   ABN_STATECHANGE    = $0000000;
  139.   {$EXTERNALSYM ABN_POSCHANGED}
  140.   ABN_POSCHANGED     = $0000001;
  141.   {$EXTERNALSYM ABN_FULLSCREENAPP}
  142.   ABN_FULLSCREENAPP  = $0000002;
  143.   {$EXTERNALSYM ABN_WINDOWARRANGE}
  144.   ABN_WINDOWARRANGE  = $0000003; { lParam = True means hide }
  145.  
  146. { flags for get state }
  147.  
  148.   {$EXTERNALSYM ABS_AUTOHIDE}
  149.   ABS_AUTOHIDE    = $0000001;
  150.   {$EXTERNALSYM ABS_ALWAYSONTOP}
  151.   ABS_ALWAYSONTOP = $0000002;
  152.  
  153.   {$EXTERNALSYM ABE_LEFT}
  154.   ABE_LEFT        = 0;
  155.   {$EXTERNALSYM ABE_TOP}
  156.   ABE_TOP         = 1;
  157.   {$EXTERNALSYM ABE_RIGHT}
  158.   ABE_RIGHT       = 2;
  159.   {$EXTERNALSYM ABE_BOTTOM}
  160.   ABE_BOTTOM      = 3;
  161.  
  162. type
  163.   PAppBarData = ^TAppBarData;
  164.   {$EXTERNALSYM _AppBarData}
  165.   _AppBarData = record
  166.     cbSize: DWORD;
  167.     hWnd: HWND;
  168.     uCallbackMessage: UINT;
  169.     uEdge: UINT;
  170.     rc: TRect;
  171.     lParam: LPARAM; { message specific }
  172.   end;
  173.   TAppBarData = _AppBarData;
  174.   {$EXTERNALSYM APPBARDATA}
  175.   APPBARDATA = _AppBarData;
  176.  
  177. {$EXTERNALSYM SHAppBarMessage}
  178. function SHAppBarMessage(dwMessage: DWORD; var pData: TAppBarData): UINT; stdcall;
  179.  
  180.  
  181. {$EXTERNALSYM DoEnvironmentSubstA}
  182. function DoEnvironmentSubstA(szString: PAnsiChar; cbString: UINT): DWORD; stdcall;
  183. {$EXTERNALSYM DoEnvironmentSubstW}
  184. function DoEnvironmentSubstW(szString: PWideChar; cbString: UINT): DWORD; stdcall;
  185. {$EXTERNALSYM DoEnvironmentSubst}
  186. function DoEnvironmentSubst(szString: PChar; cbString: UINT): DWORD; stdcall;
  187. {$EXTERNALSYM ExtractIconExA}
  188. function ExtractIconExA(lpszFile: PAnsiChar; nIconIndex: Integer;
  189.   var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT; stdcall;
  190. {$EXTERNALSYM ExtractIconExW}
  191. function ExtractIconExW(lpszFile: PWideChar; nIconIndex: Integer;
  192.   var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT; stdcall;
  193. {$EXTERNALSYM ExtractIconEx}
  194. function ExtractIconEx(lpszFile: PChar; nIconIndex: Integer;
  195.   var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT; stdcall;
  196.  
  197.  
  198. { Shell File Operations }
  199.  
  200. const
  201.   {$EXTERNALSYM FO_MOVE}
  202.   FO_MOVE           = $0001;
  203.   {$EXTERNALSYM FO_COPY}
  204.   FO_COPY           = $0002;
  205.   {$EXTERNALSYM FO_DELETE}
  206.   FO_DELETE         = $0003;
  207.   {$EXTERNALSYM FO_RENAME}
  208.   FO_RENAME         = $0004;
  209.  
  210.   {$EXTERNALSYM FOF_MULTIDESTFILES}
  211.   FOF_MULTIDESTFILES         = $0001;
  212.   {$EXTERNALSYM FOF_CONFIRMMOUSE}
  213.   FOF_CONFIRMMOUSE           = $0002;
  214.   {$EXTERNALSYM FOF_SILENT}
  215.   FOF_SILENT                 = $0004;  { don't create progress/report }
  216.   {$EXTERNALSYM FOF_RENAMEONCOLLISION}
  217.   FOF_RENAMEONCOLLISION      = $0008;
  218.   {$EXTERNALSYM FOF_NOCONFIRMATION}
  219.   FOF_NOCONFIRMATION         = $0010;  { Don't prompt the user. }
  220.   {$EXTERNALSYM FOF_WANTMAPPINGHANDLE}
  221.   FOF_WANTMAPPINGHANDLE      = $0020;  { Fill in SHFILEOPSTRUCT.hNameMappings
  222.                                          Must be freed using SHFreeNameMappings }
  223.   {$EXTERNALSYM FOF_ALLOWUNDO}
  224.   FOF_ALLOWUNDO              = $0040;
  225.   {$EXTERNALSYM FOF_FILESONLY}
  226.   FOF_FILESONLY              = $0080;  { on *.*, do only files }
  227.   {$EXTERNALSYM FOF_SIMPLEPROGRESS}
  228.   FOF_SIMPLEPROGRESS         = $0100;  { means don't show names of files }
  229.   {$EXTERNALSYM FOF_NOCONFIRMMKDIR}
  230.   FOF_NOCONFIRMMKDIR         = $0200;  { don't confirm making any needed dirs }
  231.   {$EXTERNALSYM FOF_NOERRORUI}
  232.   FOF_NOERRORUI              = $0400;  { don't put up error UI }
  233.  
  234. type
  235.   {$EXTERNALSYM FILEOP_FLAGS}
  236.   FILEOP_FLAGS = Word;
  237.  
  238. const
  239.   {$EXTERNALSYM PO_DELETE}
  240.   PO_DELETE       = $0013;  { printer is being deleted }
  241.   {$EXTERNALSYM PO_RENAME}
  242.   PO_RENAME       = $0014;  { printer is being renamed }
  243.   {$EXTERNALSYM PO_PORTCHANGE}
  244.   PO_PORTCHANGE   = $0020;  { port this printer connected to is being changed
  245.                               if this id is set, the strings received by
  246.                               the copyhook are a doubly-null terminated
  247.                               list of strings.  The first is the printer
  248.                               name and the second is the printer port. }
  249.   {$EXTERNALSYM PO_REN_PORT}
  250.   PO_REN_PORT     = $0034;  { PO_RENAME and PO_PORTCHANGE at same time. }
  251.  
  252. { no POF_ flags currently defined }
  253.  
  254. type
  255.   {$EXTERNALSYM PRINTEROP_FLAGS}
  256.   PRINTEROP_FLAGS = Word;
  257.  
  258. { implicit parameters are:
  259.       if pFrom or pTo are unqualified names the current directories are
  260.       taken from the global current drive/directory settings managed
  261.       by Get/SetCurrentDrive/Directory
  262.  
  263.       the global confirmation settings }
  264.  
  265.   PSHFileOpStructA = ^TSHFileOpStructA;
  266.   PSHFileOpStructW = ^TSHFileOpStructW;
  267.   PSHFileOpStruct = PSHFileOpStructA;
  268.   {$EXTERNALSYM _SHFILEOPSTRUCTA}
  269.   _SHFILEOPSTRUCTA = packed record
  270.     Wnd: HWND;
  271.     wFunc: UINT;
  272.     pFrom: PAnsiChar;
  273.     pTo: PAnsiChar;
  274.     fFlags: FILEOP_FLAGS;
  275.     fAnyOperationsAborted: BOOL;
  276.     hNameMappings: Pointer;
  277.     lpszProgressTitle: PAnsiChar; { only used if FOF_SIMPLEPROGRESS }
  278.   end;
  279.   {$EXTERNALSYM _SHFILEOPSTRUCTW}
  280.   _SHFILEOPSTRUCTW = packed record
  281.     Wnd: HWND;
  282.     wFunc: UINT;
  283.     pFrom: PWideChar;
  284.     pTo: PWideChar;
  285.     fFlags: FILEOP_FLAGS;
  286.     fAnyOperationsAborted: BOOL;
  287.     hNameMappings: Pointer;
  288.     lpszProgressTitle: PWideChar; { only used if FOF_SIMPLEPROGRESS }
  289.   end;
  290.   {$EXTERNALSYM _SHFILEOPSTRUCT}
  291.   _SHFILEOPSTRUCT = _SHFILEOPSTRUCTA;
  292.   TSHFileOpStructA = _SHFILEOPSTRUCTA;
  293.   TSHFileOpStructW = _SHFILEOPSTRUCTW;
  294.   TSHFileOpStruct = TSHFileOpStructA;
  295.   {$EXTERNALSYM SHFILEOPSTRUCTA}
  296.   SHFILEOPSTRUCTA = _SHFILEOPSTRUCTA;
  297.   {$EXTERNALSYM SHFILEOPSTRUCTW}
  298.   SHFILEOPSTRUCTW = _SHFILEOPSTRUCTW;
  299.   {$EXTERNALSYM SHFILEOPSTRUCT}
  300.   SHFILEOPSTRUCT = SHFILEOPSTRUCTA;
  301.  
  302. {$EXTERNALSYM SHFileOperationA}
  303. function SHFileOperationA(const lpFileOp: TSHFileOpStructA): Integer; stdcall;
  304. {$EXTERNALSYM SHFileOperationW}
  305. function SHFileOperationW(const lpFileOp: TSHFileOpStructW): Integer; stdcall;
  306. {$EXTERNALSYM SHFileOperation}
  307. function SHFileOperation(const lpFileOp: TSHFileOpStruct): Integer; stdcall;
  308. {$EXTERNALSYM SHFreeNameMappings}
  309. procedure SHFreeNameMappings(hNameMappings: THandle); stdcall;
  310.  
  311. type
  312.   PSHNameMappingA = ^TSHNameMappingA;
  313.   PSHNameMappingW = ^TSHNameMappingW;
  314.   PSHNameMapping = PSHNameMappingA;
  315.   {$EXTERNALSYM _SHNAMEMAPPINGA}
  316.   _SHNAMEMAPPINGA = record
  317.     pszOldPath: PAnsiChar;
  318.     pszNewPath: PAnsiChar;
  319.     cchOldPath: Integer;
  320.     cchNewPath: Integer;
  321.   end;
  322.   {$EXTERNALSYM _SHNAMEMAPPINGW}
  323.   _SHNAMEMAPPINGW = record
  324.     pszOldPath: PWideChar;
  325.     pszNewPath: PWideChar;
  326.     cchOldPath: Integer;
  327.     cchNewPath: Integer;
  328.   end;
  329.   {$EXTERNALSYM _SHNAMEMAPPING}
  330.   _SHNAMEMAPPING = _SHNAMEMAPPINGA;
  331.   TSHNameMappingA = _SHNAMEMAPPINGA;
  332.   TSHNameMappingW = _SHNAMEMAPPINGW;
  333.   TSHNameMapping = TSHNameMappingA;
  334.   {$EXTERNALSYM SHNAMEMAPPINGA}
  335.   SHNAMEMAPPINGA = _SHNAMEMAPPINGA;
  336.   {$EXTERNALSYM SHNAMEMAPPINGW}
  337.   SHNAMEMAPPINGW = _SHNAMEMAPPINGW;
  338.   {$EXTERNALSYM SHNAMEMAPPING}
  339.   SHNAMEMAPPING = SHNAMEMAPPINGA;
  340.  
  341.  
  342. { ShellExecute() and ShellExecuteEx() error codes }
  343. const
  344. { regular WinExec() codes }
  345.   {$EXTERNALSYM SE_ERR_FNF}
  346.   SE_ERR_FNF              = 2;       { file not found }
  347.   {$EXTERNALSYM SE_ERR_PNF}
  348.   SE_ERR_PNF              = 3;       { path not found }
  349.   {$EXTERNALSYM SE_ERR_ACCESSDENIED}
  350.   SE_ERR_ACCESSDENIED     = 5;       { access denied }
  351.   {$EXTERNALSYM SE_ERR_OOM}
  352.   SE_ERR_OOM              = 8;       { out of memory }
  353.   {$EXTERNALSYM SE_ERR_DLLNOTFOUND}
  354.   SE_ERR_DLLNOTFOUND      = 32;
  355.  
  356. { error values for ShellExecute() beyond the regular WinExec() codes }
  357.   {$EXTERNALSYM SE_ERR_SHARE}
  358.   SE_ERR_SHARE                    = 26;
  359.   {$EXTERNALSYM SE_ERR_ASSOCINCOMPLETE}
  360.   SE_ERR_ASSOCINCOMPLETE          = 27;
  361.   {$EXTERNALSYM SE_ERR_DDETIMEOUT}
  362.   SE_ERR_DDETIMEOUT               = 28;
  363.   {$EXTERNALSYM SE_ERR_DDEFAIL}
  364.   SE_ERR_DDEFAIL                  = 29;
  365.   {$EXTERNALSYM SE_ERR_DDEBUSY}
  366.   SE_ERR_DDEBUSY                  = 30;
  367.   {$EXTERNALSYM SE_ERR_NOASSOC}
  368.   SE_ERR_NOASSOC                  = 31;
  369.  
  370. { Note CLASSKEY overrides CLASSNAME }
  371.   {$EXTERNALSYM SEE_MASK_CLASSNAME}
  372.   SEE_MASK_CLASSNAME      = $00000001;
  373.   {$EXTERNALSYM SEE_MASK_CLASSKEY}
  374.   SEE_MASK_CLASSKEY       = $00000003;
  375. { Note INVOKEIDLIST overrides IDLIST }
  376.   {$EXTERNALSYM SEE_MASK_IDLIST}
  377.   SEE_MASK_IDLIST         = $00000004;
  378.   {$EXTERNALSYM SEE_MASK_INVOKEIDLIST}
  379.   SEE_MASK_INVOKEIDLIST   = $0000000c;
  380.   {$EXTERNALSYM SEE_MASK_ICON}
  381.   SEE_MASK_ICON           = $00000010;
  382.   {$EXTERNALSYM SEE_MASK_HOTKEY}
  383.   SEE_MASK_HOTKEY         = $00000020;
  384.   {$EXTERNALSYM SEE_MASK_NOCLOSEPROCESS}
  385.   SEE_MASK_NOCLOSEPROCESS = $00000040;
  386.   {$EXTERNALSYM SEE_MASK_CONNECTNETDRV}
  387.   SEE_MASK_CONNECTNETDRV  = $00000080;
  388.   {$EXTERNALSYM SEE_MASK_FLAG_DDEWAIT}
  389.   SEE_MASK_FLAG_DDEWAIT   = $00000100;
  390.   {$EXTERNALSYM SEE_MASK_DOENVSUBST}
  391.   SEE_MASK_DOENVSUBST     = $00000200;
  392.   {$EXTERNALSYM SEE_MASK_FLAG_NO_UI}
  393.   SEE_MASK_FLAG_NO_UI     = $00000400;
  394.   {$EXTERNALSYM SEE_MASK_UNICODE}
  395.   SEE_MASK_UNICODE        = $00010000; // !!! changed from previous SDK (was $00004000)
  396.   {$EXTERNALSYM SEE_MASK_NO_CONSOLE}
  397.   SEE_MASK_NO_CONSOLE     = $00008000;
  398.   {$EXTERNALSYM SEE_MASK_ASYNCOK}
  399.   SEE_MASK_ASYNCOK        = $00100000;
  400.  
  401. type
  402.   PShellExecuteInfoA = ^TShellExecuteInfoA;
  403.   PShellExecuteInfoW = ^TShellExecuteInfoW;
  404.   PShellExecuteInfo = PShellExecuteInfoA;
  405.   {$EXTERNALSYM _SHELLEXECUTEINFOA}
  406.   _SHELLEXECUTEINFOA = record
  407.     cbSize: DWORD;
  408.     fMask: ULONG;
  409.     Wnd: HWND;
  410.     lpVerb: PAnsiChar;
  411.     lpFile: PAnsiChar;
  412.     lpParameters: PAnsiChar;
  413.     lpDirectory: PAnsiChar;
  414.     nShow: Integer;
  415.     hInstApp: HINST;
  416.     { Optional fields }
  417.     lpIDList: Pointer;
  418.     lpClass: PAnsiChar;
  419.     hkeyClass: HKEY;
  420.     dwHotKey: DWORD;
  421.     hIcon: THandle;
  422.     hProcess: THandle;
  423.   end;
  424.   {$EXTERNALSYM _SHELLEXECUTEINFOW}
  425.   _SHELLEXECUTEINFOW = record
  426.     cbSize: DWORD;
  427.     fMask: ULONG;
  428.     Wnd: HWND;
  429.     lpVerb: PWideChar;
  430.     lpFile: PWideChar;
  431.     lpParameters: PWideChar;
  432.     lpDirectory: PWideChar;
  433.     nShow: Integer;
  434.     hInstApp: HINST;
  435.     { Optional fields }
  436.     lpIDList: Pointer;
  437.     lpClass: PWideChar;
  438.     hkeyClass: HKEY;
  439.     dwHotKey: DWORD;
  440.     hIcon: THandle;
  441.     hProcess: THandle;
  442.   end;
  443.   {$EXTERNALSYM _SHELLEXECUTEINFO}
  444.   _SHELLEXECUTEINFO = _SHELLEXECUTEINFOA;
  445.   TShellExecuteInfoA = _SHELLEXECUTEINFOA;
  446.   TShellExecuteInfoW = _SHELLEXECUTEINFOW;
  447.   TShellExecuteInfo = TShellExecuteInfoA;
  448.   {$EXTERNALSYM SHELLEXECUTEINFOA}
  449.   SHELLEXECUTEINFOA = _SHELLEXECUTEINFOA;
  450.   {$EXTERNALSYM SHELLEXECUTEINFOW}
  451.   SHELLEXECUTEINFOW = _SHELLEXECUTEINFOW;
  452.   {$EXTERNALSYM SHELLEXECUTEINFO}
  453.   SHELLEXECUTEINFO = SHELLEXECUTEINFOA;
  454.  
  455. {$EXTERNALSYM ShellExecuteExA}
  456. function ShellExecuteExA(lpExecInfo: PShellExecuteInfoA):BOOL; stdcall;
  457. {$EXTERNALSYM ShellExecuteExW}
  458. function ShellExecuteExW(lpExecInfo: PShellExecuteInfoW):BOOL; stdcall;
  459. {$EXTERNALSYM ShellExecuteEx}
  460. function ShellExecuteEx(lpExecInfo: PShellExecuteInfo):BOOL; stdcall;
  461.  
  462. { Tray notification definitions }
  463.  
  464. type
  465.   PNotifyIconDataA = ^TNotifyIconDataA;
  466.   PNotifyIconDataW = ^TNotifyIconDataW;
  467.   PNotifyIconData = PNotifyIconDataA;
  468.   {$EXTERNALSYM _NOTIFYICONDATAA}
  469.   _NOTIFYICONDATAA = record
  470.     cbSize: DWORD;
  471.     Wnd: HWND;
  472.     uID: UINT;
  473.     uFlags: UINT;
  474.     uCallbackMessage: UINT;
  475.     hIcon: HICON;
  476.     szTip: array [0..63] of AnsiChar;
  477.   end;
  478.   {$EXTERNALSYM _NOTIFYICONDATAW}
  479.   _NOTIFYICONDATAW = record
  480.     cbSize: DWORD;
  481.     Wnd: HWND;
  482.     uID: UINT;
  483.     uFlags: UINT;
  484.     uCallbackMessage: UINT;
  485.     hIcon: HICON;
  486.     szTip: array [0..63] of WideChar;
  487.   end;
  488.   {$EXTERNALSYM _NOTIFYICONDATA}
  489.   _NOTIFYICONDATA = _NOTIFYICONDATAA;
  490.   TNotifyIconDataA = _NOTIFYICONDATAA;
  491.   TNotifyIconDataW = _NOTIFYICONDATAW;
  492.   TNotifyIconData = TNotifyIconDataA;
  493.   {$EXTERNALSYM NOTIFYICONDATAA}
  494.   NOTIFYICONDATAA = _NOTIFYICONDATAA;
  495.   {$EXTERNALSYM NOTIFYICONDATAW}
  496.   NOTIFYICONDATAW = _NOTIFYICONDATAW;
  497.   {$EXTERNALSYM NOTIFYICONDATA}
  498.   NOTIFYICONDATA = NOTIFYICONDATAA;
  499.  
  500. const
  501.   {$EXTERNALSYM NIM_ADD}
  502.   NIM_ADD         = $00000000;
  503.   {$EXTERNALSYM NIM_MODIFY}
  504.   NIM_MODIFY      = $00000001;
  505.   {$EXTERNALSYM NIM_DELETE}
  506.   NIM_DELETE      = $00000002;
  507.  
  508.   {$EXTERNALSYM NIF_MESSAGE}
  509.   NIF_MESSAGE     = $00000001;
  510.   {$EXTERNALSYM NIF_ICON}
  511.   NIF_ICON        = $00000002;
  512.   {$EXTERNALSYM NIF_TIP}
  513.   NIF_TIP         = $00000004;
  514.  
  515. {$EXTERNALSYM Shell_NotifyIconA}
  516. function Shell_NotifyIconA(dwMessage: DWORD; lpData: PNotifyIconDataA): BOOL; stdcall;
  517. {$EXTERNALSYM Shell_NotifyIconW}
  518. function Shell_NotifyIconW(dwMessage: DWORD; lpData: PNotifyIconDataW): BOOL; stdcall;
  519. {$EXTERNALSYM Shell_NotifyIcon}
  520. function Shell_NotifyIcon(dwMessage: DWORD; lpData: PNotifyIconData): BOOL; stdcall;
  521.  
  522. { Begin SHGetFileInfo }
  523.  
  524. (*
  525.  * The SHGetFileInfo API provides an easy way to get attributes
  526.  * for a file given a pathname.
  527.  *
  528.  *   PARAMETERS
  529.  *
  530.  *     pszPath              file name to get info about
  531.  *     dwFileAttributes     file attribs, only used with SHGFI_USEFILEATTRIBUTES
  532.  *     psfi                 place to return file info
  533.  *     cbFileInfo           size of structure
  534.  *     uFlags               flags
  535.  *
  536.  *   RETURN
  537.  *     TRUE if things worked
  538.  *)
  539.  
  540. type
  541.   PSHFileInfoA = ^TSHFileInfoA;
  542.   PSHFileInfoW = ^TSHFileInfoW;
  543.   PSHFileInfo = PSHFileInfoA;
  544.   {$EXTERNALSYM _SHFILEINFOA}
  545.   _SHFILEINFOA = record
  546.     hIcon: HICON;                      { out: icon }
  547.     iIcon: Integer;                    { out: icon index }
  548.     dwAttributes: DWORD;               { out: SFGAO_ flags }
  549.     szDisplayName: array [0..MAX_PATH-1] of  AnsiChar; { out: display name (or path) }
  550.     szTypeName: array [0..79] of AnsiChar;             { out: type name }
  551.   end;
  552.   {$EXTERNALSYM _SHFILEINFOW}
  553.   _SHFILEINFOW = record
  554.     hIcon: HICON;                      { out: icon }
  555.     iIcon: Integer;                    { out: icon index }
  556.     dwAttributes: DWORD;               { out: SFGAO_ flags }
  557.     szDisplayName: array [0..MAX_PATH-1] of  WideChar; { out: display name (or path) }
  558.     szTypeName: array [0..79] of WideChar;             { out: type name }
  559.   end;
  560.   {$EXTERNALSYM _SHFILEINFO}
  561.   _SHFILEINFO = _SHFILEINFOA;
  562.   TSHFileInfoA = _SHFILEINFOA;
  563.   TSHFileInfoW = _SHFILEINFOW;
  564.   TSHFileInfo = TSHFileInfoA;
  565.   {$EXTERNALSYM SHFILEINFOA}
  566.   SHFILEINFOA = _SHFILEINFOA;
  567.   {$EXTERNALSYM SHFILEINFOW}
  568.   SHFILEINFOW = _SHFILEINFOW;
  569.   {$EXTERNALSYM SHFILEINFO}
  570.   SHFILEINFO = SHFILEINFOA;
  571.  
  572. const
  573.   {$EXTERNALSYM SHGFI_ICON}
  574.   SHGFI_ICON              = $000000100;     { get icon }
  575.   {$EXTERNALSYM SHGFI_DISPLAYNAME}
  576.   SHGFI_DISPLAYNAME       = $000000200;     { get display name }
  577.   {$EXTERNALSYM SHGFI_TYPENAME}
  578.   SHGFI_TYPENAME          = $000000400;     { get type name }
  579.   {$EXTERNALSYM SHGFI_ATTRIBUTES}
  580.   SHGFI_ATTRIBUTES        = $000000800;     { get attributes }
  581.   {$EXTERNALSYM SHGFI_ICONLOCATION}
  582.   SHGFI_ICONLOCATION      = $000001000;     { get icon location }
  583.   {$EXTERNALSYM SHGFI_EXETYPE}
  584.   SHGFI_EXETYPE           = $000002000;     { return exe type }
  585.   {$EXTERNALSYM SHGFI_SYSICONINDEX}
  586.   SHGFI_SYSICONINDEX      = $000004000;     { get system icon index }
  587.   {$EXTERNALSYM SHGFI_LINKOVERLAY}
  588.   SHGFI_LINKOVERLAY       = $000008000;     { put a link overlay on icon }
  589.   {$EXTERNALSYM SHGFI_SELECTED}
  590.   SHGFI_SELECTED          = $000010000;     { show icon in selected state }
  591.   {$EXTERNALSYM SHGFI_LARGEICON}
  592.   SHGFI_LARGEICON         = $000000000;     { get large icon }
  593.   {$EXTERNALSYM SHGFI_SMALLICON}
  594.   SHGFI_SMALLICON         = $000000001;     { get small icon }
  595.   {$EXTERNALSYM SHGFI_OPENICON}
  596.   SHGFI_OPENICON          = $000000002;     { get open icon }
  597.   {$EXTERNALSYM SHGFI_SHELLICONSIZE}
  598.   SHGFI_SHELLICONSIZE     = $000000004;     { get shell size icon }
  599.   {$EXTERNALSYM SHGFI_PIDL}
  600.   SHGFI_PIDL              = $000000008;     { pszPath is a pidl }
  601.   {$EXTERNALSYM SHGFI_USEFILEATTRIBUTES}
  602.   SHGFI_USEFILEATTRIBUTES = $000000010;     { use passed dwFileAttribute }
  603.  
  604. {$EXTERNALSYM SHGetFileInfoA}
  605. function SHGetFileInfoA(pszPath: PAnsiChar; dwFileAttributes: DWORD;
  606.   var psfi: TSHFileInfoA; cbFileInfo, uFlags: UINT): DWORD; stdcall;
  607. {$EXTERNALSYM SHGetFileInfoW}
  608. function SHGetFileInfoW(pszPath: PAnsiChar; dwFileAttributes: DWORD;
  609.   var psfi: TSHFileInfoW; cbFileInfo, uFlags: UINT): DWORD; stdcall;
  610. {$EXTERNALSYM SHGetFileInfo}
  611. function SHGetFileInfo(pszPath: PAnsiChar; dwFileAttributes: DWORD;
  612.   var psfi: TSHFileInfo; cbFileInfo, uFlags: UINT): DWORD; stdcall;
  613.  
  614. const
  615.   {$EXTERNALSYM SHGNLI_PIDL}
  616.   SHGNLI_PIDL             = $000000001;     { pszLinkTo is a pidl }
  617.   {$EXTERNALSYM SHGNLI_PREFIXNAME}
  618.   SHGNLI_PREFIXNAME       = $000000002;     { Make name "Shortcut to xxx" }
  619.   {$EXTERNALSYM SHGNLI_NOUNIQUE}
  620.   SHGNLI_NOUNIQUE         = $000000004;     { don't do the unique name generation }
  621.  
  622.   shell32 = 'shell32.dll';
  623.  
  624. implementation
  625.  
  626. function CommandLineToArgvW; external shell32 name 'CommandLineToArgvW';
  627. function DoEnvironmentSubstA; external shell32 name 'DoEnvironmentSubstA';
  628. function DoEnvironmentSubstW; external shell32 name 'DoEnvironmentSubstW';
  629. function DoEnvironmentSubst; external shell32 name 'DoEnvironmentSubstA';
  630. procedure DragAcceptFiles; external shell32 name 'DragAcceptFiles';
  631. procedure DragFinish; external shell32 name 'DragFinish';
  632. function DragQueryFileA; external shell32 name 'DragQueryFileA';
  633. function DragQueryFileW; external shell32 name 'DragQueryFileW';
  634. function DragQueryFile; external shell32 name 'DragQueryFileA';
  635. function DragQueryPoint; external shell32 name 'DragQueryPoint';
  636. function DuplicateIcon; external shell32 name 'DuplicateIcon';
  637. function ExtractAssociatedIconA; external shell32 name 'ExtractAssociatedIconA';
  638. function ExtractAssociatedIconW; external shell32 name 'ExtractAssociatedIconW';
  639. function ExtractAssociatedIcon; external shell32 name 'ExtractAssociatedIconA';
  640. function ExtractIconA; external shell32 name 'ExtractIconA';
  641. function ExtractIconW; external shell32 name 'ExtractIconW';
  642. function ExtractIcon; external shell32 name 'ExtractIconA';
  643. function ExtractIconExA; external shell32 name 'ExtractIconExA';
  644. function ExtractIconExW; external shell32 name 'ExtractIconExW';
  645. function ExtractIconEx; external shell32 name 'ExtractIconExA';
  646. function FindExecutableA; external shell32 name 'FindExecutableA';
  647. function FindExecutableW; external shell32 name 'FindExecutableW';
  648. function FindExecutable; external shell32 name 'FindExecutableA';
  649. function SHAppBarMessage; external shell32 name 'SHAppBarMessage';
  650. function SHFileOperationA; external shell32 name 'SHFileOperationA';
  651. function SHFileOperationW; external shell32 name 'SHFileOperationW';
  652. function SHFileOperation; external shell32 name 'SHFileOperationA';
  653. procedure SHFreeNameMappings; external shell32 name 'SHFreeNameMappings';
  654. function SHGetFileInfoA; external shell32 name 'SHGetFileInfoA';
  655. function SHGetFileInfoW; external shell32 name 'SHGetFileInfoW';
  656. function SHGetFileInfo; external shell32 name 'SHGetFileInfoA';
  657. function ShellAboutA; external shell32 name 'ShellAboutA';
  658. function ShellAboutW; external shell32 name 'ShellAboutW';
  659. function ShellAbout; external shell32 name 'ShellAboutA';
  660. function ShellExecuteA; external shell32 name 'ShellExecuteA';
  661. function ShellExecuteW; external shell32 name 'ShellExecuteW';
  662. function ShellExecute; external shell32 name 'ShellExecuteA';
  663. function ShellExecuteExA; external shell32 name 'ShellExecuteExA';
  664. function ShellExecuteExW; external shell32 name 'ShellExecuteExW';
  665. function ShellExecuteEx; external shell32 name 'ShellExecuteExA';
  666. function Shell_NotifyIconA; external shell32 name 'Shell_NotifyIconA';
  667. function Shell_NotifyIconW; external shell32 name 'Shell_NotifyIconW';
  668. function Shell_NotifyIcon; external shell32 name 'Shell_NotifyIconA';
  669.  
  670. end.
  671.