/// <summary>The specified items can be hosted inside a web browser or Windows Explorer frame.</summary>
SFGAO_BROWSABLE=0x8000000,
/// <summary>The specified items can be copied.</summary>
SFGAO_CANCOPY=1,
/// <summary>The specified items can be deleted.</summary>
SFGAO_CANDELETE=0x20,
/// <summary>
/// Shortcuts can be created for the specified items. This attribute has the same value as DROPEFFECT_LINK.
/// <para>
/// If a namespace extension returns this attribute, a Create Shortcut entry with a default handler is added to the shortcut menu that is displayed
/// during drag-and-drop operations. The extension can also implement its own handler for the link verb in place of the default. If the extension
/// does so, it is responsible for creating the shortcut.
/// </para>
/// <para>A Create Shortcut item is also added to the Windows Explorer File menu and to normal shortcut menus.</para>
/// <para>
/// If the item is selected, your application's IContextMenu::InvokeCommand method is invoked with the lpVerb member of the CMINVOKECOMMANDINFO
/// structure set to link. Your application is responsible for creating the link.
/// </para>
/// </summary>
SFGAO_CANLINK=4,
/// <summary>Not supported.</summary>
SFGAO_CANMONIKER=0x400000,
/// <summary>The specified items can be moved.</summary>
SFGAO_CANMOVE=2,
/// <summary>
/// The specified items can be renamed. Note that this value is essentially a suggestion; not all namespace clients allow items to be renamed.
/// However, those that do must have this attribute set.
/// </summary>
SFGAO_CANRENAME=0x10,
/// <summary>
/// This flag is a mask for the capability attributes: SFGAO_CANCOPY, SFGAO_CANMOVE, SFGAO_CANLINK, SFGAO_CANRENAME, SFGAO_CANDELETE,
/// SFGAO_HASPROPSHEET, and SFGAO_DROPTARGET. Callers normally do not use this value.
/// </summary>
SFGAO_CAPABILITYMASK=0x177,
/// <summary>The specified items are compressed.</summary>
SFGAO_COMPRESSED=0x4000000,
/// <summary>This flag is a mask for content attributes, at present only SFGAO_HASSUBFOLDER. Callers normally do not use this value.</summary>
SFGAO_CONTENTSMASK=0x80000000,
/// <summary>Do not use.</summary>
SFGAO_DISPLAYATTRMASK=0xfc000,
/// <summary>The specified items are drop targets.</summary>
SFGAO_DROPTARGET=0x100,
/// <summary>The specified items are encrypted and might require special presentation.</summary>
SFGAO_ENCRYPTED=0x2000,
/// <summary>
/// The specified folders are either file system folders or contain at least one descendant (child, grandchild, or later) that is a file system
/// (SFGAO_FILESYSTEM) folder.
/// </summary>
SFGAO_FILESYSANCESTOR=0x10000000,
/// <summary>
/// The specified folders or files are part of the file system (that is, they are files, directories, or root directories). The parsed names of the
/// items can be assumed to be valid Win32 file system paths. These paths can be either UNC or drive-letter based.
/// </summary>
SFGAO_FILESYSTEM=0x40000000,
/// <summary>
/// The specified items are folders. Some items can be flagged with both SFGAO_STREAM and SFGAO_FOLDER, such as a compressed file with a .zip file
/// name extension. Some applications might include this flag when testing for items that are both files and containers.
/// </summary>
SFGAO_FOLDER=0x20000000,
/// <summary>The specified items are shown as dimmed and unavailable to the user.</summary>
SFGAO_GHOSTED=0x8000,
/// <summary>The specified items have property sheets.</summary>
SFGAO_HASPROPSHEET=0x40,
/// <summary>Not supported.</summary>
SFGAO_HASSTORAGE=0x400000,
/// <summary>
/// The specified folders have subfolders. The SFGAO_HASSUBFOLDER attribute is only advisory and might be returned by Shell folder implementations
/// even if they do not contain subfolders. Note, however, that the converse<73>failing to return SFGAO_HASSUBFOLDER<45>definitively states that the folder
/// objects do not have subfolders.
/// <para>
/// Returning SFGAO_HASSUBFOLDER is recommended whenever a significant amount of time is required to determine whether any subfolders exist. For
/// example, the Shell always returns SFGAO_HASSUBFOLDER when a folder is located on a network drive.
/// </para>
/// </summary>
SFGAO_HASSUBFOLDER=0x80000000,
/// <summary>The item is hidden and should not be displayed unless the Show hidden files and folders option is enabled in Folder Settings.</summary>
SFGAO_HIDDEN=0x80000,
/// <summary>
/// Accessing the item (through IStream or other storage interfaces) is expected to be a slow operation. Applications should avoid accessing items
/// flagged with SFGAO_ISSLOW. <note>Opening a stream for an item is generally a slow operation at all times. SFGAO_ISSLOW indicates that it is
/// expected to be especially slow, for example in the case of slow network connections or offline (FILE_ATTRIBUTE_OFFLINE) files. However, querying
/// SFGAO_ISSLOW is itself a slow operation. Applications should query SFGAO_ISSLOW only on a background thread. An alternate method, such as
/// retrieving the PKEY_FileAttributes property and testing for FILE_ATTRIBUTE_OFFLINE, could be used in place of a method call that involves SFGAO_ISSLOW.</note>
/// </summary>
SFGAO_ISSLOW=0x4000,
/// <summary>The specified items are shortcuts.</summary>
SFGAO_LINK=0x10000,
/// <summary>The items contain new content, as defined by the particular application.</summary>
SFGAO_NEWCONTENT=0x200000,
/// <summary>
/// The items are nonenumerated items and should be hidden. They are not returned through an enumerator such as that created by the
/// IShellFolder::EnumObjects method.
/// </summary>
SFGAO_NONENUMERATED=0x100000,
/// <summary>
/// Mask used by the PKEY_SFGAOFlags property to determine attributes that are considered to cause slow calculations or lack context: SFGAO_ISSLOW,
/// SFGAO_READONLY, SFGAO_HASSUBFOLDER, and SFGAO_VALIDATE. Callers normally do not use this value.
/// </summary>
SFGAO_PKEYSFGAOMASK=0x81044000,
/// <summary>
/// The specified items are read-only. In the case of folders, this means that new items cannot be created in those folders. This should not be
/// confused with the behavior specified by the FILE_ATTRIBUTE_READONLY flag retrieved by IColumnProvider::GetItemData in a SHCOLUMNDATA structure.
/// FILE_ATTRIBUTE_READONLY has no meaning for Win32 file system folders.
/// </summary>
SFGAO_READONLY=0x40000,
/// <summary>The specified items are on removable media or are themselves removable devices.</summary>
SFGAO_REMOVABLE=0x2000000,
/// <summary>The specified objects are shared.</summary>
SFGAO_SHARE=0x20000,
/// <summary>
/// The specified items can be bound to an IStorage object through IShellFolder::BindToObject. For more information about namespace manipulation
/// capabilities, see IStorage.
/// </summary>
SFGAO_STORAGE=8,
/// <summary>Children of this item are accessible through IStream or IStorage. Those children are flagged with SFGAO_STORAGE or SFGAO_STREAM.</summary>
SFGAO_STORAGEANCESTOR=0x800000,
/// <summary>
/// This flag is a mask for the storage capability attributes: SFGAO_STORAGE, SFGAO_LINK, SFGAO_READONLY, SFGAO_STREAM, SFGAO_STORAGEANCESTOR,
/// SFGAO_FILESYSANCESTOR, SFGAO_FOLDER, and SFGAO_FILESYSTEM. Callers normally do not use this value.
/// </summary>
SFGAO_STORAGECAPMASK=0x70c50008,
/// <summary>
/// Indicates that the item has a stream associated with it. That stream can be accessed through a call to IShellFolder::BindToObject or
/// IShellItem::BindToHandler with IID_IStream in the riid parameter.
/// </summary>
SFGAO_STREAM=0x400000,
/// <summary>Windows 7 and later. The specified items are system items.</summary>
SFGAO_SYSTEM=0x00001000,
/// <summary>
/// When specified as input, SFGAO_VALIDATE instructs the folder to validate that the items contained in a folder or Shell item array exist. If one
/// or more of those items do not exist, IShellFolder::GetAttributesOf and IShellItemArray::GetAttributes return a failure code. This flag is never
/// returned as an [out] value.
/// <para>
/// When used with the file system folder, SFGAO_VALIDATE instructs the folder to discard cached properties retrieved by clients of
/// IShellFolder2::GetDetailsEx that might have accumulated for the specified items.
/// </para>
/// </summary>
SFGAO_VALIDATE=0x1000000
}
/// <summary>Determines the types of items included in an enumeration. These values are used with the IShellFolder::EnumObjects method.</summary>
/// <summary>Windows 7 and later. The calling application is checking for the existence of child items in the folder.</summary>
SHCONTF_CHECKING_FOR_CHILDREN=0x00010,
/// <summary>Include items that are folders in the enumeration.</summary>
SHCONTF_FOLDERS=0x00020,
/// <summary>Include items that are not folders in the enumeration.</summary>
SHCONTF_NONFOLDERS=0x00040,
/// <summary>Include hidden items in the enumeration. This does not include hidden system items. (To include hidden system items, use SHCONTF_INCLUDESUPERHIDDEN.)</summary>
SHCONTF_INCLUDEHIDDEN=0x00080,
/// <summary>
/// No longer used; always assumed. IShellFolder::EnumObjects can return without validating the enumeration object. Validation can be postponed until
/// the first call to IEnumIDList::Next. Use this flag when a user interface might be displayed prior to the first IEnumIDList::Next call. For a user
/// interface to be presented, hwnd must be set to a valid window handle.
/// </summary>
SHCONTF_INIT_ON_FIRST_NEXT=0x00100,
/// <summary>The calling application is looking for printer objects.</summary>
SHCONTF_NETPRINTERSRCH=0x00200,
/// <summary>The calling application is looking for resources that can be shared.</summary>
SHCONTF_SHAREABLE=0x00400,
/// <summary>Include items with accessible storage and their ancestors, including hidden items.</summary>
SHCONTF_STORAGE=0x00800,
/// <summary>Windows 7 and later. Child folders should provide a navigation enumeration.</summary>
SHCONTF_NAVIGATION_ENUM=0x01000,
/// <summary>Windows Vista and later. The calling application is looking for resources that can be enumerated quickly.</summary>
SHCONTF_FASTITEMS=0x02000,
/// <summary>Windows Vista and later. Enumerate items as a simple list even if the folder itself is not structured in that way.</summary>
SHCONTF_FLATLIST=0x04000,
/// <summary>
/// Windows Vista and later. The calling application is monitoring for change notifications. This means that the enumerator does not have to return
/// all results. Items can be reported through change notifications.
/// </summary>
SHCONTF_ENABLE_ASYNC=0x08000,
/// <summary>
/// Windows 7 and later. Include hidden system items in the enumeration. This value does not include hidden non-system items. (To include hidden
/// non-system items, use SHCONTF_INCLUDEHIDDEN.)
/// </summary>
SHCONTF_INCLUDESUPERHIDDEN=0x10000
}
/// <summary>
/// Defines the values used with the IShellFolder::GetDisplayNameOf and IShellFolder::SetNameOf methods to specify the type of file or folder names used
/// <summary>The name is displayed in an address bar combo box.</summary>
SHGDN_FORADDRESSBAR=0x4000,
/// <summary>The name is used for in-place editing when the user renames the item.</summary>
SHGDN_FOREDITING=0x1000,
/// <summary>
/// The name is used for parsing. That is, it can be passed to IShellFolder::ParseDisplayName to recover the object's PIDL. The form this name takes
/// depends on the particular object. When SHGDN_FORPARSING is used alone, the name is relative to the desktop. When combined with SHGDN_INFOLDER,
/// the name is relative to the folder from which the request was made.
/// </summary>
SHGDN_FORPARSING=0x8000,
/// <summary>
/// The name is relative to the folder from which the request was made. This is the name display to the user when used in the context of the folder.
/// For example, it is used in the view and in the address bar path segment for the folder. This name should not include disambiguation
/// information<6F>for instance "username" instead of "username (on Machine)" for a particular user's folder. Use this flag in combinations with
/// SHGDN_FORPARSING and SHGDN_FOREDITING.
/// </summary>
SHGDN_INFOLDER=1,
/// <summary>
/// When not combined with another flag, return the parent-relative name that identifies the item, suitable for displaying to the user. This name
/// often does not include extra information such as the file name extension and does not need to be unique. This name might include information that
/// identifies the folder that contains the item. For instance, this flag could cause IShellFolder::GetDisplayNameOf to return the string "username
/// (on Machine)" for a particular user's folder.
/// </summary>
SHGDN_NORMAL=0
}
/// <summary>
/// If the array contains a single item, this method provides the same results as GetAttributes. However, if the array contains multiple items, the
/// attribute sets of all the items are combined into a single attribute set and returned in the value pointed to by psfgaoAttribs. This parameter takes
/// one of the following values to define how that final attribute set is determined:
/// two items where one item can be moved (SFGAO_CANMOVE) and a second item cannot, the method returns (1 & 0) or 0 for that attribute bit.</summary>
/// <summary>Exact comparison of two instances of a Shell item.</summary>
SICHINT_ALLFIELDS=0x80000000,
/// <summary>
/// This relates to the iOrder parameter of the IShellItem::Compare interface and indicates that the comparison is based on a canonical name.
/// </summary>
SICHINT_CANONICAL=0x10000000,
/// <summary>
/// This relates to the iOrder parameter of the IShellItem::Compare interface and indicates that the comparison is based on the display in a folder view.
/// </summary>
SICHINT_DISPLAY=0,
/// <summary>Windows 7 and later. If the Shell items are not the same, test the file system paths.</summary>
SICHINT_TEST_FILESYSPATH_IF_NOT_EQUAL=0x20000000
}
/// <summary>Requests the form of an item's display name to retrieve through IShellItem::GetDisplayName and SHGetNameFromIDList.</summary>
/// <remarks>
/// Different forms of an item's name can be retrieved through the item's properties, including those listed here. Note that not all properties are
/// present on all items, so only those appropriate to the item will appear.
/// <summary>Retrieves the standard short (8.3 format) file name.</summary>
SLGP_SHORTPATH=1,
/// <summary>Unsupported; do not use.</summary>
SLGP_UNCPRIORITY=2,
/// <summary>
/// Retrieves the raw path name. A raw path is something that might not exist and may include environment variables that need to be expanded.
/// </summary>
SLGP_RAWPATH=4,
/// <summary>
/// Windows Vista and later. Retrieves the path, if possible, of the shortcut's target relative to the path set by a previous call to IShellLink::SetRelativePath.
/// </summary>
SLGP_RELATIVEPRIORITY=8
}
/// <summary>Exposes methods that allow an application to remove one or all destinations from the Recent or Frequent categories in a Jump List.</summary>
/// <summary>Retrieve an IEnumObjects or IObjectArray for IShellItems and/or IShellLinks. Items may appear in both the frequent and recent lists.</summary>
/// <param name="listtype">Which of the known list types to retrieve</param>
/// <param name="cItemsDesired">The number of items desired.</param>
/// <param name="riid">The interface Id that the return value should be queried for.</param>
/// <returns>A COM object based on the IID passed for the riid parameter.</returns>
/// Exposes a standard set of methods used to enumerate the pointers to item identifier lists (PIDLs) of the items in a Shell folder. When a folder's
/// IShellFolder::EnumObjects method is called, it creates an enumeration object and passes a pointer to the object's IEnumIDList interface back to the
/// <summary>Skips the specified number of elements in the enumeration sequence.</summary>
/// <param name="celt">The number of item identifiers to skip.</param>
voidSkip(uintcelt);
/// <summary>Returns to the beginning of the enumeration sequence.</summary>
voidReset();
/// <summary>Creates a new item enumeration object with the same contents and state as the current one.</summary>
/// <returns>
/// The address of a pointer to the new enumeration object. The calling application must eventually free the new object by calling its Release member function.
/// </returns>
[return: MarshalAs(UnmanagedType.Interface)]
IEnumIDListClone();
}
/// <summary>Exposes enumeration of IShellItem interfaces. This interface is typically obtained by calling the IEnumShellItems method.</summary>
/// <summary>Extends the IObjectArray interface by providing methods that enable clients to add and remove objects that support IUnknown in a collection.</summary>
/// Exposes methods that the Shell uses to retrieve flags and info tip information for an item that resides in an IShellFolder implementation. Info tips
/// are usually displayed inside a tooltip control.
/// <summary>Translates the display name of a file object or a folder into an item identifier list.</summary>
/// <param name="hwnd">
/// A window handle. The client should provide a window handle if it displays a dialog or message box. Otherwise set hwnd to NULL
/// </param>
/// <param name="pbc">
/// Optional. A pointer to a bind context used to pass parameters as inputs and outputs to the parsing function. These passed parameters are often
/// specific to the data source and are documented by the data source owners. For example, the file system data source accepts the name being parsed
/// (as a WIN32_FIND_DATA structure), using the STR_FILE_SYS_BIND_DATA bind context parameter. STR_PARSE_PREFER_FOLDER_BROWSING can be passed to
/// indicate that URLs are parsed using the file system data source when possible. Construct a bind context object using CreateBindCtx and populate
/// the values using IBindCtx::RegisterObjectParam. See Bind Context String Keys for a complete list of these. If no data is being passed to or
/// received from the parsing function, this value can be NULL.
/// </param>
/// <param name="pszDisplayName">
/// A null-terminated Unicode string with the display name. Because each Shell folder defines its own parsing syntax, the form this string can take
/// may vary. The desktop folder, for instance, accepts paths such as "C:\My Docs\My File.txt". It also will accept references to items in the
/// namespace that have a GUID associated with them using the "::{GUID}" syntax.
/// </param>
/// <param name="pchEaten">
/// A pointer to a ULONG value that receives the number of characters of the display name that was parsed. If your application does not need this
/// information, set pchEaten to NULL, and no value will be returned.
/// </param>
/// <param name="ppidl">
/// When this method returns, contains a pointer to the PIDL for the object. The returned item identifier list specifies the item relative to the
/// parsing folder. If the object associated with pszDisplayName is within the parsing folder, the returned item identifier list will contain only
/// one SHITEMID structure. If the object is in a subfolder of the parsing folder, the returned item identifier list will contain multiple SHITEMID
/// structures. If an error occurs, NULL is returned in this address.
/// <para>When it is no longer needed, it is the responsibility of the caller to free this resource by calling CoTaskMemFree.</para>
/// </param>
/// <param name="pdwAttributes">
/// The value used to query for file attributes. If not used, it should be set to NULL. To query for one or more attributes, initialize this
/// parameter with the SFGAO flags that represent the attributes of interest. On return, those attributes that are true and were requested will be set.
/// Retrieves a handler, typically the Shell folder object that implements IShellFolder for a particular item. Optional parameters that control the
/// construction of the handler are passed in the bind context.
/// </summary>
/// <param name="pidl">
/// The address of an ITEMIDLIST structure (PIDL) that identifies the subfolder. This value can refer to an item at any level below the parent folder
/// in the namespace hierarchy. The structure contains one or more SHITEMID structures, followed by a terminating NULL.
/// </param>
/// <param name="pbc">
/// A pointer to an IBindCtx interface on a bind context object that can be used to pass parameters to the construction of the handler. If this
/// parameter is not used, set it to NULL. Because support for this parameter is optional for folder object implementations, some folders may not
/// support the use of bind contexts.
/// <para>
/// Information that can be provided in the bind context includes a BIND_OPTS structure that includes a grfMode member that indicates the access mode
/// when binding to a stream handler. Other parameters can be set and discovered using IBindCtx::RegisterObjectParam and IBindCtx::GetObjectParam.
/// </para>
/// </param>
/// <param name="riid">
/// The identifier of the interface to return. This may be IID_IShellFolder, IID_IStream, or any other interface that identifies a particular handler.
/// </param>
/// <returns>
/// When this method returns, contains the address of a pointer to the requested interface. If an error occurs, a NULL pointer is returned at this address.
/// <summary>Requests a pointer to an object's storage interface.</summary>
/// <param name="pidl">
/// The address of an ITEMIDLIST structure that identifies the subfolder relative to its parent folder. The structure must contain exactly one
/// SHITEMID structure followed by a terminating zero.
/// </param>
/// <param name="pbc">
/// The optional address of an IBindCtx interface on a bind context object to be used during this operation. If this parameter is not used, set it to
/// NULL. Because support for pbc is optional for folder object implementations, some folders may not support the use of bind contexts.
/// </param>
/// <param name="riid">
/// The IID of the requested storage interface. To retrieve an IStream, IStorage, or IPropertySetStorage interface pointer, set riid to IID_IStream,
/// IID_IStorage, or IID_IPropertySetStorage, respectively.
/// </param>
/// <returns>The address that receives the interface pointer specified by riid. If an error occurs, a NULL pointer is returned in this address.</returns>
/// <summary>Requests an object that can be used to obtain information from or interact with a folder object.</summary>
/// <param name="hwndOwner">
/// A handle to the owner window. If you have implemented a custom folder view object, your folder view window should be created as a child of hwndOwner.
/// </param>
/// <param name="riid">A reference to the IID of the interface to retrieve through ppv, typically IID_IShellView.</param>
/// <returns>
/// When this method returns successfully, contains the interface pointer requested in riid. This is typically IShellView. See the Remarks section
/// <summary>Retrieves the display name for the specified file object or subfolder.</summary>
/// <param name="pidl">PIDL that uniquely identifies the file object or subfolder relative to the parent folder.</param>
/// <param name="uFlags">Flags used to request the type of display name to return. For a list of possible values, see the SHGDNF enumerated type.</param>
/// <returns>
/// When this method returns, contains a pointer to a STRRET structure in which to return the display name. The type of name returned in this
/// structure can be the requested type, but the Shell folder might return a different type.
/// <summary>Sets the display name of a file object or subfolder, changing the item identifier in the process.</summary>
/// <param name="hwnd">A handle to the owner window of any dialog or message box that the client displays.</param>
/// <param name="pidl">
/// A pointer to an ITEMIDLIST structure that uniquely identifies the file object or subfolder relative to the parent folder. The structure must
/// contain exactly one SHITEMID structure followed by a terminating zero.
/// </param>
/// <param name="pszName">A pointer to a null-terminated string that specifies the new display name.</param>
/// <param name="uFlags">
/// Flags that indicate the type of name specified by the pszName parameter. For a list of possible values and combinations of values, see SHGDNF.
/// </param>
/// <param name="ppidlOut">
/// Optional. If specified, the address of a pointer to an ITEMIDLIST structure that receives the ITEMIDLIST of the renamed item. The caller requests
/// this value by passing a non-null ppidlOut. Implementations of IShellFolder::SetNameOf must return a pointer to the new ITEMIDLIST in the ppidlOut parameter.
/// Exposes methods that retrieve information about a Shell item. IShellItem and IShellItem2 are the preferred representations of items in any new code.
/// <summary>Binds to a handler for an item as specified by the handler ID value (BHID).</summary>
/// <param name="pbc">
/// A pointer to an IBindCtx interface on a bind context object. Used to pass optional parameters to the handler. The contents of the bind context
/// are handler-specific. For example, when binding to BHID_Stream, the STGM flags in the bind context indicate the mode of access desired (read or read/write).
/// </param>
/// <param name="bhid">Reference to a GUID that specifies which handler will be created.</param>
/// <param name="riid">IID of the object type to retrieve.</param>
/// <returns>When this method returns, contains a pointer of type riid that is returned by the handler specified by rbhid.</returns>
/// <summary>Binds to a handler for an item as specified by the handler ID value (BHID).</summary>
/// <param name="pbc">
/// A pointer to an IBindCtx interface on a bind context object. Used to pass optional parameters to the handler. The contents of the bind context
/// are handler-specific. For example, when binding to BHID_Stream, the STGM flags in the bind context indicate the mode of access desired (read or read/write).
/// </param>
/// <param name="bhid">Reference to a GUID that specifies which handler will be created.</param>
/// <param name="riid">IID of the object type to retrieve.</param>
/// <returns>When this method returns, contains a pointer of type riid that is returned by the handler specified by rbhid.</returns>
/// <summary>Gets property store object for specified property keys.</summary>
/// <param name="rgKeys">
/// A pointer to an array of PROPERTYKEY structures. Each structure contains a unique identifier for each property used in creating the property store.
/// </param>
/// <param name="cKeys">The number of PROPERTYKEY structures in the array pointed to by rgKeys.</param>
/// <param name="flags">The GETPROPERTYSTOREFLAGS constants that modify the property store object.</param>
/// <param name="riid">A reference to the IID of the object to be retrieved.</param>
/// <summary>Binds to an object by means of the specified handler.</summary>
/// <param name="pbc">A pointer to an IBindCtx interface on a bind context object.</param>
/// <param name="rbhid">One of the following values, defined in Shlguid.h, that determine the handler.
/// <list>
/// <item><term>BHID_SFUIObject</term><description>Restricts usage to GetUIObjectOf. Use this handler type only for a flat item array, where all items are in the same folder.</description></item>
/// <item><term>BHID_DataObject</term><description>Introduced in Windows Vista: Gets an IDataObject object for use with an item or an array of items. Use this handler type only for flat data objects or item arrays created by SHCreateShellItemArrayFromDataObject.</description></item>
/// <item><term>BHID_AssociationArray</term><description>Introduced in Windows Vista: Gets an IQueryAssociations object for use with an item or an array of items. This only retrieves the association array object for the first item in the IShellItemArray</description></item>
/// </list></param>
/// <param name="riid">The IID of the object type to retrieve.</param>
/// <returns>When this /// methods returns, contains the object specified in riid that is returned by the handler specified by rbhid.</returns>
/// <param name="flags">One of the GETPROPERTYSTOREFLAGS constants.</param>
/// <param name="riid">The IID of the object type to retrieve.</param>
/// <returns>When this method returns, contains interface pointer requested in riid. This is typically IPropertyStore or IPropertyStoreCapabilities.</returns>
/// Gets the attributes of the set of items contained in an IShellItemArray. If the array contains more than one item, the attributes retrieved by
/// this method are not the attributes of single items, but a logical combination of all of the requested attributes of all of the items.
/// </summary>
/// <param name="dwAttribFlags">
/// If the array contains a single item, this method provides the same results as GetAttributes. However, if the array contains multiple items, the
/// attribute sets of all the items are combined into a single attribute set and returned in the value pointed to by psfgaoAttribs. This parameter
/// takes one of the following values to define how that final attribute set is determined:
/// </param>
/// <param name="sfgaoMask">A mask that specifies what particular attributes are being requested. A bitwise OR of one or more of the SFGAO values.</param>
/// <returns>A bitmap that, when this method returns successfully, contains the values of the requested attributes.</returns>
/// <summary>Clones the first SHITEMID structure in an ITEMIDLIST structure.</summary>
/// <param name="pidl">A pointer to the ITEMIDLIST structure to be cloned.</param>
/// <returns>
/// A pointer to an ITEMIDLIST structure that contains the first SHITEMID structure from the ITEMIDLIST structure specified by pidl. Returns NULL on failure.
/// <summary>Combines two ITEMIDLIST structures.</summary>
/// <param name="pidl1">A pointer to the first ITEMIDLIST structure.</param>
/// <param name="pidl2">A pointer to the second ITEMIDLIST structure. This structure is appended to the structure pointed to by pidl1.</param>
/// <returns>
/// Returns an ITEMIDLIST containing the combined structures. If you set either pidl1 or pidl2 to NULL, the returned ITEMIDLIST structure is a clone of
/// the non-NULL parameter. Returns NULL if pidl1 and pidl2 are both set to NULL.
/// <summary>Returns the ITEMIDLIST structure associated with a specified file path.</summary>
/// <param name="pszPath">
/// A pointer to a null-terminated Unicode string that contains the path. This string should be no more than MAX_PATH characters in length, including the
/// terminating null character.
/// </param>
/// <returns>Returns a pointer to an ITEMIDLIST structure that corresponds to the path.</returns>
/// <summary>Tests whether an ITEMIDLIST structure is the parent of another ITEMIDLIST structure.</summary>
/// <param name="pidl1">A pointer to an ITEMIDLIST (PIDL) structure that specifies the parent. This must be an absolute PIDL.</param>
/// <param name="pidl2">A pointer to an ITEMIDLIST (PIDL) structure that specifies the child. This must be an absolute PIDL.</param>
/// <param name="fImmediate">A Boolean value that is set to TRUE to test for immediate parents of pidl2, or FALSE to test for any parents of pidl2.</param>
/// <returns>
/// Returns TRUE if pidl1 is a parent of pidl2. If fImmediate is set to TRUE, the function only returns TRUE if pidl1 is the immediate parent of pidl2.
/// <summary>Retrieves the next SHITEMID structure in an ITEMIDLIST structure.</summary>
/// <param name="pidl">A constant, unaligned, relative PIDL for which the next SHITEMID structure is being retrieved.</param>
/// <returns>
/// When this function returns, contains one of three results: If pidl is valid and not the last SHITEMID in the ITEMIDLIST, then it contains a pointer
/// to the next ITEMIDLIST structure. If the last ITEMIDLIST structure is passed, it contains NULL, which signals the end of the PIDL. For other values
/// <summary>Removes the last SHITEMID structure from an ITEMIDLIST structure.</summary>
/// <param name="pidl">A pointer to the ITEMIDLIST structure to be shortened. When the function returns, this variable points to the shortened structure.</param>
/// <returns>Returns TRUE if successful, FALSE otherwise.</returns>
/// <summary>Returns the ITEMIDLIST structure associated with a specified file path.</summary>
/// <param name="pszPath">
/// A pointer to a null-terminated Unicode string that contains the path. This string should be no more than MAX_PATH characters in length, including the
/// terminating null character.
/// </param>
/// <returns>Returns a pointer to an ITEMIDLIST structure that corresponds to the path.</returns>
/// Specifies a unique application-defined Application User Model ID (AppUserModelID) that identifies the current process to the taskbar. This identifier
/// allows an application to group its associated processes and windows under a single taskbar button.
/// </summary>
/// <param name="AppID">Pointer to the AppUserModelID to assign to the current process.</param>
/// Creates and initializes a Shell item object from a pointer to an item identifier list (PIDL). The resulting shell item object supports the IShellItem interface.
/// </summary>
/// <param name="pidl">The source PIDL.</param>
/// <param name="riid">A reference to the IID of the requested interface.</param>
/// <param name="ppv">When this function returns, contains the interface pointer requested in riid. This will typically be IShellItem or IShellItem2.</param>
/// <summary>Creates and initializes a Shell item object from a parsing name.</summary>
/// <param name="pszPath">A pointer to a display name.</param>
/// <param name="pbc">Optional. A pointer to a bind context used to pass parameters as inputs and outputs to the parsing function. These passed parameters are often specific to the data source and are documented by the data source owners. For example, the file system data source accepts the name being parsed (as a WIN32_FIND_DATA structure), using the STR_FILE_SYS_BIND_DATA bind context parameter.
/// <para>STR_PARSE_PREFER_FOLDER_BROWSING can be passed to indicate that URLs are parsed using the file system data source when possible.Construct a bind context object using CreateBindCtx and populate the values using IBindCtx::RegisterObjectParam. See Bind Context String Keys for a complete list of these.See the Parsing With Parameters Sample for an example of the use of this parameter.</para>
/// <para>If no data is being passed to or received from the parsing function, this value can be NULL.</para></param>
/// <param name="riid">A reference to the IID of the interface to retrieve through ppv, typically IID_IShellItem or IID_IShellItem2.</param>
/// <param name="ppv">When this method returns successfully, contains the interface pointer requested in riid. This is typically IShellItem or IShellItem2.</param>
/// <returns>If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <param name="psiParent">A pointer to the parent Shell item.</param>
/// <param name="pszName">A pointer to a null-terminated, Unicode string that specifies a display name that is relative to the psiParent.</param>
/// <param name="pbc">A pointer to a bind context that controls the parsing operation. This parameter can be NULL.</param>
/// <param name="riid">A reference to an interface ID.</param>
/// <param name="ppv">When this function returns, contains the interface pointer requested in riid. This will usually be IShellItem or IShellItem2.</param>
/// Creates a Shell item object for a single file that exists inside a known folder.
/// </summary>
/// <param name="kfid">A reference to the KNOWNFOLDERID, a GUID that identifies the folder that contains the item.</param>
/// <param name="dwKFFlags">Flags that specify special options in the object retrieval. This value can be 0; otherwise, one or more of the KNOWN_FOLDER_FLAG values.</param>
/// <param name="pszItem">A pointer to a null-terminated buffer that contains the file name of the new item as a Unicode string. This parameter can also be NULL. In this case, an IShellItem that represents the known folder itself is created.</param>
/// <param name="riid">A reference to an interface ID.</param>
/// <param name="ppv">When this function returns, contains the interface pointer requested in riid. This will usually be IShellItem or IShellItem2.</param>
/// Create a Shell item, given a parent folder and a child item ID.
/// </summary>
/// <param name="pidlParent">The IDList of the parent folder of the item being created; the IDList of psfParent. This parameter can be NULL, if psfParent is specified.</param>
/// <param name="psfParent">A pointer to IShellFolder interface that specifies the shell data source of the child item specified by the pidl.This parameter can be NULL, if pidlParent is specified.</param>
/// <param name="pidl">A child item ID relative to its parent folder specified by psfParent or pidlParent.</param>
/// <param name="riid">A reference to an interface ID.</param>
/// <param name="ppvItem">When this function returns, contains the interface pointer requested in riid. This will usually be IShellItem or IShellItem2.</param>
// public static extern HRESULT SHCreateShellFolderView([In] ref SFV_CREATE pcsfv, [MarshalAs(UnmanagedType.Interface)] out object ppvItem);
/// <summary>
/// Creates a Shell item array object.
/// </summary>
/// <param name="pidlParent">The ID list of the parent folder of the items specified in ppidl. If psf is specified, this parameter can be NULL. If this pidlParent is not specified, it is computed from the psf parameter using IPersistFolder2.</param>
/// <param name="psf">The Shell data source object that is the parent of the child items specified in ppidl. If pidlParent is specified, this parameter can be NULL.</param>
/// <param name="cidl">The number of elements in the array specified by ppidl.</param>
/// <param name="ppidl">The list of child item IDs for which the array is being created. This value can be NULL.</param>
/// <param name="ppsiItemArray">When this function returns, contains the address of an <see cref="IShellItemArray"/> interface pointer.</param>
/// Creates an array of one element from a single Shell item.
/// </summary>
/// <param name="psi">Pointer to IShellItem object that represents the item.</param>
/// <param name="riid">A reference to the IID of the interface to retrieve through ppv, typically IID_IShellItemArray.</param>
/// <param name="ppv">When this method returns, contains the interface pointer requested in riid. This is typically a pointer to an IShellItemArray.</param>
/// <summary>Combines two ITEMIDLIST structures.</summary>
/// <param name="pidl1">A pointer to the first ITEMIDLIST structure.</param>
/// <param name="pidl2">A pointer to the second ITEMIDLIST structure. This structure is appended to the structure pointed to by pidl1.</param>
/// <returns>
/// Returns an ITEMIDLIST containing the combined structures. If you set either pidl1 or pidl2 to NULL, the returned ITEMIDLIST structure is a clone of
/// the non-NULL parameter. Returns NULL if pidl1 and pidl2 are both set to NULL.
