home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1997 May / Pcwk0597.iso / borland / cb / setup / cbuilder / data.z / SHLOBJ.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1997-02-28  |  40.6 KB  |  955 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Delphi Runtime Library                          }
  5. {       Windows 32bit API Interface Unit                }
  6. {                                                       }
  7. {       Copyright (c) 1996 Borland International        }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit ShlObj;
  12.  
  13. interface
  14.  
  15. uses Windows, OLE2, CommCtrl, ShellAPI, RegStr, Messages;
  16.  
  17. { Object identifiers in the explorer's name space (ItemID and IDList)
  18.   All the items that the user can browse with the explorer (such as files,
  19.   directories, servers, work-groups, etc.) has an identifier which is unique
  20.   among items within the parent folder. Those identifiers are called item
  21.   IDs (SHITEMID). Since all its parent folders have their own item IDs,
  22.   any items can be uniquely identified by a list of item IDs, which is called
  23.   an ID list (ITEMIDLIST).
  24.  
  25.   ID lists are almost always allocated by the task allocator (see some
  26.   description below as well as OLE 2.0 SDK) and may be passed across
  27.   some of shell interfaces (such as IShellFolder). Each item ID in an ID list
  28.   is only meaningful to its parent folder (which has generated it), and all
  29.   the clients must treat it as an opaque binary data except the first two
  30.   bytes, which indicates the size of the item ID.
  31.  
  32.   When a shell extension -- which implements the IShellFolder interace --
  33.   generates an item ID, it may put any information in it, not only the data
  34.   with that it needs to identifies the item, but also some additional
  35.   information, which would help implementing some other functions efficiently.
  36.   For example, the shell's IShellFolder implementation of file system items
  37.   stores the primary (long) name of a file or a directory as the item
  38.   identifier, but it also stores its alternative (short) name, size and date
  39.   etc.
  40.  
  41.   When an ID list is passed to one of shell APIs (such as SHGetPathFromIDList),
  42.   it is always an absolute path -- relative from the root of the name space,
  43.   which is the desktop folder. When an ID list is passed to one of IShellFolder
  44.   member function, it is always a relative path from the folder (unless it
  45.   is explicitly specified). }
  46.  
  47. const
  48.   CLSID_ShellDesktop: TGUID = (
  49.     D1:$00021400; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  50.   CLSID_ShellLink: TGUID = (
  51.     D1:$00021401; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  52.  
  53.   IID_IContextMenu : TGUID = (
  54.     D1:$000214E4; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  55.   IID_IShellFolder : TGUID = (
  56.     D1:$000214E6; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  57.   IID_IShellExtInit : TGUID = (
  58.     D1:$000214E8; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  59.   IID_IShellPropSheetExt : TGUID = (
  60.     D1:$000214E9; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  61.   IID_IExtractIcon : TGUID = (
  62.     D1:$000214EB; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  63.   IID_IShellLink : TGUID = (
  64.     D1:$000214EE; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  65.   IID_IShellCopyHook : TGUID = (
  66.     D1:$000214EF; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  67.   IID_IFileViewer : TGUID = (
  68.     D1:$000214F0; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  69.   IID_IEnumIDList : TGUID = (
  70.     D1:$000214F2; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  71.   IID_IFileViewerSite : TGUID = (
  72.     D1:$000214F3; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
  73.  
  74. type
  75. { TSHItemID -- Item ID }
  76.  
  77.   PSHItemID = ^TSHItemID;
  78.   TSHItemID = packed record           { mkid }
  79.     cb: Word;                         { Size of the ID (including cb itself) }
  80.     abID: array[0..0] of Byte;        { The item ID (variable length) }
  81.   end;
  82.  
  83. { TItemIDList -- List if item IDs (combined with 0-terminator) }
  84.  
  85.   PItemIDList = ^TItemIDList;
  86.   TItemIDList = packed record         { idl }
  87.      mkid: TSHItemID;
  88.    end;
  89.  
  90. { Task allocator API }
  91.  
  92. { All the shell extensions MUST use the task allocator (see OLE 2.0
  93.  programming guild for its definition) when they allocate or free
  94.  memory objects (mostly ITEMIDLIST) that are returned across any
  95.  shell interfaces. There are two ways to access the task allocator
  96.  from a shell extension depending on whether or not it is linked with
  97.  OLE32.DLL or not (virtual; stdcall; abstractly for efficiency).
  98.  
  99.  (1) A shell extension which calls any OLE API (i.e., linked with
  100.   OLE32.DLL) should call OLE's task allocator (by retrieving
  101.   the task allocator by calling CoGetMalloc API).
  102.  
  103.  (2) A shell extension which does not call any OLE API (i.e., not linked
  104.   with OLE32.DLL) should call the shell task allocator API (defined
  105.   below), so that the shell can quickly loads it when OLE32.DLL is not
  106.   loaded by any application at that point. }
  107.  
  108. { !!! Notes:
  109.   In next version of Windowso release, SHGetMalloc will be replaced by
  110.  the following macro.
  111.  
  112.  #define SHGetMalloc(ppmem)    CoGetMalloc(MEMCTX_TASK, ppmem) }
  113.  
  114. // !!! function SHGetMalloc(var ppMalloc: IMalloc): HResult;
  115. function SHGetMalloc(var ppMalloc: IMalloc): HResult; stdcall;
  116.  
  117. { IContextMenu interface }
  118.  
  119. { [OverView] }
  120.  
  121. { The shell uses the IContextMenu interface in following three cases.
  122.  
  123.  case-1: The shell is loading context menu extensions.
  124.    When the user clicks the right mouse button on an item within the shell's
  125.   name space (i.g., file, directory, server, work-group, etc.), it creates
  126.   the default context menu for its type, then loads context menu extensions
  127.   that are registered for that type (and its base type) so that they can
  128.   add extra menu items. Those context menu extensions are registered at
  129.   HKCR\beginProgIDend\shellex\ContextMenuHandlers.
  130.  
  131.  case-2: The shell is retrieving a context menu of sub-folders in extended
  132.    name-space.
  133.    When the explorer's name space is extended by name space extensions,
  134.   the shell calls their IShellFolder::GetUIObjectOf to get the IContextMenu
  135.   objects when it creates context menus for folders under those extended
  136.   name spaces.
  137.  
  138.  case-3: The shell is loading non-default drag and drop handler for directories.
  139.    When the user performed a non-default drag and drop onto one of file
  140.   system folders (i.e., directories), it loads shell extensions that are
  141.   registered at HKCR\beginProgIDend\DragDropHandlers. }
  142.  
  143. { [Member functions] }
  144.  
  145. { IContextMenu::QueryContextMenu }
  146.  
  147. { This member function may insert one or more menuitems to the specified 
  148.   menu (hmenu) at the specified location (indexMenu which is never be -1).
  149.   The IDs of those menuitem must be in the specified range (idCmdFirst and 
  150.   idCmdLast). It returns the maximum menuitem ID offset (ushort) in the 
  151.   'code' field (low word) of the scode. 
  152.  
  153.   The uFlags specify the context. It may have one or more of following 
  154.   flags. 
  155.  
  156.   CMF_DEFAULTONLY: This flag is passed if the user is invoking the default 
  157.   action (typically by double-clicking, case 1 and 2 only). Context menu 
  158.   extensions (case 1) should not add any menu items, and returns NOERROR. 
  159.  
  160.   CMF_VERBSONLY: The explorer passes this flag if it is constructing 
  161.   a context menu for a short-cut object (case 1 and case 2 only). If this 
  162.   flag is passed, it should not add any menu-items that is not appropriate 
  163.   from a short-cut. 
  164.   A good example is the 'Delete' menuitem, which confuses the user 
  165.   because it is not clear whether it deletes the link source item or the 
  166.   link itself. 
  167.  
  168.   CMF_EXPLORER: The explorer passes this flag if it has the left-side pane 
  169.    (case 1 and 2 only). Context menu extensions should ignore this flag. 
  170.  
  171.   High word (16-bit) are reserved for context specific communications 
  172.   and the rest of flags (13-bit) are reserved by the system. }
  173.  
  174. { IContextMenu::InvokeCommand }
  175.  
  176. { This member is called when the user has selected one of menuitems that 
  177.   are inserted by previous QueryContextMenu member. In this case, the 
  178.   LOWORD(lpici->lpVerb) contains the menuitem ID offset (menuitem ID - 
  179.   idCmdFirst). 
  180.  
  181.    This member function may also be called programmatically. In such a case, 
  182.   lpici->lpVerb specifies the canonical name of the command to be invoked, 
  183.   which is typically retrieved by GetCommandString member previously. 
  184.  
  185.   Parameters in lpci: 
  186.     cbSize -- Specifies the size of this structure (sizeof(*lpci)) 
  187.     hwnd   -- Specifies the owner window for any message/dialog box. 
  188.     fMask  -- Specifies whether or not dwHotkey/hIcon paramter is valid. 
  189.     lpVerb -- Specifies the command to be invoked. 
  190.     lpParameters -- Parameters (optional) 
  191.     lpDirectory  -- Working directory (optional) 
  192.     nShow -- Specifies the flag to be passed to ShowWindow (SW_*). 
  193.     dwHotKey -- Hot key to be assigned to the app after invoked (optional). 
  194.     hIcon -- Specifies the icon (optional). }
  195.  
  196. { IContextMenu::GetCommandString }
  197.  
  198. { This member function is called by the explorer either to get the 
  199.   canonical (language independent) command name (uFlags == GCS_VERB) or 
  200.   the help text ((uFlags & GCS_HELPTEXT) != 0) for the specified command. 
  201.   The retrieved canonical string may be passed to its InvokeCommand 
  202.   member function to invoke a command programmatically. The explorer 
  203.   displays the help texts in its status bar; therefore, the length of 
  204.   the help text should be reasonably short (<40 characters). 
  205.  
  206.   Parameters: 
  207.    idCmd -- Specifies menuitem ID offset (from idCmdFirst) 
  208.    uFlags -- Either GCS_VERB or GCS_HELPTEXT 
  209.    pwReserved -- Reserved (must pass NULL when calling, must ignore when called) 
  210.    pszName -- Specifies the string buffer. 
  211.    cchMax -- Specifies the size of the string buffer. }
  212.  
  213. const
  214. { QueryContextMenu uFlags }
  215.  
  216.   CMF_NORMAL             = $00000000;
  217.   CMF_DEFAULTONLY        = $00000001;
  218.   CMF_VERBSONLY          = $00000002;
  219.   CMF_EXPLORE            = $00000004;
  220.   CMF_RESERVED           = $FFFF0000;      { View specific }
  221.  
  222. { GetCommandString uFlags }
  223.  
  224.   GCS_VERB         = $00000000;     { canonical verb }
  225.   GCS_HELPTEXT     = $00000001;     { help text (for status bar) }
  226.   GCS_VALIDATE     = $00000002;     { validate command exists }
  227.  
  228.   CMDSTR_NEWFOLDER    = 'NewFolder';
  229.   CMDSTR_VIEWLIST     = 'ViewList';
  230.   CMDSTR_VIEWDETAILS  = 'ViewDetails';
  231.  
  232.   CMIC_MASK_HOTKEY       = SEE_MASK_HOTKEY;
  233.   CMIC_MASK_ICON         = SEE_MASK_ICON;
  234.   CMIC_MASK_FLAG_NO_UI   = SEE_MASK_FLAG_NO_UI;
  235.   CMIC_MASK_MODAL        = $80000000;        { Internal }
  236.  
  237. // CMIC_VALID_SEE_FLAGS   = !!! not found -> SEE_VALID_CMIC_FLAGS;   ( Internal }
  238.  
  239. type
  240.   PCMInvokeCommandInfo = ^TCMInvokeCommandInfo;
  241.   TCMInvokeCommandInfo = packed record
  242.     cbSize: DWORD;        { must be sizeof(CMINVOKECOMMANDINFO) }
  243.     fMask: DWORD;         { any combination of CMIC_MASK_* }
  244.     hwnd: HWND;           { might be NULL (indicating no owner window) }
  245.     lpVerb: LPCSTR;       { either a string of MAKEINTRESOURCE(idOffset) }
  246.     lpParameters: LPCSTR; { might be NULL (indicating no parameter) }
  247.     lpDirectory: LPCSTR;  { might be NULL (indicating no specific directory) }
  248.     nShow: Integer;       { one of SW_ values for ShowWindow() API }
  249.     dwHotKey: DWORD;
  250.     hIcon: THandle;
  251.   end;
  252.  
  253.   IContextMenu = class(IUnknown)
  254.     function QueryContextMenu(Menu: HMENU; 
  255.       indexMenu, idCmdFirst, idCmdLast, uFlags: UINT): HResult; virtual; stdcall; abstract;
  256.     function InvokeCommand(var lpici: TCMInvokeCommandInfo): HResult; virtual; stdcall; abstract;
  257.     function GetCommandString(idCmd, uType: UINT; pwReserved: PUINT;
  258.       pszName: LPSTR; cchMax: UINT): HResult; virtual; stdcall; abstract;
  259.     end;
  260.  
  261. { Interface: IShellExtInit }
  262.  
  263. { The IShellExtInit interface is used by the explorer to initialize shell 
  264.   extension objects. The explorer (1) calls CoCreateInstance (or equivalent) 
  265.   with the registered CLSID and IID_IShellExtInit, (2) calls its Initialize 
  266.   member, then (3) calls its QueryInterface to a particular interface (such 
  267.   as IContextMenu or IPropSheetExt and (4) performs the rest of operation. }
  268.  
  269. { [Member functions] }
  270.  
  271. { IShellExtInit.Initialize }
  272.  
  273. { This member function is called when the explorer is initializing either
  274.   context menu extension, property sheet extension or non-default drag-drop
  275.   extension.
  276.  
  277.   Parameters: (context menu or property sheet extension) 
  278.    pidlFolder -- Specifies the parent folder 
  279.    lpdobj -- Spefifies the set of items selected in that folder. 
  280.    hkeyProgID -- Specifies the type of the focused item in the selection. 
  281.  
  282.   Parameters: (non-default drag-and-drop extension) 
  283.    pidlFolder -- Specifies the target (destination) folder 
  284.    lpdobj -- Specifies the items that are dropped (see the description 
  285.     about shell's clipboard below for clipboard formats). 
  286.    hkeyProgID -- Specifies the folder type. }
  287.  
  288. type
  289.   IShellExtInit = class(IUnknown)
  290.     function Initialize(pidlFolder: PItemIDList; lpdobj: IDataObject;
  291.       hKeyProgID: HKEY): HResult; virtual; stdcall; abstract;
  292.   end;
  293.  
  294. {=========================================================================== }
  295.  
  296. { Interface: IShellPropSheetExt }
  297.  
  298. { The explorer uses the IShellPropSheetExt to allow property sheet
  299.   extensions or control panel extensions to add additional property
  300.   sheet pages. }
  301.  
  302. { [Member functions] }
  303.  
  304. { IShellPropSheetExt.AddPages }
  305.  
  306. { The explorer calls this member function when it finds a registered 
  307.   property sheet extension for a particular type of object. For each 
  308.   additional page, the extension creates a page object by calling 
  309.   CreatePropertySheetPage API and calls lpfnAddPage. 
  310.  
  311.    Parameters: 
  312.     lpfnAddPage -- Specifies the callback function. 
  313.     lParam -- Specifies the opaque handle to be passed to the callback function. }
  314.  
  315. { IShellPropSheetExt.ReplacePage }
  316.  
  317. { The explorer never calls this member of property sheet extensions. The 
  318.   explorer calls this member of control panel extensions, so that they 
  319.   can replace some of default control panel pages (such as a page of 
  320.   mouse control panel). 
  321.  
  322.    Parameters: 
  323.     uPageID -- Specifies the page to be replaced. 
  324.     lpfnReplace Specifies the callback function. 
  325.     lParam -- Specifies the opaque handle to be passed to the callback function. }
  326.  
  327. type
  328.   IShellPropSheetExt = class(IUnknown)
  329.     function AddPages(lpfnAddPage: TFNAddPropSheetPage; lParam: LPARAM): HResult; virtual; stdcall; abstract;
  330.     function ReplacePage(uPageID: UINT; lpfnReplaceWith: TFNAddPropSheetPage;
  331.       lParam: LPARAM): HResult; virtual; stdcall; abstract;
  332.   end;
  333.  
  334. { IExtractIcon interface }
  335.  
  336. { This interface is used in two different places in the shell.
  337.  
  338.   Case-1: Icons of sub-folders for the scope-pane of the explorer.
  339.  
  340.    It is used by the explorer to get the 'icon location' of
  341.   sub-folders from each shell folders. When the user expands a folder
  342.   in the scope pane of the explorer, the explorer does following:
  343.    (1) binds to the folder (gets IShellFolder),
  344.    (2) enumerates its sub-folders by calling its EnumObjects member,
  345.    (3) calls its GetUIObjectOf member to get IExtractIcon interface
  346.       for each sub-folders.
  347.    In this case, the explorer uses only IExtractIcon.GetIconLocation
  348.   member to get the location of the appropriate icon. An icon location
  349.   always consists of a file name (typically DLL or EXE) and either an icon
  350.   resource or an icon index.
  351.  
  352.   Case-2: Extracting an icon image from a file
  353.  
  354.    It is used by the shell when it extracts an icon image
  355.   from a file. When the shell is extracting an icon from a file,
  356.   it does following:
  357.    (1) creates the icon extraction handler object (by getting its CLSID
  358.       under the beginProgIDend\shell\ExtractIconHanler key and calling
  359.       CoCreateInstance requesting for IExtractIcon interface).
  360.    (2) Calls IExtractIcon.GetIconLocation.
  361.    (3) Then, calls IExtractIcon.Extract with the location/index pair.
  362.    (4) If (3) returns NOERROR, it uses the returned icon.
  363.    (5) Otherwise, it recursively calls this logic with new location
  364.       assuming that the location string contains a fully qualified path name.
  365.  
  366.    From extension programmer's point of view, there are only two cases
  367.   where they provide implementations of IExtractIcon:
  368.    Case-1) providing explorer extensions (i.e., IShellFolder).
  369.    Case-2) providing per-instance icons for some types of files.
  370.  
  371.   Because Case-1 is described above, we'll explain only Case-2 here.
  372.  
  373.   When the shell is about display an icon for a file, it does following:
  374.    (1) Finds its ProgID and ClassID.
  375.    (2) If the file has a ClassID, it gets the icon location string from the
  376.      'DefaultIcon' key under it. The string indicates either per-class
  377.      icon (e.g., 'FOOBAR.DLL,2') or per-instance icon (e.g., '%1,1').
  378.    (3) If a per-instance icon is specified, the shell creates an icon
  379.      extraction handler object for it, and extracts the icon from it
  380.      (which is described above).
  381.  
  382.    It is important to note that the shell calls IExtractIcon.GetIconLocation
  383.   first, then calls IExtractIcon.Extract. Most application programs
  384.   that support per-instance icons will probably store an icon location
  385.   (DLL/EXE name and index/id) rather than an icon image in each file.
  386.   In those cases, a programmer needs to implement only the GetIconLocation
  387.   member and it Extract member simply returns S_FALSE. They need to
  388.   implement Extract member only if they decided to store the icon images
  389.   within files themselved or some other database (which is very rare). }
  390.  
  391. { [Member functions] }
  392.  
  393. { IExtractIcon.GetIconLocation }
  394.  
  395. { This function returns an icon location.
  396.  
  397.   Parameters:
  398.    uFlags     [in]  -- Specifies if it is opened or not (GIL_OPENICON or 0)
  399.    szIconFile [out] -- Specifies the string buffer buffer for a location name.
  400.    cchMax     [in]  -- Specifies the size of szIconFile (almost always MAX_PATH)
  401.    piIndex    [out] -- Sepcifies the address of UINT for the index.
  402.    pwFlags    [out] -- Returns GIL_* flags
  403.   Returns:
  404.    NOERROR, if it returns a valid location; S_FALSE, if the shell use a
  405.    default icon.
  406.  
  407.   Notes: The location may or may not be a path to a file. The caller can
  408.    not assume anything unless the subsequent Extract member call returns
  409.    S_FALSE.
  410.  
  411.    if the returned location is not a path to a file, GIL_NOTFILENAME should
  412.    be set in the returned flags. }
  413.  
  414. { IExtractIcon.Extract }
  415.  
  416. { This function extracts an icon image from a specified file.
  417.  
  418.   Parameters:
  419.    pszFile [in] -- Specifies the icon location (typically a path to a file).
  420.    nIconIndex [in] -- Specifies the icon index.
  421.    phiconLarge [out] -- Specifies the HICON variable for large icon.
  422.    phiconSmall [out] -- Specifies the HICON variable for small icon.
  423.    nIconSize [in] -- Specifies the size icon required (size of large icon)
  424.                      LOWORD is the requested large icon size
  425.                      HIWORD is the requested small icon size
  426.   Returns:
  427.    NOERROR, if it extracted the from the file.
  428.    S_FALSE, if the caller should extract from the file specified in the
  429.            location. }
  430.  
  431. const
  432. { GetIconLocation() input flags }
  433.  
  434.   GIL_OPENICON     = $0001      { allows containers to specify an 'open' look };
  435.   GIL_FORSHELL     = $0002      { icon is to be displayed in a ShellFolder };
  436.  
  437. { GetIconLocation() return flags }
  438.  
  439.   GIL_SIMULATEDOC  = $0001      { simulate this document icon for this };
  440.   GIL_PERINSTANCE  = $0002      { icons from this class are per instance (each file has its own) };
  441.   GIL_PERCLASS     = $0004      { icons from this class per class (shared for all files of this type) };
  442.   GIL_NOTFILENAME  = $0008      { location is not a filename, must call .Extract };
  443.   GIL_DONTCACHE    = $0010      { this icon should not be cached };
  444.  
  445. type
  446.   IExtractIcon = class(IUnknown)      { exic }
  447.     function GetIconLocation(uFlags: UINT; szIconFile: LPSTR; cchMax: UINT;
  448.       var piIndex: Integer; var pwFlags: UINT): HResult; virtual; stdcall; abstract;
  449.     function Extract(pszFile: LPCSTR; nIconIndex: UINT; var phiconLarge: HICON;
  450.       var phiconSmall: HICON; nIconSize: UINT): HResult; virtual; stdcall; abstract;
  451.   end;
  452.  
  453. { IShellLink Interface }
  454. const
  455. { IShellLink.Resolve fFlags }
  456.  
  457.   SLR_NO_UI           = $0001;
  458.   SLR_ANY_MATCH       = $0002;
  459.   SLR_UPDATE          = $0004;
  460.  
  461. { IShellLink.GetPath fFlags }
  462.  
  463.   SLGP_SHORTPATH      = $0001;
  464.   SLGP_UNCPRIORITY    = $0002;
  465.  
  466. type
  467.   IShellLink = class(IUnknown) { sl }
  468.     function GetPath(pszFile: LPSTR; cchMaxPath: Integer;
  469.       var pfd: TWin32FindData; fFlags: DWORD): HResult; virtual; stdcall; abstract;
  470.     function GetIDList(var ppidl: PItemIDList): HResult; virtual; stdcall; abstract;
  471.     function SetIDList(pidl: PItemIDList): HResult; virtual; stdcall; abstract;
  472.     function GetDescription(pszName: LPSTR; cchMaxName: Integer): HResult; virtual; stdcall; abstract;
  473.     function SetDescription(pszName: LPSTR): HResult; virtual; stdcall; abstract;
  474.     function GetWorkingDirectory(pszDir: LPSTR; cchMaxPath: Integer): HResult; virtual; stdcall; abstract;
  475.     function SetWorkingDirectory(pszDir: LPSTR): HResult; virtual; stdcall; abstract;
  476.     function GetArguments(pszArgs: LPSTR; cchMaxPath: Integer): HResult; virtual; stdcall; abstract;
  477.     function SetArguments(pszArgs: LPSTR): HResult; virtual; stdcall; abstract;
  478.     function GetHotkey(var pwHotkey: Word): HResult; virtual; stdcall; abstract;
  479.     function SetHotkey(wHotkey: Word): HResult; virtual; stdcall; abstract;
  480.     function GetShowCmd(var piShowCmd: Integer): HResult; virtual; stdcall; abstract;
  481.     function SetShowCmd(iShowCmd: Integer): HResult; virtual; stdcall; abstract;
  482.     function GetIconLocation(pszIconPath: LPSTR; cchIconPath: Integer;
  483.       var piIcon: Integer): HResult; virtual; stdcall; abstract;
  484.     function SetIconLocation(pszIconPath: LPSTR; iIcon: Integer): HResult; virtual; stdcall; abstract;
  485.     function SetRelativePath(pszPathRel: LPSTR; dwReserved: DWORD): HResult; virtual; stdcall; abstract;
  486.     function Resolve(Wnd: HWND; fFlags: DWORD): HResult; virtual; stdcall; abstract;
  487.     function SetPath(pszFile: LPSTR): HResult; virtual; stdcall; abstract;
  488.   end;
  489.  
  490. { ICopyHook Interface }
  491.  
  492. { The copy hook is called whenever file system directories are
  493.   copy/moved/deleted/renamed via the shell.  It is also called by the shell
  494.   on changes of status of printers.
  495.   Clients register their id under STRREG_SHEX_COPYHOOK for file system hooks
  496.   and STRREG_SHEx_PRNCOPYHOOK for printer hooks.
  497.   the CopyCallback is called prior to the action, so the hook has the chance
  498.   to allow, deny or cancel the operation by returning the falues:
  499.      IDYES  -  means allow the operation
  500.      IDNO   -  means disallow the operation on this file, but continue with
  501.               any other operations (eg. batch copy)
  502.      IDCANCEL - means disallow the current operation and cancel any pending
  503.               operations
  504.    arguments to the CopyCallback
  505.       hwnd - window to use for any UI
  506.       wFunc - what operation is being done
  507.       wFlags - and flags (FOF_*) set in the initial call to the file operation
  508.       pszSrcFile - name of the source file
  509.       dwSrcAttribs - file attributes of the source file
  510.       pszDestFile - name of the destiation file (for move and renames)
  511.       dwDestAttribs - file attributes of the destination file }
  512.  
  513. type
  514.   ICopyHook = class(IUnknown) { sl }
  515.     function CopyCallback(Wnd: HWND; wFunc, wFlags: UINT; pszSrcFile: LPSTR; 
  516.       dwSrcAttribs: DWORD; pszDestFile: LPSTR; dwDestAttribs: DWORD): UINT; virtual; stdcall; abstract;
  517.   end;
  518.  
  519. { IFileViewerSite Interface }
  520.  
  521. type
  522.   IFileViewerSite = class(IUnknown)
  523.     function SetPinnedWindow(Wnd: HWND): HResult; virtual; stdcall; abstract;
  524.     function GetPinnedWindow(var Wnd: HWND): HResult; virtual; stdcall; abstract;
  525.   end;
  526.  
  527. { IFileViewer Interface }
  528.  
  529. { Implemented in a FileViewer component object.  Used to tell a
  530.   FileViewer to PrintTo or to view, the latter happening though
  531.   ShowInitialize and Show.  The filename is always given to the
  532.   viewer through IPersistFile. }
  533.  
  534. type
  535.   PFVShowInfo = ^TFVShowInfo;
  536.   TFVShowInfo = packed record
  537.     { Stuff passed into viewer (in) }
  538.      cbSize: DWORD;           { Size of structure for future expansion... }
  539.      hwndOwner: HWND;         { who is the owner window. }
  540.      iShow: Integer;          { The show command }
  541.      
  542.     { Passed in and updated  (in/Out) }
  543.      dwFlags: DWORD;          { flags }
  544.      rect: TRECT;             { Where to create the window may have defaults }
  545.      punkRel: IUNKNOWN;       { Relese this interface when window is visible }
  546.      
  547.     { Stuff that might be returned from viewer (out) }
  548.      strNewFile: array[0..MAX_PATH-1] of TOleChar;   { New File to view. }
  549.     end;
  550.  
  551. const
  552. { Define File View Show Info Flags. }
  553.  
  554.    FVSIF_RECT      = $00000001;      { The rect variable has valid data. }
  555.    FVSIF_PINNED    = $00000002;      { We should Initialize pinned }
  556.  
  557.    FVSIF_NEWFAILED = $08000000;      { The new file passed back failed
  558.                                        to be viewed. }
  559.  
  560.    FVSIF_NEWFILE   = $80000000;      { A new file to view has been returned }
  561.    FVSIF_CANVIEWIT = $40000000;      { The viewer can view it. }
  562.  
  563. type
  564.   IFileViewer = class(IUnknown)
  565.     function ShowInitialize(fsi: IFileViewerSite): HResult; virtual; stdcall; abstract;
  566.     function Show(var pvsi: TFVShowInfo): HResult; virtual; stdcall; abstract;
  567.     function PrintTo(pszDriver: LPSTR; fSuppressUI: BOOL): HResult; virtual; stdcall; abstract;
  568.   end;
  569.  
  570. const
  571.   STRRET_WSTR     = $0000;
  572.   STRRET_OFFSET   = $0001;
  573.   STRRET_CSTR     = $0002;
  574.  
  575. type
  576. { record for returning strings from IShellFolder member functions }
  577.  
  578.   PSTRRet = ^TStrRet;
  579.   TStrRet = packed record
  580.      uType: UINT;              { One of the STRRET_* values }
  581.      case Integer of
  582.        0: (pOleStr: LPWSTR);                    { OLESTR that will be freed }
  583.        1: (uOffset: UINT);                      { Offset into SHITEMID (ANSI) }
  584.        2: (cStr: array[0..MAX_PATH-1] of Char); { Buffer to fill in }
  585.     end;
  586.  
  587. { SHGetPathFromIDList }
  588.  
  589. { This function assumes the size of the buffer (MAX_PATH). The pidl
  590.   should point to a file system object. }
  591.  
  592. function SHGetPathFromIDList(pidl: PItemIDList; pszPath: LPSTR): BOOL; stdcall;
  593.  
  594. { SHGetSpecialFolderLocation }
  595.  
  596. { Caller should call SHFree to free the returned pidl. }
  597.  
  598. const
  599. { registry entries for special paths are kept in : }
  600.  
  601.   REGSTR_PATH_SPECIAL_FOLDERS   = REGSTR_PATH_EXPLORER + '\Shell Folders';
  602.   CSIDL_DESKTOP            = $0000;
  603.   CSIDL_PROGRAMS           = $0002;
  604.   CSIDL_CONTROLS           = $0003;
  605.   CSIDL_PRINTERS           = $0004;
  606.   CSIDL_PERSONAL           = $0005;
  607.   CSIDL_FAVORITES          = $0006;
  608.   CSIDL_STARTUP            = $0007;
  609.   CSIDL_RECENT             = $0008;
  610.   CSIDL_SENDTO             = $0009;
  611.   CSIDL_BITBUCKET          = $000A;
  612.   CSIDL_STARTMENU          = $000B;
  613.   CSIDL_DESKTOPDIRECTORY   = $0010;
  614.   CSIDL_DRIVES             = $0011;
  615.   CSIDL_NETWORK            = $0012;
  616.   CSIDL_NETHOOD            = $0013;
  617.   CSIDL_FONTS              = $0014;
  618.   CSIDL_TEMPLATES          = $0015;
  619.  
  620. function SHGetSpecialFolderLocation(hwndOwner: HWND; nFolder: Integer;
  621.   var ppidl: PItemIDList): HResult; stdcall;
  622.  
  623. { SHBrowseForFolder API }
  624.  
  625. type
  626.   TFNBFFCallBack = function(Wnd: HWND; uMsg: UINT; lParam, lpData: LPARAM): Integer stdcall;
  627.   
  628.   PBrowseInfo = ^TBrowseInfo;
  629.   TBrowseInfo = packed record
  630.     hwndOwner: HWND;
  631.     pidlRoot: PItemIDList;
  632.     pszDisplayName: LPSTR;  { Return display name of item selected. }
  633.     lpszTitle: LPCSTR;      { text to go in the banner over the tree. }
  634.     ulFlags: UINT;          { Flags that control the return stuff }
  635.     lpfn: TFNBFFCallBack;
  636.     lParam: LPARAM;         { extra info that's passed back in callbacks }
  637.     iImage: Integer;        { output var: where to return the Image index. }
  638.   end;
  639.  
  640. const
  641. { Browsing for directory. }
  642.  
  643.   BIF_RETURNONLYFSDIRS   = $0001  { For finding a folder to start document searching };
  644.   BIF_DONTGOBELOWDOMAIN  = $0002  { For starting the Find Computer };
  645.   BIF_STATUSTEXT         = $0004;
  646.   BIF_RETURNFSANCESTORS  = $0008;
  647.  
  648.   BIF_BROWSEFORCOMPUTER  = $1000  { Browsing for Computers. };
  649.   BIF_BROWSEFORPRINTER   = $2000  { Browsing for Printers };
  650.  
  651. { message from browser }
  652.  
  653.   BFFM_INITIALIZED       = 1;
  654.   BFFM_SELCHANGED        = 2;
  655.  
  656. { messages to browser }
  657.  
  658.   BFFM_SETSTATUSTEXT      = (WM_USER + 100);
  659.   BFFM_ENABLEOK           = (WM_USER + 101);
  660.   BFFM_SETSELECTION       = (WM_USER + 102);
  661.  
  662. function SHBrowseForFolder(var lpbi: TBrowseInfo): PItemIDList; stdcall;
  663.  
  664. { SHLoadInProc }
  665.  
  666. { When this function is called, the shell calls CoCreateInstance
  667.   (or equivalent) with CLSCTX_INPROC_SERVER and the specified CLSID
  668.   from within the shell's process and release it immediately. }
  669.  
  670. function SHLoadInProc(rclsid: TCLSID): HRESULT; stdcall;
  671.  
  672. { IEnumIDList interface }
  673.  
  674. { IShellFolder.EnumObjects member returns an IEnumIDList object. }
  675.  
  676. type
  677.   IEnumIDList = class(IUnknown)
  678.     function Next(celt: ULONG; var rgelt: PItemIDList;
  679.       var pceltFetched: ULONG): HResult; virtual; stdcall; abstract;
  680.     function Skip(celt: ULONG): HResult; virtual; stdcall; abstract;
  681.     function Reset: HResult; virtual; stdcall; abstract;
  682.     function Clone(var ppenum: IEnumIDList): HResult; virtual; stdcall; abstract;
  683.   end;
  684.  
  685. { IShellFolder interface }
  686.  
  687. { [Member functions] }
  688.  
  689. { IShellFolder.BindToObject(pidl, pbc, riid, ppvOut)
  690.   This function returns an instance of a sub-folder which is specified
  691.   by the IDList (pidl).
  692.  IShellFolder.BindToStorage(pidl, pbc, riid, ppvObj)
  693.    This function returns a storage instance of a sub-folder which is
  694.    specified by the IDList (pidl). The shell never calls this member
  695.    function in the first release of Win95.
  696.  IShellFolder.CompareIDs(lParam, pidl1, pidl2)
  697.    This function compares two IDLists and returns the result. The shell
  698.    explorer always passes 0 as lParam, which indicates 'sort by name'.
  699.    It should return 0 (as CODE of the scode), if two id indicates the
  700.    same object; negative value if pidl1 should be placed before pidl2;
  701.    positive value if pidl2 should be placed before pidl1.
  702.  IShellFolder.CreateViewObject(hwndOwner, riid, ppvOut)
  703.    This function creates a view object of the folder itself. The view
  704.    object is a difference instance from the shell folder object.
  705.  IShellFolder.GetAttributesOf(cidl, apidl, prgfInOut)
  706.    This function returns the attributes of specified objects in that
  707.    folder. 'cidl' and 'apidl' specifies objects. 'apidl' contains only
  708.    simple IDLists. The explorer initializes *prgfInOut with a set of
  709.    flags to be evaluated. The shell folder may optimize the operation
  710.    by not returning unspecified flags.
  711.  IShellFolder.GetUIObjectOf(hwndOwner, cidl, apidl, riid, prgfInOut, ppvOut)
  712.    This function creates a UI object to be used for specified objects.
  713.    The shell explorer passes either IID_IDataObject (for transfer operation)
  714.    or IID_IContextMenu (for context menu operation) as riid.
  715.  IShellFolder.GetDisplayNameOf
  716.    This function returns the display name of the specified object.
  717.    If the ID contains the display name (in the locale character set),
  718.    it returns the offset to the name. Otherwise, it returns a pointer
  719.    to the display name string (UNICODE), which is allocated by the
  720.    task allocator, or fills in a buffer.
  721.  IShellFolder.SetNameOf
  722.    This function sets the display name of the specified object.
  723.    If it changes the ID as well, it returns the new ID which is
  724.    alocated by the task allocator. }
  725.  
  726. const
  727. { IShellFolder.GetDisplayNameOf/SetNameOf uFlags }
  728.  
  729.   SHGDN_NORMAL     = 0;        { default (display purpose) }
  730.   SHGDN_INFOLDER   = 1;        { displayed under a folder (relative) }
  731.   SHGDN_FORPARSING = $8000;    { for ParseDisplayName or path }
  732.  
  733. { IShellFolder.EnumObjects }
  734.  
  735.   SHCONTF_FOLDERS         = 32;       { for shell browser }
  736.   SHCONTF_NONFOLDERS      = 64;       { for default view }
  737.   SHCONTF_INCLUDEHIDDEN   = 128;      { for hidden/system objects }
  738.  
  739. { IShellFolder.GetAttributesOf flags }
  740.  
  741.   SFGAO_CANCOPY           = DROPEFFECT_COPY; { Objects can be copied }
  742.   SFGAO_CANMOVE           = DROPEFFECT_MOVE; { Objects can be moved }
  743.   SFGAO_CANLINK           = DROPEFFECT_LINK; { Objects can be linked }
  744.   SFGAO_CANRENAME         = $00000010;       { Objects can be renamed }
  745.   SFGAO_CANDELETE         = $00000020;       { Objects can be deleted }
  746.   SFGAO_HASPROPSHEET      = $00000040;       { Objects have property sheets }
  747.   SFGAO_DROPTARGET        = $00000100;       { Objects are drop target }
  748.   SFGAO_CAPABILITYMASK    = $00000177;      
  749.   SFGAO_LINK              = $00010000;       { Shortcut (link) }
  750.   SFGAO_SHARE             = $00020000;       { shared }
  751.   SFGAO_READONLY          = $00040000;       { read-only }
  752.   SFGAO_GHOSTED           = $00080000;       { ghosted icon }
  753.   SFGAO_DISPLAYATTRMASK   = $000F0000;      
  754.   SFGAO_FILESYSANCESTOR   = $10000000;       { It contains file system folder }
  755.   SFGAO_FOLDER            = $20000000;       { It's a folder. }
  756.   SFGAO_FILESYSTEM        = $40000000;       { is a file system thing (file/folder/root) }
  757.   SFGAO_HASSUBFOLDER      = $80000000;       { Expandable in the map pane }
  758.   SFGAO_CONTENTSMASK      = $80000000;      
  759.   SFGAO_VALIDATE          = $01000000;       { invalidate cached information }
  760.   SFGAO_REMOVABLE         = $02000000;       { is this removeable media? }
  761.  
  762. type
  763.   IShellFolder = class(IUnknown)
  764.     function ParseDisplayName(hwndOwner: HWND;
  765.       pbcReserved: Pointer; lpszDisplayName: POLESTR; var pchEaten: ULONG; 
  766.       var ppidl: PItemIDList; var dwAttributes: ULONG): HResult; virtual; stdcall; abstract;
  767.     function EnumObjects(hwndOwner: HWND; grfFlags: DWORD;
  768.       var EnumIDList: IEnumIDList): HResult; virtual; stdcall; abstract;
  769.     function BindToObject(pidl: PItemIDList; pbcReserved: Pointer;
  770.       const riid: TIID; var ppvOut: Pointer): HResult; virtual; stdcall; abstract;
  771.     function BindToStorage(pidl: PItemIDList; pbcReserved: Pointer;
  772.       riid: TIID; var ppvObj: Pointer): HResult; virtual; stdcall; abstract;
  773.     function CompareIDs(lParam: LPARAM;
  774.       pidl1, pidl2: PItemIDList): HResult; virtual; stdcall; abstract;
  775.     function CreateViewObject(hwndOwner: HWND; riid: TIID;
  776.       var ppvOut: Pointer): HResult; virtual; stdcall; abstract;
  777.     function GetAttributesOf(cidl: UINT; var apidl: PItemIDList;
  778.       var rgfInOut: UINT): HResult; virtual; stdcall; abstract;
  779.     function GetUIObjectOf(hwndOwner: HWND; cidl: UINT; var apidl: PItemIDList;
  780.       riid: TIID; var  prgfInOut: UINT; var ppvOut: Pointer): HResult; virtual; stdcall; abstract;
  781.     function GetDisplayNameOf(pidl: PItemIDList; uFlags: DWORD;
  782.       var lpName: TStrRet): HResult; virtual; stdcall; abstract;
  783.     function SetNameOf(hwndOwner: HWND; pidl: PItemIDList; lpszName: POLEStr; 
  784.       uFlags: DWORD; var ppidlOut: PItemIDList): HResult; virtual; stdcall; abstract;
  785.   end;
  786.  
  787. { Helper function which returns a IShellFolder interface to the desktop
  788.   folder. This is equivalent to call CoCreateInstance with CLSID_ShellDesktop. }
  789.  
  790. function SHGetDesktopFolder(var ppshf: IShellFolder): HResult; stdcall;
  791.  
  792. const
  793. { Clipboard format which may be supported by IDataObject from system
  794.   defined shell folders (such as directories, network, ...). }
  795.   
  796.   CFSTR_SHELLIDLIST       = 'Shell IDList Array';    { CF_IDLIST }
  797.   CFSTR_SHELLIDLISTOFFSET = 'Shell Object Offsets';  { CF_OBJECTPOSITIONS }
  798.   CFSTR_NETRESOURCES      = 'Net Resource';          { CF_NETRESOURCE }
  799.   CFSTR_FILEDESCRIPTOR    = 'FileGroupDescriptor';   { CF_FILEGROUPDESCRIPTOR }
  800.   CFSTR_FILECONTENTS      = 'FileContents';          { CF_FILECONTENTS }
  801.   CFSTR_FILENAME          = 'FileName';              { CF_FILENAME }
  802.   CFSTR_PRINTERGROUP      = 'PrinterFriendlyName';   { CF_PRINTERS }
  803.   CFSTR_FILENAMEMAP       = 'FileNameMap';           { CF_FILENAMEMAP }
  804.  
  805. { CF_OBJECTPOSITIONS }
  806.  
  807.   DVASPECT_SHORTNAME     = 2; { use for CF_HDROP to get short name version }
  808.  
  809. type
  810. { format of CF_NETRESOURCE }
  811.  
  812.   PNResArray = ^TNResArray;
  813.   TNResArray = packed record { anr }
  814.     cItems: UINT;
  815.     nr: array[0..0] of TNetResource;
  816.   end;
  817.  
  818. { format of CF_IDLIST }
  819.  
  820.   PIDA = ^TIDA;
  821.   TIDA = packed record
  822.     cidl: UINT;                      { number of relative IDList }
  823.     aoffset: array[0..0] of UINT;    { [0]: folder IDList, [1]-[cidl]: item IDList }
  824.   end;
  825.  
  826. const
  827. { FILEDESCRIPTOR.dwFlags field indicate which fields are to be used }
  828.  
  829.     FD_CLSID            = $0001;
  830.     FD_SIZEPOINT        = $0002;
  831.     FD_ATTRIBUTES       = $0004;
  832.     FD_CREATETIME       = $0008;
  833.     FD_ACCESSTIME       = $0010;
  834.     FD_WRITESTIME       = $0020;
  835.     FD_FILESIZE         = $0040;
  836.     FD_LINKUI           = $8000;       { 'link' UI is prefered }
  837.  
  838. type
  839.   PFileDescriptor = ^TFileDescriptor;
  840.   TFileDescriptor = packed record { fod }
  841.     dwFlags: DWORD;
  842.     clsid: TCLSID;
  843.     sizel: TSize;
  844.     pointl: TPoint;
  845.     dwFileAttributes: DWORD;
  846.     ftCreationTime: TFileTime;
  847.     ftLastAccessTime: TFileTime;
  848.     ftLastWriteTime: TFileTime;
  849.     nFileSizeHigh: DWORD;
  850.     nFileSizeLow: DWORD;
  851.     cFileName: array[0..MAX_PATH-1] of Char;
  852.   end;
  853.  
  854. { format of CF_FILEGROUPDESCRIPTOR }
  855.  
  856.   PFileGroupDescriptor = ^TFileGroupDescriptor;
  857.   TFileGroupDescriptor = packed record { fgd }
  858.     cItems: UINT;
  859.     fgd: array[0..0] of TFileDescriptor;
  860.   end;
  861.  
  862. { format of CF_HDROP and CF_PRINTERS, in the HDROP case the data that follows
  863.   is a double null terinated list of file names, for printers they are printer
  864.   friendly names }
  865.  
  866.   PDropFiles = ^TDropFiles;
  867.   TDropFiles = packed record
  868.     pFiles: DWORD;                       { offset of file list }
  869.     pt: TPoint;                          { drop point (client coords) }
  870.     fNC: BOOL;                           { is it on NonClient area }
  871.                                          { and pt is in screen coords }
  872.     fWide: BOOL;                         { WIDE character switch }
  873.   end;
  874.  
  875. { File System Notification APIs }
  876.  
  877. const
  878. { File System Notification flags }
  879.  
  880.   SHCNE_RENAMEITEM          = $00000001;
  881.   SHCNE_CREATE              = $00000002;
  882.   SHCNE_DELETE              = $00000004;
  883.   SHCNE_MKDIR               = $00000008;
  884.   SHCNE_RMDIR               = $00000010;
  885.   SHCNE_MEDIAINSERTED       = $00000020;
  886.   SHCNE_MEDIAREMOVED        = $00000040;
  887.   SHCNE_DRIVEREMOVED        = $00000080;
  888.   SHCNE_DRIVEADD            = $00000100;
  889.   SHCNE_NETSHARE            = $00000200;
  890.   SHCNE_NETUNSHARE          = $00000400;
  891.   SHCNE_ATTRIBUTES          = $00000800;
  892.   SHCNE_UPDATEDIR           = $00001000;
  893.   SHCNE_UPDATEITEM          = $00002000;
  894.   SHCNE_SERVERDISCONNECT    = $00004000;
  895.   SHCNE_UPDATEIMAGE         = $00008000;
  896.   SHCNE_DRIVEADDGUI         = $00010000;
  897.   SHCNE_RENAMEFOLDER        = $00020000;
  898.   SHCNE_FREESPACE           = $00040000;
  899.  
  900.   SHCNE_ASSOCCHANGED        = $08000000;
  901.  
  902.   SHCNE_DISKEVENTS          = $0002381F;
  903.   SHCNE_GLOBALEVENTS        = $0C0581E0; { Events that dont match pidls first }
  904.   SHCNE_ALLEVENTS           = $7FFFFFFF;
  905.   SHCNE_INTERRUPT           = $80000000; { The presence of this flag indicates }
  906.                                          { that the event was generated by an }
  907.                                          { interrupt.  It is stripped out before }
  908.                                          { the clients of SHCNNotify_ see it. }
  909.  
  910. { uFlags & SHCNF_TYPE is an ID which indicates what dwItem1 and dwItem2 mean }
  911.  
  912.   SHCNF_IDLIST      = $0000;        { PItemIDList }
  913.   SHCNF_PATH        = $0001;        { path name }
  914.   SHCNF_PRINTER     = $0002;        { printer friendly name }
  915.   SHCNF_DWORD       = $0003;        { DWORD }
  916.   SHCNF_TYPE        = $00FF;
  917.   SHCNF_FLUSH       = $1000;
  918.   SHCNF_FLUSHNOWAIT = $2000;
  919.  
  920. { APIs }
  921.  
  922. procedure SHChangeNotify(wEventId: Longint; uFlags: UINT;
  923.   dwItem1, dwItem2: Pointer); stdcall;
  924. procedure SHAddToRecentDocs(uFlags: UINT; pv: Pointer); stdcall;
  925. function SHGetInstanceExplorer(var ppUnk: IUnknown): HResult; stdcall;
  926.  
  927. { SHAddToRecentDocs }
  928.  
  929. const
  930.   SHARD_PIDL      = $00000001;
  931.   SHARD_PATH      = $00000002;
  932.  
  933. implementation
  934.  
  935. const 
  936.   shell32 = 'shell32.dll';
  937.  
  938. function SHGetMalloc; external shell32 name 'SHGetMalloc';
  939. function SHGetPathFromIDList; external shell32 name 'SHGetPathFromIDList';
  940. function SHGetSpecialFolderLocation; external shell32 name 'SHGetSpecialFolderLocation';
  941. function SHBrowseForFolder; external shell32 name 'SHBrowseForFolder';
  942. function SHLoadInProc; external shell32 name 'SHLoadInProc';
  943. function SHGetDesktopFolder; external shell32 name 'SHGetDesktopFolder';
  944. procedure SHChangeNotify; external shell32 name 'SHChangeNotify';
  945. procedure SHAddToRecentDocs; external shell32 name 'SHAddToRecentDocs';
  946. function SHGetInstanceExplorer;  external shell32 name 'SHGetInstanceExplorer';
  947.  
  948. { !!! function SHGetMalloc(var ppMalloc: IMalloc): HResult;
  949. begin
  950.   Result := CoGetMalloc(MEMCTX_TASK, ppMalloc);
  951. end; }
  952.  
  953. end.
  954.  
  955.