Vanara/PInvoke/Shell32/ShObjIdl.IShellFolder.cs

647 lines
43 KiB
C#
Raw Normal View History

using System;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Security;
using static Vanara.PInvoke.Ole32;
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable UnusedParameter.Global
// ReSharper disable UnusedMember.Global
// ReSharper disable FieldCanBeMadeReadOnly.Global
// ReSharper disable InconsistentNaming
// ReSharper disable MemberHidesStaticFromOuterClass
// ReSharper disable UnusedMethodReturnValue.Global
namespace Vanara.PInvoke
{
public static partial class Shell32
{
/// <summary>Determines the types of items included in an enumeration. These values are used with the IShellFolder::EnumObjects method.</summary>
[PInvokeData("Shobjidl.h", MSDNShortId = "bb762539")]
[Flags]
public enum SHCONTF
{
/// <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
/// by those methods.
/// </summary>
[PInvokeData("Shobjidl.h", MSDNShortId = "bb762541")]
[Flags]
public enum SHGDNF
{
/// <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—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>A standard OLE enumerator used by a client to determine the available search objects for a folder.</summary>
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("0E700BE1-9DB6-11d1-A1CE-00C04FD75D13")]
[PInvokeData("Shobjidl.h", MSDNShortId = "bb761992")]
public interface IEnumExtraSearch
{
/// <summary>Used to request information on one or more search objects.</summary>
/// <param name="celt">The number of search objects to be enumerated, starting from the current object. If celt is too large, the method should stop and return the actual number of search objects in pceltFetched.</param>
/// <param name="rgelt">A pointer to an array of pceltFetched EXTRASEARCH structures containing information on the enumerated objects.</param>
/// <param name="pceltFetched">The number of objects actually enumerated. This may be less than celt.</param>
/// <returns>Returns S_OK if successful, or a COM-defined error code otherwise.</returns>
[PreserveSig]
HRESULT Next([In] uint celt,
[Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] EXTRASEARCH[] rgelt,
out uint pceltFetched);
/// <summary>Skip a specified number of objects.</summary>
/// <param name="celt">The number of objects to skip.</param>
/// <returns>Returns S_OK if successful, or a COM-defined error code otherwise.</returns>
[PreserveSig]
HRESULT Skip([In] uint celt);
/// <summary>Used to reset the enumeration index to zero.</summary>
void Reset();
/// <summary>Used to request a duplicate of the enumerator object to preserve its current state.</summary>
/// <returns>A pointer to the IEnumExtraSearch interface of a new enumerator object.</returns>
[return: MarshalAs(UnmanagedType.Interface)]
IEnumExtraSearch Clone();
}
/// <summary>Exposed by all Shell namespace folder objects, its methods are used to manage folders.</summary>
[SuppressUnmanagedCodeSecurity]
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("000214E6-0000-0000-C000-000000000046")]
[PInvokeData("Shobjidl.h", MSDNShortId = "bb775075")]
public interface IShellFolder
{
/// <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.
/// </param>
2018-10-26 14:24:07 -04:00
void ParseDisplayName(HWND hwnd, [In, Optional] IBindCtx pbc, [MarshalAs(UnmanagedType.LPWStr)] string pszDisplayName, out uint pchEaten, out PIDL ppidl, [In, Out] ref SFGAO pdwAttributes);
/// <summary>
/// Enables a client to determine the contents of a folder by creating an item identifier enumeration object and returning its IEnumIDList interface.
/// The methods supported by that interface can then be used to enumerate the folder's contents.
/// </summary>
/// <param name="hwnd">
/// If user input is required to perform the enumeration, this window handle should be used by the enumeration object as the parent window to take
/// user input. An example would be a dialog box to ask for a password or prompt the user to insert a CD or floppy disk. If hwndOwner is set to NULL,
/// the enumerator should not post any messages, and if user input is required, it should silently fail.
/// </param>
/// <param name="grfFlags">
/// Flags indicating which items to include in the enumeration. For a list of possible values, see the SHCONTF enumerated type.
/// </param>
/// <returns>
/// The address that receives a pointer to the IEnumIDList interface of the enumeration object created by this method. If an error occurs or no
/// suitable subobjects are found, ppenumIDList is set to NULL.
/// </returns>
2018-10-26 14:24:07 -04:00
IEnumIDList EnumObjects(HWND hwnd, SHCONTF grfFlags);
/// <summary>
/// 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.
/// </returns>
[return: MarshalAs(UnmanagedType.Interface)]
2018-10-26 14:24:07 -04:00
object BindToObject([In] PIDL pidl, [In, Optional] IBindCtx pbc, in Guid riid);
/// <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>
[return: MarshalAs(UnmanagedType.Interface)]
2018-10-26 14:24:07 -04:00
object BindToStorage([In] PIDL pidl, [In, Optional] IBindCtx pbc, in Guid riid);
/// <summary>Determines the relative order of two file objects or folders, given their item identifier lists.</summary>
/// <param name="lParam">
/// A value that specifies how the comparison should be performed.
/// <para>
/// The lower sixteen bits of lParam define the sorting rule. Most applications set the sorting rule to the default value of zero, indicating that
/// the two items should be compared by name. The system does not define any other sorting rules. Some folder objects might allow calling
/// applications to use the lower sixteen bits of lParam to specify folder-specific sorting rules. The rules and their associated lParam values are
/// defined by the folder.
/// </para>
/// <para>
/// When the system folder view object calls IShellFolder::CompareIDs, the lower sixteen bits of lParam are used to specify the column to be used for
/// the comparison.
/// </para>
/// <para>The upper sixteen bits of lParam are used for flags that modify the sorting rule. The system currently defines these modifier flags.</para>
/// <list>
/// <item>
/// <term>SHCIDS_ALLFIELDS</term>
/// <description>
/// Version 5.0. Compare all the information contained in the ITEMIDLIST structure, not just the display names. This flag is valid only for folder
/// objects that support the IShellFolder2 interface. For instance, if the two items are files, the folder should compare their names, sizes, file
/// times, attributes, and any other information in the structures. If this flag is set, the lower sixteen bits of lParam must be zero.
/// </description>
/// </item>
/// <item>
/// <term>SHCIDS_CANONICALONLY</term>
/// <description>
/// Version 5.0. When comparing by name, compare the system names but not the display names. When this flag is passed, the two items are compared by
/// whatever criteria the Shell folder determines are most efficient, as long as it implements a consistent sort function. This flag is useful when
/// comparing for equality or when the results of the sort are not displayed to the user. This flag cannot be combined with other flags.
/// </description>
/// </item>
/// </list>
/// </param>
/// <param name="pidl1">
/// A pointer to the first item's ITEMIDLIST structure. It will be relative to the folder. This ITEMIDLIST structure can contain more than one
/// element; therefore, the entire structure must be compared, not just the first element.
/// </param>
/// <param name="pidl2">
/// A pointer to the second item's ITEMIDLIST structure. It will be relative to the folder. This ITEMIDLIST structure can contain more than one
/// element; therefore, the entire structure must be compared, not just the first element.
/// </param>
/// <returns>
/// If this method is successful, the CODE field of the HRESULT contains one of the following values. For information regarding the extraction of the
/// CODE field from the returned HRESULT, see Remarks. If this method is unsuccessful, it returns a COM error code.
/// </returns>
[PreserveSig]
HRESULT CompareIDs(IntPtr lParam, [In] PIDL pidl1, [In] PIDL pidl2);
/// <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
/// for more details.
/// </returns>
[return: MarshalAs(UnmanagedType.Interface)]
2018-10-26 14:24:07 -04:00
object CreateViewObject(HWND hwndOwner, in Guid riid);
/// <summary>Gets the attributes of one or more file or folder objects contained in the object represented by IShellFolder.</summary>
/// <param name="cidl">The number of items from which to retrieve attributes.</param>
/// <param name="apidl">
/// The address of an array of pointers to ITEMIDLIST structures, each of which uniquely identifies an item relative to the parent folder. Each
/// ITEMIDLIST structure must contain exactly one SHITEMID structure followed by a terminating zero.
/// </param>
/// <param name="rgfInOut">
/// Pointer to a single ULONG value that, on entry, contains the bitwise SFGAO attributes that the calling application is requesting. On exit, this
/// value contains the requested attributes that are common to all of the specified items.
/// </param>
void GetAttributesOf(uint cidl, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] IntPtr[] apidl, ref SFGAO rgfInOut);
/// <summary>Gets an object that can be used to carry out actions on the specified file objects or folders.</summary>
/// <param name="hwndOwner">A handle to the owner window that the client should specify if it displays a dialog box or message box.</param>
/// <param name="cidl">The number of file objects or subfolders specified in the apidl parameter.</param>
/// <param name="apidl">
/// The address of an array of pointers to ITEMIDLIST structures, each of which uniquely identifies a file object or subfolder relative to the parent
/// folder. Each item identifier list must contain exactly one SHITEMID structure followed by a terminating zero.
/// </param>
/// <param name="riid">
/// A reference to the IID of the interface to retrieve through ppv. This can be any valid interface identifier that can be created for an item. The
/// most common identifiers used by the Shell are listed in the comments at the end of this reference.
/// </param>
/// <param name="rgfReserved">Reserved.</param>
/// <returns>When this method returns successfully, contains the interface pointer requested in riid.</returns>
[return: MarshalAs(UnmanagedType.Interface)]
2018-10-26 14:24:07 -04:00
object GetUIObjectOf(HWND hwndOwner, uint cidl, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] IntPtr[] apidl, in Guid riid, IntPtr rgfReserved = default);
/// <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.
/// </returns>
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(STRRETMarshaler))]
string GetDisplayNameOf([In] PIDL pidl, SHGDNF uFlags);
/// <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.
/// </param>
2018-10-26 14:24:07 -04:00
void SetNameOf(HWND hwnd, [In] PIDL pidl, [MarshalAs(UnmanagedType.LPWStr)] string pszName, SHGDNF uFlags, out PIDL ppidlOut);
}
2018-03-29 20:24:12 -04:00
/// <summary>Extends the capabilities of IShellFolder. Its methods provide a variety of information about the contents of a Shell folder.</summary>
/// <seealso cref="Vanara.PInvoke.Shell32.IShellFolder"/>
[SuppressUnmanagedCodeSecurity]
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("93F2F68C-1D1B-11d3-A30E-00C04F79ABD1")]
[PInvokeData("Shobjidl.h", MSDNShortId = "bb775075")]
public interface IShellFolder2 : IShellFolder
{
/// <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.
/// </param>
2018-10-26 14:24:07 -04:00
new void ParseDisplayName(HWND hwnd, [In, Optional] IBindCtx pbc, [MarshalAs(UnmanagedType.LPWStr)] string pszDisplayName, out uint pchEaten, out PIDL ppidl, [In, Out] ref SFGAO pdwAttributes);
/// <summary>
/// Enables a client to determine the contents of a folder by creating an item identifier enumeration object and returning its IEnumIDList interface.
/// The methods supported by that interface can then be used to enumerate the folder's contents.
/// </summary>
/// <param name="hwnd">
/// If user input is required to perform the enumeration, this window handle should be used by the enumeration object as the parent window to take
/// user input. An example would be a dialog box to ask for a password or prompt the user to insert a CD or floppy disk. If hwndOwner is set to NULL,
/// the enumerator should not post any messages, and if user input is required, it should silently fail.
/// </param>
/// <param name="grfFlags">
/// Flags indicating which items to include in the enumeration. For a list of possible values, see the SHCONTF enumerated type.
/// </param>
/// <returns>
/// The address that receives a pointer to the IEnumIDList interface of the enumeration object created by this method. If an error occurs or no
/// suitable subobjects are found, ppenumIDList is set to NULL.
/// </returns>
2018-10-26 14:24:07 -04:00
new IEnumIDList EnumObjects(HWND hwnd, SHCONTF grfFlags);
/// <summary>
/// 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.
/// </returns>
[return: MarshalAs(UnmanagedType.Interface)]
2018-10-26 14:24:07 -04:00
new object BindToObject([In] PIDL pidl, [In, Optional] IBindCtx pbc, in Guid riid);
/// <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>
[return: MarshalAs(UnmanagedType.Interface)]
2018-10-26 14:24:07 -04:00
new object BindToStorage([In] PIDL pidl, [In, Optional] IBindCtx pbc, in Guid riid);
/// <summary>Determines the relative order of two file objects or folders, given their item identifier lists.</summary>
/// <param name="lParam">
/// A value that specifies how the comparison should be performed.
/// <para>
/// The lower sixteen bits of lParam define the sorting rule. Most applications set the sorting rule to the default value of zero, indicating that
/// the two items should be compared by name. The system does not define any other sorting rules. Some folder objects might allow calling
/// applications to use the lower sixteen bits of lParam to specify folder-specific sorting rules. The rules and their associated lParam values are
/// defined by the folder.
/// </para>
/// <para>
/// When the system folder view object calls IShellFolder::CompareIDs, the lower sixteen bits of lParam are used to specify the column to be used for
/// the comparison.
/// </para>
/// <para>The upper sixteen bits of lParam are used for flags that modify the sorting rule. The system currently defines these modifier flags.</para>
/// <list>
/// <item>
/// <term>SHCIDS_ALLFIELDS</term>
/// <description>
/// Version 5.0. Compare all the information contained in the ITEMIDLIST structure, not just the display names. This flag is valid only for folder
/// objects that support the IShellFolder2 interface. For instance, if the two items are files, the folder should compare their names, sizes, file
/// times, attributes, and any other information in the structures. If this flag is set, the lower sixteen bits of lParam must be zero.
/// </description>
/// </item>
/// <item>
/// <term>SHCIDS_CANONICALONLY</term>
/// <description>
/// Version 5.0. When comparing by name, compare the system names but not the display names. When this flag is passed, the two items are compared by
/// whatever criteria the Shell folder determines are most efficient, as long as it implements a consistent sort function. This flag is useful when
/// comparing for equality or when the results of the sort are not displayed to the user. This flag cannot be combined with other flags.
/// </description>
/// </item>
/// </list>
/// </param>
/// <param name="pidl1">
/// A pointer to the first item's ITEMIDLIST structure. It will be relative to the folder. This ITEMIDLIST structure can contain more than one
/// element; therefore, the entire structure must be compared, not just the first element.
/// </param>
/// <param name="pidl2">
/// A pointer to the second item's ITEMIDLIST structure. It will be relative to the folder. This ITEMIDLIST structure can contain more than one
/// element; therefore, the entire structure must be compared, not just the first element.
/// </param>
/// <returns>
/// If this method is successful, the CODE field of the HRESULT contains one of the following values. For information regarding the extraction of the
/// CODE field from the returned HRESULT, see Remarks. If this method is unsuccessful, it returns a COM error code.
/// </returns>
[PreserveSig]
new HRESULT CompareIDs(IntPtr lParam, [In] PIDL pidl1, [In] PIDL pidl2);
/// <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
/// for more details.
/// </returns>
[return: MarshalAs(UnmanagedType.Interface)]
2018-10-26 14:24:07 -04:00
new object CreateViewObject(HWND hwndOwner, in Guid riid);
/// <summary>Gets the attributes of one or more file or folder objects contained in the object represented by IShellFolder.</summary>
/// <param name="cidl">The number of items from which to retrieve attributes.</param>
/// <param name="apidl">
/// The address of an array of pointers to ITEMIDLIST structures, each of which uniquely identifies an item relative to the parent folder. Each
/// ITEMIDLIST structure must contain exactly one SHITEMID structure followed by a terminating zero.
/// </param>
/// <param name="rgfInOut">
/// Pointer to a single ULONG value that, on entry, contains the bitwise SFGAO attributes that the calling application is requesting. On exit, this
/// value contains the requested attributes that are common to all of the specified items.
/// </param>
new void GetAttributesOf(uint cidl, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] IntPtr[] apidl, ref SFGAO rgfInOut);
/// <summary>Gets an object that can be used to carry out actions on the specified file objects or folders.</summary>
/// <param name="hwndOwner">A handle to the owner window that the client should specify if it displays a dialog box or message box.</param>
/// <param name="cidl">The number of file objects or subfolders specified in the apidl parameter.</param>
/// <param name="apidl">
/// The address of an array of pointers to ITEMIDLIST structures, each of which uniquely identifies a file object or subfolder relative to the parent
/// folder. Each item identifier list must contain exactly one SHITEMID structure followed by a terminating zero.
/// </param>
/// <param name="riid">
/// A reference to the IID of the interface to retrieve through ppv. This can be any valid interface identifier that can be created for an item. The
/// most common identifiers used by the Shell are listed in the comments at the end of this reference.
/// </param>
/// <param name="rgfReserved">Reserved.</param>
/// <returns>When this method returns successfully, contains the interface pointer requested in riid.</returns>
[return: MarshalAs(UnmanagedType.Interface)]
2018-10-26 14:24:07 -04:00
new object GetUIObjectOf(HWND hwndOwner, uint cidl, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] IntPtr[] apidl, in Guid riid, IntPtr rgfReserved = default(IntPtr));
/// <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.
/// </returns>
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(STRRETMarshaler))]
new string GetDisplayNameOf([In] PIDL pidl, SHGDNF uFlags);
/// <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.
/// </param>
2018-10-26 14:24:07 -04:00
new void SetNameOf(HWND hwnd, [In] PIDL pidl, [MarshalAs(UnmanagedType.LPWStr)] string pszName, SHGDNF uFlags, out PIDL ppidlOut);
/// <summary>Returns the globally unique identifier (GUID) of the default search object for the folder.</summary>
/// <returns>The GUID of the default search object.</returns>
Guid GetDefaultSearchGUID();
/// <summary>Requests a pointer to an interface that allows a client to enumerate the available search objects.</summary>
/// <returns>The address of a pointer to an enumerator object's IEnumExtraSearch interface.</returns>
[return: MarshalAs(UnmanagedType.IUnknown)]
IEnumExtraSearch EnumSearches();
/// <summary>Gets the default sorting and display columns.</summary>
/// <param name="dwRes">Reserved. Set to zero.</param>
/// <param name="pSort">A pointer to a value that receives the index of the default sorted column.</param>
/// <param name="pDisplay">A pointer to a value that receives the index of the default display column.</param>
[PreserveSig]
void GetDefaultColumn(uint dwRes, out uint pSort, out uint pDisplay);
/// <summary>Gets the default state for a specified column.</summary>
/// <param name="iColumn">An integer that specifies the column number.</param>
/// <returns>
/// A pointer to a value that contains flags that indicate the default column state. This parameter can include a combination of the following flags.
/// </returns>
SHCOLSTATE GetDefaultColumnState(uint iColumn);
/// <summary>
/// Gets detailed information, identified by a property set identifier (FMTID) and a property identifier (PID), on an item in a Shell folder.
/// </summary>
/// <param name="pidl">
/// A PIDL of the item, relative to the parent folder. This method accepts only single-level PIDLs. The structure must contain exactly one SHITEMID
/// structure followed by a terminating zero. This value cannot be NULL.
/// </param>
/// <param name="pscid">A pointer to an SHCOLUMNID structure that identifies the column.</param>
/// <returns>
/// A pointer to a VARIANT with the requested information. The value is fully typed. The value returned for properties from the property system must
/// conform to the type specified in that property definition's typeInfo as the legacyType attribute.
/// </returns>
object GetDetailsEx(PIDL pidl, PROPERTYKEY pscid);
/// <summary>Gets detailed information, identified by a column index, on an item in a Shell folder.</summary>
/// <param name="pidl">
/// PIDL of the item for which you are requesting information. This method accepts only single-level PIDLs. The structure must contain exactly one
/// SHITEMID structure followed by a terminating zero. If this parameter is set to NULL, the title of the information field specified by iColumn is returned.
/// </param>
/// <param name="iColumn">
/// The zero-based index of the desired information field. It is identical to the column number of the information as it is displayed in a Windows
/// Explorer Details view.
/// </param>
/// <returns>
/// The zero-based index of the desired information field. It is identical to the column number of the information as it is displayed in a Windows
/// Explorer Details view.
/// </returns>
SHELLDETAILS GetDetailsOf(PIDL pidl, uint iColumn);
/// <summary>Converts a column to the appropriate property set ID (FMTID) and property ID (PID).</summary>
/// <param name="iColumn">The column ID.</param>
/// <returns>A pointer to an SHCOLUMNID structure containing the FMTID and PID.</returns>
PROPERTYKEY MapColumnToSCID(uint iColumn);
}
2018-03-29 20:24:12 -04:00
/// <summary>Used by an IEnumExtraSearch enumerator object to return information on the search objects supported by a Shell Folder object.</summary>
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
[PInvokeData("Shobjidl.h", MSDNShortId = "bb773283")]
public struct EXTRASEARCH
{
2018-03-29 20:24:12 -04:00
/// <summary>A search object's GUID.</summary>
public Guid guidSearch;
2018-03-29 20:24:12 -04:00
/// <summary>A Unicode string containing the search object's friendly name. It will be used to identify the search engine on the Search Assistant menu.</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
public string wszFriendlyName;
2018-03-29 20:24:12 -04:00
/// <summary>The URL that will be displayed in the search pane.</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 2084)]
public string wszUrl;
}
}
}