Unit ShellOBJ;

interface

uses
  Windows,
  Messages,
  OLE2,
  COMMCTRL,
  ShellAPI{,
  REGSTR};


{=========================================================================== }
{ Object identifiers in the explorer's name space (ItemID and IDList) }
{  All the items that the user can browse with the explorer (such as files, }
{ directories, servers, work-groups, etc.) has an identifier which is unique }
{ among items within the parent folder. Those identifiers are called item }
{ IDs (SHITEMID). Since all its parent folders have their own item IDs, }
{ any items can be uniquely identified by a list of item IDs, which is called }
{ an ID list (ITEMIDLIST). }

{  ID lists are almost always allocated by the task allocator (see some }
{ description below as well as OLE 2.0 SDK) and may be passed across }
{ some of shell interfaces (such as IShellFolder). Each item ID in an ID list }
{ is only meaningful to its parent folder (which has generated it), and all }
{ the clients must treat it as an opaque binary data except the first two }
{ bytes, which indicates the size of the item ID. }

{  When a shell extension -- which implements the IShellFolder interace -- }
{ generates an item ID, it may put any information in it, not only the data }
{ with that it needs to identifies the item, but also some additional }
{ information, which would help implementing some other functions efficiently. }
{ For example, the shell's IShellFolder implementation of file system items }
{ stores the primary (long) name of a file or a directory as the item }
{ identifier, but it also stores its alternative (short) name, size and date }
{ etc. }

{  When an ID list is passed to one of shell APIs (such as SHGetPathFromIDList), }
{ it is always an absolute path -- relative from the root of the name space, }
{ which is the desktop folder. When an ID list is passed to one of IShellFolder }
{ member function, it is always a relative path from the folder (unless it }
{ is explicitly specified). }

const
 CLSID_ShellDesktop: TGUID = (
       D1:$00021400; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 CLSID_ShellLink: TGUID = (
       D1:$00021401; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));

 IID_IContextMenu : TGUID = (
       D1:$000214E4; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 IID_IShellFolder : TGUID = (
       D1:$000214E6; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 IID_IShellExtInit : TGUID = (
       D1:$000214E8; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 IID_IShellPropSheetExt : TGUID = (
       D1:$000214E9; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 IID_IExtractIcon : TGUID = (
       D1:$000214EB; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 IID_IShellLink : TGUID = (
       D1:$000214EE; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 IID_IShellCopyHook : TGUID = (
       D1:$000214EF; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 IID_IFileViewer : TGUID = (
       D1:$000214F0; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 IID_IEnumIDList : TGUID = (
       D1:$000214F2; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));
 IID_IFileViewerSite : TGUID = (
       D1:$000214F3; D2:$0000; D3:$0000; D4:($C0,$00,$00,$00,$00,$00,$00,$46));

{ SHITEMID -- Item ID }
type
  PSHItemID = ^TSHItemID;
  TSHItemID = record        { mkid }
    cb:word;             { Size of the ID (including cb itself) }
    abID:array[0..0] of BYTE;        { The item ID (variable length) }
    end;

{ ITEMIDLIST -- List if item IDs (combined with 0-terminator) }
  PItemIDList = ^TItemIDList;
  TItemIDList = record { idl }
     mkid: TSHITEMID;
     end;

{=========================================================================== }
{ Task allocator API }
{  All the shell extensions MUST use the task allocator (see OLE 2.0 }
{ programming guild for its definition) when they allocate or free }
{ memory objects (mostly ITEMIDLIST) that are returned across any }
{ shell interfaces. There are two ways to access the task allocator }
{ from a shell extension depending on whether or not it is linked with }
{ OLE32.DLL or not (virtual; stdcall; abstractly for efficiency). }

{ (1) A shell extension which calls any OLE API (i.e., linked with }
{  OLE32.DLL) should call OLE's task allocator (by retrieving }
{  the task allocator by calling CoGetMalloc API). }

{ (2) A shell extension which does not call any OLE API (i.e., not linked }
{  with OLE32.DLL) should call the shell task allocator API (defined }
{  below), so that the shell can quickly loads it when OLE32.DLL is not }
{  loaded by any application at that point. }

{ Notes: }
{  In next version of Windowso release, SHGetMalloc will be replaced by }
{ the following macro. }

{ #define SHGetMalloc(ppmem)   CoGetMalloc(MEMCTX_TASK, ppmem) }

{=========================================================================== }


function SHGetMalloc(var ppMalloc: IMALLOC):HResult;


{=========================================================================== }
{ IContextMenu interface }
{ [OverView] }
{  The shell uses the IContextMenu interface in following three cases. }

{ case-1: The shell is loading context menu extensions. }
{   When the user clicks the right mouse button on an item within the shell's }
{  name space (i.g., file, directory, server, work-group, etc.), it creates }
{  the default context menu for its type, then loads context menu extensions }
{  that are registered for that type (and its base type) so that they can }
{  add extra menu items. Those context menu extensions are registered at }
{  HKCR\beginProgIDend\shellex\ContextMenuHandlers. }

{ case-2: The shell is retrieving a context menu of sub-folders in extended }
{   name-space. }
{   When the explorer's name space is extended by name space extensions, }
{  the shell calls their IShellFolder::GetUIObjectOf to get the IContextMenu }
{  objects when it creates context menus for folders under those extended }
{  name spaces. }

{ case-3: The shell is loading non-default drag and drop handler for directories. }
{   When the user performed a non-default drag and drop onto one of file }
{  system folders (i.e., directories), it loads shell extensions that are }
{  registered at HKCR\beginProgIDend\DragDropHandlers. }

{ [Member functions] }

{ IContextMenu::QueryContextMenu }
{  This member function may insert one or more menuitems to the specified }
{  menu (hmenu) at the specified location (indexMenu which is never be -1). }
{  The IDs of those menuitem must be in the specified range (idCmdFirst and }
{  idCmdLast). It returns the maximum menuitem ID offset (ushort) in the }
{  'code' field (low word) of the scode. }

{  The uFlags specify the context. It may have one or more of following }
{  flags. }

{  CMF_DEFAULTONLY: This flag is passed if the user is invoking the default }
{  action (typically by double-clicking, case 1 and 2 only). Context menu }
{  extensions (case 1) should not add any menu items, and returns NOERROR. }

{  CMF_VERBSONLY: The explorer passes this flag if it is constructing }
{  a context menu for a short-cut object (case 1 and case 2 only). If this }
{  flag is passed, it should not add any menu-items that is not appropriate }
{  from a short-cut. }
{  A good example is the 'Delete' menuitem, which confuses the user }
{  because it is not clear whether it deletes the link source item or the }
{  link itself. }

{  CMF_EXPLORER: The explorer passes this flag if it has the left-side pane }
{   (case 1 and 2 only). Context menu extensions should ignore this flag. }

{  High word (16-bit) are reserved for context specific communications }
{  and the rest of flags (13-bit) are reserved by the system. }


{ IContextMenu::InvokeCommand }

{   This member is called when the user has selected one of menuitems that }
{  are inserted by previous QueryContextMenu member. In this case, the }
{  LOWORD(lpici->lpVerb) contains the menuitem ID offset (menuitem ID - }
{  idCmdFirst). }

{   This member function may also be called programmatically. In such a case, }
{  lpici->lpVerb specifies the canonical name of the command to be invoked, }
{  which is typically retrieved by GetCommandString member previously. }

{  Parameters in lpci: }
{    cbSize -- Specifies the size of this structure (sizeof(*lpci)) }
{    hwnd   -- Specifies the owner window for any message/dialog box. }
{    fMask  -- Specifies whether or not dwHotkey/hIcon paramter is valid. }
{    lpVerb -- Specifies the command to be invoked. }
{    lpParameters -- Parameters (optional) }
{    lpDirectory  -- Working directory (optional) }
{    nShow -- Specifies the flag to be passed to ShowWindow (SW_*). }
{    dwHotKey -- Hot key to be assigned to the app after invoked (optional). }
{    hIcon -- Specifies the icon (optional). }


{ IContextMenu::GetCommandString }

{   This member function is called by the explorer either to get the }
{  canonical (language independent) command name (uFlags == GCS_VERB) or }
{  the help text ((uFlags & GCS_HELPTEXT) != 0) for the specified command. }
{  The retrieved canonical string may be passed to its InvokeCommand }
{  member function to invoke a command programmatically. The explorer }
{  displays the help texts in its status bar; therefore, the length of }
{  the help text should be reasonably short (<40 characters). }

{  Parameters: }
{   idCmd -- Specifies menuitem ID offset (from idCmdFirst) }
{   uFlags -- Either GCS_VERB or GCS_HELPTEXT }
{   pwReserved -- Reserved (must pass NULL when calling, must ignore when called) }
{   pszName -- Specifies the string buffer. }
{   cchMax -- Specifies the size of the string buffer. }

{=========================================================================== }

const
   { QueryContextMenu uFlags }
   CMF_NORMAL             = $00000000;
   CMF_DEFAULTONLY        = $00000001;
   CMF_VERBSONLY          = $00000002;
   CMF_EXPLORE            = $00000004;
   CMF_RESERVED           = $ffff0000      { View specific };

   { GetCommandString uFlags }
   GCS_VERB         =$00000000     { canonical verb };
   GCS_HELPTEXT     =$00000001     { help text (for status bar) };
   GCS_VALIDATE     =$00000002     { validate command exists };

   CMDSTR_NEWFOLDER    = 'NewFolder';
   CMDSTR_VIEWLIST     = 'ViewList';
   CMDSTR_VIEWDETAILS  = 'ViewDetails';

   CMIC_MASK_HOTKEY       = SEE_MASK_HOTKEY;
   CMIC_MASK_ICON         = SEE_MASK_ICON;
   CMIC_MASK_FLAG_NO_UI   = SEE_MASK_FLAG_NO_UI;
   CMIC_MASK_MODAL         =$80000000        (* ; Internal *);

  (*!! CMIC_VALID_SEE_FLAGS   = SEE_VALID_CMIC_FLAGS;   (* ; Internal *)


type
  PCMInvokeCommandInfo = ^TCMInvokeCommandInfo;
  TCMInvokeCommandInfo = record
     cbSize:DWORD;        { must be sizeof(CMINVOKECOMMANDINFO) }
     fMask:DWORD;         { any combination of CMIC_MASK_* }
     hwnd:HWND;           { might be NULL (indicating no owner window) }
     lpVerb:LPCSTR;       { either a string of MAKEINTRESOURCE(idOffset) }
     lpParameters:LPCSTR; { might be NULL (indicating no parameter) }
     lpDirectory:LPCSTR;  { might be NULL (indicating no specific directory) }
     nShow:integer;           { one of SW_ values for ShowWindow() API }

     dwHotKey:DWORD;
     hIcon:THANDLE;
     end;

  IContextMenu = class(IUnknown)
    function QueryContextMenu(Menu:HMENU; indexMenu:UINT;
                              idCmdFirst:UINT;idCmdLast:UINT;
                              uFlags:UINT):HResult; virtual; stdcall; abstract;

    function InvokeCommand(lpici: PCMINVOKECOMMANDINFO): HResult; virtual; stdcall; abstract;

    function GetCommandString(idCmd:UINT; uType:UINT; var pwReserved:UINT;
                              pszName:LPSTR; cchMax:UINT):HResult; virtual; stdcall; abstract;
    end;

{=========================================================================== }

{ Interface: IShellExtInit }

{  The IShellExtInit interface is used by the explorer to initialize shell }
{ extension objects. The explorer (1) calls CoCreateInstance (or equivalent) }
{ with the registered CLSID and IID_IShellExtInit, (2) calls its Initialize }
{ member, then (3) calls its QueryInterface to a particular interface (such }
{ as IContextMenu or IPropSheetExt and (4) performs the rest of operation. }


{ [Member functions] }

{ IShellExtInit::Initialize }

{  This member function is called when the explorer is initializing either }
{ context menu extension, property sheet extension or non-default drag-drop }
{ extension. }

{  Parameters: (context menu or property sheet extension) }
{   pidlFolder -- Specifies the parent folder }
{   lpdobj -- Spefifies the set of items selected in that folder. }
{   hkeyProgID -- Specifies the type of the focused item in the selection. }

{  Parameters: (non-default drag-and-drop extension) }
{   pidlFolder -- Specifies the target (destination) folder }
{   lpdobj -- Specifies the items that are dropped (see the description }
{    about shell's clipboard below for clipboard formats). }
{   hkeyProgID -- Specifies the folder type. }

{=========================================================================== }

type
    IShellExtInit = class(IUnknown)
      function Initialize(pidlFolder:PItemIDList;
                          lpdobj: IDataObject;
                          hKeyProgID:HKEY):HResult; virtual; stdcall; abstract;
    end;

{=========================================================================== }

{ Interface: IShellPropSheetExt }

{  The explorer uses the IShellPropSheetExt to allow property sheet }
{ extensions or control panel extensions to add additional property }
{ sheet pages. }


{ [Member functions] }

{ IShellPropSheetExt::AddPages }

{  The explorer calls this member function when it finds a registered }
{ property sheet extension for a particular type of object. For each }
{ additional page, the extension creates a page object by calling }
{ CreatePropertySheetPage API and calls lpfnAddPage. }

{  Parameters: }
{   lpfnAddPage -- Specifies the callback function. }
{   lParam -- Specifies the opaque handle to be passed to the callback function. }


{ IShellPropSheetExt::ReplacePage }

{  The explorer never calls this member of property sheet extensions. The }
{ explorer calls this member of control panel extensions, so that they }
{ can replace some of default control panel pages (such as a page of }
{ mouse control panel). }

{  Parameters: }
{   uPageID -- Specifies the page to be replaced. }
{   lpfnReplace Specifies the callback function. }
{   lParam -- Specifies the opaque handle to be passed to the callback function. }

{=========================================================================== }

type
 IShellPropSheetExt = class(IUnknown)
    function AddPages(lpfnAddPage: TFNADDPROPSHEETPAGE; lParam:LPARAM):HResult; virtual; stdcall; abstract;
    function ReplacePage(uPageID:UINT;
                         lpfnReplaceWith:TFNADDPROPSHEETPAGE;
                          lParam:LPARAM):HResult; virtual; stdcall; abstract;
    end;

{=========================================================================== }

{ IExtractIcon interface }

{  This interface is used in two different places in the shell. }

{ Case-1: Icons of sub-folders for the scope-pane of the explorer. }

{  It is used by the explorer to get the 'icon location' of }
{ sub-folders from each shell folders. When the user expands a folder }
{ in the scope pane of the explorer, the explorer does following: }
{  (1) binds to the folder (gets IShellFolder), }
{  (2) enumerates its sub-folders by calling its EnumObjects member, }
{  (3) calls its GetUIObjectOf member to get IExtractIcon interface }
{     for each sub-folders. }
{  In this case, the explorer uses only IExtractIcon::GetIconLocation }
{ member to get the location of the appropriate icon. An icon location }
{ always consists of a file name (typically DLL or EXE) and either an icon }
{ resource or an icon index. }


{ Case-2: Extracting an icon image from a file }

{  It is used by the shell when it extracts an icon image }
{ from a file. When the shell is extracting an icon from a file, }
{ it does following: }
{  (1) creates the icon extraction handler object (by getting its CLSID }
{     under the beginProgIDend\shell\ExtractIconHanler key and calling }
{     CoCreateInstance requesting for IExtractIcon interface). }
{  (2) Calls IExtractIcon::GetIconLocation. }
{  (3) Then, calls IExtractIcon::Extract with the location/index pair. }
{  (4) If (3) returns NOERROR, it uses the returned icon. }
{  (5) Otherwise, it recursively calls this logic with new location }
{     assuming that the location string contains a fully qualified path name. }

{  From extension programmer's point of view, there are only two cases }
{ where they provide implementations of IExtractIcon: }
{  Case-1) providing explorer extensions (i.e., IShellFolder). }
{  Case-2) providing per-instance icons for some types of files. }

{ Because Case-1 is described above, we'll explain only Case-2 here. }

{ When the shell is about display an icon for a file, it does following: }
{  (1) Finds its ProgID and ClassID. }
{  (2) If the file has a ClassID, it gets the icon location string from the }
{    'DefaultIcon' key under it. The string indicates either per-class }
{    icon (e.g., 'FOOBAR.DLL,2') or per-instance icon (e.g., '%1,1'). }
{  (3) If a per-instance icon is specified, the shell creates an icon }
{    extraction handler object for it, and extracts the icon from it }
{    (which is described above). }

{  It is important to note that the shell calls IExtractIcon::GetIconLocation }
{ first, then calls IExtractIcon::Extract. Most application programs }
{ that support per-instance icons will probably store an icon location }
{ (DLL/EXE name and index/id) rather than an icon image in each file. }
{ In those cases, a programmer needs to implement only the GetIconLocation }
{ member and it Extract member simply returns S_FALSE. They need to }
{ implement Extract member only if they decided to store the icon images }
{ within files themselved or some other database (which is very rare). }



{ [Member functions] }


{ IExtractIcon::GetIconLocation }

{  This function returns an icon location. }

{  Parameters: }
{   uFlags     [in]  -- Specifies if it is opened or not (GIL_OPENICON or 0) }
{   szIconFile [out] -- Specifies the string buffer buffer for a location name. }
{   cchMax     [in]  -- Specifies the size of szIconFile (almost always MAX_PATH) }
{   piIndex    [out] -- Sepcifies the address of UINT for the index. }
{   pwFlags    [out] -- Returns GIL_* flags }
{  Returns: }
{   NOERROR, if it returns a valid location; S_FALSE, if the shell use a }
{   default icon. }

{  Notes: The location may or may not be a path to a file. The caller can }
{   not assume anything unless the subsequent Extract member call returns }
{   S_FALSE. }

{   if the returned location is not a path to a file, GIL_NOTFILENAME should }
{   be set in the returned flags. }

{ IExtractIcon::Extract }

{  This function extracts an icon image from a specified file. }

{  Parameters: }
{   pszFile [in] -- Specifies the icon location (typically a path to a file). }
{   nIconIndex [in] -- Specifies the icon index. }
{   phiconLarge [out] -- Specifies the HICON variable for large icon. }
{   phiconSmall [out] -- Specifies the HICON variable for small icon. }
{   nIconSize [in] -- Specifies the size icon required (size of large icon) }
{                     LOWORD is the requested large icon size }
{                     HIWORD is the requested small icon size }
{  Returns: }
{   NOERROR, if it extracted the from the file. }
{   S_FALSE, if the caller should extract from the file specified in the }
{           location. }

{=========================================================================== }

{ GetIconLocation() input flags }
const
  GIL_OPENICON     =$0001      { allows containers to specify an 'open' look };
  GIL_FORSHELL     =$0002      { icon is to be displayed in a ShellFolder };

  { GetIconLocation() return flags }

  GIL_SIMULATEDOC  =$0001      { simulate this document icon for this };
  GIL_PERINSTANCE  =$0002      { icons from this class are per instance (each file has its own) };
  GIL_PERCLASS     =$0004      { icons from this class per class (shared for all files of this type) };
  GIL_NOTFILENAME  =$0008      { location is not a filename, must call ::Extract };
  GIL_DONTCACHE    =$0010      { this icon should not be cached };

type
  IExtractIcon = class(IUnknown)      { exic }
    function GetIconLocation(uFlags:UINT; szIconFile:LPSTR; cchMax:UINT;
                           var piIndex:integer;
                           var pwFlags:UINT):HResult; virtual; stdcall; abstract;

    function Extract(pszFile:LPCSTR; nIconIndex:UINT; var phiconLarge:HICON;
                     var phiconSmall:HICON;
                     nIconSize:UINT):HResult; virtual; stdcall; abstract;
    end;


{=========================================================================== }

{ IShellLink Interface }

{=========================================================================== }
const
    { IShellLink::Resolve fFlags }
    SLR_NO_UI           = $0001;
    SLR_ANY_MATCH       = $0002;
    SLR_UPDATE          = $0004;

    { IShellLink::GetPath fFlags }
    SLGP_SHORTPATH      = $0001;
    SLGP_UNCPRIORITY    = $0002;

type
  IShellLink = class(IUnknown) { sl }
    function GetPath(pszFile:LPSTR; cchMaxPath:integer;
                     var pfd:TWin32FindData;
                     fFlags:DWORD):HResult; virtual; stdcall; abstract;

    function GetIDList(var ppidl:PITEMIDLIST):HResult; virtual; stdcall; abstract;
    function SetIDList(pidl:PITEMIDLIST):HResult; virtual; stdcall; abstract;

    function GetDescription(pszName:LPSTR; cchMaxName:integer):HResult; virtual; stdcall; abstract;
    function SetDescription(pszName:LPSTR):HResult; virtual; stdcall; abstract;

    function GetWorkingDirectory(pszDir:LPSTR; cchMaxPath:integer):HResult; virtual; stdcall; abstract;
    function SetWorkingDirectory(pszDir:LPSTR):HResult; virtual; stdcall; abstract;

    function GetArguments(pszArgs:LPSTR; cchMaxPath:integer):HResult; virtual; stdcall; abstract;
    function SetArguments(pszArgs:LPSTR):HResult; virtual; stdcall; abstract;

    function GetHotkey(var pwHotkey:word):HResult; virtual; stdcall; abstract;
    function SetHotkey(wHotkey:word):HResult; virtual; stdcall; abstract;

    function GetShowCmd(var piShowCmd:integer):HResult; virtual; stdcall; abstract;
    function SetShowCmd(iShowCmd:integer):HResult; virtual; stdcall; abstract;

    function GetIconLocation(pszIconPath:LPSTR; cchIconPath:integer;
                             var piIcon:integer):HResult; virtual; stdcall; abstract;
    function SetIconLocation(pszIconPath:LPSTR; iIcon:integer):HResult; virtual; stdcall; abstract;

    function SetRelativePath(pszPathRel:LPSTR; dwReserved:DWORD):HResult; virtual; stdcall; abstract;

    function Resolve(Wnd:HWND; fFlags: DWORD):HResult; virtual; stdcall; abstract;

    function SetPath(pszFile:LPSTR):HResult; virtual; stdcall; abstract;
end;

{=========================================================================== }
{ ICopyHook Interface }
{  The copy hook is called whenever file system directories are }
{  copy/moved/deleted/renamed via the shell.  It is also called by the shell }
{  on changes of status of printers. }
{  Clients register their id under STRREG_SHEX_COPYHOOK for file system hooks }
{  and STRREG_SHEx_PRNCOPYHOOK for printer hooks. }
{  the CopyCallback is called prior to the action, so the hook has the chance }
{  to allow, deny or cancel the operation by returning the falues: }
{     IDYES  -  means allow the operation }
{     IDNO   -  means disallow the operation on this file, but continue with }
{              any other operations (eg. batch copy) }
{     IDCANCEL - means disallow the current operation and cancel any pending }
{              operations }
{   arguments to the CopyCallback }
{      hwnd - window to use for any UI }
{      wFunc - what operation is being done }
{      wFlags - and flags (FOF_*) set in the initial call to the file operation }
{      pszSrcFile - name of the source file }
{      dwSrcAttribs - file attributes of the source file }
{      pszDestFile - name of the destiation file (for move and renames) }
{      dwDestAttribs - file attributes of the destination file }
{=========================================================================== }

type
  ICopyHook = class(IUnknown) { sl }
    function CopyCallback(Wnd:HWND;wFunc:UINT; wFlags:UINT;
                          pszSrcFile:LPSTR; dwSrcAttribs:DWORD;
                          pszDestFile:LPSTR; dwDestAttribs:DWORD):UINT; virtual; stdcall; abstract;
    end;

{=========================================================================== }

{ IFileViewerSite Interface }

{=========================================================================== }

type
  IFileViewerSite = class(IUnknown)
    function SetPinnedWindow(Wnd:HWND):HResult; virtual; stdcall; abstract;
    function GetPinnedWindow(var Wnd:HWND):HResult; virtual; stdcall; abstract;
    end;

{=========================================================================== }
{ IFileViewer Interface }
{ Implemented in a FileViewer component object.  Used to tell a }
{ FileViewer to PrintTo or to view, the latter happening though }
{ ShowInitialize and Show.  The filename is always given to the }
{ viewer through IPersistFile. }
{=========================================================================== }

type
  PFVShowInfo = ^TFVShowInfo;
  TFVShowInfo = record
    { Stuff passed into viewer (in) }
     cbSize:DWORD;           { Size of structure for future expansion... }
     hwndOwner:HWND;         { who is the owner window. }
     iShow:integer;              { The show command }
    { Passed in and updated  (in/Out) }
     dwFlags:DWORD;          { flags }
     rect:TRECT;              { Where to create the window may have defaults }
     punkRel:IUNKNOWN;       { Relese this interface when window is visible }
    { Stuff that might be returned from viewer (out) }
     strNewFile:array[0..MAX_PATH-1] of TOLECHAR;   { New File to view. }
    end;

   { Define File View Show Info Flags. }
const
   FVSIF_RECT      =$00000001      { The rect variable has valid data. };
   FVSIF_PINNED    =$00000002      { We should Initialize pinned };

   FVSIF_NEWFAILED =$08000000      { The new file passed back failed };
                                           { to be viewed. }

   FVSIF_NEWFILE   =$80000000      { A new file to view has been returned };
   FVSIF_CANVIEWIT =$40000000      { The viewer can view it. };

type
  IFileViewer = class(IUnknown)
    function ShowInitialize(fsi:IFILEVIEWERSITE):HResult; virtual; stdcall; abstract;
    function Show(pvsi:PFVSHOWINFO):HResult; virtual; stdcall; abstract;
    function PrintTo(pszDriver:LPSTR; fSuppressUI:BOOL):HResult; virtual; stdcall; abstract;
    end;

{------------------------------------------------------------------------- }
{ struct STRRET }
{ structure for returning strings from IShellFolder member functions }
{------------------------------------------------------------------------- }
const
  STRRET_WSTR     =$0000;
  STRRET_OFFSET   =$0001;
  STRRET_CSTR     =$0002;

type
  PSTRRet = ^TStrRet;
  TSTRRET = record
     uType:UINT; { One of the STRRET_* values }
     case integer of
       0:(pOleStr:LPWSTR);        { OLESTR that will be freed }
       1:(uOffset:UINT);        { Offset into SHITEMID (ANSI) }
       2:(cStr: array[0..MAX_PATH-1] of char); { Buffer to fill in }
    end;

{------------------------------------------------------------------------- }
{ SHGetPathFromIDList }
{  This function assumes the size of the buffer (MAX_PATH). The pidl }
{ should point to a file system object. }
{------------------------------------------------------------------------- }

function SHGetPathFromIDList(pidl:PITEMIDLIST; pszPath:LPSTR):BOOL; stdcall;

{------------------------------------------------------------------------- }
{ SHGetSpecialFolderLocation }
{  Caller should call SHFree to free the returned pidl. }
{------------------------------------------------------------------------- }

{ registry entries for special paths are kept in : }
const
  {REGSTR_PATH_SPECIAL_FOLDERS   = REGSTR_PATH_EXPLORER+'\Shell Folders';}
  CSIDL_DESKTOP            =$0000;
  CSIDL_PROGRAMS           =$0002;
  CSIDL_CONTROLS           =$0003;
  CSIDL_PRINTERS           =$0004;
  CSIDL_PERSONAL           =$0005;
  CSIDL_FAVORITES          =$0006;
  CSIDL_STARTUP            =$0007;
  CSIDL_RECENT             =$0008;
  CSIDL_SENDTO             =$0009;
  CSIDL_BITBUCKET          =$000a;
  CSIDL_STARTMENU          =$000b;
  CSIDL_DESKTOPDIRECTORY   =$0010;
  CSIDL_DRIVES             =$0011;
  CSIDL_NETWORK            =$0012;
  CSIDL_NETHOOD            =$0013;
  CSIDL_FONTS              =$0014;
  CSIDL_TEMPLATES          =$0015;

function SHGetSpecialFolderLocation(hwndOwner:HWND; nFolder:integer;
                                    var ppidl:PITEMIDLIST):HResult; stdcall;

{------------------------------------------------------------------------- }
{ SHBrowseForFolder API }
{------------------------------------------------------------------------- }

type
  BFFCALLBACK = function(Wnd:HWND;uMsg:UINT;lParam,lpData:LPARAM):integer stdcall;
  PBrowseInfo = ^TBrowseInfo;
  TBrowseInfo = record
     hwndOwner:HWND;
     pidlRoot:PITEMIDLIST;
     pszDisplayName:LPSTR;  { Return display name of item selected. }
     lpszTitle:LPCSTR;      { text to go in the banner over the tree. }
     ulFlags:UINT;          { Flags that control the return stuff }
     lpfn:BFFCALLBACK;
     lParam:LPARAM;         { extra info that's passed back in callbacks }
     iImage:integer;        { output var: where to return the Image index. }
     end;

const
{ Browsing for directory. }
   BIF_RETURNONLYFSDIRS   =$0001  { For finding a folder to start document searching };
   BIF_DONTGOBELOWDOMAIN  =$0002  { For starting the Find Computer };
   BIF_STATUSTEXT         =$0004;
   BIF_RETURNFSANCESTORS  =$0008;

   BIF_BROWSEFORCOMPUTER  =$1000  { Browsing for Computers. };
   BIF_BROWSEFORPRINTER   =$2000  { Browsing for Printers };

   { message from browser }
   BFFM_INITIALIZED       = 1;
   BFFM_SELCHANGED        = 2;

   { messages to browser }
   BFFM_SETSTATUSTEXT      =(WM_USER + 100);
   BFFM_ENABLEOK           =(WM_USER + 101);
   BFFM_SETSELECTION       =(WM_USER + 102);

function SHBrowseForFolder(lpbi:PBROWSEINFO):PItemIDList; stdcall;

{------------------------------------------------------------------------- }
{ SHLoadInProc }
{   When this function is called, the shell calls CoCreateInstance }
{  (or equivalent) with CLSCTX_INPROC_SERVER and the specified CLSID }
{  from within the shell's process and release it immediately. }
{------------------------------------------------------------------------- }

function SHLoadInProc(rclsid:TCLSID):HRESULT; stdcall;

{------------------------------------------------------------------------- }
{ IEnumIDList interface }
{  IShellFolder::EnumObjects member returns an IEnumIDList object. }
{------------------------------------------------------------------------- }

type
  IEnumIDList = class(IUnknown)
    function Next( celt:ULONG;
                   var rgelt: PITEMIDLIST;
                   var pceltFetched:ULONG):HResult; virtual; stdcall; abstract;
    function Skip(celt:ULONG):HResult; virtual; stdcall; abstract;
    function Reset:HResult; virtual; stdcall; abstract;
    function Clone(var ppenum:IEnumIDList):HResult; virtual; stdcall; abstract;
    end;

{------------------------------------------------------------------------- }
{ IShellFolder interface }
{ [Member functions] }
{ IShellFolder::BindToObject(pidl, pbc, riid, ppvOut) }
{   This function returns an instance of a sub-folder which is specified }
{   by the IDList (pidl). }
{ IShellFolder::BindToStorage(pidl, pbc, riid, ppvObj) }
{   This function returns a storage instance of a sub-folder which is }
{   specified by the IDList (pidl). The shell never calls this member }
{   function in the first release of Win95. }
{ IShellFolder::CompareIDs(lParam, pidl1, pidl2) }
{   This function compares two IDLists and returns the result. The shell }
{   explorer always passes 0 as lParam, which indicates 'sort by name'. }
{   It should return 0 (as CODE of the scode), if two id indicates the }
{   same object; negative value if pidl1 should be placed before pidl2; }
{   positive value if pidl2 should be placed before pidl1. }
{ IShellFolder::CreateViewObject(hwndOwner, riid, ppvOut) }
{   This function creates a view object of the folder itself. The view }
{   object is a difference instance from the shell folder object. }
{ IShellFolder::GetAttributesOf(cidl, apidl, prgfInOut) }
{   This function returns the attributes of specified objects in that }
{   folder. 'cidl' and 'apidl' specifies objects. 'apidl' contains only }
{   simple IDLists. The explorer initializes *prgfInOut with a set of }
{   flags to be evaluated. The shell folder may optimize the operation }
{   by not returning unspecified flags. }
{ IShellFolder::GetUIObjectOf(hwndOwner, cidl, apidl, riid, prgfInOut, ppvOut) }
{   This function creates a UI object to be used for specified objects. }
{   The shell explorer passes either IID_IDataObject (for transfer operation) }
{   or IID_IContextMenu (for context menu operation) as riid. }
{ IShellFolder::GetDisplayNameOf }
{   This function returns the display name of the specified object. }
{   If the ID contains the display name (in the locale character set), }
{   it returns the offset to the name. Otherwise, it returns a pointer }
{   to the display name string (UNICODE), which is allocated by the }
{   task allocator, or fills in a buffer. }
{ IShellFolder::SetNameOf }
{   This function sets the display name of the specified object. }
{   If it changes the ID as well, it returns the new ID which is }
{   alocated by the task allocator. }
{------------------------------------------------------------------------- }

const
  { IShellFolder::GetDisplayNameOf/SetNameOf uFlags }
  SHGDN_NORMAL     = 0;        { default (display purpose) }
  SHGDN_INFOLDER   = 1;        { displayed under a folder (relative) }
  SHGDN_FORPARSING = $8000;    { for ParseDisplayName or path }

  { IShellFolder::EnumObjects }
  SHCONTF_FOLDERS         = 32;       { for shell browser }
  SHCONTF_NONFOLDERS      = 64;       { for default view }
  SHCONTF_INCLUDEHIDDEN   = 128;      { for hidden/system objects }

  { IShellFolder::GetAttributesOf flags }
  SFGAO_CANCOPY          = DROPEFFECT_COPY { Objects can be copied };
  SFGAO_CANMOVE          = DROPEFFECT_MOVE { Objects can be moved };
  SFGAO_CANLINK          = DROPEFFECT_LINK { Objects can be linked };
  SFGAO_CANRENAME         =$00000010     { Objects can be renamed };
  SFGAO_CANDELETE         =$00000020     { Objects can be deleted };
  SFGAO_HASPROPSHEET      =$00000040     { Objects have property sheets };
  SFGAO_DROPTARGET        =$00000100     { Objects are drop target };
  SFGAO_CAPABILITYMASK    =$00000177;
  SFGAO_LINK              =$00010000     { Shortcut (link) };
  SFGAO_SHARE             =$00020000     { shared };
  SFGAO_READONLY          =$00040000     { read-only };
  SFGAO_GHOSTED           =$00080000     { ghosted icon };
  SFGAO_DISPLAYATTRMASK   =$000F0000;
  SFGAO_FILESYSANCESTOR   =$10000000     { It contains file system folder };
  SFGAO_FOLDER            =$20000000     { It's a folder. };
  SFGAO_FILESYSTEM        =$40000000     { is a file system thing (file/folder/root) };
  SFGAO_HASSUBFOLDER      =$80000000     { Expandable in the map pane };
  SFGAO_CONTENTSMASK      =$80000000;
  SFGAO_VALIDATE          =$01000000     { invalidate cached information };
  SFGAO_REMOVABLE         =$02000000     { is this removeable media? };

type
   IShellFolder = class(IUnknown)
    function ParseDisplayName(hwndOwner:HWND;
             pbcReserved:{LPBC}pointer; lpszDisplayName:POLESTR;
             var pchEaten:ULONG; var ppidl:PITEMIDLIST;
             var dwAttributes:ULONG):HResult; virtual; stdcall; abstract;
    function EnumObjects(hwndOwner:HWND; grfFlags:DWORD;
                         var EnumIDList: IENUMIDLIST):HResult; virtual; stdcall; abstract;
    function BindToObject(pidl:PITEMIDLIST; pbcReserved:{LPBC}pointer;
                          riid:TIID; var ppvOut:pointer):HResult; virtual; stdcall; abstract;
    function BindToStorage(pidl:PITEMIDLIST; pbcReserved:{LPBC}pointer;
                           riid:TIID; var ppvObj:pointer):HResult; virtual; stdcall; abstract;
    function CompareIDs(lParam:LPARAM;
                        pidl1,pidl2: PITEMIDLIST):HResult; virtual; stdcall; abstract;
    function CreateViewObject(hwndOwner:HWND; riid:TIID;
                              var ppvOut: pointer):HResult; virtual; stdcall; abstract;
    function GetAttributesOf(cidl:UINT; var apidl: PITEMIDLIST;
                             var rgfInOut:UINT):HResult; virtual; stdcall; abstract;
    function GetUIObjectOf(hwndOwner:HWND; cidl:UINT; var apidl: PITEMIDLIST;
                           riid:TIID; var  prgfInOut:UINT; var ppvOut:pointer):HResult; virtual; stdcall; abstract;
    function GetDisplayNameOf(pidl: PITEMIDLIST; uFlags:DWORD;
                              lpName: PSTRRET):HResult; virtual; stdcall; abstract;
    function SetNameOf(hwndOwner:HWND; pidl: PITEMIDLIST;
                       lpszName:POLEStr; uFlags: DWORD;
                       var ppidlOut: PITEMIDLIST):HResult; virtual; stdcall; abstract;
    end;

{  Helper function which returns a IShellFolder interface to the desktop }
{ folder. This is equivalent to call CoCreateInstance with CLSID_ShellDesktop. }

{  CoCreateInstance(CLSID_Desktop, NULL, }
{                   CLSCTX_INPROC, IID_IShellFolder, &pshf); }

function SHGetDesktopFolder(var ppshf: ISHELLFOLDER):HResult; stdcall;

{========================================================================== }
{ Clipboard format which may be supported by IDataObject from system }
{ defined shell folders (such as directories, network, ...). }
{========================================================================== }
const
  CFSTR_SHELLIDLIST       ='Shell IDList Array'    { CF_IDLIST };
  CFSTR_SHELLIDLISTOFFSET ='Shell Object Offsets'  { CF_OBJECTPOSITIONS };
  CFSTR_NETRESOURCES      ='Net Resource'          { CF_NETRESOURCE };
  CFSTR_FILEDESCRIPTOR    ='FileGroupDescriptor'   { CF_FILEGROUPDESCRIPTOR };
  CFSTR_FILECONTENTS      ='FileContents'          { CF_FILECONTENTS };
  CFSTR_FILENAME          ='FileName'              { CF_FILENAME };
  CFSTR_PRINTERGROUP      ='PrinterFriendlyName'   { CF_PRINTERS };
  CFSTR_FILENAMEMAP       ='FileNameMap'           { CF_FILENAMEMAP };

  { CF_OBJECTPOSITIONS }

  DVASPECT_SHORTNAME     = 2 { use for CF_HDROP to get short name version };

{ format of CF_NETRESOURCE }

type
  PNRESARRAY = ^TNRESARRAY;
  TNRESARRAY = record { anr }
     cItems:UINT;
     nr: array[0..0] of TNETRESOURCE;
     end;


{ format of CF_IDLIST }
  PIDA = ^TIDA;
  TIDA = record
     cidl:UINT;          { number of relative IDList }
     aoffset: array[0..0] of UINT;    { [0]: folder IDList, [1]-[cidl]: item IDList }
     end;


{ FILEDESCRIPTOR.dwFlags field indicate which fields are to be used }
const
    FD_CLSID            = $0001;
    FD_SIZEPOINT        = $0002;
    FD_ATTRIBUTES       = $0004;
    FD_CREATETIME       = $0008;
    FD_ACCESSTIME       = $0010;
    FD_WRITESTIME       = $0020;
    FD_FILESIZE         = $0040;
    FD_LINKUI           = $8000;       { 'link' UI is prefered }

type
  PFILEDESCRIPTOR = ^TFILEDESCRIPTOR;
  TFILEDESCRIPTOR = record { fod }
     dwFlags:DWORD;
     clsid:TCLSID;
     sizel:TSIZE;
     pointl:TPOINT;
     dwFileAttributes:DWORD;
     ftCreationTime:TFILETIME;
     ftLastAccessTime:TFILETIME;
     ftLastWriteTime:TFILETIME;
     nFileSizeHigh:DWORD;
     nFileSizeLow:DWORD;
     cFileName: array[0..MAX_PATH-1] of CHAR;
     end;


{ format of CF_FILEGROUPDESCRIPTOR }
  PFILEGROUPDESCRIPTOR = ^TFILEGROUPDESCRIPTOR;
  TFILEGROUPDESCRIPTOR = record { fgd }
      cItems:UINT;
      fgd: array[0..0] of TFILEDESCRIPTOR;
      end;


{ format of CF_HDROP and CF_PRINTERS, in the HDROP case the data that follows }
{ is a double null terinated list of file names, for printers they are printer }
{ friendly names }
  PDROPFILES = ^TDROPFILES;
  TDROPFILES = record
    pFiles:DWORD;                       { offset of file list }
    pt:TPOINT;                          { drop point (client coords) }
    fNC:BOOL;                           { is it on NonClient area }
                                        { and pt is in screen coords }
    fWide:BOOL;                         { WIDE character switch }
    end;

{====== File System Notification APIs =============================== }
const
   {  File System Notification flags }
   SHCNE_RENAMEITEM          =$00000001;
   SHCNE_CREATE              =$00000002;
   SHCNE_DELETE              =$00000004;
   SHCNE_MKDIR               =$00000008;
   SHCNE_RMDIR               =$00000010;
   SHCNE_MEDIAINSERTED       =$00000020;
   SHCNE_MEDIAREMOVED        =$00000040;
   SHCNE_DRIVEREMOVED        =$00000080;
   SHCNE_DRIVEADD            =$00000100;
   SHCNE_NETSHARE            =$00000200;
   SHCNE_NETUNSHARE          =$00000400;
   SHCNE_ATTRIBUTES          =$00000800;
   SHCNE_UPDATEDIR           =$00001000;
   SHCNE_UPDATEITEM          =$00002000;
   SHCNE_SERVERDISCONNECT    =$00004000;
   SHCNE_UPDATEIMAGE         =$00008000;
   SHCNE_DRIVEADDGUI         =$00010000;
   SHCNE_RENAMEFOLDER        =$00020000;
   SHCNE_FREESPACE           =$00040000;

   SHCNE_ASSOCCHANGED        =$08000000;

   SHCNE_DISKEVENTS          =$0002381F;
   SHCNE_GLOBALEVENTS        =$0C0581E0 { Events that dont match pidls first };
   SHCNE_ALLEVENTS           =$7FFFFFFF;
   SHCNE_INTERRUPT           =$80000000 { The presence of this flag indicates };
                                        { that the event was generated by an }
                                        { interrupt.  It is stripped out before }
                                        { the clients of SHCNNotify_ see it. }

   { Flags }
   { uFlags & SHCNF_TYPE is an ID which indicates what dwItem1 and dwItem2 mean }
   SHCNF_IDLIST      =$0000        { LPITEMIDLIST };
   SHCNF_PATH        =$0001        { path name };
   SHCNF_PRINTER     =$0002        { printer friendly name };
   SHCNF_DWORD       =$0003        { DWORD };
   SHCNF_TYPE        =$00FF;
   SHCNF_FLUSH       =$1000;
   SHCNF_FLUSHNOWAIT =$2000;

{  APIs }

procedure SHChangeNotify(wEventId:longint; uFlags:UINT;
                         dwItem1,dwItem2:pointer); stdcall;

procedure SHAddToRecentDocs(uFlags:UINT; pv:pointer); stdcall;

function SHGetInstanceExplorer(var Unk:IUnknown):HResult; stdcall;

{ SHAddToRecentDocs }
const
  SHARD_PIDL      =$00000001;
  SHARD_PATH      =$00000002;


implementation

const Shell32DLL = 'shell32.dll';

function SHGetMalloc(var ppMalloc: IMALLOC):HResult;
begin
  Result := CoGetMalloc(MEMCTX_TASK,ppMalloc);
end;

function SHGetPathFromIDList; external Shell32DLL name 'SHGetPathFromIDList';
function SHGetSpecialFolderLocation; external Shell32DLL name 'SHGetSpecialFolderLocation';
function SHBrowseForFolder; external Shell32DLL name 'SHBrowseForFolder';
function SHLoadInProc; external Shell32DLL name 'SHLoadInProc';
function SHGetDesktopFolder; external Shell32DLL name 'SHGetDesktopFolder';
procedure SHChangeNotify;    external Shell32DLL name 'SHChangeNotify';
procedure SHAddToRecentDocs; external Shell32DLL name 'SHAddToRecentDocs';
function SHGetInstanceExplorer;  external Shell32DLL name 'SHGetInstanceExplorer';

end.
